/*
* JBoss, Home of Professional Open Source
* Copyright 2007, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.test.managed.factory;
import java.io.Serializable;
import java.util.Arrays;
import java.util.Set;
import org.jboss.managed.api.ManagedObject;
import org.jboss.managed.api.ManagedProperty;
import org.jboss.managed.api.factory.ManagedObjectFactory;
import org.jboss.managed.plugins.factory.AbstractManagedObjectFactory;
import org.jboss.managed.spi.factory.ManagedObjectBuilder;
import org.jboss.metadata.spi.MetaData;
import org.jboss.metatype.api.types.CompositeMetaType;
import org.jboss.metatype.api.types.GenericMetaType;
import org.jboss.metatype.api.types.MetaType;
import org.jboss.metatype.api.types.MetaTypeFactory;
import org.jboss.metatype.api.values.GenericValueSupport;
import org.jboss.metatype.api.values.MetaValue;
import org.jboss.metatype.api.values.MetaValueFactory;
import org.jboss.test.BaseTestCase;
import org.jboss.util.Strings;
/**
* AbstractManagedObjectFactoryTest.
*
* @author <a href="adrian@jboss.com">Adrian Brock</a>
* @version $Revision: 1.1 $
*/
public abstract class AbstractManagedObjectFactoryTest extends BaseTestCase
{
/** The managed object factory */
private static final ManagedObjectFactory managedObjectFactory = ManagedObjectFactory.getInstance();
/** The meta type factory */
private static final MetaTypeFactory metaTypeFactory = MetaTypeFactory.getInstance();
/** The meta value factory */
private static final MetaValueFactory metaValueFactory = MetaValueFactory.getInstance();
/**
* Create a new AbstractManagedObjectFactoryTest.
*
* @param name the test name
*/
public AbstractManagedObjectFactoryTest(String name)
{
super(name);
}
/**
* Initialize a managed object
*
* @param object the object
* @return the managed object
*/
protected ManagedObject initManagedObject(Object object)
{
ManagedObject result = getMOF().initManagedObject(object, null, null);
getLog().debug("Inited managed: " + result + " for object=" + Strings.defaultToString(object));
return result;
}
protected ManagedObjectFactory getMOF()
{
return managedObjectFactory;
}
/**
* Create a managed object
*
* @param <T> the type
* @param clazz the type
* @param metaData the metadata repository
* @return the managed object
*/
protected <T> ManagedObject createManagedObject(Class<T> clazz)
{
MetaData metaData = null;
ManagedObject result = getMOF().createManagedObject(clazz, metaData);
getLog().debug("Created managed: " + result + " for class=" + clazz.getName());
return result;
}
/**
* Set a builder for a class
*
* @param clazz the class
* @param builder the builder
*/
protected void setBuilder(Class<?> clazz, ManagedObjectBuilder builder)
{
getMOF().setBuilder(clazz, builder);
}
/**
* Resolve a meta type
*
* @param clazz the class
* @return the meta type
*/
protected MetaType resolve(Class<?> clazz)
{
return metaTypeFactory.resolve(clazz);
}
/**
* Create and check a managed object
*
* @param clazz the object
* @return the managed obejct
*/
protected ManagedObject createAndCheckDefaultManagedObject(Class<? extends Serializable> clazz)
{
ManagedObject managedObject = createManagedObject(clazz);
checkManagedObjectDefaults(clazz, managedObject);
checkDefaultManagedProperties(managedObject, clazz);
return managedObject;
}
/**
* Initialize and check a managed object
*
* @param test the object
* @return the managed object
*/
protected ManagedObject checkManagedObject(Serializable test)
{
ManagedObject managedObject = initManagedObject(test);
checkManagedObjectDefaults(test.getClass(), managedObject);
checkDefaultManagedProperties(managedObject, test.getClass());
return managedObject;
}
/**
* Check managed object defaults
*
* @param clazz the class
* @param managedObject the managed object
*/
protected void checkManagedObjectDefaults(Class<? extends Serializable> clazz, ManagedObject managedObject)
{
checkManagedObjectDefaults(clazz, managedObject, null);
}
/**
* Check managed object defaults
*
* @param clazz the class
* @param managedObject the managed object
* @param expectedAttachment the expected attachment
*/
protected void checkManagedObjectDefaults(Class<? extends Serializable> clazz, ManagedObject managedObject, Object expectedAttachment)
{
checkManagedObject(clazz, managedObject, clazz.getName(), expectedAttachment);
}
/**
* Check a managed object
*
* @param clazz the class
* @param managedObject the managed object
* @param name the managed object name
* @param expectedAttachment the expected attachment
*/
protected void checkManagedObject(Class<? extends Serializable> clazz, ManagedObject managedObject, String name, Object expectedAttachment)
{
getLog().debug("CheckMangedObject: clazz=" + clazz.getName() + " managedObject=" + managedObject + " name=" + name + " expectedAttachment=" + Strings.defaultToString(expectedAttachment));
assertNotNull(managedObject);
String managedObjectName = managedObject.getName();
getLog().debug("... name=" + managedObjectName);
assertEquals(name, managedObjectName);
Object attachment = managedObject.getAttachment();
getLog().debug("... attachment=" + Strings.defaultToString(attachment));
assertInstanceOf(attachment, clazz, false);
if (expectedAttachment != null)
assertTrue("ManagedObject should have the correct attachment expected " + Strings.defaultToString(expectedAttachment) + " got " + Strings.defaultToString(attachment), expectedAttachment == attachment);
}
/**
* Check default managed properties
*
* @param managedObject the managed object
* @param clazz the class
*/
protected void checkDefaultManagedProperties(ManagedObject managedObject, Class<?> clazz)
{
CompositeMetaType metaType = assertInstanceOf(resolve(clazz), CompositeMetaType.class);
Set<String> expectedNames = metaType.itemSet();
Set<String> propertyNames = managedObject.getPropertyNames();
getLog().debug("checkDefaultProperties");
getLog().debug("... expectedNames=" + expectedNames);
getLog().debug("..... actualNames=" + propertyNames);
assertEquals("Expected properties " + expectedNames + " got " + propertyNames, expectedNames.size(), propertyNames.size());
for (String name : expectedNames)
{
ManagedProperty managedProperty = managedObject.getProperty(name);
assertNotNull("Expected property '" + name + "' in " + propertyNames, managedProperty);
assertEquals(managedObject, managedProperty.getManagedObject());
}
}
/**
* Check managed properties
*
* @param managedObject the managed object
* @param names the expected property names
*/
protected void checkManagedProperties(ManagedObject managedObject, String... names)
{
Set<String> propertyNames = managedObject.getPropertyNames();
getLog().debug("checkManagedProperties");
getLog().debug("... expectedNames=" + Arrays.asList(names));
getLog().debug("..... actualNames=" + propertyNames);
assertEquals("Expected properties " + Arrays.asList(names) + " got " + propertyNames, names.length, propertyNames.size());
for (String name : names)
{
ManagedProperty managedProperty = managedObject.getProperty(name);
assertNotNull("Expected property '" + name + "' in " + propertyNames, managedProperty);
assertEquals(managedObject, managedProperty.getManagedObject());
}
}
/**
* Check property defaults
*
* @param managedObject the managed object
* @param name the property name
* @param clazz the property class
*/
protected void checkPropertyDefaults(ManagedObject managedObject, String name, Class<?> clazz)
{
checkPropertyDefaults(managedObject, name, clazz, null);
}
/**
* Check property defaults
*
* @param managedObject the managed object
* @param name the property name
* @param clazz the property class
* @param value the expected property value
*/
protected void checkPropertyDefaults(ManagedObject managedObject, String name, Class<?> clazz, Object value)
{
checkProperty(managedObject, name, clazz, name, false, value);
}
/**
* Check property
*
* @param managedObject the managed object
* @param name the property name
* @param clazz the property class
* @param description the property description
* @param mandatory whether the property is expected mandatory
* @param value the expected property value
*/
protected void checkProperty(ManagedObject managedObject, String name, Class<?> clazz, String description, boolean mandatory, Object value)
{
MetaType expectedType = resolve(clazz);
MetaValue expectedValue = metaValueFactory.create(value, clazz);
checkProperty(managedObject, name, expectedType, expectedValue, description, mandatory);
}
/**
* Check a property is a managed object
*
* @param managedObject the managed object
* @param name the property name
* @param description the property description
* @param mandatory whether the property is expected mandatory
* @param value the expected property value
*/
protected void checkPropertyIsManagedObject(ManagedObject managedObject, String name, String description, boolean mandatory, Object value)
{
GenericMetaType expectedType = AbstractManagedObjectFactory.MANAGED_OBJECT_META_TYPE;
MetaValue expectedValue = new GenericValueSupport(expectedType, initManagedObject((Serializable) value));
checkProperty(managedObject, name, expectedType, expectedValue, description, mandatory);
}
/**
* Check a property
*
* @param managedObject the managed object
* @param name the property name
* @param expectedType the expected meta type
* @param expectedValue the expected meta value
* @param description the property description
* @param mandatory whether the property is expected mandatory
*/
protected void checkProperty(ManagedObject managedObject, String name, MetaType expectedType, MetaValue expectedValue, String description, boolean mandatory)
{
getLog().debug("checkProperty name=" + name + " type=" + expectedType + " desc=" + description + " mandatory=" + mandatory + " value=" + expectedValue);
ManagedProperty managedProperty = managedObject.getProperty(name);
getLog().debug("... managedProperty=" + managedProperty);
assertNotNull("Expected property " + name + " in " + managedObject.getPropertyNames(), managedProperty);
String propertyName = managedProperty.getName();
getLog().debug("... name=" + propertyName);
assertEquals("Property '" + name + "' has the wrong name", name, propertyName);
String propertyDescription = managedProperty.getDescription();
getLog().debug("... description=" + propertyDescription);
assertEquals("Property '" + name + "' has the wrong description", description, propertyDescription);
boolean propertyMandatory = managedProperty.isMandatory();
getLog().debug("... mandatory=" + propertyMandatory);
assertEquals("Property '" + name + "' has the wrong mandatory flag", mandatory, propertyMandatory);
getLog().debug("... expected metaType=" + expectedType);
MetaType actualType = managedProperty.getMetaType();
getLog().debug("..... actual metaType=" + expectedType);
assertEquals("Property '" + name + "' has the wrong type", expectedType, actualType);
getLog().debug("... expected value=" + expectedValue);
Object actualValue = managedProperty.getValue();
getLog().debug("..... actual value=" + actualValue);
assertEquals("Property '" + name + "' has the wrong value", expectedValue, actualValue);
}
}