public void Test_SetDisplayPropertyValue_WithRelatedPropName_ShouldSetPropValue()
{
//---------------Set up test pack-------------------
const string underlyingPropName = "MyRelatedTestProp";
const string propName = "MyRelationship." + underlyingPropName;
ClassDef.ClassDefs.Clear();
var myBOClassDef = MyBO.LoadClassDefWithRelationship();
var relatedClassDef = MyRelatedBo.LoadClassDef();
MyBO myBO = (MyBO)myBOClassDef.CreateNewBusinessObject();
MyRelatedBo myRelatedBo = (MyRelatedBo)relatedClassDef.CreateNewBusinessObject();
myBO.Relationships.SetRelatedObject("MyRelationship", myRelatedBo);
BOMapper boMapper = new BOMapper(myBO);
var initialPropValue = RandomValueGen.GetRandomString();
myRelatedBo.SetPropertyValue(underlyingPropName, initialPropValue);
//---------------Assert Precondition----------------
Assert.AreEqual(initialPropValue, myRelatedBo.GetPropertyValue(underlyingPropName));
//---------------Execute Test ----------------------
var expectedPropValue = RandomValueGen.GetRandomString();
boMapper.SetDisplayPropertyValue(propName, expectedPropValue);
//---------------Test Result -----------------------
Assert.AreEqual(expectedPropValue, myRelatedBo.GetPropertyValue(underlyingPropName));
}
public void Test_Create_WhenReflectiveProp_WithTwoRelationshipLevels_ShouldCreateReflectivePropMapper()
{
//---------------Set up test pack-------------------
const string propName = "MyName";
var propNameWithDashes = string.Format("-{0}-", propName);
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
var bo = new MyBO();
var myRelatedBo = new MyRelatedBo();
bo.MyRelationship = myRelatedBo;
bo.MyRelationship.MyRelationship = new MyBO();
var propertyPath = "MyRelationship.MyRelationship." + propNameWithDashes;
//---------------Assert Precondition----------------
Assert.IsNotNull(ReflectionUtilities.GetPropertyInfo(bo.MyRelationship.MyRelationship.GetType(), propName));
//---------------Execute Test ----------------------
IBOPropertyMapper propMapper = BOPropMapperFactory.CreateMapper(bo, propertyPath);
//---------------Test Result -----------------------
Assert.IsInstanceOf <ReflectionPropertyMapper>(propMapper);
Assert.AreEqual(propName, propMapper.PropertyName);
Assert.AreSame(bo.MyRelationship.MyRelationship, propMapper.BusinessObject);
}
public void Test_MarkForDelete_WhenSingle_WhenDeleteRelated_WhenHasRelatedBO_ShouldDoNothing()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
ClassDef.ClassDefs.Clear();
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo = (MyBO)classDef.CreateNewBusinessObject();
bo.Save();
ReflectionUtilities.SetPropertyValue(bo.Status, "IsDeleted", true);
ISingleRelationship relationship = (ISingleRelationship)bo.Relationships["MyRelationship"];
MyRelatedBo myRelatedBO = new MyRelatedBo();
relationship.SetRelatedObject(myRelatedBO);
SetDeleteRelatedAction(relationship, DeleteParentAction.DeleteRelated);
//---------------Assert Precondition----------------
Assert.IsTrue(bo.Status.IsDeleted);
Assert.IsFalse(myRelatedBO.Status.IsDeleted);
Assert.IsNotNull(relationship.GetRelatedObject());
Assert.AreEqual(DeleteParentAction.DeleteRelated, relationship.DeleteParentAction);
//---------------Execute Test ----------------------
relationship.MarkForDelete();
//---------------Test Result -----------------------
Assert.IsTrue(bo.Status.IsDeleted);
Assert.IsTrue(myRelatedBO.Status.IsDeleted);
}
public void Test_IsDeletable_WhenSingle_WhenDeleteAction_EQ_PreventDelete_WhenHasRelated_ShouldBeFalse()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
ClassDef.ClassDefs.Clear();
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo = (MyBO)classDef.CreateNewBusinessObject();
bo.Save();
SingleRelationship <MyRelatedBo> relationship = (SingleRelationship <MyRelatedBo>)bo.Relationships["MyRelationship"];
relationship.SetRelatedObject(new MyRelatedBo());
//---------------Assert Precondition----------------
Assert.IsFalse(bo.Status.IsDeleted);
Assert.IsNotNull(relationship.GetRelatedObject());
Assert.AreEqual(DeleteParentAction.Prevent, relationship.DeleteParentAction);
//---------------Execute Test ----------------------
string message;
bool isDeletable = relationship.IsDeletable(out message);
//---------------Test Result -----------------------
Assert.IsFalse(isDeletable);
}
public void Test_MarkForDelete_WhenMultiple_WhenDerefenceRelated_WhenHasRelatedBO_ShouldDoNothing()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
ClassDef.ClassDefs.Clear();
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo = (MyBO)classDef.CreateNewBusinessObject();
bo.Save();
ReflectionUtilities.SetPropertyValue(bo.Status, "IsDeleted", true);
MyRelatedBo myRelatedBO = bo.MyMultipleRelationship.CreateBusinessObject();
IRelationship relationship = bo.Relationships["MyMultipleRelationship"];
((RelationshipDef)relationship.RelationshipDef).DeleteParentAction = DeleteParentAction.DereferenceRelated;
//---------------Assert Precondition----------------
Assert.IsTrue(bo.Status.IsDeleted);
Assert.IsFalse(myRelatedBO.Status.IsDeleted);
Assert.AreEqual(1, bo.MyMultipleRelationship.Count);
Assert.AreEqual(DeleteParentAction.DereferenceRelated, relationship.DeleteParentAction);
//---------------Execute Test ----------------------
relationship.MarkForDelete();
//---------------Test Result -----------------------
Assert.IsTrue(bo.Status.IsDeleted);
Assert.IsFalse(myRelatedBO.Status.IsDeleted);
}
public void Test_IsDeletable_WhenDeleteAction_EQ_DeleteRelated_WhenHasRelatedObject_ShouldBeTrue()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory();
ClassDef.ClassDefs.Clear();
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo = (MyBO)classDef.CreateNewBusinessObject();
bo.Save();
IRelationship relationship = bo.Relationships["MyMultipleRelationship"];
SetDeleteRelatedAction(relationship, DeleteParentAction.DeleteRelated);
bo.MyMultipleRelationship.CreateBusinessObject();
//---------------Assert Precondition----------------
Assert.IsFalse(bo.Status.IsDeleted);
Assert.AreEqual(1, bo.MyMultipleRelationship.Count);
Assert.AreEqual(DeleteParentAction.DeleteRelated, relationship.DeleteParentAction);
//---------------Execute Test ----------------------
string message;
bool isDeletable = relationship.IsDeletable(out message);
//---------------Test Result -----------------------
Assert.IsTrue(isDeletable);
}
public void Test_IsOneToOne_WhenHasNoReverseRelationship_ShouldBeFalse()
{
//---------------Set up test pack-------------------
var classDef = MyBO.LoadClassDefWithRelationship();
var relationshipDef = classDef.RelationshipDefCol["MyRelationship"];
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
bool isOneToOne = relationshipDef.IsOneToOne;
//---------------Test Result -----------------------
Assert.IsFalse(isOneToOne);
}
public void TestIndexer()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)classDef.CreateNewBusinessObject();
//---------------Execute Test ----------------------
IRelationship relationship = bo1.Relationships["MyMultipleRelationship"];
//---------------Test Result -----------------------
Assert.IsNotNull(relationship);
}
public void RelationshipType_ShouldBeSameAsRelationshipDefRelationshipType()
{
//---------------Set up test pack-------------------
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
var bo = new MyBO();
var relationship = bo.Relationships["MyRelationship"];
var expectedRelationshipType = relationship.RelationshipDef.RelationshipType;
//---------------Execute Test ----------------------
RelationshipType relationshipType = relationship.RelationshipType;
//---------------Test Result -----------------------
Assert.AreEqual(expectedRelationshipType, relationshipType);
}
public void Test_Criteria_OneProp()
{
//--------------- Set up test pack ------------------
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO myBO = new MyBO();
MultipleRelationship <MyRelatedBo> relationship = myBO.Relationships.GetMultiple <MyRelatedBo>("MyMultipleRelationship");
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
Criteria relCriteria = relationship.RelKey.Criteria;
//--------------- Test Result -----------------------
StringAssert.AreEqualIgnoringCase("MyBoID = '" + myBO.MyBoID.Value.ToString("B") + "'", relCriteria.ToString());
}
public void TestSetRelatedBusinessObject()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
IClassDef relatedClassDef = MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)classDef.CreateNewBusinessObject();
MyRelatedBo relatedBo1 = (MyRelatedBo)relatedClassDef.CreateNewBusinessObject();
//---------------Execute Test ----------------------
bo1.Relationships.SetRelatedObject("MyRelationship", relatedBo1);
//---------------Test Result -----------------------
Assert.AreSame(relatedBo1, bo1.Relationships.GetRelatedObject <MyRelatedBo>("MyRelationship"));
Assert.AreSame(bo1.GetPropertyValue("RelatedID"), relatedBo1.GetPropertyValue("MyRelatedBoID"));
}
public void Test_Criteria_OneProp_NullValue()
{
//--------------- Set up test pack ------------------
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyRelatedBo myRelatedBo = new MyRelatedBo();
SingleRelationship <MyBO> relationship = myRelatedBo.Relationships.GetSingle <MyBO>("MyRelationship");
//--------------- Test Preconditions ----------------
//--------------- Execute Test ----------------------
Criteria relCriteria = relationship.RelKey.Criteria;
//--------------- Test Result -----------------------
StringAssert.AreEqualIgnoringCase("MyBoID IS NULL", relCriteria.ToString());
}
protected void SetupClassDefs(object propValue)
{
ClassDef.ClassDefs.Clear();
IClassDef itsClassDef = MyBO.LoadClassDefWithRelationship();
IClassDef itsRelatedClassDef = MyRelatedBo.LoadClassDef();
itsMyBo = (MyBO)itsClassDef.CreateNewBusinessObject();
MyRelatedBo relatedBo = (MyRelatedBo)itsRelatedClassDef.CreateNewBusinessObject();
Guid myRelatedBoGuid = relatedBo.ID.GetAsGuid();
itsMyBo.SetPropertyValue("RelatedID", myRelatedBoGuid);
relatedBo.SetPropertyValue("MyRelatedTestProp", propValue);
itsMyBo.Save();
relatedBo.Save();
}
public void TestSetOrderCriteria_AddsJoinToSource_OnlyOnce()
{
//---------------Set up test pack-------------------
MyRelatedBo.LoadClassDefWithDifferentTableAndFieldNames();
IClassDef myBoClassdef = MyBO.LoadClassDefWithRelationship();
ISelectQuery selectQuery = QueryBuilder.CreateSelectQuery(myBoClassdef);
IOrderCriteria orderCriteria = QueryBuilder.CreateOrderCriteria(myBoClassdef, "MyRelationship.MyRelatedTestProp, MyRelationship.MyRelatedTestProp2");
//---------------Execute Test ----------------------
selectQuery.OrderCriteria = orderCriteria;
//---------------Test Result -----------------------
Assert.AreEqual(1, selectQuery.Source.Joins.Count);
//---------------Tear Down -------------------------
}
public void Test_GetPropertyValue_WithDot()
{
ClassDef.ClassDefs.Clear();
_itsClassDef = MyBO.LoadClassDefWithRelationship();
_itsRelatedClassDef = MyRelatedBo.LoadClassDef();
//MyBO bo1 = (MyBO)itsClassDef.CreateNewBusinessObject(connection);
MyBO bo1 = (MyBO)_itsClassDef.CreateNewBusinessObject();
MyRelatedBo relatedBo = (MyRelatedBo)_itsRelatedClassDef.CreateNewBusinessObject();
Guid myRelatedBoGuid = relatedBo.ID.GetAsGuid();
bo1.SetPropertyValue("RelatedID", myRelatedBoGuid);
relatedBo.SetPropertyValue("MyRelatedTestProp", "MyValue");
BOMapper mapper = new BOMapper(bo1);
Assert.AreEqual("MyValue", mapper.GetPropertyValueToDisplay("MyRelationship.MyRelatedTestProp"));
}
public void CreateQueryField_WithRelatedClass()
{
//---------------Set up test pack-------------------
var classDef = MyBO.LoadClassDefWithRelationship();
var relatedClassDef = MyRelatedBo.LoadClassDef();
const string relationshipName = "MyRelationship";
const string propertyName = "MyRelatedTestProp";
const string fullpropertyName = relationshipName + "." + propertyName;
//---------------Execute Test ----------------------
var queryField = QueryBuilder.CreateQueryField(classDef, fullpropertyName);
//---------------Test Result -----------------------
Assert.AreEqual(propertyName, queryField.PropertyName);
Assert.AreEqual(propertyName, queryField.FieldName);
Assert.AreEqual(new Source(relatedClassDef.ClassName), queryField.Source);
}
public void TestGetMultiple()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)classDef.CreateNewBusinessObject();
string relationshipName = "MyMultipleRelationship";
//---------------Execute Test ----------------------
IMultipleRelationship relationship = bo1.Relationships.GetMultiple(relationshipName);
//---------------Test Result -----------------------
Assert.IsNotNull(relationship);
Assert.AreEqual(relationshipName, relationship.RelationshipName);
}
public void Test_GetPropertyValueToDisplay_WhenRelatedVirtualPropertyValue_WithNullRelationship_ShouldReturnNullValue()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
var bo = new MyRelatedBo();
bo.MyRelationship = null;
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var mapper = CreateBOMapper(bo);
var propertyValueToDisplay = mapper.GetPropertyValueToDisplay("MyRelationship.-MyName-");
//---------------Test Result -----------------------
Assert.IsNull(propertyValueToDisplay);
}
public void Test_SetDisplayPropertyValue_WithRelatedVirtualPropName_ShouldSetPropValue()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
var bo = new MyRelatedBo();
bo.MyRelationship = new MyBO();
var myNewValue = "MyNewValue";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var mapper = CreateBOMapper(bo);
mapper.SetDisplayPropertyValue("MyRelationship.-MySettableVirtualProp-", myNewValue);
//---------------Test Result -----------------------
Assert.AreEqual(myNewValue, bo.MyRelationship.MySettableVirtualProp);
}
public void Test_CreateBusinessObject_OnlyFiresOneAddedEvent()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo = new MyBO();
IMultipleRelationship rel = bo.Relationships.GetMultiple("MyMultipleRelationship");
RelatedBusinessObjectCollection <MyRelatedBo> col = (RelatedBusinessObjectCollection <MyRelatedBo>)rel.BusinessObjectCollection;
int addedEventCount = 0;
col.BusinessObjectAdded += (sender, e) => addedEventCount++;
//---------------Assert Precondition----------------
Assert.AreEqual(0, addedEventCount);
//---------------Execute Test ----------------------
col.CreateBusinessObject();
//---------------Test Result -----------------------
Assert.AreEqual(1, addedEventCount);
}
public void Test_SetDisplayPropertyValue_WithRelatedPropName_WhenNullRelationship_ShouldSetPropValue()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
var bo = new MyRelatedBo();
bo.MyRelationship = null;
var myNewValue = "MyNewValue";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var mapper = CreateBOMapper(bo);
Assert.DoesNotThrow(() =>
{
mapper.SetDisplayPropertyValue("MyRelationship.TestProp", myNewValue);
});
//---------------Test Result -----------------------
}
public void TestGetMultiple_Fail()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)classDef.CreateNewBusinessObject();
string relationshipName = "MyRelationship";
//---------------Execute Test ----------------------
try
{
IMultipleRelationship relationship = bo1.Relationships.GetMultiple(relationshipName);
Assert.Fail("Should have failed because we're accessing a single relationship as a multiple.");
//---------------Test Result -----------------------
}
catch (InvalidRelationshipAccessException)
{
}
}
public void TestSetRelatedBusinessObjectWithWrongRelationshipType()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
IClassDef relatedClassDef = MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)classDef.CreateNewBusinessObject();
MyRelatedBo relatedBo1 = (MyRelatedBo)relatedClassDef.CreateNewBusinessObject();
//---------------Execute Test ----------------------
try
{
bo1.Relationships.SetRelatedObject("MyMultipleRelationship", relatedBo1);
Assert.Fail("Expected to throw an InvalidRelationshipAccessException");
}
//---------------Test Result -----------------------
catch (InvalidRelationshipAccessException ex)
{
StringAssert.Contains("SetRelatedObject() was passed a relationship (MyMultipleRelationship) that is of type 'multiple' when it expects a 'single' relationship", ex.Message);
}
}
public void TestMissingRelationshipErrorMessageMultiple()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)classDef.CreateNewBusinessObject();
//---------------Execute Test ----------------------
try
{
bo1.Relationships.GetRelatedCollection("WrongRelationshipName");
Assert.Fail("Expected to throw an RelationshipNotFoundException");
}
//---------------Test Result -----------------------
catch (RelationshipNotFoundException ex)
{
StringAssert.Contains("The relationship WrongRelationshipName was not found on a BusinessObject of type Habanero.Test.MyBO", ex.Message);
}
}
public void TestInvalidRelationshipAccessSingle()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)classDef.CreateNewBusinessObject();
//---------------Execute Test ----------------------
try
{
bo1.Relationships.GetRelatedCollection("MyRelationship");
Assert.Fail("Expected to throw an InvalidRelationshipAccessException");
}
//---------------Test Result -----------------------
catch (InvalidRelationshipAccessException ex)
{
StringAssert.Contains("The 'single' relationship MyRelationship was accessed as a 'multiple' relationship (using GetRelatedCollection()).", ex.Message);
}
}
public void Test_CreateBusinessObject_AddedToTheCollection()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadClassDefWithRelationship();
MyRelatedBo.LoadClassDef();
MyBO bo = new MyBO();
IMultipleRelationship rel = bo.Relationships.GetMultiple("MyMultipleRelationship");
RelatedBusinessObjectCollection <MyRelatedBo> col = new RelatedBusinessObjectCollection <MyRelatedBo>(rel);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
MyRelatedBo relatedBo = col.CreateBusinessObject();
//---------------Test Result -----------------------
Assert.AreEqual(bo.MyBoID, relatedBo.MyBoID, "The foreign key should eb set");
Assert.IsTrue(relatedBo.Status.IsNew);
Assert.AreEqual(1, col.CreatedBusinessObjects.Count, "The created BOs should be added");
Assert.AreEqual(0, col.AddedBusinessObjects.Count);
Assert.AreEqual(1, col.Count);
}
public void Test_GetPropertyValue_WithDot_IncorrectRelationshipName()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
_itsClassDef = MyBO.LoadClassDefWithRelationship();
_itsRelatedClassDef = MyRelatedBo.LoadClassDef();
MyBO bo1 = (MyBO)_itsClassDef.CreateNewBusinessObject();
BOMapper mapper = new BOMapper(bo1);
//---------------Execute Test ----------------------
try
{
mapper.GetPropertyValueToDisplay("MyIncorrectRelationship.MyRelatedTestProp");
Assert.Fail("Expected to throw an RelationshipNotFoundException");
}
//---------------Test Result -----------------------
catch (RelationshipNotFoundException ex)
{
StringAssert.Contains("The relationship 'MyIncorrectRelationship' on 'MyBO' cannot be found", ex.Message);
}
}
public void TestCreateOrderCriteria_ThroughRelationship()
{
//---------------Set up test pack-------------------
IClassDef myRelatedBoClassDef = MyRelatedBo.LoadClassDefWithDifferentTableAndFieldNames();
IClassDef myBoClassdef = MyBO.LoadClassDefWithRelationship();
//---------------Execute Test ----------------------
IOrderCriteria orderCriteria = QueryBuilder.CreateOrderCriteria(myBoClassdef, "MyRelationship.MyRelatedTestProp");
//---------------Test Result -----------------------
IOrderCriteriaField orderCriteriaField = orderCriteria.Fields[0];
Assert.AreEqual(myRelatedBoClassDef.GetPropDef("MyRelatedTestProp").DatabaseFieldName, orderCriteriaField.FieldName);
Assert.AreEqual(myBoClassdef.ClassName, orderCriteriaField.Source.Name);
Assert.AreEqual(myBoClassdef.GetTableName(), orderCriteriaField.Source.EntityName);
Assert.AreEqual(1, orderCriteriaField.Source.Joins.Count);
Source.Join relJoin = orderCriteriaField.Source.Joins[0];
Assert.AreEqual("MyRelationship", relJoin.ToSource.Name);
Assert.AreEqual(myRelatedBoClassDef.GetTableName(), relJoin.ToSource.EntityName);
Assert.AreEqual(1, relJoin.JoinFields.Count);
Assert.AreEqual("RelatedID", relJoin.JoinFields[0].FromField.PropertyName);
Assert.AreEqual("MyRelatedBoID", relJoin.JoinFields[0].ToField.PropertyName);
//---------------Tear Down -------------------------
}