public void Test_Validate_PrimaryKey_IsObjectID_True_MultipleProps()
{
//-------------Setup Test Pack ------------------
const string xml = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid""/>
<property name=""TestRelatedClassID"" type=""Guid"" />
<primaryKey isObjectID=""true"">
<prop name=""TestClassID""/>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//-------------Execute test ---------------------
try
{
loader.LoadClassDefs(xml);
//---------------Test Result -----------------------
Assert.Fail("Should have thrown an InvalidPropertyException");
}
catch (RecordedExceptionsException ex)
{
StringAssert.Contains("class definition for the class 'TestClass", ex.Message);
StringAssert.Contains("You cannot have more than one property for a primary key that represents an object's Guid ID", ex.Message);
}
}
public void Test_Valid_Relationship_ShouldSetOwningClassDef()
{
//----------------------Test Setup ----------------------
const string classDefsString = @"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey isObjectID=""false"">
<prop name=""TestRelatedClassID""/>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//--------------------Execute Test-------------------------
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
//---------------Test Result -----------------------
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef reverseRelDef = reverseClassDef.RelationshipDefCol["TestClass"];
Assert.AreSame(reverseClassDef, reverseRelDef.OwningClassDef);
}
public void Test_Force_PrimaryKey_IsObjectID_False_AsCompulsoryWriteOnce_WithReadWriteRule_ReadWrite()
{
//-------------Setup Test Pack ------------------
const string xml = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""string"" readWriteRule=""ReadWrite""/>
<primaryKey isObjectID=""false"">
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//-------------Execute test ---------------------
ClassDefCol classDefs = loader.LoadClassDefs(xml);
//---------------Test Result -----------------------
Assert.AreEqual(1, classDefs.Count);
Assert.IsTrue(classDefs.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
IClassDef classDef = classDefs["Habanero.Test.BO.Loaders", "TestClass"];
Assert.AreEqual(1, classDef.PrimaryKeyDef.Count);
IPropDef keyPropDef = classDef.PrimaryKeyDef[0];
Assert.IsFalse(keyPropDef.Compulsory);
Assert.AreEqual(PropReadWriteRule.ReadWrite, keyPropDef.ReadWriteRule);
}
public void TestLoadClassDefs_WithParameterLessConstructor_ShouldLoadTwoClasses()
{
const string classDefsXml = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
IClassDefsLoader loader = new XmlClassDefsLoader(classDefsXml, new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefList =
loader.LoadClassDefs();
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
}
public void Test_Force_PrimaryKey_IsObjectID_AsCompulsoryWriteOnce_WithReadWriteRule_WriteNew()
{
//-------------Setup Test Pack ------------------
const string xml =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" readWriteRule=""WriteNew""/>
<primaryKey isObjectID=""true"">
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(xml);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
IClassDef classDef = classDefList["Habanero.Test.BO.Loaders", "TestClass"];
IPropDef keyPropDef = classDef.PrimaryKeyDef[0];
//---------------Assert PreConditions---------------
Assert.IsFalse(keyPropDef.Compulsory);
Assert.AreEqual(PropReadWriteRule.WriteNew, keyPropDef.ReadWriteRule);
//-------------Execute test ---------------------
validator.ValidateClassDefs(classDefList);
//---------------Test Result -----------------------
Assert.IsTrue(keyPropDef.Compulsory);
Assert.AreEqual(PropReadWriteRule.WriteNew, keyPropDef.ReadWriteRule);
}
public void Test_Validate_PrimaryKey_IsObjectID_True_NonGuidProp()
{
//-------------Setup Test Pack ------------------
const string xml =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID""/>
<primaryKey isObjectID=""true"">
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(xml);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//-------------Execute test ---------------------
try
{
validator.ValidateClassDefs(classDefList);
//---------------Test Result -----------------------
Assert.Fail("Should have thrown an InvalidXmlDefinitionException");
}
catch (InvalidXmlDefinitionException ex)
{
Assert.AreEqual(
"In the class called 'TestClass', the primary key is set as IsObjectID but the property 'TestClassID' " +
"defined as part of the ObjectID primary key is not a Guid.", ex.Message);
}
}
public void Test_Validate_PrimaryKey_HasNoProps_IsNotObjectGuid()
{
//-------------Setup Test Pack ------------------
const string xml = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID""/>
<primaryKey isObjectID=""false"">
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//-------------Execute test ---------------------
try
{
loader.LoadClassDefs(xml);
//---------------Test Result -----------------------
Assert.Fail("Should have thrown an InvalidXmlDefinitionException");
}
catch (RecordedExceptionsException ex)
{
StringAssert.Contains("class definition for the class 'TestClass", ex.Message);
StringAssert.Contains("A primaryKey node must have one or more prop nodes", ex.Message);
//Assert.AreEqual("In the class called 'TestClass', the primary key has no properties defined.", ex.Message);
//TODO Mark: 09 Feb 2009 - Improve this error message to something similar to above
}
}
public void Test_Valid_Relationship_1_M_Relationships_PrimaryAndForeignKeyDoesNotMatchRelationshipCardinality()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""multiple"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestRelatedClass"" owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestClass"" owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//--------------------Execute Test-------------------------
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"),
"Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"),
"Class 'TestRelatedClass' should have been loaded.");
Assert.Fail("wRITE TEST THSI should throw validation error");
IClassDef classDef = classDefList.FindByClassName("TestClass");
IRelationshipDef relationshipDef = classDef.RelationshipDefCol["TestRelatedClass"];
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef reverseRelationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey);
Assert.IsTrue(reverseRelationshipDef.OwningBOHasForeignKey);
}
public void Test_Add_WithCollection_ShouldAddEachItem()
{
//---------------Set up test pack-------------------
XmlClassDefsLoader loader = new XmlClassDefsLoader(GetTestClassDefinition(""), new DtdLoader(), new DefClassFactory());
ClassDefCol classDefCol = new ClassDefCol();
ClassDefCol classDefs = loader.LoadClassDefs();
//---------------Assert PreConditions---------------
Assert.AreEqual(2, classDefs.Count);
//---------------Execute Test ----------------------
classDefCol.Add(classDefs);
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefCol.Count);
}
public void TestNoRootNodeException()
{
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
try
{
loader.LoadClassDefs(@"<invalidRootNode>");
Assert.Fail("Expected to throw an EXCEPTION");
}
//---------------Test Result -----------------------
catch (XmlException ex)
{
StringAssert.Contains("has no root element", ex.Message);
}
}
public void Test_Load_ShouldSetUIDefsClassDef()
{
//---------------Set up test pack-------------------
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), new DefClassFactory());
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
ClassDefCol classDefs =
loader.LoadClassDefs(TestClassWithUIDef);
//---------------Test Result -----------------------
IClassDef classDef = classDefs["Habanero.Test", "Sample"];
var uiDef = classDef.UIDefCol.FirstOrDefault();
Assert.IsNotNull(uiDef);
Assert.AreSame(classDef, uiDef.ClassDef);
}
public void Test_Load_WhenClassWithRelatedClassXml_OnlyOneReverseRelationshipIndicated_ShouldLoadEachRel()
{
//---------------Set up test pack-------------------
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), new DefClassFactory());
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
ClassDefCol classDefs =
loader.LoadClassDefs(TestClassWithRelatedClassXml_OnlyOneReverseRelationshipIndicated);
//---------------Test Result -----------------------
IClassDef classDef = classDefs["FireStarter.Test.Logic", "FireStarter.Test.Logic.Loaders.TestClass"];
IClassDef relatedClassDef =
classDefs["FireStarter.Test.Logic", "FireStarter.Test.Logic.Loaders.TestRelatedClass"];
Assert.AreEqual(1, classDef.RelationshipDefCol.Count);
Assert.AreEqual(1, relatedClassDef.RelationshipDefCol.Count);
}
public void Test_Invalid_Relationship_SingleSingleRelationships_BothSetAsOwning_NeitherIsPrimaryKey()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<property name=""ForeignKeyProp"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" owningBOHasForeignKey=""true"" reverseRelationship=""TestClass"">
<relatedProperty property=""ForeignKeyProp"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" owningBOHasForeignKey=""true"" reverseRelationship=""TestRelatedClass"">
<relatedProperty property=""TestClassID"" relatedProperty=""ForeignKeyProp"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefs = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Execute Test-------------------------
try
{
validator.ValidateClassDefs(classDefs);
Assert.Fail("expected Err");
}
//---------------Test Result -----------------------
catch (InvalidXmlDefinitionException ex)
{
StringAssert.Contains(
"The relationship 'TestRelatedClass' could not be loaded because the reverse relationship 'TestClass' ",
ex.Message);
StringAssert.Contains("are both set up as owningBOHasForeignKey = true", ex.Message);
}
}
public void Test_Valid_Relationship_SingleSingleRelationships_OnlyOneHasOwningBOHasForeignKey()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" owningBOHasForeignKey=""true"" reverseRelationship=""TestClass"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" reverseRelationship=""TestRelatedClass"" owningBOHasForeignKey=""false"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Assert PreConditions---------------
IClassDef classDef = classDefList.FindByClassName("TestClass");
IRelationshipDef relationshipDef = classDef.RelationshipDefCol["TestRelatedClass"];
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey, "This defaults to true");
IClassDef revesreclassDef = classDefList.FindByClassName("TestClass");
IRelationshipDef reverserelationshipDef = revesreclassDef.RelationshipDefCol["TestRelatedClass"];
Assert.IsTrue(reverserelationshipDef.OwningBOHasForeignKey, "This defaults to true");
//--------------------Execute Test-------------------------
validator.ValidateClassDefs(classDefList);
//---------------Test Result -----------------------
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey, "Should have converted this to false");
Assert.IsFalse(reverserelationshipDef.OwningBOHasForeignKey, "Should have converted this to false");
}
public void Test_Valid_Relationship_1_M_Relationships_CanDetermine_OwningBOHasForeignKey_SecondClass_NotSetUp()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""multiple"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestClass"" owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
reverseRelationship=""TestRelatedClass"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
IClassDef classDef = classDefList.FindByClassName("TestClass");
IRelationshipDef relationshipDef = classDef.RelationshipDefCol["TestRelatedClass"];
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef reverseRelationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
//---------------Assert PreConditions---------------
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey);
Assert.IsTrue(reverseRelationshipDef.OwningBOHasForeignKey);
//--------------------Execute Test-------------------------
validator.ValidateClassDefs(classDefList);
//---------------Test Result -----------------------
Assert.IsFalse(relationshipDef.OwningBOHasForeignKey);
Assert.IsTrue(reverseRelationshipDef.OwningBOHasForeignKey);
}
public void TestLoadClassDefs_InheritedClassWithNoPrimaryKey_WithRelationship()
{
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList =
loader.LoadClassDefs(
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestClass2"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClass2ID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClass2ID""/>
</primaryKey>
</class>
<class name=""TestClassInherited"" assembly=""Habanero.Test.BO.Loaders"" >
<superClass class=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" />
<property name=""RelatedTestClassID"" type=""Guid"" />
<relationship name=""TestRelationship"" type=""single""
relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""RelatedTestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" );
Assert.AreEqual(3, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass2"), "Class 'TestClass2' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClassInherited"), "Class 'TestClassInherited' should have been loaded.");
IClassDef classDefTestClass = classDefList["Habanero.Test.BO.Loaders", "TestClass"];
IClassDef classDefInherited = classDefList["Habanero.Test.BO.Loaders", "TestClassInherited"];
Assert.IsNotNull(classDefTestClass);
Assert.IsNotNull(classDefInherited.SuperClassDef);
Assert.IsNull(classDefInherited.PrimaryKeyDef);
IRelationshipDefCol relDefCol = classDefInherited.RelationshipDefCol;
Assert.AreEqual(1, relDefCol.Count, "There should be one relationship def from the given xml definition");
Assert.IsNotNull(relDefCol["TestRelationship"], "'TestRelationship' should be the name of the relationship created");
}
public void Test_Invalid_Relationship_PropDefForReverseRelationshipNotSameAsRelationship()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<property name=""OtherFieldID"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" owningBOHasForeignKey=""true"" reverseRelationship=""TestClass"">
<relatedProperty property=""OtherFieldID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" reverseRelationship=""TestRelatedClass"" owningBOHasForeignKey=""false"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefs = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Execute Test-------------------------
try
{
validator.ValidateClassDefs(classDefs);
Assert.Fail("expected Err");
}
//---------------Test Result -----------------------
catch (InvalidXmlDefinitionException ex)
{
StringAssert.Contains("do not have the same properties defined as the relationship keys", ex.Message);
}
}
public void Test_Invalid_Relationship_PropDefDoesNotExistOnOwningClassDef()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""PropDefDoesNonExist"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefs = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Execute Test-------------------------
try
{
validator.ValidateClassDefs(classDefs);
Assert.Fail("expected Err");
}
//---------------Test Result -----------------------
catch (InvalidXmlDefinitionException ex)
{
StringAssert.Contains(
"In a 'relatedProperty' element for the 'TestRelatedClass' relationship of the 'TestClass' class, " +
"the property 'PropDefDoesNonExist' given in the 'property' attribute does not exist", ex.Message);
}
}
public void Test_Invalid_Relationship_RelatedClassDefDoesNotExist()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""RelatedClassDoesNotExist"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Execute Test-------------------------
try
{
validator.ValidateClassDefs(classDefList);
Assert.Fail("expected Err");
}
//---------------Test Result -----------------------
catch (InvalidXmlDefinitionException ex)
{
StringAssert.Contains(
"The relationship 'TestRelatedClass' could not be loaded because when trying to retrieve its related class the folllowing",
ex.Message);
}
}
public void Test_Add_WithNewClassDefs_ShouldAddThem()
{
//---------------Set up test pack-------------------
XmlClassDefsLoader loader1 = new XmlClassDefsLoader(GetTestClassDefinition(""), new DtdLoader(), new DefClassFactory());
ClassDefCol classDefCol = new ClassDefCol();
ClassDefCol classDefs1 = loader1.LoadClassDefs();
classDefCol.Add(classDefs1);
XmlClassDefsLoader loader2 = new XmlClassDefsLoader(GetTestClassDefinition("Other"), new DtdLoader(), new DefClassFactory());
ClassDefCol classDefs2 = loader2.LoadClassDefs();
//---------------Assert PreConditions---------------
Assert.AreEqual(2, classDefCol.Count);
Assert.AreEqual(2, classDefs2.Count);
//---------------Execute Test ----------------------
classDefCol.Add(classDefs2);
//---------------Test Result -----------------------
Assert.AreEqual(4, classDefCol.Count);
}
public void TestLoadClassDefs_KeyDefinedWithInheritedProperties()
{
//-------------Setup Test Pack ------------------
const string xml =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<property name=""TestClassName"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestClassInherited"" assembly=""Habanero.Test.BO.Loaders"" >
<superClass class=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" />
<key>
<prop name=""TestClassName""/>
</key>
</class>
</classes>
" ;
var loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
var classDefList = loader.LoadClassDefs(xml);
var validator = new ClassDefValidator(GetDefClassFactory());
//--------------------Assert Preconditions-----------------
var classDefTestClass = classDefList["Habanero.Test.BO.Loaders", "TestClass"];
var propDef = classDefTestClass.PropDefcol["TestClassName"];
var classDefInherited = classDefList["Habanero.Test.BO.Loaders", "TestClassInherited"];
var keyDef = classDefInherited.KeysCol.GetKeyDefAtIndex(0);
var keyDefPropDef = keyDef["TestClassName"];
Assert.AreNotSame(propDef, keyDefPropDef,
"The key's property should have been resolved to be the property of the superclass by the validator.");
//-------------Execute test ---------------------
validator.ValidateClassDefs(classDefList);
//-------------Test Result ----------------------
var keyDefPropDefAfterValidate = keyDef["TestClassName"];
Assert.AreSame(propDef, keyDefPropDefAfterValidate,
"The key's property should have been resolved to be the property of the superclass by the loader.");
}
public void Test_Valid_Relationship_1_1_NoReverse_RelatatedProp_IsPartOfCompositePrimaryKey()
{
//----------------------Test Setup ----------------------
const string classDefsString = @"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey isObjectID=""false"">
<prop name=""TestRelatedClassID""/>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestClass"" type=""single"" relatedClass=""TestClass"" relatedAssembly=""Habanero.Test.BO.Loaders""
owningBOHasForeignKey=""true"" >
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//--------------------Execute Test-------------------------
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
IClassDef reverseClassDef = classDefList.FindByClassName("TestRelatedClass");
IRelationshipDef relationshipDef = reverseClassDef.RelationshipDefCol["TestClass"];
Assert.IsTrue(relationshipDef.OwningBOHasForeignKey);
}
public void TestLoadClassDefs_KeyDefinedWithNonExistantProperty()
{
//-------------Setup Test Pack ------------------
const string xml =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" />
<property name=""TestClassName"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestClassInherited"" assembly=""Habanero.Test.BO.Loaders"" >
<superClass class=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" />
<key>
<prop name=""DoesNotExist""/>
</key>
</class>
</classes>
" ;
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefs = loader.LoadClassDefs(xml);
ClassDefValidator validator = new ClassDefValidator(GetDefClassFactory());
//-------------Execute test ---------------------
try
{
validator.ValidateClassDefs(classDefs);
Assert.Fail("expected Err");
}
//---------------Test Result -----------------------
catch (InvalidXmlDefinitionException ex)
{
StringAssert.Contains("In a 'prop' element for the '' key of the 'TestClassInherited' class, " +
"the propery 'DoesNotExist' given in the 'name' attribute does not exist for the class or " +
"for any of it's superclasses. Either add the property definition or check the spelling and " +
"capitalisation of the specified property", ex.Message);
}
}
public void Test_Valid_Relationship_Loads_Where_RelatedClass_IsLoaded_After_InitialLoad_NoReverseRelationshipSetup()
{
//----------------------Test Setup ----------------------
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefCol = new ClassDefCol();
const string classDefsString = @"
<classes>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
classDefCol.Add(loader.LoadClassDefs(classDefsString));
//--------------------Execute Test-------------------------
const string secondClassDefStringToLoad = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
</classes>
" ;
classDefCol.Add(loader.LoadClassDefs(secondClassDefStringToLoad));
//---------------Test Result -----------------------
Assert.AreEqual(2, classDefCol.Count);
Assert.IsTrue(classDefCol.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefCol.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"), "Class 'TestRelatedClass' should have been loaded.");
}
public void Test_CheckRelationships_RelationshipWithTypeParameterChecksAgainstCorrectRelatedClassDef()
{
//----------------------Test Setup ----------------------
const string classDefsString = @"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single""
relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"" typeParameter=""Special"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassSpecialID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" typeParameter=""Special"">
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" type=""Guid"" />
<property name=""TestClassSpecialID"" type=""Guid"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
//--------------------Execute Test-------------------------
loader.LoadClassDefs(classDefsString);
//---------------Test Result -----------------------
}
public void Test_Valid_Relationship()
{
//----------------------Test Setup ----------------------
const string classDefsString =
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
<relationship name=""TestRelatedClass"" type=""single"" relatedClass=""TestRelatedClass"" relatedAssembly=""Habanero.Test.BO.Loaders"">
<relatedProperty property=""TestClassID"" relatedProperty=""TestClassID"" />
</relationship>
</class>
<class name=""TestRelatedClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestRelatedClassID"" type=""Guid"" />
<property name=""TestClassID"" />
<primaryKey>
<prop name=""TestRelatedClassID""/>
</primaryKey>
</class>
</classes>
" ;
XmlClassDefsLoader loader = new XmlClassDefsLoader("", new DtdLoader(), GetDefClassFactory());
ClassDefCol classDefList = loader.LoadClassDefs(classDefsString);
ClassDefValidator defValidator = new ClassDefValidator(GetDefClassFactory());
//--------------------Assert Preconditions-----------------
Assert.AreEqual(2, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"),
"Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestRelatedClass"),
"Class 'TestRelatedClass' should have been loaded.");
//--------------------Execute Test-------------------------
defValidator.ValidateClassDefs(classDefList);
//--------------------Assert Results ----------------------
}
public void TestLoadClassDefs_InheritedClassWithNoPrimaryKey()
{
XmlClassDefsLoader loader = CreateXmlClassDefsLoader();
ClassDefCol classDefList =
loader.LoadClassDefs(
@"
<classes>
<class name=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClassID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClassID""/>
</primaryKey>
</class>
<class name=""TestClass2"" assembly=""Habanero.Test.BO.Loaders"" >
<property name=""TestClass2ID"" type=""Guid"" />
<primaryKey>
<prop name=""TestClass2ID""/>
</primaryKey>
</class>
<class name=""TestClassInherited"" assembly=""Habanero.Test.BO.Loaders"" >
<superClass class=""TestClass"" assembly=""Habanero.Test.BO.Loaders"" />
</class>
</classes>
" );
Assert.AreEqual(3, classDefList.Count);
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass"), "Class 'TestClass' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClass2"), "Class 'TestClass2' should have been loaded.");
Assert.IsTrue(classDefList.Contains("Habanero.Test.BO.Loaders", "TestClassInherited"), "Class 'TestClassInherited' should have been loaded.");
IClassDef classDefTestClass = classDefList["Habanero.Test.BO.Loaders", "TestClass"];
IClassDef classDefInherited = classDefList["Habanero.Test.BO.Loaders", "TestClassInherited"];
Assert.IsNotNull(classDefTestClass);
Assert.IsNotNull(classDefInherited.SuperClassDef);
//This is expecting a null PrimaryKeyDef because the global ClassDef.Classdefs col is not loaded yet.
Assert.IsNull(classDefInherited.PrimaryKeyDef);
}
