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