public void GetMetadata_WithInvalidOppositePropertyName() { var type1 = GetClassWithInvalidBidirectionalRelationLeftSide(); var type2 = GetClassWithInvalidBidirectionalRelationRightSide(); var classDefinition1 = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(type1); classDefinition1.SetPropertyDefinitions(new PropertyDefinitionCollection()); classDefinition1.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); var propertyInfo = EnsurePropertyDefinitionExisitsOnClassDefinition(classDefinition1, type1, "InvalidOppositePropertyNameLeftSide"); var classDefinition2 = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(type2); classDefinition2.SetPropertyDefinitions(new PropertyDefinitionCollection()); classDefinition2.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); EnsurePropertyDefinitionExisitsOnClassDefinition( classDefinition2, type2, "InvalidPropertyNameInBidirectionalRelationAttributeOnOppositePropertyRightSide"); var relationReflector = CreateRelationReflector(classDefinition1, propertyInfo); _classDefinitions.Add(classDefinition1.ClassType, classDefinition1); _classDefinitions.Add(classDefinition2.ClassType, classDefinition2); var result = relationReflector.GetMetadata(_classDefinitions); Assert.That( result.ID, Is.EqualTo( "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Errors.ClassWithInvalidBidirectionalRelationLeftSide:" + "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Errors.ClassWithInvalidBidirectionalRelationLeftSide." + "InvalidOppositePropertyNameLeftSide->" + "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Errors.ClassWithInvalidBidirectionalRelationRightSide.Invalid")); }
public void GetMetadata_OppositeClassDefinition_IsDeclaringTypeOfOppositeProperty_NotReturnTypeOfThisProperty() { var originatingClass = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(Class1)); originatingClass.SetPropertyDefinitions(new PropertyDefinitionCollection()); originatingClass.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); var originatingProperty = EnsurePropertyDefinitionExisitsOnClassDefinition(originatingClass, typeof(Class1), "RelationProperty"); var classDeclaringOppositeProperty = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(BaseClass2)); classDeclaringOppositeProperty.SetPropertyDefinitions(new PropertyDefinitionCollection()); classDeclaringOppositeProperty.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); var oppositeProperty = EnsurePropertyDefinitionExisitsOnClassDefinition(classDeclaringOppositeProperty, typeof(BaseClass2), "RelationPropertyOnBaseClass"); var derivedOfClassDeclaringOppositeProperty = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(DerivedClass2), baseClass: classDeclaringOppositeProperty); derivedOfClassDeclaringOppositeProperty.SetPropertyDefinitions(new PropertyDefinitionCollection()); derivedOfClassDeclaringOppositeProperty.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); // This tests the scenario that the relation property's return type is a subclass of the opposite property's declaring type Assert.That(originatingProperty.PropertyType, Is.Not.SameAs(classDeclaringOppositeProperty.ClassType)); Assert.That(originatingProperty.PropertyType.BaseType, Is.SameAs(classDeclaringOppositeProperty.ClassType)); var classDefinitions = new[] { originatingClass, classDeclaringOppositeProperty, derivedOfClassDeclaringOppositeProperty } .ToDictionary(cd => cd.ClassType); var relationReflector = CreateRelationReflector(originatingClass, originatingProperty); var result = relationReflector.GetMetadata(classDefinitions); Assert.That(result.EndPointDefinitions[0].PropertyInfo, Is.SameAs(originatingProperty)); Assert.That(result.EndPointDefinitions[0].ClassDefinition, Is.SameAs(originatingClass)); Assert.That(result.EndPointDefinitions[1].PropertyInfo, Is.SameAs(oppositeProperty)); Assert.That(result.EndPointDefinitions[1].ClassDefinition, Is.SameAs(classDeclaringOppositeProperty)); }
public void PersistenceModelIsLoaded() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Order), baseClass: null); classDefinition.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection()); classDefinition.SetDerivedClasses(new ClassDefinition[0]); StubMockMappingLoader(new[] { classDefinition }, new RelationDefinition[0]); var persistenceModelLoaderMock = MockRepository.GenerateStrictMock <IPersistenceModelLoader>(); persistenceModelLoaderMock .Expect(mock => mock.ApplyPersistenceModelToHierarchy(classDefinition)) .WhenCalled(mi => classDefinition.SetStorageEntity(TableDefinitionObjectMother.Create(TestDomainStorageProviderDefinition))); persistenceModelLoaderMock .Expect(mock => mock.CreatePersistenceMappingValidator(classDefinition)) .Return(new PersistenceMappingValidator()); persistenceModelLoaderMock.Replay(); _mockRepository.ReplayAll(); new MappingConfiguration(_mockMappingLoader, persistenceModelLoaderMock); persistenceModelLoaderMock.VerifyAllExpectations(); }
public void SetUp() { _classDefinitions = new Dictionary <Type, ClassDefinition>(); _mappingObjectFactoryMock = MockRepository.GenerateStrictMock <IMappingObjectFactory>(); _classDefinitionCollectionFactory = new ClassDefinitionCollectionFactory(_mappingObjectFactoryMock); _fakeClassDefinition = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(Order)); }
public void GetMetadata_OppositePropertyIsAlsoDeclaredInBaseClass() { var originatingClass = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(ClassWithOppositeProperty)); originatingClass.SetPropertyDefinitions(new PropertyDefinitionCollection()); originatingClass.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); var originatingProperty = EnsurePropertyDefinitionExisitsOnClassDefinition(originatingClass, typeof(ClassWithOppositeProperty), "OppositeProperty"); var oppositeBaseClass = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(OppositeBaseClass)); oppositeBaseClass.SetPropertyDefinitions(new PropertyDefinitionCollection()); oppositeBaseClass.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); var oppositePropertyFromBaseClass = EnsurePropertyDefinitionExisitsOnClassDefinition(oppositeBaseClass, typeof(OppositeBaseClass), "OppositeProperty"); var oppositeClass = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(OppositeClass)); oppositeClass.SetPropertyDefinitions(new PropertyDefinitionCollection()); oppositeClass.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); var oppositeProperty = EnsurePropertyDefinitionExisitsOnClassDefinition(oppositeClass, typeof(OppositeClass), "OppositeProperty"); var classDefinitions = new[] { originatingClass, oppositeClass, oppositeBaseClass }.ToDictionary(cd => cd.ClassType); var relationReflector = CreateRelationReflector(originatingClass, originatingProperty); var result = relationReflector.GetMetadata(classDefinitions); Assert.That(result.EndPointDefinitions[0].PropertyInfo, Is.SameAs(originatingProperty)); Assert.That(result.EndPointDefinitions[0].ClassDefinition, Is.SameAs(originatingClass)); Assert.That(result.EndPointDefinitions[1].PropertyInfo, Is.Not.SameAs(oppositePropertyFromBaseClass)); Assert.That(result.EndPointDefinitions[1].PropertyInfo, Is.SameAs(oppositeProperty)); Assert.That(result.EndPointDefinitions[1].ClassDefinition, Is.SameAs(oppositeClass)); }
public void CreatePropertyDefinitions() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Order), baseClass: null); var propertyInfo1 = PropertyInfoAdapter.Create(typeof(Order).GetProperty("OrderNumber")); var propertyInfo2 = PropertyInfoAdapter.Create(typeof(Order).GetProperty("DeliveryDate")); var fakePropertyDefinition1 = PropertyDefinitionObjectMother.CreateForFakePropertyInfo(classDefinition, "P1"); var fakePropertyDefinition2 = PropertyDefinitionObjectMother.CreateForFakePropertyInfo(classDefinition, "P2"); _mappingObjectFactoryMock .Expect(mock => mock.CreatePropertyDefinition(classDefinition, propertyInfo1)) .Return(fakePropertyDefinition1); _mappingObjectFactoryMock .Expect(mock => mock.CreatePropertyDefinition(classDefinition, propertyInfo2)) .Return(fakePropertyDefinition2); _mappingObjectFactoryMock.Replay(); var result = _factory.CreatePropertyDefinitions(classDefinition, new[] { propertyInfo1, propertyInfo2 }); _mappingObjectFactoryMock.VerifyAllExpectations(); Assert.That(result.Count, Is.EqualTo(2)); Assert.That(result[0], Is.SameAs(fakePropertyDefinition1)); Assert.That(result[1], Is.SameAs(fakePropertyDefinition2)); }
public void CreateRelationEndPointDefinitionCollection() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(OrderTicket)); var propertyDefinition = PropertyDefinitionObjectMother.CreateForFakePropertyInfo_ObjectID(classDefinition); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection(new[] { propertyDefinition }, true)); var fakeRelationEndPoint = new RelationEndPointDefinition(propertyDefinition, false); var expectedPropertyInfo = PropertyInfoAdapter.Create(typeof(OrderTicket).GetProperty("Order")); _mappingObjectFactoryMock .Expect( mock => mock.CreateRelationEndPointDefinition( Arg.Is(classDefinition), Arg.Is(PropertyInfoAdapter.Create(expectedPropertyInfo.PropertyInfo)))) .Return(fakeRelationEndPoint); _mappingObjectFactoryMock.Replay(); var result = _factory.CreateRelationEndPointDefinitionCollection(classDefinition); _mappingObjectFactoryMock.VerifyAllExpectations(); _memberInformationNameResolverMock.VerifyAllExpectations(); Assert.That(result.Count, Is.EqualTo(1)); Assert.That(result[0], Is.SameAs(fakeRelationEndPoint)); }
public ClassDefinition[] GetClassDefinitions() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition("Fake", typeof(Company)); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection()); classDefinition.SetDerivedClasses(new ClassDefinition[0]); return(new[] { classDefinition }); }
public void CreatePropertyDefinition() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Order), baseClass: null); var propertyInfo = PropertyInfoAdapter.Create(typeof(Order).GetProperty("OrderItems")); var result = _factory.CreatePropertyDefinition(classDefinition, propertyInfo); Assert.That(result, Is.Not.Null); Assert.That(result.PropertyInfo, Is.SameAs(propertyInfo)); }
public override void SetUp() { base.SetUp(); _classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(); _propertyInformationStub = MockRepository.GenerateStub <IPropertyInformation>(); _propertyInformationStub.Stub(stub => stub.Name).Return("Test"); _propertyInformationStub.Stub(stub => stub.DeclaringType).Return(TypeAdapter.Create(typeof(Order))); _propertyInformationStub.Stub(stub => stub.GetOriginalDeclaringType()).Return(TypeAdapter.Create(typeof(Order))); }
public void CreateRelationEndPointDefinition() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Order), baseClass: null); var propertyInfo = PropertyInfoAdapter.Create(typeof(Order).GetProperty("OrderItems")); var result = _factory.CreateRelationEndPointDefinition(classDefinition, propertyInfo); Assert.That(result, Is.TypeOf(typeof(VirtualRelationEndPointDefinition))); Assert.That(((VirtualRelationEndPointDefinition)result).PropertyInfo, Is.SameAs(propertyInfo)); }
public void ClassDefinitionsAreValidated() { var type = typeof(GenericTypeDomainObject <string>); var classDefinition = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(type); StubMockMappingLoaderWithValidation(new[] { classDefinition }, new RelationDefinition[0]); _mockRepository.ReplayAll(); new MappingConfiguration( _mockMappingLoader, new PersistenceModelLoader(new StorageGroupBasedStorageProviderDefinitionFinder(DomainObjectsConfiguration.Current.Storage))); }
public void GetMetadata_PersistentMixinFinder_ForDerivedClass() { ClassIDProviderStub.Stub(stub => stub.GetClassID(typeof(DerivedClassWithDifferentProperties))).Return("ClassID"); var classReflector = CreateClassReflector(typeof(DerivedClassWithDifferentProperties)); var baseClassDefinition = ClassDefinitionObjectMother.CreateClassDefinition_WithEmptyMembers_AndDerivedClasses(); var actual = classReflector.GetMetadata(baseClassDefinition); Assert.That(actual.PersistentMixinFinder.IncludeInherited, Is.False); }
public void GetOppositePropertyInfo_WithStorageClassNoneOppositeProperty() { var classType = typeof(TestDomain.RelationReflector.OppositePropertyHasStorageClassNoneAttribute.ClassWithOppositeProperty); var originatingClass = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(classType); var originatingProperty = PropertyInfoAdapter.Create(classType.GetProperty("OppositeProperty")); var relationReflector = CreateRelationReflector(originatingClass, originatingProperty); var oppositePropertyInfo = (IPropertyInformation)PrivateInvoke.InvokeNonPublicMethod(relationReflector, "GetOppositePropertyInfo"); Assert.That(oppositePropertyInfo, Is.Null); }
public void CreatePropertyDefinitionCollection() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Order), baseClass: null); var propertyInfo1 = PropertyInfoAdapter.Create(typeof(Order).GetProperty("OrderNumber")); var propertyInfo2 = PropertyInfoAdapter.Create(typeof(Order).GetProperty("DeliveryDate")); var result = _factory.CreatePropertyDefinitionCollection(classDefinition, new[] { propertyInfo1, propertyInfo2 }); Assert.That(result.Count, Is.EqualTo(2)); Assert.That(result[0].PropertyInfo, Is.SameAs(propertyInfo1)); Assert.That(result[1].PropertyInfo, Is.SameAs(propertyInfo2)); }
private static ClassDefinition CreateFileSystemItemDefinition_WithEmptyMembers_AndWithDerivedClasses() { var fileSystemItemClassDefinition = ClassDefinitionObjectMother.CreateClassDefinition("FileSystemItem", typeof(FileSystemItem)); var fileClassDefinition = ClassDefinitionObjectMother.CreateClassDefinition_WithEmptyMembers_AndDerivedClasses("File", typeof(File), fileSystemItemClassDefinition); var folderClassDefinition = ClassDefinitionObjectMother.CreateClassDefinition_WithEmptyMembers_AndDerivedClasses("Folder", typeof(Folder), fileSystemItemClassDefinition); fileSystemItemClassDefinition.SetDerivedClasses(new [] { fileClassDefinition, folderClassDefinition }); fileSystemItemClassDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection()); fileSystemItemClassDefinition.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); return(fileSystemItemClassDefinition); }
public void Initialize() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Order)); var propertyDefinition = PropertyDefinitionObjectMother.CreateForFakePropertyInfo_ObjectID(classDefinition); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection { propertyDefinition }); var endPoint = new RelationEndPointDefinition(propertyDefinition, true); Assert.That(endPoint.PropertyInfo, Is.SameAs(propertyDefinition.PropertyInfo)); }
public void CreateClassDefinition_WithBaseClass() { var companyClass = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(Company)); companyClass.SetPropertyDefinitions(new PropertyDefinitionCollection()); companyClass.SetRelationEndPointDefinitions(new RelationEndPointDefinitionCollection()); var result = _factory.CreateClassDefinition(typeof(Customer), companyClass); Assert.That(result, Is.Not.Null); Assert.That(result.ClassType, Is.SameAs(typeof(Customer))); Assert.That(result.InstanceCreator, Is.SameAs(_domainObjectCreator)); Assert.That(result.BaseClass, Is.SameAs(companyClass)); }
public void CreateForAllPropertyDefinitions_ClassDefinitionWithoutBaseClassDefinition_MakeCollectionReadOnlyIsTrue() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(); var propertyDefinition = PropertyDefinitionObjectMother.CreateForFakePropertyInfo(classDefinition); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection(new[] { propertyDefinition }, false)); var propertyDefinitions = PropertyDefinitionCollection.CreateForAllProperties(classDefinition, true); Assert.That(propertyDefinitions.Count, Is.EqualTo(1)); Assert.That(propertyDefinitions.IsReadOnly, Is.True); Assert.That(propertyDefinitions[0], Is.SameAs(propertyDefinition)); }
public void CreateRelationEndPointDefinitionCollection() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(OrderTicket), baseClass: null); var propertyDefinition = PropertyDefinitionObjectMother.CreateForRealPropertyInfo(classDefinition, typeof(OrderTicket), "Order"); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection(new[] { propertyDefinition }, true)); var result = _factory.CreateRelationEndPointDefinitionCollection(classDefinition); Assert.That(result.Count, Is.EqualTo(1)); Assert.That( ((RelationEndPointDefinition)result[0]).PropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.OrderTicket.Order")); }
public void GetClassDefinition_ValueFound() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(RelationEndPointPropertyClass)); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection()); classDefinition.SetDerivedClasses(Enumerable.Empty <ClassDefinition>()); StubMockMappingLoader(new[] { classDefinition }, _emptyRelationDefinitions); var persistenceModelLoaderStub = CreatePersistenceModelLoaderStub(); _mockRepository.ReplayAll(); var configuration = new MappingConfiguration(_mockMappingLoader, persistenceModelLoaderStub); Assert.That(configuration.GetClassDefinition(classDefinition.ID), Is.SameAs(classDefinition)); }
public void PersistenceModelIsLoaded_NoStorageEntityIsAppliedToTheRootClass() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition("Order", typeof(Order)); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection()); Assert.That(classDefinition.StorageEntityDefinition, Is.Null); var persistenceModelStub = MockRepository.GenerateStub <IPersistenceModelLoader>(); StubMockMappingLoader(new[] { classDefinition }, new RelationDefinition[0]); _mockRepository.ReplayAll(); new MappingConfiguration(_mockMappingLoader, persistenceModelStub); }
public void PropertyDefinitionsAreValidated() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(DerivedValidationDomainObjectClass)); var propertyDefinition = PropertyDefinitionObjectMother.CreateForRealPropertyInfo( classDefinition, typeof(DerivedValidationDomainObjectClass), "PropertyWithStorageClassNone"); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection(new[] { propertyDefinition }, true)); StubMockMappingLoaderWithValidation(new[] { classDefinition }, new RelationDefinition[0]); _mockRepository.ReplayAll(); new MappingConfiguration( _mockMappingLoader, new PersistenceModelLoader(new StorageGroupBasedStorageProviderDefinitionFinder(DomainObjectsConfiguration.Current.Storage))); }
public override void SetUp() { base.SetUp(); _customerClassDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Customer)); _customerOrdersEndPoint = VirtualRelationEndPointDefinitionFactory.Create( _customerClassDefinition, "Orders", false, CardinalityType.Many, typeof(OrderCollection), "OrderNumber desc"); _orderClassDefinition = CreateOrderDefinition_WithEmptyMembers_AndDerivedClasses(); }
public void GetMetadata_Mixed_PropertyAboveInheritanceRoot() { var classAboveInheritanceRoot = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(RelationTargetForPersistentMixinAboveInheritanceRoot)); CreateRelationReflectorForProperty( classAboveInheritanceRoot, typeof(RelationTargetForPersistentMixinAboveInheritanceRoot), "RelationProperty1"); var relationReflector = CreateRelationReflectorForProperty( _inheritanceRootInheritingMixinClassDefinition, typeof(MixinAddingPersistentPropertiesAboveInheritanceRoot), "PersistentRelationProperty"); _classDefinitions.Add(classAboveInheritanceRoot.ClassType, classAboveInheritanceRoot); Assert.That(relationReflector.GetMetadata(_classDefinitions), Is.Not.Null); }
public void GetClassDefinition_ForDerivedClass_WithDerivedClassAlreadyInClassDefinitionCollection() { var existing = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(Order)); _classDefinitions.Add(existing.ClassType, existing); _mappingObjectFactoryMock.Replay(); var actual = _classDefinitionCollectionFactory.GetClassDefinition(_classDefinitions, typeof(Order)); _mappingObjectFactoryMock.VerifyAllExpectations(); Assert.That(actual, Is.Not.Null); Assert.That(_classDefinitions.Count, Is.EqualTo(1)); Assert.That(_classDefinitions[typeof(Order)], Is.SameAs(actual)); Assert.That(actual, Is.SameAs(existing)); }
public override void SetUp() { base.SetUp(); _classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(); var propertyDefinition1 = PropertyDefinitionObjectMother.CreateForFakePropertyInfo_ObjectID(_classDefinition, "Property1"); var propertyDefinition2 = PropertyDefinitionObjectMother.CreateForFakePropertyInfo_ObjectID(_classDefinition, "Property2"); var propertyDefinition3 = PropertyDefinitionObjectMother.CreateForFakePropertyInfo_ObjectID(_classDefinition, "Property3"); var propertyDefinition4 = PropertyDefinitionObjectMother.CreateForFakePropertyInfo_ObjectID(_classDefinition, "Property4"); _classDefinition.SetPropertyDefinitions( new PropertyDefinitionCollection(new[] { propertyDefinition1, propertyDefinition2, propertyDefinition3, propertyDefinition4 }, true)); _endPoint1 = new RelationEndPointDefinition(propertyDefinition1, false); _endPoint2 = new RelationEndPointDefinition(propertyDefinition2, false); _collection = new RelationEndPointDefinitionCollection(); }
public void GetClassDefinition_ForDerivedClass() { var fakeBaseClassDefinition = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(ClassWithDifferentProperties)); _mappingObjectFactoryMock .Expect(mock => mock.CreateClassDefinition(typeof(ClassWithDifferentProperties), null)) .Return(fakeBaseClassDefinition); _mappingObjectFactoryMock .Expect(mock => mock.CreateClassDefinition(typeof(DerivedClassWithDifferentProperties), fakeBaseClassDefinition)) .Return(_fakeClassDefinition); _mappingObjectFactoryMock.Replay(); var result = _classDefinitionCollectionFactory.GetClassDefinition(_classDefinitions, typeof(DerivedClassWithDifferentProperties)); _mappingObjectFactoryMock.VerifyAllExpectations(); Assert.That(result, Is.SameAs(_fakeClassDefinition)); }
public void RelationDefinitionsAreValidated() { var classDefinition = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(RelationEndPointPropertyClass)); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection()); var relationDefinition = FakeMappingConfiguration.Current.RelationDefinitions[ "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Order:" + "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Order.Customer->" + "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Customer.Orders"]; StubMockMappingLoaderWithValidation(new[] { classDefinition }, new[] { relationDefinition }); _mockRepository.ReplayAll(); new MappingConfiguration( _mockMappingLoader, new PersistenceModelLoader(new StorageGroupBasedStorageProviderDefinitionFinder(DomainObjectsConfiguration.Current.Storage))); }
public void CreateForAllPropertyDefinitions_ClassDefinitionWithBaseClassDefinition() { var baseClassDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Company)); var classDefinition = ClassDefinitionObjectMother.CreateClassDefinition(classType: typeof(Partner), baseClass: baseClassDefinition); var propertyDefinitionInBaseClass = PropertyDefinitionObjectMother.CreateForFakePropertyInfo(baseClassDefinition, "Property1"); var propertyDefinitionInDerivedClass = PropertyDefinitionObjectMother.CreateForFakePropertyInfo(classDefinition, "Property2"); baseClassDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection(new[] { propertyDefinitionInBaseClass }, true)); classDefinition.SetPropertyDefinitions(new PropertyDefinitionCollection(new[] { propertyDefinitionInDerivedClass }, true)); var propertyDefinitions = PropertyDefinitionCollection.CreateForAllProperties(classDefinition, false); Assert.That(propertyDefinitions.Count, Is.EqualTo(2)); Assert.That(propertyDefinitions[0], Is.SameAs(propertyDefinitionInDerivedClass)); Assert.That(propertyDefinitions[1], Is.SameAs(propertyDefinitionInBaseClass)); }