public void RelationToClassNotInMapping()
{
var endPoint1 = new VirtualRelationEndPointDefinition(
_derivedClassDefinition1,
"RelationProperty4",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(DerivedRelationEndPointPropertyClass1).GetProperty("RelationProperty4")));
var endPoint2 = new VirtualRelationEndPointDefinition(
_derivedClassDefinition2,
"RelationProperty4",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(DerivedRelationEndPointPropertyClass2).GetProperty("RelationProperty4")));
var relationDefinition = CreateRelationDefinitionAndSetBackReferences("Test", endPoint1, endPoint2);
var validationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"The type 'BaseRelationEndPointPropertyClass2' cannot be assigned to the type of the opposite relation propery 'RelationProperty4' declared "
+ "on type 'DerivedRelationEndPointPropertyClass1'.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Validation.Reflection."
+ "RelationEndPointTypesAreConsistentValidationRule.BaseRelationEndPointPropertyClass2\r\n"
+ "Property: RelationProperty4";
AssertMappingValidationResult(validationResult, false, expectedMessage);
}
private IDictionary <ObjectID, ILoadedObjectData> CorrelateRelatedObjects(
IEnumerable <LoadedObjectDataWithDataSourceData> relatedObjects,
VirtualRelationEndPointDefinition relationEndPointDefinition)
{
var relatedObjectsWithForeignKey = GetForeignKeysForVirtualEndPointDefinition(relatedObjects, relationEndPointDefinition);
var dictionary = new Dictionary <ObjectID, ILoadedObjectData>();
foreach (var tuple in relatedObjectsWithForeignKey.Where(tuple => tuple.Item1 != null))
{
try
{
dictionary.Add(tuple.Item1, tuple.Item2.LoadedObjectData);
}
catch (ArgumentException ex)
{
var message = string.Format(
"Two items in the related object result set point back to the same object. This is not allowed in a 1:1 relation. "
+ "Object 1: '{0}'. Object 2: '{1}'. Foreign key property: '{2}'",
dictionary[tuple.Item1].ObjectID,
tuple.Item2.LoadedObjectData.ObjectID,
relationEndPointDefinition.GetOppositeEndPointDefinition().PropertyName);
throw new InvalidOperationException(message, ex);
}
}
return(dictionary);
}
public void RelationDefinitionWithTypeNotFoundClassDefinition()
{
var classDefinition = new ClassDefinitionForUnresolvedRelationPropertyType(
"Test",
typeof(ClassOutOfInheritanceHierarchy),
PropertyInfoAdapter.Create(typeof(DerivedValidationDomainObjectClass).GetProperty("Property")));
var endPoint = new VirtualRelationEndPointDefinition(
classDefinition,
"RelationProperty",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(DerivedValidationDomainObjectClass).GetProperty("Property")));
var relationDefinition = new RelationDefinition("ID", endPoint, endPoint);
var validationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"The relation property 'Property' has return type 'String', which is not a part of the mapping. "
+ "Relation properties must not point to classes above the inheritance root.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Validation.DerivedValidationDomainObjectClass\r\n"
+ "Property: Property";
AssertMappingValidationResult(validationResult, false, expectedMessage);
}
public void OppositeRelationPropertyNameDoesNotMatch()
{
var endPointDefinition1 = new VirtualRelationEndPointDefinition(
_classDefinition1,
"RelationProperty3",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(RelationEndPointPropertyClass1).GetProperty("RelationProperty3")));
var endPointDefinition2 = new VirtualRelationEndPointDefinition(
_classDefinition2,
"RelationPopertyWithNonMatchingPropertyName",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(RelationEndPointPropertyClass2).GetProperty("RelationPopertyWithNonMatchingPropertyName")));
var relationDefinition = CreateRelationDefinitionAndSetBackReferences("Test", endPointDefinition1, endPointDefinition2);
var validationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"Opposite relation property 'RelationPopertyWithNonMatchingPropertyName' declared on type 'RelationEndPointPropertyClass2' "
+ "defines a 'DBBidirectionalRelationAttribute' whose opposite property does not match.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Validation.Reflection."
+ "RelationEndPointNamesAreConsistentValidationRule.RelationEndPointPropertyClass1\r\n"
+ "Property: RelationProperty3";
AssertMappingValidationResult(validationResult, false, expectedMessage);
}
public void PropertyInfo()
{
ClassDefinition employeeClassDefinition = MappingConfiguration.Current.GetTypeDefinition(typeof(Employee));
VirtualRelationEndPointDefinition relationEndPointDefinition =
(VirtualRelationEndPointDefinition)employeeClassDefinition.GetRelationEndPointDefinition(typeof(Employee) + ".Computer");
Assert.That(relationEndPointDefinition.PropertyInfo, Is.EqualTo(PropertyInfoAdapter.Create(typeof(Employee).GetProperty("Computer"))));
}
private ILookup <ObjectID, ILoadedObjectData> CorrelateRelatedObjects(
IEnumerable <LoadedObjectDataWithDataSourceData> relatedObjects,
VirtualRelationEndPointDefinition relationEndPointDefinition)
{
var relatedObjectsWithForeignKey = GetForeignKeysForVirtualEndPointDefinition(relatedObjects, relationEndPointDefinition);
return(relatedObjectsWithForeignKey.ToLookup(k => k.Item1, k => k.Item2.LoadedObjectData));
}
private IRelationEndPointDefinition CreateEquivalentEndPointDefinitionFake(VirtualRelationEndPointDefinition sourceEndPoint)
{
var invalidEndPoint = MockRepository.GenerateStub <IRelationEndPointDefinition> ();
invalidEndPoint.Stub(stub => stub.ClassDefinition).Return(sourceEndPoint.ClassDefinition);
invalidEndPoint.Stub(stub => stub.PropertyName).Return(sourceEndPoint.PropertyName);
return(invalidEndPoint);
}
public void ValidSortExpressionWithoutSortingDirection()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition, "Orders", false, CardinalityType.Many, "OrderNumber", MockRepository.GenerateStub <IPropertyInformation>());
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
endPointDefinition.SetRelationDefinition(relationDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public override void SetUp()
{
base.SetUp();
_customerClass = FakeMappingConfiguration.Current.TypeDefinitions[typeof(Customer)];
_customerToOrder =
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"];
_customerEndPoint = (VirtualRelationEndPointDefinition)_customerToOrder.EndPointDefinitions[0];
_orderEndPoint = (RelationEndPointDefinition)_customerToOrder.EndPointDefinitions[1];
}
public void BidirectionalRelation_PropertyTypeDomainObject()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"DomainObjectPropertyWithBidirectionalAttribute",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(RelationEndPointPropertyClass).GetProperty("DomainObjectPropertyWithBidirectionalAttribute")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public override void SetUp()
{
base.SetUp();
RelationDefinition customerToOrder = 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"];
_customerEndPoint = (VirtualRelationEndPointDefinition)customerToOrder.GetEndPointDefinition(
"Customer", "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Customer.Orders");
_orderEndPoint = (RelationEndPointDefinition)customerToOrder.GetEndPointDefinition(
"Order", "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Order.Customer");
}
public void NoCollectionProperty_ContainsForeignKeyIsTrue()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"NoCollectionProperty_ContainsForeignKey",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(ForeignKeyIsSupportedClass).GetProperty("NoCollectionProperty_ContainsForeignKey")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void PropertyWithNoDBBidirectionalRelationAttribute()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"PropertyWithNoDbBidirectionalRelationAttribute",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(ForeignKeyIsSupportedClass).GetProperty("PropertyWithNoDbBidirectionalRelationAttribute")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
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 TwoVirtualRelationEndPoint_OneEndPointIsAnonymous()
{
var anonymousEndPointDefinition = new AnonymousRelationEndPointDefinition(_orderClass);
var virtualEndPointDefinition = new VirtualRelationEndPointDefinition(
_orderClass, "OrderNumber", false, CardinalityType.One, "", PropertyInfoAdapter.Create(typeof(Order).GetProperty("OrderNumber")));
var relationDefinition = new RelationDefinition("Test", virtualEndPointDefinition, anonymousEndPointDefinition);
var mappingValidationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"Relation 'Test' cannot have two virtual end points.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Order\r\n"
+ "Property: OrderNumber\r\n"
+ "Relation ID: Test";
AssertMappingValidationResult(mappingValidationResult, false, expectedMessage);
}
public void RightEndPointIsAnonymous()
{
var endPointDefinition1 = new VirtualRelationEndPointDefinition(
_classDefinition1,
"RelationProperty2",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(RelationEndPointPropertyClass1).GetProperty("RelationProperty2")));
var endPointDefinition2 = new AnonymousRelationEndPointDefinition(_classDefinition2);
var relationDefinition = CreateRelationDefinitionAndSetBackReferences("Test", endPointDefinition1, endPointDefinition2);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void RightEndPointWithoutPropertyType()
{
var endPoint1 = new VirtualRelationEndPointDefinition(
_baseClassDefinition1,
"RelationProperty2",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(BaseRelationEndPointPropertyClass1).GetProperty("RelationProperty2")));
var endPoint2 = new PropertyNotFoundRelationEndPointDefinition(_baseClassDefinition2, "PropertyName");
var relationDefinition = CreateRelationDefinitionAndSetBackReferences("Test", endPoint1, endPoint2);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void TwoVirtualRelationEndPoints()
{
var virtualEndPointDefinition = new VirtualRelationEndPointDefinition(
_orderClass, "OrderNumber", false, CardinalityType.One, "", PropertyInfoAdapter.Create(typeof(Order).GetProperty("OrderNumber")));
var relationDefinition = new RelationDefinition("Test", virtualEndPointDefinition, virtualEndPointDefinition);
var mappingValidationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"The relation between property 'OrderNumber', declared on type 'Order', and property 'OrderNumber' declared on type "
+ "'Order', contains two virtual end points. One of the two properties must set 'ContainsForeignKey' to 'true' on the "
+ "'DBBidirectionalRelationAttribute'.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Order\r\n"
+ "Property: OrderNumber\r\n"
+ "Relation ID: Test";
AssertMappingValidationResult(mappingValidationResult, false, expectedMessage);
}
protected IEnumerable <Tuple <ObjectID, LoadedObjectDataWithDataSourceData> > GetForeignKeysForVirtualEndPointDefinition(
IEnumerable <LoadedObjectDataWithDataSourceData> loadedObjectData,
VirtualRelationEndPointDefinition virtualEndPointDefinition)
{
ArgumentUtility.CheckNotNull("loadedObjectData", loadedObjectData);
ArgumentUtility.CheckNotNull("virtualEndPointDefinition", virtualEndPointDefinition);
var oppositeEndPointDefinition = (RelationEndPointDefinition)virtualEndPointDefinition.GetOppositeEndPointDefinition();
return(from data in loadedObjectData
where !data.IsNull
let dataContainer = CheckRelatedObjectAndGetDataContainer(
data,
virtualEndPointDefinition,
oppositeEndPointDefinition)
let originatingObjectID = (ObjectID)dataContainer.GetValueWithoutEvents(oppositeEndPointDefinition.PropertyDefinition, ValueAccess.Current)
select Tuple.Create(originatingObjectID, data));
}
public void GetMetadata_BidirectionalOneToOne()
{
var propertyInfo = PropertyInfoAdapter.Create(_classType.GetProperty("BidirectionalOneToOne"));
var relationEndPointReflector = CreateRelationEndPointReflector(propertyInfo);
DomainModelConstraintProviderStub.Stub(stub => stub.IsNullable(propertyInfo)).Return(true);
IRelationEndPointDefinition actual = relationEndPointReflector.GetMetadata();
Assert.IsInstanceOf(typeof(VirtualRelationEndPointDefinition), actual);
VirtualRelationEndPointDefinition relationEndPointDefinition = (VirtualRelationEndPointDefinition)actual;
Assert.That(relationEndPointDefinition.ClassDefinition, Is.SameAs(_classDefinition));
Assert.That(relationEndPointDefinition.PropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.ReflectionBasedMappingSample.ClassWithVirtualRelationEndPoints.BidirectionalOneToOne"));
Assert.That(relationEndPointDefinition.PropertyInfo.PropertyType, Is.SameAs(typeof(ClassWithRealRelationEndPoints)));
Assert.That(relationEndPointDefinition.Cardinality, Is.EqualTo(CardinalityType.One));
Assert.That(relationEndPointDefinition.RelationDefinition, Is.Null);
DomainModelConstraintProviderStub.VerifyAllExpectations();
}
private DataContainerCollection LoadOppositeDataContainers(
RelationEndPointID relationEndPointID, VirtualRelationEndPointDefinition virtualEndPointDefinition)
{
var oppositeEndPointDefinition = virtualEndPointDefinition.GetOppositeEndPointDefinition();
var oppositeProvider =
_storageProviderManager.GetMandatory(oppositeEndPointDefinition.ClassDefinition.StorageEntityDefinition.StorageProviderDefinition.Name);
var oppositeDataContainers = oppositeProvider.LoadDataContainersByRelatedID(
(RelationEndPointDefinition)oppositeEndPointDefinition,
virtualEndPointDefinition.GetSortExpression(),
relationEndPointID.ObjectID);
var oppositeDataContainerCollection = new DataContainerCollection();
foreach (var oppositeDataContainer in oppositeDataContainers)
{
CheckClassIDForVirtualEndPoint(relationEndPointID, oppositeDataContainer);
oppositeDataContainerCollection.Add(oppositeDataContainer);
}
return(oppositeDataContainerCollection);
}
public void NoBidirectionalRelation_PropertyTypeNoDomainObject()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"PropertyWithoutBidirectionalAttribute",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(RelationEndPointPropertyClass).GetProperty("PropertyWithoutBidirectionalAttribute")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"The property type of an uni-directional relation property must be assignable to 'DomainObject'.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Validation.Reflection."
+ "RelationEndPointPropertyTypeIsSupportedValidationRule.RelationEndPointPropertyClass\r\n"
+ "Property: PropertyWithoutBidirectionalAttribute";
AssertMappingValidationResult(validationResult, false, expectedMessage);
}
public void GetMetadata_BidirectionalOneToMany()
{
DomainModelConstraintProviderStub
.Stub(stub => stub.IsNullable(Arg <IPropertyInformation> .Matches(pi => pi.Name == "BaseBidirectionalOneToMany")))
.Return(true);
var propertyInfo = PropertyInfoAdapter.Create(_classType.GetProperty("BaseBidirectionalOneToMany"));
var relationEndPointReflector = CreateRelationEndPointReflector(propertyInfo);
IRelationEndPointDefinition actual = relationEndPointReflector.GetMetadata();
Assert.IsInstanceOf(typeof(VirtualRelationEndPointDefinition), actual);
VirtualRelationEndPointDefinition relationEndPointDefinition = (VirtualRelationEndPointDefinition)actual;
Assert.That(relationEndPointDefinition.ClassDefinition, Is.SameAs(_classDefinition));
Assert.That(relationEndPointDefinition.PropertyName, Is.EqualTo("Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.ReflectionBasedMappingSample.ClassWithOneSideRelationPropertiesNotInMapping.BaseBidirectionalOneToMany"));
Assert.That(relationEndPointDefinition.PropertyInfo.PropertyType, Is.SameAs(typeof(ObjectList <ClassWithRealRelationEndPoints>)));
Assert.That(relationEndPointDefinition.Cardinality, Is.EqualTo(CardinalityType.Many));
Assert.That(relationEndPointDefinition.RelationDefinition, Is.Null);
Assert.That(relationEndPointDefinition.SortExpressionText, Is.EqualTo("NoAttribute"));
}
public void CollectionProperty_ContainsForeignKeyIsTrue_BothEndPoints()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"CollectionProperty_ContainsForeignKey",
false,
CardinalityType.One,
null,
PropertyInfoAdapter.Create(typeof(ForeignKeyIsSupportedClass).GetProperty("CollectionProperty_ContainsForeignKey")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"Only relation end points with a property type of 'DomainObject' can contain the foreign key.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Validation.Reflection."
+ "ForeignKeyIsSupportedForCardinalityOfRelationPropertyValidationRule.ForeignKeyIsSupportedClass\r\n"
+ "Property: CollectionProperty_ContainsForeignKey";
AssertMappingValidationResult(validationResult, false, expectedMessage);
}
public void InvalidSortExpression()
{
var endPointDefinition = new VirtualRelationEndPointDefinition(
_classDefinition,
"Orders",
false,
CardinalityType.Many,
"Test",
PropertyInfoAdapter.Create(typeof(Customer).GetProperty("Orders")));
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
endPointDefinition.SetRelationDefinition(relationDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
var expectedMessage =
"SortExpression 'Test' cannot be parsed: 'Test' is not a valid mapped property name. Expected the .NET property name of a property "
+ "declared by the 'Order' class or its base classes. Alternatively, to resolve ambiguities or to use a property declared by a mixin "
+ "or a derived class of 'Order', the full unique re-store property identifier can be specified.\r\n\r\n"
+ "Declaring type: Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Customer\r\nProperty: Orders";
AssertMappingValidationResult(validationResult, false, expectedMessage);
}
