public void CreatePropertyFinder()
{
IPropertyFinder finder = BindableObjectMetadataFactory.Create().CreatePropertyFinder(typeof(TestClass));
Assert.That(finder.GetType(), Is.SameAs(typeof(ReflectionBasedPropertyFinder)));
Assert.That(new List <IPropertyInformation> (finder.GetPropertyInfos())[0].DeclaringType, Is.SameAs(TypeAdapter.Create(typeof(TestClass))));
}
public void CreateClassReflector()
{
BindableObjectProvider provider = new BindableObjectProvider();
IClassReflector classReflector = BindableObjectMetadataFactory.Create().CreateClassReflector(typeof(TestClass), provider);
Assert.That(classReflector.TargetType, Is.SameAs(typeof(TestClass)));
Assert.That(classReflector.BusinessObjectProvider, Is.SameAs(provider));
}
public override void SetUp()
{
base.SetUp();
_type = typeof(DerivedBusinessObjectClass);
_businessObjectProvider = new BindableObjectProvider();
_metadataFactory = BindableObjectMetadataFactory.Create();
_bindableObjectGlobalizationService = SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>();
}
public void Instantiate_WithMixin()
{
using (MixinConfiguration.BuildNew().ForClass(typeof(BindableObjectMetadataFactory)).AddMixin <MixinStub>().EnterScope())
{
BindableObjectMetadataFactory factory = BindableObjectMetadataFactory.Create();
Assert.That(factory, Is.InstanceOf(typeof(BindableObjectMetadataFactory)));
Assert.That(factory, Is.InstanceOf(typeof(IMixinTarget)));
}
}
public void GetPropertyDefinition_WithInvalidPropertyName()
{
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass.GetPropertyDefinition("Invalid"), Is.Null);
}
public void HasPropertyDefinition_ForMixedProperty()
{
var classReflector = new ClassReflector(
typeof(ClassWithMixedProperty),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass.HasPropertyDefinition("MixedProperty"), Is.True);
}
public void CreatePropertyReflector()
{
using (MixinConfiguration.BuildNew().EnterScope())
{
PropertyInfo propertyInfo = typeof(TestClass).GetProperty("Property");
IPropertyInformation property = PropertyInfoAdapter.Create(propertyInfo);
PropertyReflector propertyReflector =
BindableObjectMetadataFactory.Create().CreatePropertyReflector(typeof(TestClass), property, new BindableObjectProvider());
Assert.That(propertyReflector.GetType(), Is.SameAs(typeof(PropertyReflector)));
Assert.That(propertyReflector.PropertyInfo, Is.SameAs(property));
}
}
public void HasPropertyDefinition()
{
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
Assert.That(bindableObjectClass.HasPropertyDefinition("String"), Is.True);
Assert.That(bindableObjectClass.HasPropertyDefinition("Invalid"), Is.False);
}
public void GetPropertyDefinition()
{
PropertyReflector propertyReflector =
PropertyReflector.Create(GetPropertyInfo(typeof(SimpleBusinessObjectClass), "String"), _bindableObjectProvider);
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
CheckPropertyBase(propertyReflector.GetMetadata(), bindableObjectClass.GetPropertyDefinition("String"));
}
public void GetPropertyDefinitions()
{
Type type = typeof(ClassWithReferenceType <SimpleReferenceType>);
var expectedProperties = new[]
{
CreateProperty(type, "Scalar"),
CreateProperty(type, "ReadOnlyScalar"),
CreateProperty(type, "ReadOnlyAttributeScalar"),
CreateProperty(type, "ReadOnlyNonPublicSetterScalar"),
CreateProperty(type, "Array"),
CreateProperty(type, "ImplicitInterfaceScalar"),
CreateProperty(type, "ImplicitInterfaceReadOnlyScalar"),
CreateProperty(
type,
"Remotion.ObjectBinding.UnitTests.TestDomain.IInterfaceWithReferenceType<T>.ExplicitInterfaceScalar")
,
CreateProperty(
type,
"Remotion.ObjectBinding.UnitTests.TestDomain.IInterfaceWithReferenceType<T>.ExplicitInterfaceReadOnlyScalar"),
CreateProperty(type, "PropertyWithNoSetter"),
CreateProperty(type, "ThrowingProperty"),
};
var classReflector = new ClassReflector(
type,
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
IBusinessObjectProperty[] actualProperties = bindableObjectClass.GetPropertyDefinitions();
Assert.That(actualProperties.Length, Is.EqualTo(expectedProperties.Length));
foreach (PropertyBase expectedProperty in expectedProperties)
{
bool isFound = false;
foreach (IBusinessObjectProperty actualProperty in actualProperties)
{
if (actualProperty.Identifier == expectedProperty.Identifier)
{
Assert.That(isFound, Is.False, "Multiple properties '{0}' found", expectedProperty.Identifier, BindableObjectMetadataFactory.Create());
CheckPropertyBase(expectedProperty, actualProperty);
isFound = true;
}
}
Assert.That(isFound, Is.True, "Property '{0}' was not found", expectedProperty.Identifier);
}
}
public override void SetUp()
{
base.SetUp();
_businessObjectProvider = CreateBindableObjectProviderWithStubBusinessObjectServiceFactory();
_bindableObjectGlobalizationService = SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>();
ClassReflector classReflector = new ClassReflector(
typeof(ClassWithValueType <bool>),
_businessObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
_businessObjectClass = classReflector.GetMetadata();
_mockRepository = new MockRepository();
}
public void GetPropertyDefinition_ForMixedProperty()
{
PropertyReflector propertyReflector = PropertyReflector.Create(
GetPropertyInfo(
MixinTypeUtility.GetConcreteMixedType(typeof(ClassWithMixedProperty)),
typeof(IMixinAddingProperty).FullName + ".MixedProperty"),
_bindableObjectProvider);
var classReflector = new ClassReflector(
typeof(ClassWithMixedProperty),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
_bindableObjectGlobalizationService);
BindableObjectClass bindableObjectClass = classReflector.GetMetadata();
CheckPropertyBase(propertyReflector.GetMetadata(), bindableObjectClass.GetPropertyDefinition("MixedProperty"));
}
public void GetDisplayName_WithGlobalizationService()
{
var mockMemberInformationGlobalizationService = _mockRepository.StrictMock <IMemberInformationGlobalizationService> ();
var classReflector = new ClassReflector(
typeof(ClassWithAllDataTypes),
_bindableObjectProvider,
BindableObjectMetadataFactory.Create(),
new BindableObjectGlobalizationService(
MockRepository.GenerateStub <IGlobalizationService>(),
mockMemberInformationGlobalizationService,
MockRepository.GenerateStub <IEnumerationGlobalizationService>(),
MockRepository.GenerateStub <IExtensibleEnumGlobalizationService>()));
var bindableObjectClass = classReflector.GetMetadata();
Expect.Call(
mockMemberInformationGlobalizationService.TryGetTypeDisplayName(
Arg <ITypeInformation> .Matches(c => c.ConvertToRuntimeType() == bindableObjectClass.TargetType),
Arg <ITypeInformation> .Matches(c => c.ConvertToRuntimeType() == bindableObjectClass.TargetType),
out Arg <string> .Out("MockString").Dummy))
.Return(true);
_mockRepository.ReplayAll();
Assert.That(bindableObjectClass.GetDisplayName(), Is.EqualTo("MockString"));
}
protected BindableObjectProvider CreateBindableObjectProviderWithStubBusinessObjectServiceFactory()
{
return(new BindableObjectProvider(BindableObjectMetadataFactory.Create(), MockRepository.GenerateStub <IBusinessObjectServiceFactory>()));
}
public override void SetUp()
{
base.SetUp();
_factory = BindableObjectMetadataFactory.Create();
}
