public MappingValidationResult Validate(RelationDefinition relationDefinition)
{
ArgumentUtility.CheckNotNull("relationDefinition", relationDefinition);
foreach (var endPointDefinition in relationDefinition.EndPointDefinitions)
{
if (endPointDefinition is PropertyNotFoundRelationEndPointDefinition)
{
return(MappingValidationResult.CreateInvalidResultForType(
endPointDefinition.ClassDefinition.ClassType,
"Property '{0}' on class '{1}' could not be found.",
endPointDefinition.PropertyName,
endPointDefinition.ClassDefinition.ClassType.Name));
}
else if (endPointDefinition is TypeNotObjectIDRelationEndPointDefinition)
{
return(MappingValidationResult.CreateInvalidResultForType(
endPointDefinition.ClassDefinition.ClassType,
"Relation property '{0}' on class '{1}' is of type '{2}', but non-virtual relation properties must be of type '{3}'.",
endPointDefinition.PropertyName,
endPointDefinition.ClassDefinition.ClassType.Name,
endPointDefinition.PropertyInfo.PropertyType.Name,
typeof(ObjectID).Name));
}
}
return(MappingValidationResult.CreateValidResult());
}
public void GetMetadata_WithRealRelationEndPoint_BidirectionalOneToOne_CheckEndPoint1()
{
EnsurePropertyDefinitionExisitsOnClassDefinition(
_classWithRealRelationEndPoints, typeof(ClassWithRealRelationEndPoints), "BidirectionalOneToOne");
EnsurePropertyDefinitionExisitsOnClassDefinition(
_classWithVirtualRelationEndPoints, typeof(ClassWithVirtualRelationEndPoints), "BidirectionalOneToOne");
var relationReflector = CreateRelationReflector(
_classWithRealRelationEndPoints,
typeof(ClassWithRealRelationEndPoints),
"BidirectionalOneToOne");
RelationDefinition actualRelationDefinition = relationReflector.GetMetadata(_classDefinitions);
Assert.That(actualRelationDefinition.EndPointDefinitions[1], Is.InstanceOf(typeof(VirtualRelationEndPointDefinition)));
var oppositeEndPointDefinition =
(VirtualRelationEndPointDefinition)actualRelationDefinition.EndPointDefinitions[1];
Assert.That(oppositeEndPointDefinition.ClassDefinition, Is.SameAs(_classWithVirtualRelationEndPoints));
Assert.That(
oppositeEndPointDefinition.PropertyName,
Is.EqualTo(
"Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.ReflectionBasedMappingSample.ClassWithVirtualRelationEndPoints.BidirectionalOneToOne"));
Assert.That(oppositeEndPointDefinition.PropertyInfo.PropertyType, Is.SameAs(typeof(ClassWithRealRelationEndPoints)));
}
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 override MappingValidationResult Validate(RelationDefinition relationDefinition)
{
ArgumentUtility.CheckNotNull("relationDefinition", relationDefinition);
var endPointDefinition1 = relationDefinition.EndPointDefinitions[0];
var endPointDefinition2 = relationDefinition.EndPointDefinitions[1];
if (IsInvalidEndPointDefinition(endPointDefinition1) || IsInvalidEndPointDefinition(endPointDefinition2))
{
return(MappingValidationResult.CreateValidResult());
}
if (endPointDefinition1.IsAnonymous && endPointDefinition2.IsAnonymous)
{
return(MappingValidationResult.CreateInvalidResult("Relation '{0}' cannot have two anonymous end points.", relationDefinition.ID));
}
if (endPointDefinition1.IsVirtual && endPointDefinition2.IsVirtual)
{
var endPointDefinition1AsVirtualRelationEndPointDefinition = endPointDefinition1 as VirtualRelationEndPointDefinition;
var endPointDefinition2AsVirtualRelationEndPointDefinition = endPointDefinition2 as VirtualRelationEndPointDefinition;
if (endPointDefinition1AsVirtualRelationEndPointDefinition != null && endPointDefinition2AsVirtualRelationEndPointDefinition != null)
{
return(MappingValidationResult.CreateInvalidResultForRelation(
relationDefinition.ID,
endPointDefinition1.PropertyInfo,
"The relation between property '{0}', declared on type '{1}', and property '{2}' declared on type '{3}', contains two virtual end points. "
+ "One of the two properties must set 'ContainsForeignKey' to 'true' on the '{4}'.",
endPointDefinition1.PropertyInfo.Name,
endPointDefinition1.ClassDefinition.ClassType.Name,
endPointDefinition2.PropertyInfo.Name,
endPointDefinition2.ClassDefinition.ClassType.Name,
typeof(DBBidirectionalRelationAttribute).Name));
}
else
{
return(MappingValidationResult.CreateInvalidResultForRelation(
relationDefinition.ID,
endPointDefinition1.PropertyInfo,
"Relation '{0}' cannot have two virtual end points.",
relationDefinition.ID));
}
}
if (!endPointDefinition1.IsVirtual && !endPointDefinition2.IsVirtual)
{
return(MappingValidationResult.CreateInvalidResultForRelation(
relationDefinition.ID,
endPointDefinition1.PropertyInfo,
"The relation between property '{0}', declared on type '{1}', and property '{2}' declared on type '{3}', contains two non-virtual end points. "
+ "One of the two properties must set 'ContainsForeignKey' to 'false' on the '{4}'.",
endPointDefinition1.PropertyInfo.Name,
endPointDefinition1.ClassDefinition.ClassType.Name,
endPointDefinition2.PropertyInfo.Name,
endPointDefinition2.ClassDefinition.ClassType.Name,
typeof(DBBidirectionalRelationAttribute).Name));
}
return(MappingValidationResult.CreateValidResult());
}
private RelationDefinition ReadDefinition()
{
var versionPath = Path.Combine("Definitions", "game.ver");
if (!File.Exists(versionPath))
{
throw new InvalidOperationException("Definitions\\game.ver must exist.");
}
var version = File.ReadAllText(versionPath).Trim();
var def = new RelationDefinition()
{
Version = version
};
foreach (var sheetFileName in Directory.EnumerateFiles("Definitions", "*.json"))
{
var json = File.ReadAllText(Path.Combine(sheetFileName), Encoding.UTF8);
var obj = JsonConvert.DeserializeObject <Newtonsoft.Json.Linq.JObject>(json);
var sheetDef = SheetDefinition.FromJson(obj);
def.SheetDefinitions.Add(sheetDef);
if (!_GameData.SheetExists(sheetDef.Name))
{
var msg = $"Defined sheet {sheetDef.Name} is missing.";
Debug.WriteLine(msg);
Console.WriteLine(msg);
}
}
return(def);
}
private void CheckEndPointDefinitions(RelationDefinition expectedRelationDefinition, RelationDefinition actualRelationDefinition)
{
foreach (IRelationEndPointDefinition expectedEndPointDefinition in expectedRelationDefinition.EndPointDefinitions)
{
IRelationEndPointDefinition actualEndPointDefinition = actualRelationDefinition.GetEndPointDefinition(
expectedEndPointDefinition.ClassDefinition.ID, expectedEndPointDefinition.PropertyName);
Assert.IsNotNull(
actualEndPointDefinition,
"End point definition was not found (relation definition: '{0}', class: '{1}', property name: '{2}').",
expectedRelationDefinition.ID,
expectedEndPointDefinition.ClassDefinition.ID,
expectedEndPointDefinition.PropertyName);
var endPointDefinitionChecker = new RelationEndPointDefinitionChecker();
endPointDefinitionChecker.Check(expectedEndPointDefinition, actualEndPointDefinition, true);
Assert.AreSame(
actualRelationDefinition,
actualEndPointDefinition.RelationDefinition,
"End point definition does not reference the correct relation definition (relation definition: '{0}', class: '{1}', property name: '{2}').",
actualRelationDefinition.ID,
actualEndPointDefinition.ClassDefinition.ID,
actualEndPointDefinition.PropertyName);
}
}
private bool TryGetDefinitionVersion(ZipFile zip, string version, out RelationDefinition definition, out DateTime lastMod)
{
var storedVersionEntry = zip[VersionFile];
string storedVersion;
using (var s = storedVersionEntry.OpenReader()) {
using (var r = new StreamReader(s))
storedVersion = r.ReadToEnd();
}
if (storedVersion != version)
{
var existingDefPath = string.Format("{0}/{1}", version, DefinitionFile);
if (zip.ContainsEntry(existingDefPath))
{
ZipCopy(zip, existingDefPath, DefinitionFile);
UpdateVersion(zip);
zip.Save();
definition = ReadDefinition(zip, DefinitionFile, out lastMod);
return(true);
}
definition = null;
lastMod = DateTime.MinValue;
return(false);
}
definition = ReadDefinition(zip, DefinitionFile, out lastMod);
return(true);
}
/// <summary>
/// Serialize a <see cref="RelationDefinition" /> into a <see cref="ZipFile" />.
/// </summary>
/// <param name="zip"><see cref="ZipFile" /> to write to.</param>
/// <param name="definition"><see cref="RelationDefinition" /> to store.</param>
/// <param name="path">File name inside the storage to write to.</param>
private static void StoreDefinition(ZipFile zip, RelationDefinition definition, string path)
{
var obj = definition.ToJson();
var json = Newtonsoft.Json.JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented);
zip.UpdateEntry(path, json);
}
public bool HasSimilarRelationM2M(RelationDefinition relation)
{
return(_relations.OfType <RelationDefinition>().Any(item =>
relation != item && (
(item.Left.Entity.Identifier == relation.Left.Entity.Identifier && item.Right.Entity.Identifier == relation.Right.Entity.Identifier) ||
(item.Left.Entity.Identifier == relation.Right.Entity.Identifier && item.Right.Entity.Identifier == relation.Left.Entity.Identifier))
));
}
public void EndPointDefinitionsAreReturnedAsReadOnlyCollection()
{
RelationDefinition relation = new RelationDefinition("RelationID", _customerEndPoint, _orderEndPoint);
Assert.That(relation.EndPointDefinitions.Length, Is.EqualTo(2));
Assert.That(relation.EndPointDefinitions[0], Is.SameAs(_customerEndPoint));
Assert.That(relation.EndPointDefinitions[1], Is.SameAs(_orderEndPoint));
}
protected RelationDefinition CreateRelationDefinitionAndSetBackReferences(string id, IRelationEndPointDefinition endPointDefinition1, IRelationEndPointDefinition endPointDefinition2)
{
var relationDefinition = new RelationDefinition(id, endPointDefinition1, endPointDefinition2);
endPointDefinition1.SetRelationDefinition(relationDefinition);
endPointDefinition2.SetRelationDefinition(relationDefinition);
return(relationDefinition);
}
public void IsEndPoint()
{
RelationDefinition relation = new RelationDefinition("myRelation", _customerEndPoint, _orderEndPoint);
Assert.That(relation.IsEndPoint("Order", "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Order.Customer"), Is.True);
Assert.That(relation.IsEndPoint("Customer", "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Customer.Orders"), Is.True);
Assert.That(relation.IsEndPoint("Order", "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Customer.Orders"), Is.False);
Assert.That(relation.IsEndPoint("Customer", "Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Order.Customer"), Is.False);
}
public void Check(RelationDefinition expectedDefinition, RelationDefinition actualDefinition)
{
ArgumentUtility.CheckNotNull("expectedDefinition", expectedDefinition);
ArgumentUtility.CheckNotNull("actualDefinition", actualDefinition);
Assert.AreEqual(expectedDefinition.ID, actualDefinition.ID, "IDs of relation definitions do not match.");
CheckEndPointDefinitions(expectedDefinition, actualDefinition);
}
public void NoVirtualRelationEndPointDefinition()
{
var endPointDefinition = new AnonymousRelationEndPointDefinition(_classDefinition);
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void SetRelationDefinition()
{
var endPoint = new AnonymousRelationEndPointDefinition(_classDefinition);
var relationDefinition = new RelationDefinition("Test", endPoint, endPoint);
_invalidEndPointDefinition.SetRelationDefinition(relationDefinition);
Assert.That(_invalidEndPointDefinition.RelationDefinition, Is.SameAs(relationDefinition));
}
/// <summary>
/// Serialize a <see cref="RelationDefinition" /> into a <see cref="ZipFile" />.
/// </summary>
/// <param name="zip"><see cref="ZipFile" /> to write to.</param>
/// <param name="definition"><see cref="RelationDefinition" /> to store.</param>
/// <param name="path">File name inside the storage to write to.</param>
private static void StoreDefinition(ZipFile zip, RelationDefinition definition, string path)
{
using (var ms = new MemoryStream()) {
using (var writer = new StreamWriter(ms, ZipEncoding)) {
definition.Serialize(writer);
writer.Flush();
zip.UpdateEntry(path, ms.ToArray());
}
}
}
public void CardinalityIsOne_And_EndPointDefinitionHasNoSortExpression()
{
var endPointDefinition = VirtualRelationEndPointDefinitionFactory.Create(
_classDefinition, "PropertyName", false, CardinalityType.One, typeof(DerivedValidationDomainObjectClass), null);
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public override void SetUp()
{
base.SetUp();
_relation = FakeMappingConfiguration.Current.RelationDefinitions[
"Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Location:Remotion.Data.DomainObjects.UnitTests.Mapping."
+ "TestDomain.Integration.Location.Client"];
_clientEndPoint = (AnonymousRelationEndPointDefinition)_relation.EndPointDefinitions[0];
_locationEndPoint = (RelationEndPointDefinition)_relation.EndPointDefinitions[1];
}
public void TypeNotObjectIDRelationEndPointDefinition_RightEndPoint()
{
var anonymousEndPointDefinition = new AnonymousRelationEndPointDefinition(_orderClass);
var invalidRelationEndPointDefinition = new TypeNotObjectIDRelationEndPointDefinition(_orderClass, "Invalid", typeof(string));
var relationDefinition = new RelationDefinition("Test", anonymousEndPointDefinition, invalidRelationEndPointDefinition);
var mappingValidationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(mappingValidationResult, true, null);
}
public void PropertyNotFoundRelationEndPointDefinition_RightEndPoint()
{
var anonymousEndPointDefinition = new AnonymousRelationEndPointDefinition(_orderClass);
var invalidRelationEndPointDefinition = new PropertyNotFoundRelationEndPointDefinition(_orderClass, "Invalid");
var relationDefinition = new RelationDefinition("Test", anonymousEndPointDefinition, invalidRelationEndPointDefinition);
var mappingValidationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(mappingValidationResult, true, null);
}
public void RelationDefinitionWithNoTypeNotFoundClassDefinition()
{
var classDefinition = ClassDefinitionObjectMother.CreateClassDefinitionWithMixins(typeof(DerivedValidationDomainObjectClass));
var endPoint = new AnonymousRelationEndPointDefinition(classDefinition);
var relationDefinition = new RelationDefinition("ID", endPoint, endPoint);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void CardinalityIsMany()
{
var endPointDefinition = VirtualRelationEndPointDefinitionFactory.Create(
_classDefinition, "PropertyName", false, CardinalityType.Many, typeof(DomainObjectCollection), null);
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void VirtualRelationEndPointDefinitionWithCardinalityOne_And_PropertyTypeDerivedFromDomainObject()
{
var endPointDefinition = VirtualRelationEndPointDefinitionFactory.Create(
_classDefinition, "PropertyName", false, CardinalityType.One, typeof(BaseOfBaseValidationDomainObjectClass), null);
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void SetUp()
{
_relationDefinition1 = CreateRelationDefinition("RelationDefinition1");
_relationDefinition2 = CreateRelationDefinition("RelationDefinition2");
_relationDefinition3 = CreateRelationDefinition("RelationDefinition3");
_validationRuleMock = MockRepository.GenerateStrictMock <IRelationDefinitionValidatorRule> ();
_fakeValidMappingValidationResult = MappingValidationResult.CreateValidResult();
_fakeInvalidMappingValidationResult = MappingValidationResult.CreateInvalidResult("Test");
}
private void NormalizeRelationAccessors(RelationDefinitionBase relation,
string searchedName, EntityDefinition rdbEntity)
{
if (string.IsNullOrEmpty(searchedName))
{
return;
}
var q1 =
from r in Model.GetActiveRelations().OfType <SelfRelationDefinition>()
where r != relation && r.Entity.Identifier == rdbEntity.Identifier &&
(r.Left.AccessorName == searchedName || r.Right.AccessorName == searchedName)
select r as RelationDefinitionBase;
var q2 =
from r in Model.GetActiveRelations().OfType <RelationDefinition>()
where r != relation &&
(r.Right.Entity.Identifier == rdbEntity.Identifier &&
r.Left.AccessorName == searchedName) ||
(r.Left.Entity.Identifier == rdbEntity.Identifier &&
r.Right.AccessorName == searchedName)
select r as RelationDefinitionBase;
int i = 0;
foreach (RelationDefinitionBase r in q1.Union(q2))
{
i++;
RelationDefinition rd = r as RelationDefinition;
SelfRelationDefinition srd = r as SelfRelationDefinition;
if (srd != null)
{
if (srd.Left.AccessorName == searchedName)
{
srd.Left.AccessorName += i.ToString();
}
else if (srd.Right.AccessorName == searchedName)
{
srd.Right.AccessorName += i.ToString();
}
}
else if (rd != null)
{
if (rd.Left.AccessorName == searchedName)
{
rd.Left.AccessorName += i.ToString();
}
else if (rd.Right.AccessorName == searchedName)
{
rd.Right.AccessorName += i.ToString();
}
}
}
}
public void SetRelationDefinition()
{
var propertyDefinition = MappingConfiguration.Current.GetTypeDefinition(typeof(Location))
["Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Location.Client"];
var oppositeEndPoint = new RelationEndPointDefinition(propertyDefinition, true);
var relationDefinition = new RelationDefinition("Remotion.Data.DomainObjects.UnitTests.Mapping.TestDomain.Integration.Location.Client", _definition, oppositeEndPoint);
_definition.SetRelationDefinition(relationDefinition);
Assert.That(_definition.RelationDefinition, Is.Not.Null);
}
public void PropertyTypeIsSubclassOfDomainObject()
{
var propertyType = typeof(BaseOfBaseValidationDomainObjectClass);
var endPointDefinition =
VirtualRelationEndPointDefinitionFactory.Create(_classDefinition, "Property", false, CardinalityType.One, propertyType);
var relationDefinition = new RelationDefinition("Test", endPointDefinition, endPointDefinition);
var validationResult = _validationRule.Validate(relationDefinition);
AssertMappingValidationResult(validationResult, true, null);
}
public void Contains()
{
RelationDefinition relation = new RelationDefinition("myRelation", _customerEndPoint, _orderEndPoint);
Assert.That(relation.Contains(_orderEndPoint), Is.True);
Assert.That(relation.Contains(_customerEndPoint), Is.True);
var invalidEndPoint = CreateEquivalentEndPointDefinitionFake(_customerEndPoint);
Assert.That(relation.Contains(invalidEndPoint), Is.False);
}
public void TwoAnonymousRelationEndPoints()
{
var anonymousEndPointDefinition = new AnonymousRelationEndPointDefinition(_orderClass);
var relationDefinition = new RelationDefinition("Test", anonymousEndPointDefinition, anonymousEndPointDefinition);
var mappingValidationResult = _validationRule.Validate(relationDefinition);
var expectedMessage = "Relation 'Test' cannot have two anonymous end points.";
AssertMappingValidationResult(mappingValidationResult, false, expectedMessage);
}
public void SetUp()
{
_validationRule = new RdbmsRelationEndPointCombinationIsSupportedValidationRule();
_orderClass = FakeMappingConfiguration.Current.TypeDefinitions[typeof(Order)];
_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"];
}
