public void IsAssignableStandardTypeToObject()
{
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(object), typeof(object)), Is.True);
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(object), typeof(List <int>)), Is.True);
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(object), typeof(int)), Is.True);
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(object), typeof(string)), Is.True);
}
public void IsIsGeneratedByMixinEngine_OnGeneratedMixinType()
{
var mixedInstance = ObjectFactory.Create <ClassOverridingMixinMembers> (ParamList.Empty);
Type mixinType = Mixin.Get <MixinWithAbstractMembers> (mixedInstance).GetType();
Assert.That(MixinTypeUtility.IsGeneratedByMixinEngine(mixinType), Is.True);
}
public override void SetUp()
{
base.SetUp();
_dataSource = new BindableObjectDataSource();
_mockRepository = new MockRepository();
_stubSite = _mockRepository.Stub <ISite>();
SetupResult.For(_stubSite.DesignMode).Return(true);
_dataSource.Site = _stubSite;
_mockDesignerHost = _mockRepository.StrictMock <IDesignerHost>();
SetupResult.For(_stubSite.GetService(typeof(IDesignerHost))).Return(_mockDesignerHost);
var helperStub = _mockRepository.Stub <IDesignModeHelper> ();
SetupResult.For(helperStub.DesignerHost).Return(_mockDesignerHost);
_typeResolutionServiceMock = _mockRepository.StrictMock <ITypeResolutionService> ();
SetupResult.For(_mockDesignerHost.GetService(typeof(ITypeResolutionService))).Return(_typeResolutionServiceMock);
var typeDiscoveryServiceStub = _mockRepository.Stub <ITypeDiscoveryService> ();
SetupResult.For(typeDiscoveryServiceStub.GetTypes(null, false)).IgnoreArguments().Return(Assembly.GetExecutingAssembly().GetTypes());
SetupResult.For(_mockDesignerHost.GetService(typeof(ITypeDiscoveryService))).Return(typeDiscoveryServiceStub);
// initialize IoC and mixin infrastructure to remove sideeffects in test.
MixinTypeUtility.GetConcreteMixedType(typeof(SimpleBusinessObjectClass));
DesignerUtility.SetDesignMode(helperStub);
}
public void IsAssignableStandardTypeToBaseClass()
{
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(ValueType), typeof(object)), Is.False);
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(ValueType), typeof(List <int>)), Is.False);
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(ValueType), typeof(int)), Is.True);
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(ValueType), typeof(string)), Is.False);
}
public void GetOrderedMixinTypes_OpenGenericMixinTypesAreClosed()
{
var concreteMixedType = MixinTypeUtility.GetConcreteMixedType(typeof(BaseType3));
Assert.That(MixinReflector.GetOrderedMixinTypesFromConcreteType(concreteMixedType),
Has.Member(typeof(BT3Mixin3 <BaseType3, IBaseType33>)));
}
public void GetAscribableMixinOnUnmixedTypes()
{
Assert.That(MixinTypeUtility.GetAscribableMixinType(typeof(object), typeof(NullMixin)), Is.Null);
Assert.That(MixinTypeUtility.GetAscribableMixinType(typeof(int), typeof(object)), Is.Null);
Assert.That(MixinTypeUtility.GetAscribableMixinType(typeof(int), typeof(List <>)), Is.Null);
Assert.That(MixinTypeUtility.GetAscribableMixinType(typeof(int), typeof(List <int>)), Is.Null);
}
public void HasAscribableMixinOnUnmixedTypes()
{
Assert.That(MixinTypeUtility.HasAscribableMixin(typeof(object), typeof(NullMixin)), Is.False);
Assert.That(MixinTypeUtility.HasAscribableMixin(typeof(int), typeof(object)), Is.False);
Assert.That(MixinTypeUtility.HasAscribableMixin(typeof(int), typeof(List <>)), Is.False);
Assert.That(MixinTypeUtility.HasAscribableMixin(typeof(int), typeof(List <int>)), Is.False);
}
protected static void CheckOrderedMixinTypes(object instance, params Type[] expectedMixinTypes)
{
var type = instance.GetType();
var mixinTypes = MixinTypeUtility.GetMixinTypesExact(type);
Assert.That(mixinTypes, Is.EqualTo(expectedMixinTypes));
}
public void HasMixinsOnMixedTypesWithoutMixins()
{
using (MixinConfiguration.BuildNew().ForClass <object>().EnterScope())
{
Assert.That(MixinTypeUtility.HasMixins(typeof(object)), Is.False);
}
}
private static Type FindProviderAttributeType(Type type)
{
var concreteType = MixinTypeUtility.GetConcreteMixedType(type);
var attribute = AttributeUtility.GetCustomAttribute <BusinessObjectProviderAttribute> (concreteType, true);
if (attribute == null)
{
var message = string.Format(
"The type '{0}' does not have the '{1}' applied.",
type.FullName,
typeof(BusinessObjectProviderAttribute).FullName);
throw new ArgumentException(message, "type");
}
if (!TypeExtensions.CanAscribeTo(attribute.BusinessObjectProviderType, typeof(BindableObjectProvider)))
{
var message = string.Format(
"The business object provider associated with the type '{0}' is not of type '{1}'.",
type.FullName,
typeof(BindableObjectProvider).FullName);
throw new ArgumentException(message, "type");
}
return(attribute.GetType());
}
public void CreatePropertyRuleReflectorForConcreteTypeBasedOnDomainObjectAndMixin_AnnotatedPropertiesPartOfAnInterface_DoesNotIncludePropertiesCopeisToConcreteType()
{
using (MixinConfiguration
.BuildNew()
.ForClass <MixinTarget_AnnotatedPropertiesPartOfInterface>()
.AddMixin <MixinTypeWithDomainObjectAttributes_AnnotatedPropertiesPartOfInterface>()
.EnterScope())
{
var result =
_provider.GetValidationCollectors(
new[]
{
MixinTypeUtility.GetConcreteMixedType(typeof(MixinTarget_AnnotatedPropertiesPartOfInterface)),
typeof(MixinTypeWithDomainObjectAttributes_AnnotatedPropertiesPartOfInterface)
})
.SelectMany(c => c)
.ToArray();
var resultForConcreteType = result.SingleOrDefault(r => MixinTypeUtility.IsGeneratedConcreteMixedType(r.Collector.ValidatedType));
Assert.That(resultForConcreteType, Is.Null);
var resultForMixin = result.SingleOrDefault(
r => r.Collector.ValidatedType == typeof(IMixinTypeWithDomainObjectAttributes_AnnotatedPropertiesPartOfInterface));
Assert.That(resultForMixin, Is.Not.Null);
Assert.That(resultForMixin.Collector.AddedPropertyRules.Count, Is.EqualTo(10));
}
}
public void GetConcreteMixedType_StandardType()
{
Assert.That(MixinTypeUtility.GetConcreteMixedType(typeof(object)), Is.SameAs(typeof(object)));
Assert.That(MixinTypeUtility.GetConcreteMixedType(typeof(int)), Is.SameAs(typeof(int)));
Assert.That(MixinTypeUtility.GetConcreteMixedType(typeof(List <int>)), Is.SameAs(typeof(List <int>)));
Assert.That(MixinTypeUtility.GetConcreteMixedType(typeof(List <>)), Is.SameAs(typeof(List <>)));
}
public void GetClassContextForConcreteType()
{
Type bt1Type = TypeFactory.GetConcreteType(typeof(BaseType1));
Assert.That(MixinTypeUtility.GetClassContextForConcreteType(bt1Type),
Is.EqualTo(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType1))));
}
public void GetBindableObjectClass()
{
var mockRepository = new MockRepository();
var metadataFactoryMock = mockRepository.StrictMock <IMetadataFactory>();
var classReflectorMock = mockRepository.StrictMock <IClassReflector>();
var provider = new BindableObjectProvider(metadataFactoryMock, _serviceFactoryStub);
BindableObjectProvider.SetProvider(typeof(BindableObjectProviderAttribute), provider);
Type targetType = typeof(SimpleBusinessObjectClass);
Type concreteType = MixinTypeUtility.GetConcreteMixedType(targetType);
var expectedBindableObjectClass = new BindableObjectClass(
concreteType,
provider,
SafeServiceLocator.Current.GetInstance <BindableObjectGlobalizationService>(),
new PropertyBase[0]);
Expect.Call(metadataFactoryMock.CreateClassReflector(targetType, provider)).Return(classReflectorMock);
Expect.Call(classReflectorMock.GetMetadata()).Return(expectedBindableObjectClass);
mockRepository.ReplayAll();
BindableObjectClass actual = provider.GetBindableObjectClass(targetType);
mockRepository.VerifyAll();
Assert.That(actual, Is.SameAs(expectedBindableObjectClass));
}
public void GetUnderlyingTargetTypeOnDerivedConcreteType()
{
Type concreteType = MixinTypeUtility.GetConcreteMixedType(typeof(BaseType1));
var derivedType = GenerateDerivedType(concreteType);
Assert.That(MixinTypeUtility.GetUnderlyingTargetType(derivedType), Is.SameAs(typeof(BaseType1)));
}
public void GetMixinTypesExact_OnGeneratedTypes()
{
Assert.That(
MixinTypeUtility.GetMixinTypesExact(MixinTypeUtility.GetConcreteMixedType(typeof(BaseType7))),
Is.EqualTo(BigTestDomainScenarioTest.ExpectedBaseType7OrderedMixinTypesSmall));
Assert.That(MixinTypeUtility.GetMixinTypesExact(MixinTypeUtility.GetConcreteMixedType(typeof(BaseType3))), Has.Member(typeof(BT3Mixin3 <BaseType3, IBaseType33>)));
}
public void HasMixinsOnSimpleTypes()
{
Assert.That(MixinTypeUtility.HasMixins(typeof(object)), Is.False);
using (MixinConfiguration.BuildNew().EnterScope())
{
Assert.That(MixinTypeUtility.HasMixins(typeof(BaseType1)), Is.False);
}
}
public void IsAssignableRightParameterIsMadeConcrete()
{
using (MixinConfiguration.BuildFromActive().ForClass <NullTarget> ().Clear().AddMixins(typeof(NullMixin)).EnterScope())
{
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(NullTarget), typeof(NullTarget)), Is.True);
Assert.That(MixinTypeUtility.IsAssignableFrom(CreateMixedType(typeof(NullTarget), typeof(NullMixin)), typeof(NullTarget)), Is.True);
}
}
public void GetOrderedMixinTypes_OrderedMixinTypes()
{
var concreteMixedType = MixinTypeUtility.GetConcreteMixedType(typeof(BaseType7));
Assert.That(
MixinReflector.GetOrderedMixinTypesFromConcreteType(concreteMixedType),
Is.EqualTo(BigTestDomainScenarioTest.ExpectedBaseType7OrderedMixinTypesSmall));
}
private IEnumerable <IEnumerable <Type> > GetMixins(Type type)
{
return
(MixinTypeUtility.GetMixinTypesExact(type)
.Where(_validationTypeFilter.IsValidatableType)
.Select(mixinType => new[] { mixinType })
.ToArray());
}
public void IsAssignableInterfaceImplementedViaMixin()
{
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(IMixinIII4), typeof(NullTarget)), Is.False);
using (MixinConfiguration.BuildFromActive().ForClass <NullTarget> ().Clear().AddMixins(typeof(MixinIntroducingInheritedInterface)).EnterScope())
{
Assert.That(MixinTypeUtility.IsAssignableFrom(typeof(IMixinIII4), typeof(NullTarget)), Is.True);
}
}
protected override ILookup <Type, IAttributesBasedValidationPropertyRuleReflector> CreatePropertyRuleReflectors(IEnumerable <Type> types)
{
ArgumentUtility.CheckNotNull("types", types);
return(types
.Where(type => !MixinTypeUtility.IsGeneratedConcreteMixedType(type))
.SelectMany(t => CreatePropertyRuleReflectors(t, t.GetInterfaces()))
.ToLookup(r => r.Item1, r => r.Item2));
}
public void GetMixinConfigurationFromConcreteType_DerivedType()
{
Type concreteType = MixinTypeUtility.GetConcreteMixedType(typeof(BaseType1));
var derivedType = GenerateDerivedType(concreteType);
Assert.That(
MixinTypeUtility.GetClassContextForConcreteType(derivedType),
Is.EqualTo(MixinConfiguration.ActiveConfiguration.GetContext(typeof(BaseType1))));
}
public void NoPropertiesFromBindableObjectMixins()
{
Type targetType = typeof(ClassWithIdentity);
Type concreteType = MixinTypeUtility.GetConcreteMixedType(targetType);
var targetTypeProperties = new List <IPropertyInformation> (new ReflectionBasedPropertyFinder(targetType).GetPropertyInfos());
var concreteTypeProperties = new List <IPropertyInformation> (new ReflectionBasedPropertyFinder(concreteType).GetPropertyInfos());
Assert.That(concreteTypeProperties, Is.EquivalentTo(targetTypeProperties));
}
public void Initialize_WithGeneric()
{
var bindableObjectClass = new BindableObjectClass(
MixinTypeUtility.GetConcreteMixedType(typeof(ClassWithReferenceType <SimpleReferenceType>)),
_bindableObjectProvider,
_bindableObjectGlobalizationService,
new PropertyBase[0]);
Assert.That(bindableObjectClass.TargetType, Is.SameAs(typeof(ClassWithReferenceType <SimpleReferenceType>)));
}
