public void Test_Map_WhenSingleRelationshipToSubClass_WhenIDPropDeclaredInClassDefXml_ShouldSetRelatedPropToNonStandardID_FixBug1355()
{
//---------------Set up test pack-------------------
var superClassDef = SuperClassWithPKFromClassDef.LoadClassDef();//Loaded from XML
var defCol = new ClassDefCol {
superClassDef
};
var subClassWithPKFromClassDef = typeof(SubClassWithPKFromClassDef);
var relatedToSubClassWithPKFromClassDefType = typeof(RelatedToSubClassWithPKFromClassDef);
var source = new FakeTypeSource(new[] { subClassWithPKFromClassDef, relatedToSubClassWithPKFromClassDefType });
AllClassesAutoMapper.ClassDefCol = defCol;
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var relatedToSubClassWithPKFromClassDef = classDefCol.FindByClassName(relatedToSubClassWithPKFromClassDefType.Name);
Assert.AreEqual(1, relatedToSubClassWithPKFromClassDef.RelationshipDefCol.Count);
var subClassWithPKFromClassDefRelDef = relatedToSubClassWithPKFromClassDef.RelationshipDefCol["SubClassWithPKFromClassDefSingleRel"];
Assert.AreEqual(1, subClassWithPKFromClassDefRelDef.RelKeyDef.Count, "Should have a non composite Key");
var relPropDef = subClassWithPKFromClassDefRelDef.RelKeyDef.FirstOrDefault();
Assert.AreEqual("SubClassWithPKFromClassDefSingleRelID", relPropDef.OwnerPropertyName);
Assert.AreEqual("MYPKID", relPropDef.RelatedClassPropName);
}
public void Test_Map_WhenInheritanceWithNonStandardIDProp_ShouldMapWithCorrectNonStandardIDProp()
{
//---------------Set up test pack-------------------
var subClassWithNonStdID = typeof(SubClassWithNonStandardID);
var superClassWithNonStdID = typeof(SuperClassWithNonStandardID);
var source = new FakeTypeSource(new[] { subClassWithNonStdID, superClassWithNonStdID });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreSame(superClassWithNonStdID, subClassWithNonStdID.BaseType);
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefCol.Count);
classDefCol.ShouldContain(def => def.ClassName == subClassWithNonStdID.Name, "Should contain SubClass");
classDefCol.ShouldContain(def => def.ClassName == superClassWithNonStdID.Name, "Should Contain SuperClass");
var subClassDef = classDefCol.FindByClassName(subClassWithNonStdID.Name);
Assert.IsNull(subClassDef.PrimaryKeyDef);
var superClassDef = classDefCol.FindByClassName(superClassWithNonStdID.Name);
Assert.IsNotNull(superClassDef.PrimaryKeyDef);
Assert.AreEqual(1, superClassDef.PrimaryKeyDef.Count, "The PrimaryKey (ObjectID) Should not be composite");
var propDef = superClassDef.PrimaryKeyDef[0];
Assert.AreEqual("NonStandardID", propDef.PropertyName);
}
public void Test_CreateRevRelationship_WhenIsOneToOne_ShouldCreateSingleRevRel()
{
//---------------Set up test pack-------------------
var singleRelationshipDef = new FakeSingleRelationshipDef();
singleRelationshipDef.SetAsOneToOne();
IClassDef cDefWith121 = typeof(FakeBoNoProps).MapClass();
ClassDefCol classDefCol = new ClassDefCol {
cDefWith121
};
//---------------Assert Precondition----------------
Assert.IsTrue(singleRelationshipDef.IsOneToOne);
//---------------Execute Test ----------------------
IRelationshipDef reverseRelDef = AllClassesAutoMapper.CreateReverseRelationship(classDefCol, cDefWith121, singleRelationshipDef);
//---------------Test Result -----------------------
Assert.AreEqual(singleRelationshipDef.ReverseRelationshipName, reverseRelDef.RelationshipName);
Assert.AreEqual(singleRelationshipDef.RelationshipName, reverseRelDef.ReverseRelationshipName);
Assert.IsInstanceOf(typeof(SingleRelationshipDef), reverseRelDef);
Assert.AreEqual(RelationshipType.Association, reverseRelDef.RelationshipType);
Assert.AreEqual(DeleteParentAction.DoNothing, reverseRelDef.DeleteParentAction);
Assert.IsTrue(reverseRelDef.OwningBOHasForeignKey);
}
public void Test_Map_GivenTypeSourceProvidesSubClassBeforeSuperClass_WhenInheritance_ShouldCreateDiscriminatorPropInSuperClass()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClass);
var subClass = typeof(FakeBOSubClass);
var source = new FakeTypeSource(new[] { subClass, superClass });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(2);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
var discriminatorPropName = subClassDef.SuperClassDef.Discriminator;
var superClassProps = superClassDef.PropDefcol;
superClassProps.ShouldHaveCount(2);
superClassProps.ShouldContain(propDef => propDef.PropertyName == discriminatorPropName);
}
public void Test_Map_WhenNotHasRevRelDefined_AndIsOneToOne_ShouldCreateSingleRevRel()
{
//---------------Set up test pack-------------------
Type boWith12M = typeof(FakeBOWithOneToOneRel);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWith12M, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWith12M = classDefCol[boWith12M];
cDefWith12M.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWith12M.RelationshipDefCol.First();
Assert.IsInstanceOf(typeof(SingleRelationshipDef), relationshipDef);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
Assert.AreEqual(relationshipDef.ReverseRelationshipName, reverseRelDef.RelationshipName);
Assert.AreEqual(relationshipDef.RelationshipName, reverseRelDef.ReverseRelationshipName);
Assert.IsInstanceOf(typeof(SingleRelationshipDef), reverseRelDef);
Assert.AreEqual(RelationshipType.Association, reverseRelDef.RelationshipType);
Assert.AreEqual(DeleteParentAction.DoNothing, reverseRelDef.DeleteParentAction);
Assert.IsTrue(reverseRelDef.OwningBOHasForeignKey);
}
public void Test_Map_GivenTypeSourceProvidesSubClassBeforeSuperClass_WhenInheritanceAndHasRelationship_ShouldCreateCorrectRelPropDefs()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClass);
var subClass = typeof(FakeBOSubClassWithRelationships);
var source = new FakeTypeSource(new[] { subClass, superClass });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(2);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
subClassDef.PropDefcol.ShouldHaveCount(1, "Should have FK for MultipleRel Created");
superClassDef.PropDefcol.ShouldHaveCount(2, "Should have PK and Discriminator Created");
subClassDef.RelationshipDefCol.ShouldHaveCount(2, "Should have Multiple and single Rel");
var multipleRelDef = subClassDef.RelationshipDefCol.First(relationshipDef => relationshipDef.IsOneToMany);
var multipleRelPropDef = multipleRelDef.RelKeyDef.First();
Assert.AreEqual("FakeBOSuperClassID", multipleRelPropDef.OwnerPropertyName);
Assert.AreEqual("FakeBOSuperClassID", multipleRelPropDef.RelatedClassPropName);
var singleRelDef = subClassDef.RelationshipDefCol.First(relationshipDef => relationshipDef.IsManyToOne);
var singleRelPropDef = singleRelDef.RelKeyDef.First();
Assert.AreEqual("SingleRelID", singleRelPropDef.OwnerPropertyName);
Assert.AreEqual("FakeBoNoPropsID", singleRelPropDef.RelatedClassPropName);
}
public void Test_Map_WhenNotHasFKPropDefined_AndIsOneToMany_ShouldFKProp()
{
//---------------Set up test pack-------------------
Type boWith12M = typeof(FakeBOWithMultipleRel);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWith12M, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWith12M = classDefCol[boWith12M];
cDefWith12M.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWith12M.RelationshipDefCol.First();
Assert.IsInstanceOf(typeof(MultipleRelationshipDef), relationshipDef);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
IRelPropDef reverseRelPropDef = reverseRelDef.RelKeyDef.First();
cDefNoDefinedRel.PropDefcol.ShouldContain(propDef => propDef.PropertyName == reverseRelPropDef.OwnerPropertyName);
}
public void Test_Map_When2LayersOfInheritance_AndHasDiscriminatorProp_ShouldNotCreateDiscriminator()
{
//---------------Set up test pack-------------------
var superSuperClass = typeof(FakeBOSuperClassWithDesc);
var superClass = typeof(FakeBOSubClassSuperHasDesc);
var subClass = typeof(FakeBOSubSubClassSuperHasDesc);
var source = new FakeTypeSource(new[] { superSuperClass, superClass, subClass });
//---------------Assert Precondition----------------
Assert.AreEqual(3, source.GetTypes().Count());
//---------------Execute Test ----------------------
var allClassesAutoMapper = new AllClassesAutoMapper(source);
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var subClassDef = classDefCol.First(def => def.ClassName == "FakeBOSubSubClassSuperHasDesc");
var inheritanceDef = subClassDef.SuperClassDef;
var superClassClassDef = inheritanceDef.SuperClassClassDef;
var superSuperClassClassDef = superClassClassDef.SuperClassDef.SuperClassClassDef;
superClassClassDef.PropDefcol.ShouldHaveCount(0,
"No Properties Should be created for SuperClass since ID and Discriminator will be on SuperSuperClass");
var superSuperClassProps = superSuperClassClassDef.PropDefcol;
superSuperClassProps.ShouldHaveCount(2, "Discriminator and ID Prop should be created");
superSuperClassProps.ShouldContain(def => def.PropertyName == "FakeBOSuperClassWithDescType");
}
public void Test_Map_WhenSingleRelationshipToSubClass_WhenNonStandardIDProp_ShouldSetRelatedPropToNonStandardID_FixBug1355()
{
//---------------Set up test pack-------------------
var subClassWithNonStdID = typeof(SubClassWithNonStandardID);
var superClassWithNonStdID = typeof(SuperClassWithNonStandardID);
var relatedToSubClassWithNonStandardID = typeof(RelatedToSubClassWithNonStandardID);
var source = new FakeTypeSource(new[] { subClassWithNonStdID, superClassWithNonStdID, relatedToSubClassWithNonStandardID });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var relatedToSubClassWithNonStandardIDClassDef = classDefCol.FindByClassName(relatedToSubClassWithNonStandardID.Name);
Assert.AreEqual(1, relatedToSubClassWithNonStandardIDClassDef.RelationshipDefCol.Count);
var subClassWithNonStandardIDRelDef = relatedToSubClassWithNonStandardIDClassDef.RelationshipDefCol["SubClassWithNonStandardIDSingleRel"];
Assert.AreEqual(1, subClassWithNonStandardIDRelDef.RelKeyDef.Count, "Should have a non composite Key");
var relPropDef = subClassWithNonStandardIDRelDef.RelKeyDef.FirstOrDefault();
Assert.AreEqual("SubClassWithNonStandardIDSingleRelID", relPropDef.OwnerPropertyName);
Assert.AreEqual("NonStandardID", relPropDef.RelatedClassPropName);
}
public void Test_Map_GivenTypeSourceProvidesSubClassBeforeSuperClasses_When2LayersOfInheritance_ShouldMapInheritanceRelationships()
{
//---------------Set up test pack-------------------
var superSuperClass = typeof(FakeBOSuperClassWithDesc);
var superClass = typeof(FakeBOSubClassSuperHasDesc);
var subClass = typeof(FakeBOSubSubClassSuperHasDesc);
var source = new FakeTypeSource(new[] { subClass, superSuperClass, superClass });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(3, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(3);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
var superSuperClassDef = classDefCol.First(def => def.ClassType == superSuperClass);
Assert.AreEqual(superClassDef.ClassType, subClassDef.SuperClassDef.SuperClassClassDef.ClassType);
Assert.AreSame(superClassDef, subClassDef.SuperClassDef.SuperClassClassDef);
Assert.AreEqual(superSuperClassDef.ClassType, superClassDef.SuperClassDef.SuperClassClassDef.ClassType);
Assert.AreSame(superSuperClassDef, superClassDef.SuperClassDef.SuperClassClassDef);
}
public static IEnumerable <IClassDef> GetClassDefs()
{
var loadClassDefs = new ClassDefCol();
AllClassesAutoMapper.ClassDefCol = loadClassDefs;
var allClassesAutoMapper = new AllClassesAutoMapper(new AssemblyTypeSource(typeof(Car).Assembly));
allClassesAutoMapper.Map();
return(loadClassDefs);
}
public void Test_MapWhenHasAbstract_ShouldNotMap()
{
//---------------Set up test pack-------------------
FakeTypeSource source = new FakeTypeSource(typeof(FakeAbstractBoShouldNotBeLoaded));
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(1, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(0, classDefCol.Count);
}
public void TestAccept_LoadClassDefs_ShouldLoadAllClassDefs()
{
//---------------Set up test pack-------------------
ITypeSource source = new AssemblyTypeSource(typeof(FakeExtBoShouldBeLoaded));
IClassDefsLoader loader = new ReflectionClassDefLoader(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var defs = loader.LoadClassDefs();
//---------------Test Result -----------------------
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
var expectedDefs = allClassesAutoMapper.Map();
Assert.IsNotNull(defs);
defs.ShouldHaveCount(expectedDefs.Count);
defs.ShouldContain(expectedDefs, "Should contain all elements loaded via the mapper");
}
public void Test_MapWhenHasInterface_ShouldNotMap()
{
//---------------Set up test pack-------------------
FakeTypeSource source = new FakeTypeSource();
source.Add <IFakeBoInterfaceShouldNotBeLoaded>();
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(1, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(0, classDefCol.Count);
}
public void TestAccept_LoadClassDefs_ShouldLoadAllClassDefs()
{
//---------------Set up test pack-------------------
ITypeSource source = new AssemblyTypeSource(typeof(FakeExtBoShouldBeLoaded));
IClassDefsLoader loader = new ReflectionClassDefLoader(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var defs = loader.LoadClassDefs();
//---------------Test Result -----------------------
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
var expectedDefs = allClassesAutoMapper.Map();
Assert.IsNotNull(defs);
defs.ShouldHaveCount(expectedDefs.Count);
defs.ShouldContain(expectedDefs, "Should contain all elements loaded via the mapper");
}
public void Test_Map_WhenRelatedClassNotInClassDefCol_ShouldNotRaiseError()
{
//---------------Set up test pack-------------------
Type boWith12M = typeof(FakeBOWithMultipleRel);
FakeTypeSource source = new FakeTypeSource(
new[] { boWith12M });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(1, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(1);
}
public void TestAccept_Validate_WhenAllClassDefsLoaded_ShouldBeTrue()
{
//---------------Set up test pack-------------------
Func <TypeWrapper, bool> whereClause = type
=> (type.Namespace == "Habanero.Smooth.Test.ValidFakeBOs");
AppDomainTypeSource source = new AppDomainTypeSource(whereClause);
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
ClassDefCol classDefCol = allClassesAutoMapper.Map();
ClassDefValidator validator = new ClassDefValidator(new DefClassFactory());
//---------------Assert Precondition----------------
Assert.Greater(classDefCol.Count, 0);
//---------------Execute Test ----------------------
validator.ValidateClassDefs(classDefCol);
//---------------Test Result -----------------------
Assert.IsNotNull(classDefCol);
//Should Validate without Error if it gets here then it has validated
}
public void Test_Map_WhenHaveTwoClassesShouldMapBoth()
{
//---------------Set up test pack-------------------
Type type1 = typeof(FakeBOWithNoRelationship);
Type type2 = typeof(FakeBoNoProps);
FakeTypeSource source = new FakeTypeSource(
new[] { type1, type2 });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.IsNotNull(classDefCol);
Assert.AreEqual(2, classDefCol.Count);
classDefCol.ShouldContain(def => def.ClassName == type1.Name);
classDefCol.ShouldContain(def => def.ClassName == type2.Name);
}
public void Test_Map_GivenTypeSourceProvidesSubClassesBeforeSuperClass_WhenInheritanceWithMultipleDerivatives_ShouldSameSuperClass()
{
//---------------Set up test pack-------------------
var parentSuperClass = typeof(FakeBOSuperClass);
var parentSubClassA = typeof(FakeBOSubClass);
var parentSubClassB = typeof(FakeBOSubClassA);
var source = new FakeTypeSource(new[] { parentSubClassA, parentSubClassB, parentSuperClass });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(3, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(3);
Assert.AreSame(classDefCol[parentSubClassA].SuperClassClassDef, classDefCol[parentSuperClass]);
Assert.AreSame(classDefCol[parentSubClassB].SuperClassClassDef, classDefCol[parentSuperClass]);
Assert.AreSame(classDefCol[parentSubClassA].SuperClassClassDef, classDefCol[parentSubClassB].SuperClassClassDef);
}
public void Test_Map_WhenSubClassHasSuperClassWithUniqueConstraint_ShouldNotCreateDuplicate()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClassWithUC);
var subClass = typeof(FakeBOSubClassWithSuperHasUC);
var source = new FakeTypeSource(new[] { superClass, subClass });
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var allClassesAutoMapper = new AllClassesAutoMapper(source);
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var subClassDef = classDefCol.First(def => def.ClassName == "FakeBOSubClassWithSuperHasUC");
var inheritanceDef = subClassDef.SuperClassDef;
var superClassClassDef = inheritanceDef.SuperClassClassDef;
Assert.AreEqual(0, subClassDef.KeysCol.Count);
Assert.AreEqual(1, superClassClassDef.KeysCol.Count);
Assert.AreEqual("UC_Fake", superClassClassDef.KeysCol["UC_Fake"].KeyName);
}
public void Test_Map_WhenTypeInSourceTwice_ShouldAddSingleClassDef()
{
//---------------Set up test pack-------------------
Type typeFirstTime = typeof(FakeBOWithOneToOneRel);
Type typeSecondTime = typeof(FakeBOWithOneToOneRel);
FakeTypeSource source = new FakeTypeSource(
new[] { typeFirstTime, typeSecondTime });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(1, classDefCol.Count);
var classDef = classDefCol.First();
Assert.AreSame(typeSecondTime, classDef.ClassType);
}
public void Test_Map_WhenHaveTwoClassesShouldMapBoth()
{
//---------------Set up test pack-------------------
Type type1 = typeof(FakeBOWithNoRelationship);
Type type2 = typeof(FakeBoNoProps);
FakeTypeSource source = new FakeTypeSource(
new[] { type1, type2 });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.IsNotNull(classDefCol);
Assert.AreEqual(2, classDefCol.Count);
classDefCol.ShouldContain(def => def.ClassName == type1.Name);
classDefCol.ShouldContain(def => def.ClassName == type2.Name);
}
public void Test_Map_WhenSingleRelationshipToSubClass_WhenNonStandardIDProp_ShouldSetRelatedPropToNonStandardID_FixBug1355()
{
//---------------Set up test pack-------------------
var subClassWithNonStdID = typeof(SubClassWithNonStandardID);
var superClassWithNonStdID = typeof(SuperClassWithNonStandardID);
var relatedToSubClassWithNonStandardID = typeof(RelatedToSubClassWithNonStandardID);
var source = new FakeTypeSource(new[] { subClassWithNonStdID, superClassWithNonStdID, relatedToSubClassWithNonStandardID });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var relatedToSubClassWithNonStandardIDClassDef = classDefCol.FindByClassName(relatedToSubClassWithNonStandardID.Name);
Assert.AreEqual(1, relatedToSubClassWithNonStandardIDClassDef.RelationshipDefCol.Count);
var subClassWithNonStandardIDRelDef = relatedToSubClassWithNonStandardIDClassDef.RelationshipDefCol["SubClassWithNonStandardIDSingleRel"];
Assert.AreEqual(1, subClassWithNonStandardIDRelDef.RelKeyDef.Count, "Should have a non composite Key");
var relPropDef = subClassWithNonStandardIDRelDef.RelKeyDef.FirstOrDefault();
Assert.AreEqual("SubClassWithNonStandardIDSingleRelID", relPropDef.OwnerPropertyName);
Assert.AreEqual("NonStandardID", relPropDef.RelatedClassPropName);
}
public void Test_Map_WhenNotHasReverseRelDefined_ShouldCreateReverseRel()
{
//---------------Set up test pack-------------------
Type boWithM21 = typeof(FakeManyToOneBoRelNoFK);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWithM21, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWithM21 = classDefCol[boWithM21];
cDefWithM21.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWithM21.RelationshipDefCol.FirstOrDefault();
Assert.IsNotNull(relationshipDef);
Assert.IsNotNullOrEmpty(relationshipDef.ReverseRelationshipName);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
cDefNoDefinedRel.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
Assert.AreEqual(relationshipDef.ReverseRelationshipName, reverseRelDef.RelationshipName);
Assert.AreEqual(relationshipDef.RelationshipName, reverseRelDef.ReverseRelationshipName);
Assert.IsInstanceOf(typeof(MultipleRelationshipDef), reverseRelDef);
Assert.AreEqual(RelationshipType.Association, reverseRelDef.RelationshipType);
Assert.AreEqual(DeleteParentAction.Prevent, reverseRelDef.DeleteParentAction);
Assert.IsFalse(reverseRelDef.OwningBOHasForeignKey);
}
public void Test_Map_WhenNotHasReverseRelDefined_ShouldCreateRelProp()
{
//---------------Set up test pack-------------------
Type boWithM21 = typeof(FakeManyToOneBoRelNoFK);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWithM21, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWithM21 = classDefCol[boWithM21];
cDefWithM21.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWithM21.RelationshipDefCol.FirstOrDefault();
Assert.IsNotNull(relationshipDef);
relationshipDef.RelKeyDef.ShouldHaveCount(1);
IRelPropDef relPropDef = relationshipDef.RelKeyDef.FirstOrDefault();
Assert.IsNotNull(relPropDef);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
reverseRelDef.RelKeyDef.ShouldHaveCount(1);
IRelPropDef revereRelPropDef = reverseRelDef.RelKeyDef.FirstOrDefault();
Assert.IsNotNull(revereRelPropDef, "ReverseRelationship ShouldHave Been Created");
Assert.AreEqual(relPropDef.OwnerPropertyName, revereRelPropDef.RelatedClassPropName);
Assert.AreEqual(relPropDef.RelatedClassPropName, revereRelPropDef.OwnerPropertyName);
}
public void Test_Map_WhenSingleRelationshipToSubClass_WhenIDPropDeclaredInClassDefXml_ShouldNotCreatePropDefOnSubClass()
{
//---------------Set up test pack-------------------
var superClassDef = SuperClassWithPKFromClassDef.LoadClassDef();//Loaded from XML
var defCol = new ClassDefCol {
superClassDef
};
var subClassWithPKFromClassDef = typeof(SubClassWithPKFromClassDef);
var relatedToSubClassWithPKFromClassDefType = typeof(RelatedToSubClassWithPKFromClassDef);
var source = new FakeTypeSource(new[] { subClassWithPKFromClassDef, relatedToSubClassWithPKFromClassDefType });
AllClassesAutoMapper.ClassDefCol = defCol;
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var relatedToSubClassWithPKFromClassDef = classDefCol.FindByClassName(subClassWithPKFromClassDef.Name);
relatedToSubClassWithPKFromClassDef.PropDefcol.ShouldNotContain(def => def.PropertyName == "MYPKID");
}
public void Test_Map_WhenInheritanceWithNonStandardIDProp_ShouldMapWithCorrectNonStandardIDProp()
{
//---------------Set up test pack-------------------
var subClassWithNonStdID = typeof (SubClassWithNonStandardID);
var superClassWithNonStdID = typeof(SuperClassWithNonStandardID);
var source = new FakeTypeSource(new[] { subClassWithNonStdID, superClassWithNonStdID });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreSame(superClassWithNonStdID, subClassWithNonStdID.BaseType);
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefCol.Count);
classDefCol.ShouldContain(def => def.ClassName == subClassWithNonStdID.Name, "Should contain SubClass");
classDefCol.ShouldContain(def => def.ClassName == superClassWithNonStdID.Name, "Should Contain SuperClass");
var subClassDef = classDefCol.FindByClassName(subClassWithNonStdID.Name);
Assert.IsNull(subClassDef.PrimaryKeyDef);
var superClassDef = classDefCol.FindByClassName(superClassWithNonStdID.Name);
Assert.IsNotNull(superClassDef.PrimaryKeyDef);
Assert.AreEqual(1, superClassDef.PrimaryKeyDef.Count, "The PrimaryKey (ObjectID) Should not be composite");
var propDef = superClassDef.PrimaryKeyDef[0];
Assert.AreEqual("NonStandardID", propDef.PropertyName);
}
public void Test_Map_WhenInheritance_ShouldNotCreatePKInSubClass()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClass);
var subClass = typeof(FakeBOSubClass);
var source = new FakeTypeSource(new[] { superClass, subClass });
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(2);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
Assert.IsNotNull(superClassDef.PrimaryKeyDef);
Assert.IsNull(subClassDef.PrimaryKeyDef, "Should Not Create a PK since it will use the super classes PK");
subClassDef.PropDefcol.ShouldBeEmpty();
superClassDef.PropDefcol.ShouldNotBeEmpty();
}
public void Test_Map_WhenNotHasRevRelDefined_AndIsOneToOne_ShouldCreateSingleRevRel()
{
//---------------Set up test pack-------------------
Type boWith12M = typeof(FakeBOWithOneToOneRel);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWith12M, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWith12M = classDefCol[boWith12M];
cDefWith12M.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWith12M.RelationshipDefCol.First();
Assert.IsInstanceOf(typeof(SingleRelationshipDef), relationshipDef);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
Assert.AreEqual(relationshipDef.ReverseRelationshipName, reverseRelDef.RelationshipName);
Assert.AreEqual(relationshipDef.RelationshipName, reverseRelDef.ReverseRelationshipName);
Assert.IsInstanceOf(typeof(SingleRelationshipDef), reverseRelDef);
Assert.AreEqual(RelationshipType.Association, reverseRelDef.RelationshipType);
Assert.AreEqual(DeleteParentAction.DoNothing, reverseRelDef.DeleteParentAction);
Assert.IsTrue(reverseRelDef.OwningBOHasForeignKey);
}
public void Test_Map_WhenNotHasFKPropDefined_AndIsOneToMany_ShouldFKProp()
{
//---------------Set up test pack-------------------
Type boWith12M = typeof(FakeBOWithMultipleRel);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWith12M, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWith12M = classDefCol[boWith12M];
cDefWith12M.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWith12M.RelationshipDefCol.First();
Assert.IsInstanceOf(typeof(MultipleRelationshipDef), relationshipDef);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
IRelPropDef reverseRelPropDef = reverseRelDef.RelKeyDef.First();
cDefNoDefinedRel.PropDefcol.ShouldContain(propDef => propDef.PropertyName == reverseRelPropDef.OwnerPropertyName);
}
public void Test_Map_WhenNotHasReverseRelDefined_ShouldCreateRelProp()
{
//---------------Set up test pack-------------------
Type boWithM21 = typeof(FakeManyToOneBoRelNoFK);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWithM21, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWithM21 = classDefCol[boWithM21];
cDefWithM21.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWithM21.RelationshipDefCol.FirstOrDefault();
Assert.IsNotNull(relationshipDef);
relationshipDef.RelKeyDef.ShouldHaveCount(1);
IRelPropDef relPropDef = relationshipDef.RelKeyDef.FirstOrDefault();
Assert.IsNotNull(relPropDef);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
reverseRelDef.RelKeyDef.ShouldHaveCount(1);
IRelPropDef revereRelPropDef = reverseRelDef.RelKeyDef.FirstOrDefault();
Assert.IsNotNull(revereRelPropDef, "ReverseRelationship ShouldHave Been Created");
Assert.AreEqual(relPropDef.OwnerPropertyName, revereRelPropDef.RelatedClassPropName);
Assert.AreEqual(relPropDef.RelatedClassPropName, revereRelPropDef.OwnerPropertyName);
}
public void Test_Map_GivenTypeSourceProvidesSubClassBeforeSuperClass_WhenInheritanceAndHasRelationship_ShouldCreateCorrectRelPropDefs()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClass);
var subClass = typeof(FakeBOSubClassWithRelationships);
var source = new FakeTypeSource(new[] {subClass, superClass});
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(2);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
subClassDef.PropDefcol.ShouldHaveCount(1, "Should have FK for MultipleRel Created");
superClassDef.PropDefcol.ShouldHaveCount(2, "Should have PK and Discriminator Created");
subClassDef.RelationshipDefCol.ShouldHaveCount(2, "Should have Multiple and single Rel");
var multipleRelDef = subClassDef.RelationshipDefCol.First(relationshipDef => relationshipDef.IsOneToMany);
var multipleRelPropDef = multipleRelDef.RelKeyDef.First();
Assert.AreEqual("FakeBOSuperClassID", multipleRelPropDef.OwnerPropertyName);
Assert.AreEqual("FakeBOSuperClassID", multipleRelPropDef.RelatedClassPropName);
var singleRelDef = subClassDef.RelationshipDefCol.First(relationshipDef => relationshipDef.IsManyToOne);
var singleRelPropDef = singleRelDef.RelKeyDef.First();
Assert.AreEqual("SingleRelID", singleRelPropDef.OwnerPropertyName);
Assert.AreEqual("FakeBoNoPropsID", singleRelPropDef.RelatedClassPropName);
}
public void Test_Map_WhenInheritance_ShouldNotCreatePKInSubClass()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClass);
var subClass = typeof(FakeBOSubClass);
var source = new FakeTypeSource(new[] {superClass, subClass});
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(2);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
Assert.IsNotNull(superClassDef.PrimaryKeyDef);
Assert.IsNull(subClassDef.PrimaryKeyDef, "Should Not Create a PK since it will use the super classes PK");
subClassDef.PropDefcol.ShouldBeEmpty();
superClassDef.PropDefcol.ShouldNotBeEmpty();
}
public void Test_Map_GivenTypeSourceProvidesSubClassBeforeSuperClasses_When2LayersOfInheritance_ShouldMapInheritanceRelationships()
{
//---------------Set up test pack-------------------
var superSuperClass = typeof(FakeBOSuperClassWithDesc);
var superClass = typeof(FakeBOSubClassSuperHasDesc);
var subClass = typeof(FakeBOSubSubClassSuperHasDesc);
var source = new FakeTypeSource(new[] {subClass, superSuperClass, superClass});
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(3, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(3);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
var superSuperClassDef = classDefCol.First(def => def.ClassType == superSuperClass);
Assert.AreEqual(superClassDef.ClassType, subClassDef.SuperClassDef.SuperClassClassDef.ClassType);
Assert.AreSame(superClassDef, subClassDef.SuperClassDef.SuperClassClassDef);
Assert.AreEqual(superSuperClassDef.ClassType, superClassDef.SuperClassDef.SuperClassClassDef.ClassType);
Assert.AreSame(superSuperClassDef, superClassDef.SuperClassDef.SuperClassClassDef);
}
public void Test_Map_WhenSingleRelationshipToSubClass_WhenIDPropDeclaredInClassDefXml_ShouldNotCreatePropDefOnSubClass()
{
//---------------Set up test pack-------------------
var superClassDef = SuperClassWithPKFromClassDef.LoadClassDef();//Loaded from XML
var defCol = new ClassDefCol {superClassDef};
var subClassWithPKFromClassDef = typeof(SubClassWithPKFromClassDef);
var relatedToSubClassWithPKFromClassDefType = typeof(RelatedToSubClassWithPKFromClassDef);
var source = new FakeTypeSource(new[] {subClassWithPKFromClassDef, relatedToSubClassWithPKFromClassDefType });
AllClassesAutoMapper.ClassDefCol = defCol;
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var relatedToSubClassWithPKFromClassDef = classDefCol.FindByClassName(subClassWithPKFromClassDef.Name);
relatedToSubClassWithPKFromClassDef.PropDefcol.ShouldNotContain(def => def.PropertyName == "MYPKID");
}
public void Test_Map_WhenTypeInSourceTwice_ShouldAddSingleClassDef()
{
//---------------Set up test pack-------------------
Type typeFirstTime = typeof(FakeBOWithOneToOneRel);
Type typeSecondTime = typeof(FakeBOWithOneToOneRel);
FakeTypeSource source = new FakeTypeSource(
new[] { typeFirstTime, typeSecondTime });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(1, classDefCol.Count);
var classDef = classDefCol.First();
Assert.AreSame(typeSecondTime, classDef.ClassType);
}
public void Test_Map_WhenSingleRelationshipToSubClass_WhenIDPropDeclaredInClassDefXml_ShouldSetRelatedPropToNonStandardID_FixBug1355()
{
//---------------Set up test pack-------------------
var superClassDef = SuperClassWithPKFromClassDef.LoadClassDef();//Loaded from XML
var defCol = new ClassDefCol {superClassDef};
var subClassWithPKFromClassDef = typeof(SubClassWithPKFromClassDef);
var relatedToSubClassWithPKFromClassDefType = typeof(RelatedToSubClassWithPKFromClassDef);
var source = new FakeTypeSource(new[] {subClassWithPKFromClassDef, relatedToSubClassWithPKFromClassDefType });
AllClassesAutoMapper.ClassDefCol = defCol;
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var relatedToSubClassWithPKFromClassDef = classDefCol.FindByClassName(relatedToSubClassWithPKFromClassDefType.Name);
Assert.AreEqual(1, relatedToSubClassWithPKFromClassDef.RelationshipDefCol.Count);
var subClassWithPKFromClassDefRelDef = relatedToSubClassWithPKFromClassDef.RelationshipDefCol["SubClassWithPKFromClassDefSingleRel"];
Assert.AreEqual(1, subClassWithPKFromClassDefRelDef.RelKeyDef.Count, "Should have a non composite Key");
var relPropDef = subClassWithPKFromClassDefRelDef.RelKeyDef.FirstOrDefault();
Assert.AreEqual("SubClassWithPKFromClassDefSingleRelID", relPropDef.OwnerPropertyName);
Assert.AreEqual("MYPKID", relPropDef.RelatedClassPropName);
}
public void Test_Map_WhenRelatedClassNotInClassDefCol_ShouldNotRaiseError()
{
//---------------Set up test pack-------------------
Type boWith12M = typeof(FakeBOWithMultipleRel);
FakeTypeSource source = new FakeTypeSource(
new[] { boWith12M});
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(1, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(1);
}
public void Test_MapWhenHasInterface_ShouldNotMap()
{
//---------------Set up test pack-------------------
FakeTypeSource source = new FakeTypeSource();
source.Add<IFakeBoInterfaceShouldNotBeLoaded>();
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(1, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(0, classDefCol.Count);
}
public void Test_Map_GivenTypeSourceProvidesSubClassesBeforeSuperClass_WhenInheritanceWithMultipleDerivatives_ShouldSameSuperClass()
{
//---------------Set up test pack-------------------
var parentSuperClass = typeof(FakeBOSuperClass);
var parentSubClassA = typeof(FakeBOSubClass);
var parentSubClassB = typeof(FakeBOSubClassA);
var source = new FakeTypeSource(new[] {parentSubClassA, parentSubClassB, parentSuperClass});
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(3, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(3);
Assert.AreSame(classDefCol[parentSubClassA].SuperClassClassDef, classDefCol[parentSuperClass]);
Assert.AreSame(classDefCol[parentSubClassB].SuperClassClassDef, classDefCol[parentSuperClass]);
Assert.AreSame(classDefCol[parentSubClassA].SuperClassClassDef, classDefCol[parentSubClassB].SuperClassClassDef);
}
public void Test_MapWhenHasAbstract_ShouldNotMap()
{
//---------------Set up test pack-------------------
FakeTypeSource source = new FakeTypeSource(typeof(FakeAbstractBoShouldNotBeLoaded));
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(1, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(0, classDefCol.Count);
}
public void Test_Map_GivenTypeSourceProvidesSubClassBeforeSuperClass_WhenInheritance_ShouldCreateDiscriminatorPropInSuperClass()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClass);
var subClass = typeof(FakeBOSubClass);
var source = new FakeTypeSource(new[] {subClass, superClass});
var allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
classDefCol.ShouldHaveCount(2);
var subClassDef = classDefCol.First(def => def.ClassType == subClass);
var superClassDef = classDefCol.First(def => def.ClassType == superClass);
var discriminatorPropName = subClassDef.SuperClassDef.Discriminator;
var superClassProps = superClassDef.PropDefcol;
superClassProps.ShouldHaveCount(2);
superClassProps.ShouldContain(propDef => propDef.PropertyName == discriminatorPropName);
}
public void Test_Map_WhenNotHasReverseRelDefined_ShouldCreateReverseRel()
{
//---------------Set up test pack-------------------
Type boWithM21 = typeof(FakeManyToOneBoRelNoFK);
Type boWithNoDefinedRel = typeof(FakeBOWithNoRelationship);
FakeTypeSource source = new FakeTypeSource(
new[] { boWithM21, boWithNoDefinedRel });
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
ClassDefCol classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
IClassDef cDefWithM21 = classDefCol[boWithM21];
cDefWithM21.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef relationshipDef = cDefWithM21.RelationshipDefCol.FirstOrDefault();
Assert.IsNotNull(relationshipDef);
Assert.IsNotNullOrEmpty(relationshipDef.ReverseRelationshipName);
IClassDef cDefNoDefinedRel = classDefCol[boWithNoDefinedRel];
cDefNoDefinedRel.RelationshipDefCol.ShouldHaveCount(1);
IRelationshipDef reverseRelDef = cDefNoDefinedRel.RelationshipDefCol[relationshipDef.ReverseRelationshipName];
Assert.AreEqual(relationshipDef.ReverseRelationshipName, reverseRelDef.RelationshipName);
Assert.AreEqual(relationshipDef.RelationshipName, reverseRelDef.ReverseRelationshipName);
Assert.IsInstanceOf(typeof(MultipleRelationshipDef), reverseRelDef);
Assert.AreEqual(RelationshipType.Association, reverseRelDef.RelationshipType);
Assert.AreEqual(DeleteParentAction.Prevent, reverseRelDef.DeleteParentAction);
Assert.IsFalse(reverseRelDef.OwningBOHasForeignKey);
}
public void Test_Map_When2LayersOfInheritance_AndHasDiscriminatorProp_ShouldNotCreateDiscriminator()
{
//---------------Set up test pack-------------------
var superSuperClass = typeof(FakeBOSuperClassWithDesc);
var superClass = typeof(FakeBOSubClassSuperHasDesc);
var subClass = typeof(FakeBOSubSubClassSuperHasDesc);
var source = new FakeTypeSource(new[] {superSuperClass, superClass, subClass});
//---------------Assert Precondition----------------
Assert.AreEqual(3, source.GetTypes().Count());
//---------------Execute Test ----------------------
var allClassesAutoMapper = new AllClassesAutoMapper(source);
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var subClassDef = classDefCol.First(def => def.ClassName == "FakeBOSubSubClassSuperHasDesc");
var inheritanceDef = subClassDef.SuperClassDef;
var superClassClassDef = inheritanceDef.SuperClassClassDef;
var superSuperClassClassDef = superClassClassDef.SuperClassDef.SuperClassClassDef;
superClassClassDef.PropDefcol.ShouldHaveCount(0,
"No Properties Should be created for SuperClass since ID and Discriminator will be on SuperSuperClass");
var superSuperClassProps = superSuperClassClassDef.PropDefcol;
superSuperClassProps.ShouldHaveCount(2, "Discriminator and ID Prop should be created");
superSuperClassProps.ShouldContain(def => def.PropertyName == "FakeBOSuperClassWithDescType");
}
public void Test_Map_WhenSubClassHasSuperClassWithUniqueConstraint_ShouldNotCreateDuplicate()
{
//---------------Set up test pack-------------------
var superClass = typeof(FakeBOSuperClassWithUC);
var subClass = typeof(FakeBOSubClassWithSuperHasUC);
var source = new FakeTypeSource(new[] {superClass, subClass});
//---------------Assert Precondition----------------
Assert.AreEqual(2, source.GetTypes().Count());
//---------------Execute Test ----------------------
var allClassesAutoMapper = new AllClassesAutoMapper(source);
var classDefCol = allClassesAutoMapper.Map();
//---------------Test Result -----------------------
var subClassDef = classDefCol.First(def => def.ClassName == "FakeBOSubClassWithSuperHasUC");
var inheritanceDef = subClassDef.SuperClassDef;
var superClassClassDef = inheritanceDef.SuperClassClassDef;
Assert.AreEqual(0, subClassDef.KeysCol.Count);
Assert.AreEqual(1, superClassClassDef.KeysCol.Count);
Assert.AreEqual("UC_Fake", superClassClassDef.KeysCol["UC_Fake"].KeyName);
}
public void TestAccept_Validate_WhenAllClassDefsLoaded_ShouldBeTrue()
{
//---------------Set up test pack-------------------
Func<TypeWrapper, bool> whereClause = type
=> (type.Namespace == "Habanero.Smooth.Test.ValidFakeBOs");
AppDomainTypeSource source = new AppDomainTypeSource(whereClause);
AllClassesAutoMapper allClassesAutoMapper = new AllClassesAutoMapper(source);
ClassDefCol classDefCol = allClassesAutoMapper.Map();
ClassDefValidator validator = new ClassDefValidator(new DefClassFactory());
//---------------Assert Precondition----------------
Assert.Greater(classDefCol.Count, 0);
//---------------Execute Test ----------------------
validator.ValidateClassDefs(classDefCol);
//---------------Test Result -----------------------
Assert.IsNotNull(classDefCol);
//Should Validate without Error if it gets here then it has validated
}
public void TestAutoMap_WithTwoSingleRelationshipToTheSameBO_WhereReverseRelsAreDefined_WithPropAndRelNameMatching()
{
//---------------Set up test pack-------------------
const string parentClassDefXML = @"<classes>
<class name=""FakeBOWithTwoRelToSameProp"" assembly=""Habanero.Smooth.Test"">
<property name =""FakeBOWithTwoRelToSamePropID"" type=""Guid""/>
<primaryKey isObjectID=""true"">
<prop name=""FakeBOWithTwoRelToSamePropID"" />
</primaryKey>
<relationship name=""FakeBOWithTwoSingleRelToSamePropWithSameNames"" type=""multiple"" relatedClass=""FakeBOWithTwoSingleRelToSamePropWithSameName"" reverseRelationship=""FakeBOWithTwoRelToSameProp"" relatedAssembly=""Habanero.Smooth.Test"">
<relatedProperty property=""FakeBOWithTwoRelToSamePropID"" relatedProperty=""FakeBOWithTwoRelToSamePropID"" />
</relationship>
<relationship name=""FakeBORel2"" type=""multiple"" relatedClass=""FakeBOWithTwoSingleRelToSamePropWithSameName"" reverseRelationship=""SingleRel2"" relatedAssembly=""Habanero.Smooth.Test"">
<relatedProperty property=""FakeBOWithTwoRelToSamePropID"" relatedProperty=""SingleRel2ID"" />
</relationship>
</class>
</classes>";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var xmlClassDefsLoader = new XmlClassDefsLoader(parentClassDefXML, new DtdLoader());
var loadedClassDefs = xmlClassDefsLoader.LoadClassDefs();
var relatedClassType = typeof(FakeBOWithTwoSingleRelToSamePropWithSameName);
var allClassesAutoMapper = new AllClassesAutoMapper(new CustomTypeSource(new[] { relatedClassType }));
AllClassesAutoMapper.ClassDefCol = loadedClassDefs;
allClassesAutoMapper.Map();
//---------------Test Result -----------------------
Assert.AreEqual(2, AllClassesAutoMapper.ClassDefCol.Count);
var relationshipDefCol = AllClassesAutoMapper.ClassDefCol[relatedClassType].RelationshipDefCol;
Assert.AreEqual(2, relationshipDefCol.Count);
var relationshipDef = relationshipDefCol["FakeBOWithTwoRelToSameProp"];
Assert.AreEqual("FakeBOWithTwoSingleRelToSamePropWithSameNames", relationshipDef.ReverseRelationshipName);
var relationshipDef2 = relationshipDefCol["SingleRel2"];
Assert.AreEqual("FakeBORel2", relationshipDef2.ReverseRelationshipName);
var validator = new ClassDefValidator(new DefClassFactory());
validator.ValidateClassDefs(AllClassesAutoMapper.ClassDefCol);
}
