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>))); }