public void TestDeleteRelated()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
AddressTestBO address;
ContactPersonTestBO contactPersonTestBO =
ContactPersonTestBO.CreateContactPersonWithOneAddress_CascadeDelete(out address, TestUtil.GetRandomString());
contactPersonTestBO.MarkForDelete();
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(contactPersonTestBO);
//---------------Execute Test ----------------------
committer.CommitTransaction();
//---------------Test Result -----------------------
AssertBOStateIsValidAfterDelete(contactPersonTestBO);
AssertBOStateIsValidAfterDelete(address);
AssertBusinessObjectNotInDataStore(contactPersonTestBO);
AssertBusinessObjectNotInDataStore(address);
}
public void Read_ShouldLoadObjectsAsSaved()
{
//---------------Set up test pack-------------------
LoadMyBOClassDefsWithNoUIDefs();
var savedDataStore = new DataStoreInMemory();
var savedBo = new MyBO();
var transactionCommitter = new TransactionCommitterInMemory(savedDataStore);
transactionCommitter.AddBusinessObject(savedBo);
transactionCommitter.CommitTransaction();
var writeStream = GetStreamForDataStore(savedDataStore);
var reader = new DataStoreInMemoryXmlReader();
//---------------Assert Precondition----------------
Assert.AreEqual(1, savedDataStore.Count);
//---------------Execute Test ----------------------
var loadedDataStore = reader.Read(writeStream);
//---------------Test Result -----------------------
Assert.AreEqual(1, loadedDataStore.Count);
IBusinessObject loadedBo;
var success = loadedDataStore.AllObjects.TryGetValue(savedBo.MyBoID.GetValueOrDefault(), out loadedBo);
Assert.IsTrue(success);
Assert.IsNotNull(loadedBo);
Assert.IsInstanceOf(typeof(MyBO), loadedBo);
var loadedMyBo = (MyBO)loadedBo;
Assert.AreNotSame(savedBo, loadedMyBo);
Assert.IsFalse(loadedBo.Status.IsNew, "Should not be New");
Assert.IsFalse(loadedBo.Status.IsDeleted, "Should not be Deleted");
Assert.IsFalse(loadedBo.Status.IsDirty, "Should not be Dirty");
Assert.IsFalse(loadedBo.Status.IsEditing, "Should not be Editing");
}
public void Test_CommitTransaction_WithAutoIncrementBo_ShouldUseNumberGeneratorsInDatastore()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
IClassDef classDef = TestAutoInc.LoadClassDefWithAutoIncrementingID();
DataStoreInMemory dataStore = MockRepository.GeneratePartialMock <DataStoreInMemory>();
dataStore.Replay();
int nextAutoIncNumber = TestUtil.GetRandomInt();
dataStore.Stub(t => t.GetNextAutoIncrementingNumber(classDef)).Return(nextAutoIncNumber);
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
TestAutoInc bo = new TestAutoInc();
bo.SetPropertyValue("testfield", "testing 123");
transactionCommitter.AddBusinessObject(bo);
//---------------Assert Precondition----------------
Assert.IsFalse(bo.TestAutoIncID.HasValue);
Assert.AreSame(classDef, bo.ClassDef);
Assert.IsTrue(bo.Props.HasAutoIncrementingField);
//---------------Execute Test ----------------------
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
dataStore.AssertWasCalled(memory => memory.GetNextAutoIncrementingNumber(classDef));
Assert.IsNotNull(bo.TestAutoIncID);
Assert.AreEqual(nextAutoIncNumber, bo.TestAutoIncID);
Assert.IsFalse(bo.Status.IsDirty);
}
public void TestUpdate()
{
//---------------Set up test pack-------------------
ContactPersonTestBO cp = GetContactPerson();
DataStoreInMemory dataStore = new DataStoreInMemory();
IBusinessObjectLoader loader = new BusinessObjectLoaderInMemory(dataStore);
ITransactionCommitter firstTransactionCommitter = new TransactionCommitterInMemory(dataStore);
firstTransactionCommitter.AddBusinessObject(cp);
firstTransactionCommitter.CommitTransaction();
//---------------Execute Test ----------------------
cp.Surname = Guid.NewGuid().ToString("N");
ITransactionCommitter secondTransactionCommitter = new TransactionCommitterInMemory(dataStore);
secondTransactionCommitter.AddBusinessObject(cp);
secondTransactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.AreEqual(1, dataStore.Count);
Assert.AreSame(cp, loader.GetBusinessObject <ContactPersonTestBO>(cp.ID));
Assert.IsFalse(cp.Status.IsDirty);
//---------------Tear Down -------------------------
}
public void Test_LoadingFromMultipleSources()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore1 = new DataStoreInMemory();
DataStoreInMemory dataStore2 = new DataStoreInMemory();
MyBO.LoadDefaultClassDef();
TransactionCommitterInMemory committer1 = new TransactionCommitterInMemory(dataStore1);
var bo1 = new MyBO();
committer1.AddBusinessObject(bo1);
committer1.CommitTransaction();
MyRelatedBo.LoadClassDef();
TransactionCommitterInMemory committer2 = new TransactionCommitterInMemory(dataStore2);
var bo2 = new MyRelatedBo();
committer2.AddBusinessObject(bo2);
committer2.CommitTransaction();
DataAccessorInMemory dataAccessorInMemory1 = new DataAccessorInMemory(dataStore1);
DataAccessorInMemory dataAccessorInMemory2 = new DataAccessorInMemory(dataStore2);
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
DataAccessorMultiSource dataAccessor = new DataAccessorMultiSource(new DataAccessorInMemory());
dataAccessor.AddDataAccessor(typeof(MyBO), dataAccessorInMemory1);
dataAccessor.AddDataAccessor(typeof(MyRelatedBo), dataAccessorInMemory2);
var loadedBo1 = dataAccessor.BusinessObjectLoader.GetBusinessObject<MyBO>(bo1.ID);
var loadedBo2 = dataAccessor.BusinessObjectLoader.GetBusinessObject<MyRelatedBo>(bo2.ID);
//---------------Tear down -------------------------
Assert.AreSame(loadedBo1, bo1);
Assert.AreSame(loadedBo2, bo2);
}
public void TestPreventDelete()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStoreInMemory = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStoreInMemory);
AddressTestBO address;
ContactPersonTestBO contactPersonTestBO =
ContactPersonTestBO.CreateContactPersonWithOneAddress_PreventDelete(out address);
// contactPersonTestBO.MarkForDelete();
ReflectionUtilities.SetPropertyValue(contactPersonTestBO.Status, "IsDeleted", true);
ITransactionCommitter committer = new TransactionCommitterInMemory(dataStoreInMemory);
committer.AddBusinessObject(contactPersonTestBO);
//---------------Execute Test ----------------------
try
{
committer.CommitTransaction();
Assert.Fail("Expected to throw an BusObjPersistException");
}
//---------------Test Result -----------------------
catch (BusObjPersistException ex)
{
StringAssert.Contains("You cannot delete ContactPersonTestBO", ex.Message);
}
}
public void TestDeleteRelated_WhenCircularDelete_ShouldResolve()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
Entity.LoadDefaultClassDef_WithCircularDeleteRelatedToSelf();
Entity entity1 = new Entity();
Entity entity2 = new Entity();
entity1.Relationships.SetRelatedObject("RelatedEntity", entity2);
entity2.Relationships.SetRelatedObject("RelatedEntity", entity1);
entity1.Save();
entity2.Save();
entity1.MarkForDelete();
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(entity1);
//---------------Execute Test ----------------------
committer.CommitTransaction();
//---------------Test Result -----------------------
AssertBOStateIsValidAfterDelete(entity1);
AssertBOStateIsValidAfterDelete(entity2);
AssertBusinessObjectNotInDataStore(entity1);
AssertBusinessObjectNotInDataStore(entity2);
}
public void TestCheckForDuplicate()
{
DataStoreInMemory dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
ContactPersonTestBO.LoadClassDefWithCompositeAlternateKey();
ContactPersonTestBO contactPerson = GetSavedContactPerson(dataStore);
ContactPersonTestBO duplicateContactPerson = new ContactPersonTestBO();
duplicateContactPerson.Surname = contactPerson.Surname;
duplicateContactPerson.FirstName = contactPerson.FirstName;
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(duplicateContactPerson);
//---------------Execute Test ----------------------
try
{
committer.CommitTransaction();
Assert.Fail("Commit should have failed due to duplicate key violation");
}
//---------------Test Result -----------------------
catch (BusObjDuplicateConcurrencyControlException ex)
{
StringAssert.Contains("Surname", ex.Message);
StringAssert.Contains("FirstName", ex.Message);
}
}
public void TestDelete()
{
//---------------Set up test pack-------------------
ContactPersonTestBO cp = GetContactPerson();
DataStoreInMemory dataStore = new DataStoreInMemory();
ITransactionCommitter firstTransactionCommitter = new TransactionCommitterInMemory(dataStore);
firstTransactionCommitter.AddBusinessObject(cp);
firstTransactionCommitter.CommitTransaction();
//---------------Assert Preconditions--------------
Assert.AreEqual(1, dataStore.Count);
//---------------Execute Test ----------------------
cp.MarkForDelete();
ITransactionCommitter secondTransactionCommitter = new TransactionCommitterInMemory(dataStore);
secondTransactionCommitter.AddBusinessObject(cp);
secondTransactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.AreEqual(0, dataStore.Count);
// Assert.IsNull(loader.GetBusinessObject<ContactPersonTestBO>(cp.PrimaryKey));
}
public void Read_ShouldLoadObjectsAsSaved()
{
//---------------Set up test pack-------------------
LoadMyBOClassDefsWithNoUIDefs();
var savedDataStore = new DataStoreInMemory();
var savedBo = new MyBO();
var transactionCommitter = new TransactionCommitterInMemory(savedDataStore);
transactionCommitter.AddBusinessObject(savedBo);
transactionCommitter.CommitTransaction();
var writeStream = GetStreamForDataStore(savedDataStore);
var reader = new DataStoreInMemoryXmlReader();
//---------------Assert Precondition----------------
Assert.AreEqual(1, savedDataStore.Count);
//---------------Execute Test ----------------------
var loadedDataStore = reader.Read(writeStream);
//---------------Test Result -----------------------
Assert.AreEqual(1, loadedDataStore.Count);
IBusinessObject loadedBo;
var success = loadedDataStore.AllObjects.TryGetValue(savedBo.MyBoID.GetValueOrDefault(), out loadedBo);
Assert.IsTrue(success);
Assert.IsNotNull(loadedBo);
Assert.IsInstanceOf(typeof(MyBO), loadedBo);
var loadedMyBo = (MyBO)loadedBo;
Assert.AreNotSame(savedBo, loadedMyBo);
Assert.IsFalse(loadedBo.Status.IsNew, "Should not be New");
Assert.IsFalse(loadedBo.Status.IsDeleted, "Should not be Deleted");
Assert.IsFalse(loadedBo.Status.IsDirty, "Should not be Dirty");
Assert.IsFalse(loadedBo.Status.IsEditing, "Should not be Editing");
}
public void Read_ShouldLoadObjectsAsNew()
{
//---------------Set up test pack-------------------
LoadMyBOClassDefsWithNoUIDefs();
var savedDataStore = new DataStoreInMemory();
var savedBo = new MyBO();
var transactionCommitter = new TransactionCommitterInMemory(savedDataStore);
transactionCommitter.AddBusinessObject(savedBo);
transactionCommitter.CommitTransaction();
var stream = GetStreamForDataStore(savedDataStore);
var xmlReader = GetXmlReader(stream);
var reader = new BusinessObjectXmlReader();
//---------------Assert Precondition----------------
Assert.AreEqual(1, savedDataStore.Count);
//---------------Execute Test ----------------------
var loadedObjects = reader.Read(xmlReader);
//---------------Test Result -----------------------
var businessObjects = loadedObjects.ToList();
Assert.AreEqual(1, businessObjects.Count);
var loadedMyBo = (MyBO)businessObjects[0];
Assert.AreNotSame(savedBo, loadedMyBo);
Assert.IsTrue(loadedMyBo.Status.IsNew, "Should not be New");
Assert.IsFalse(loadedMyBo.Status.IsDeleted, "Should not be Deleted");
}
private static ContactPersonTestBO GetSavedContactPerson(DataStoreInMemory dataStore)
{
ContactPersonTestBO contactPersonCompositeKey = GetUnsavedContactPerson();
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(contactPersonCompositeKey);
committer.CommitTransaction();
return(contactPersonCompositeKey);
}
private MyRelatedBo CreateMyRelatedBO(DataStoreInMemory dataStore2)
{
MyRelatedBo.LoadClassDef();
TransactionCommitterInMemory committer2 = new TransactionCommitterInMemory(dataStore2);
var bo2 = new MyRelatedBo();
committer2.AddBusinessObject(bo2);
committer2.CommitTransaction();
return(bo2);
}
private MyBO CreateMyBO(DataStoreInMemory dataStore1)
{
MyBO.LoadDefaultClassDef();
TransactionCommitterInMemory committer1 = new TransactionCommitterInMemory(dataStore1);
var bo1 = new MyBO();
committer1.AddBusinessObject(bo1);
committer1.CommitTransaction();
return(bo1);
}
public void TestInsert()
{
//---------------Set up test pack-------------------
ContactPersonTestBO cp = GetContactPerson();
DataStoreInMemory dataStore = new DataStoreInMemory();
IBusinessObjectLoader loader = new BusinessObjectLoaderInMemory(dataStore);
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
//---------------Execute Test ----------------------
transactionCommitter.AddBusinessObject(cp);
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.AreEqual(1, dataStore.Count);
Assert.AreSame(cp, loader.GetBusinessObject<ContactPersonTestBO>(cp.ID));
//---------------Tear Down -------------------------
}
public void TestInsert()
{
//---------------Set up test pack-------------------
ContactPersonTestBO cp = GetContactPerson();
DataStoreInMemory dataStore = new DataStoreInMemory();
IBusinessObjectLoader loader = new BusinessObjectLoaderInMemory(dataStore);
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
//---------------Execute Test ----------------------
transactionCommitter.AddBusinessObject(cp);
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.AreEqual(1, dataStore.Count);
Assert.AreSame(cp, loader.GetBusinessObject <ContactPersonTestBO>(cp.ID));
//---------------Tear Down -------------------------
}
public void Test_CommitTransaction_WithAutoIncrementBo_ShouldAutoIncrementAfterInsert()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
TestAutoInc.LoadClassDefWithAutoIncrementingID();
DataStoreInMemory dataStore = new DataStoreInMemory();
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
TestAutoInc bo = new TestAutoInc();
bo.SetPropertyValue("testfield", "testing 123");
transactionCommitter.AddBusinessObject(bo);
//---------------Assert Precondition----------------
Assert.IsFalse(bo.TestAutoIncID.HasValue);
//---------------Execute Test ----------------------
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.IsNotNull(bo.TestAutoIncID);
Assert.AreNotEqual(0, bo.TestAutoIncID);
Assert.IsFalse(bo.Status.IsDirty);
}
public void Read_ShouldLoadPropertiesCorrectly()
{
//---------------Set up test pack-------------------
LoadMyBOClassDefsWithNoUIDefs();
var savedBo = new MyBO {
TestProp = TestUtil.GetRandomString(), TestProp2 = TestUtil.GetRandomString()
};
var savedDataStore = new DataStoreInMemory();
var transactionCommitter = new TransactionCommitterInMemory(savedDataStore);
transactionCommitter.AddBusinessObject(savedBo);
transactionCommitter.CommitTransaction();
var stream = GetStreamForDataStore(savedDataStore);
var xmlReader = GetXmlReader(stream);
var reader = new BusinessObjectXmlReader();
//---------------Assert Precondition----------------
Assert.AreEqual(1, savedDataStore.Count);
//---------------Execute Test ----------------------
var loadedObjects = reader.Read(xmlReader);
//---------------Test Result -----------------------
var businessObjects = loadedObjects.ToList();
Assert.AreEqual(1, businessObjects.Count());
var myBos = businessObjects.Select(o => (MyBO)o);
var matchedBos = myBos.Where(bo => bo.TestProp.Equals(savedBo.TestProp));
Assert.AreEqual(1, matchedBos.Count());
var loadedMyBo = matchedBos.First();
Assert.AreNotSame(savedBo, loadedMyBo);
Assert.AreEqual(savedBo.MyBoID, loadedMyBo.MyBoID);
Assert.AreEqual(savedBo.Props["MyBoID"].PersistedPropertyValue, loadedMyBo.Props["MyBoID"].PersistedPropertyValue);
Assert.AreEqual(savedBo.TestProp, loadedMyBo.TestProp);
Assert.AreEqual(savedBo.Props["TestProp"].PersistedPropertyValue, loadedMyBo.Props["TestProp"].PersistedPropertyValue);
Assert.AreEqual(savedBo.TestProp2, loadedMyBo.TestProp2);
Assert.AreEqual(savedBo.Props["TestProp2"].PersistedPropertyValue, loadedMyBo.Props["TestProp2"].PersistedPropertyValue);
}
public void Test_LoadingFromMultipleSources()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore1 = new DataStoreInMemory();
DataStoreInMemory dataStore2 = new DataStoreInMemory();
MyBO.LoadDefaultClassDef();
TransactionCommitterInMemory committer1 = new TransactionCommitterInMemory(dataStore1);
var bo1 = new MyBO();
committer1.AddBusinessObject(bo1);
committer1.CommitTransaction();
MyRelatedBo.LoadClassDef();
TransactionCommitterInMemory committer2 = new TransactionCommitterInMemory(dataStore2);
var bo2 = new MyRelatedBo();
committer2.AddBusinessObject(bo2);
committer2.CommitTransaction();
DataAccessorInMemory dataAccessorInMemory1 = new DataAccessorInMemory(dataStore1);
DataAccessorInMemory dataAccessorInMemory2 = new DataAccessorInMemory(dataStore2);
//---------------Execute Test ----------------------
//---------------Test Result -----------------------
DataAccessorMultiSource dataAccessor = new DataAccessorMultiSource(new DataAccessorInMemory());
dataAccessor.AddDataAccessor(typeof(MyBO), dataAccessorInMemory1);
dataAccessor.AddDataAccessor(typeof(MyRelatedBo), dataAccessorInMemory2);
var loadedBo1 = dataAccessor.BusinessObjectLoader.GetBusinessObject <MyBO>(bo1.ID);
var loadedBo2 = dataAccessor.BusinessObjectLoader.GetBusinessObject <MyRelatedBo>(bo2.ID);
//---------------Tear down -------------------------
Assert.AreSame(loadedBo1, bo1);
Assert.AreSame(loadedBo2, bo2);
}
public void TestUpdate()
{
//---------------Set up test pack-------------------
ContactPersonTestBO cp = GetContactPerson();
DataStoreInMemory dataStore = new DataStoreInMemory();
IBusinessObjectLoader loader = new BusinessObjectLoaderInMemory(dataStore);
ITransactionCommitter firstTransactionCommitter = new TransactionCommitterInMemory(dataStore);
firstTransactionCommitter.AddBusinessObject(cp);
firstTransactionCommitter.CommitTransaction();
//---------------Execute Test ----------------------
cp.Surname = Guid.NewGuid().ToString("N");
ITransactionCommitter secondTransactionCommitter = new TransactionCommitterInMemory(dataStore);
secondTransactionCommitter.AddBusinessObject(cp);
secondTransactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.AreEqual(1, dataStore.Count);
Assert.AreSame(cp, loader.GetBusinessObject<ContactPersonTestBO>(cp.ID));
Assert.IsFalse(cp.Status.IsDirty);
//---------------Tear Down -------------------------
}
public void Test_CommitTransaction_NonAutoIncrementingBo_ShouldNotCall_GetNextAutoIncrementingNumber()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
ContactPersonTestBO cp = GetContactPerson();
ClassDef classDef = cp.ClassDef;
DataStoreInMemory dataStore = MockRepository.GeneratePartialMock <DataStoreInMemory>();
dataStore.Replay();
dataStore.Stub(t => t.GetNextAutoIncrementingNumber(classDef)).Return(1);
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
transactionCommitter.AddBusinessObject(cp);
//---------------Assert Precondition----------------
Assert.AreSame(classDef, cp.ClassDef);
Assert.IsFalse(cp.Props.HasAutoIncrementingField);
//---------------Execute Test ----------------------
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
dataStore.AssertWasNotCalled(memory => memory.GetNextAutoIncrementingNumber(Arg <IClassDef> .Is.Anything));
}
public void Test_AddDirtyChildrenToTransactionCommitter()
{
//---------------Set up test pack-------------------
new AddressTestBO();
ContactPersonTestBO.LoadClassDefOrganisationTestBORelationship_MultipleReverse();
OrganisationTestBO.LoadDefaultClassDef_WithMultipleRelationshipToAddress();
OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation();
RelationshipCol relationships = organisationTestBO.Relationships;
MultipleRelationship <ContactPersonTestBO> contactPersonRelationship = organisationTestBO.Relationships.GetMultiple <ContactPersonTestBO>("ContactPeople");
BusinessObjectCollection <ContactPersonTestBO> contactPersonCol = contactPersonRelationship.BusinessObjectCollection;
MultipleRelationship <AddressTestBO> addressRelationship = organisationTestBO.Relationships.GetMultiple <AddressTestBO>("Addresses");
BusinessObjectCollection <AddressTestBO> addressCol = addressRelationship.BusinessObjectCollection;
contactPersonCol.CreateBusinessObject();
addressCol.CreateBusinessObject();
//---------------Execute Test ----------------------
TransactionCommitterInMemory tc = new TransactionCommitterInMemory(new DataStoreInMemory());
relationships.AddDirtyChildrenToTransactionCommitter(tc);
//---------------Test Result -----------------------
Assert.AreEqual(2, tc.OriginalTransactions.Count);
}
public void Read_ShouldLoadObjectsAsNew_WhenNotInExistingDataStore()
{
//---------------Set up test pack-------------------
LoadMyBOClassDefsWithNoUIDefs();
var savedDataStore = new DataStoreInMemory();
var savedBo = new MyBO();
var transactionCommitter = new TransactionCommitterInMemory(savedDataStore);
transactionCommitter.AddBusinessObject(savedBo);
transactionCommitter.CommitTransaction();
var writeStream = GetStreamForDataStore(savedDataStore);
var reader = new ObjectTreeXmlReader();
//---------------Assert Precondition----------------
Assert.AreEqual(1, savedDataStore.Count);
//---------------Execute Test ----------------------
var loadedObjects = reader.Read(writeStream);
//---------------Test Result -----------------------
var businessObjects = loadedObjects.ToList();
Assert.AreEqual(1, businessObjects.Count);
var loadedMyBo = (MyBO)businessObjects[0];
Assert.AreNotSame(savedBo, loadedMyBo);
Assert.IsTrue(loadedMyBo.Status.IsNew, "Should not be New");
Assert.IsFalse(loadedMyBo.Status.IsDeleted, "Should not be Deleted");
}
public void Test_CommitTransaction_WithAutoIncrementBo_ShouldAutoIncrementAfterInsert()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
TestAutoInc.LoadClassDefWithAutoIncrementingID();
DataStoreInMemory dataStore = new DataStoreInMemory();
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
TestAutoInc bo = new TestAutoInc();
bo.SetPropertyValue("testfield", "testing 123");
transactionCommitter.AddBusinessObject(bo);
//---------------Assert Precondition----------------
Assert.IsFalse(bo.TestAutoIncID.HasValue);
//---------------Execute Test ----------------------
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.IsNotNull(bo.TestAutoIncID);
Assert.AreNotEqual(0, bo.TestAutoIncID);
Assert.IsFalse(bo.Status.IsDirty);
}
private MyRelatedBo CreateMyRelatedBO(DataStoreInMemory dataStore2)
{
MyRelatedBo.LoadClassDef();
TransactionCommitterInMemory committer2 = new TransactionCommitterInMemory(dataStore2);
var bo2 = new MyRelatedBo();
committer2.AddBusinessObject(bo2);
committer2.CommitTransaction();
return bo2;
}
public void TestPersistSimpleBO_NewDelete()
{
//---------------Set up test pack-------------------
MockBO mockBo = new MockBO();
TransactionCommitterInMemory inMemoryCommitter = new TransactionCommitterInMemory(new DataStoreInMemory());
inMemoryCommitter.AddBusinessObject(mockBo);
inMemoryCommitter.CommitTransaction();
TransactionCommitterDB committerDB = new TransactionCommitterDB(DatabaseConnection.CurrentConnection);
mockBo.MarkForDelete();
committerDB.AddTransaction(new TransactionalBusinessObjectDB(mockBo, committerDB.DatabaseConnection));
//---------------Execute Test ----------------------
committerDB.CommitTransaction();
//---------------Test Result -----------------------
BOTestUtils.AssertBOStateIsValidAfterDelete(mockBo);
AssertMockBONotInDatabase(mockBo.MockBOID);
}
public void Read_ShouldLoadPropertiesCorrectly()
{
//---------------Set up test pack-------------------
LoadMyBOClassDefsWithNoUIDefs();
var savedBo = new MyBO {TestProp = TestUtil.GetRandomString(), TestProp2 = TestUtil.GetRandomString()};
var savedDataStore = new DataStoreInMemory();
var transactionCommitter = new TransactionCommitterInMemory(savedDataStore);
transactionCommitter.AddBusinessObject(savedBo);
transactionCommitter.CommitTransaction();
var stream = GetStreamForDataStore(savedDataStore);
var xmlReader = GetXmlReader(stream);
var reader = new BusinessObjectXmlReader();
//---------------Assert Precondition----------------
Assert.AreEqual(1, savedDataStore.Count);
//---------------Execute Test ----------------------
var loadedObjects = reader.Read(xmlReader);
//---------------Test Result -----------------------
var businessObjects = loadedObjects.ToList();
Assert.AreEqual(1, businessObjects.Count());
var myBos = businessObjects.Select(o => (MyBO)o);
var matchedBos = myBos.Where(bo => bo.TestProp.Equals(savedBo.TestProp));
Assert.AreEqual(1, matchedBos.Count());
var loadedMyBo = matchedBos.First();
Assert.AreNotSame(savedBo, loadedMyBo);
Assert.AreEqual(savedBo.MyBoID, loadedMyBo.MyBoID);
Assert.AreEqual(savedBo.Props["MyBoID"].PersistedPropertyValue, loadedMyBo.Props["MyBoID"].PersistedPropertyValue);
Assert.AreEqual(savedBo.TestProp, loadedMyBo.TestProp);
Assert.AreEqual(savedBo.Props["TestProp"].PersistedPropertyValue, loadedMyBo.Props["TestProp"].PersistedPropertyValue);
Assert.AreEqual(savedBo.TestProp2, loadedMyBo.TestProp2);
Assert.AreEqual(savedBo.Props["TestProp2"].PersistedPropertyValue, loadedMyBo.Props["TestProp2"].PersistedPropertyValue);
}
public void TestDelete()
{
//---------------Set up test pack-------------------
ContactPersonTestBO cp = GetContactPerson();
DataStoreInMemory dataStore = new DataStoreInMemory();
ITransactionCommitter firstTransactionCommitter = new TransactionCommitterInMemory(dataStore);
firstTransactionCommitter.AddBusinessObject(cp);
firstTransactionCommitter.CommitTransaction();
//---------------Assert Preconditions--------------
Assert.AreEqual(1, dataStore.Count);
//---------------Execute Test ----------------------
cp.MarkForDelete();
ITransactionCommitter secondTransactionCommitter = new TransactionCommitterInMemory(dataStore);
secondTransactionCommitter.AddBusinessObject(cp);
secondTransactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
Assert.AreEqual(0, dataStore.Count);
// Assert.IsNull(loader.GetBusinessObject<ContactPersonTestBO>(cp.PrimaryKey));
}
public void Test_CommitTransaction_NonAutoIncrementingBo_ShouldNotCall_GetNextAutoIncrementingNumber()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
ContactPersonTestBO cp = GetContactPerson();
ClassDef classDef = cp.ClassDef;
DataStoreInMemory dataStore = MockRepository.GeneratePartialMock<DataStoreInMemory>();
dataStore.Replay();
dataStore.Stub(t => t.GetNextAutoIncrementingNumber(classDef)).Return(1);
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
transactionCommitter.AddBusinessObject(cp);
//---------------Assert Precondition----------------
Assert.AreSame(classDef, cp.ClassDef);
Assert.IsFalse(cp.Props.HasAutoIncrementingField);
//---------------Execute Test ----------------------
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
dataStore.AssertWasNotCalled(memory => memory.GetNextAutoIncrementingNumber(Arg<IClassDef>.Is.Anything));
}
private MyBO CreateMyBO(DataStoreInMemory dataStore1)
{
MyBO.LoadDefaultClassDef();
TransactionCommitterInMemory committer1 = new TransactionCommitterInMemory(dataStore1);
var bo1 = new MyBO();
committer1.AddBusinessObject(bo1);
committer1.CommitTransaction();
return bo1;
}
public void Test_AddDirtyChildrenToTransactionCommitter()
{
//---------------Set up test pack-------------------
new AddressTestBO();
ContactPersonTestBO.LoadClassDefOrganisationTestBORelationship_MultipleReverse();
OrganisationTestBO.LoadDefaultClassDef_WithMultipleRelationshipToAddress();
OrganisationTestBO organisationTestBO = OrganisationTestBO.CreateSavedOrganisation();
RelationshipCol relationships = organisationTestBO.Relationships;
MultipleRelationship<ContactPersonTestBO> contactPersonRelationship = organisationTestBO.Relationships.GetMultiple<ContactPersonTestBO>("ContactPeople");
BusinessObjectCollection<ContactPersonTestBO> contactPersonCol = contactPersonRelationship.BusinessObjectCollection;
MultipleRelationship<AddressTestBO> addressRelationship = organisationTestBO.Relationships.GetMultiple<AddressTestBO>("Addresses");
BusinessObjectCollection<AddressTestBO> addressCol = addressRelationship.BusinessObjectCollection;
contactPersonCol.CreateBusinessObject();
addressCol.CreateBusinessObject();
//---------------Execute Test ----------------------
TransactionCommitterInMemory tc = new TransactionCommitterInMemory(new DataStoreInMemory());
relationships.AddDirtyChildrenToTransactionCommitter(tc);
//---------------Test Result -----------------------
Assert.AreEqual(2, tc.OriginalTransactions.Count);
}
public void Test_CommitTransaction_WithAutoIncrementBo_ShouldUseNumberGeneratorsInDatastore()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
IClassDef classDef = TestAutoInc.LoadClassDefWithAutoIncrementingID();
DataStoreInMemory dataStore = MockRepository.GeneratePartialMock<DataStoreInMemory>();
dataStore.Replay();
int nextAutoIncNumber = TestUtil.GetRandomInt();
dataStore.Stub(t => t.GetNextAutoIncrementingNumber(classDef)).Return(nextAutoIncNumber);
ITransactionCommitter transactionCommitter = new TransactionCommitterInMemory(dataStore);
TestAutoInc bo = new TestAutoInc();
bo.SetPropertyValue("testfield", "testing 123");
transactionCommitter.AddBusinessObject(bo);
//---------------Assert Precondition----------------
Assert.IsFalse(bo.TestAutoIncID.HasValue);
Assert.AreSame(classDef, bo.ClassDef);
Assert.IsTrue(bo.Props.HasAutoIncrementingField);
//---------------Execute Test ----------------------
transactionCommitter.CommitTransaction();
//---------------Test Result -----------------------
dataStore.AssertWasCalled(memory => memory.GetNextAutoIncrementingNumber(classDef));
Assert.IsNotNull(bo.TestAutoIncID);
Assert.AreEqual(nextAutoIncNumber, bo.TestAutoIncID);
Assert.IsFalse(bo.Status.IsDirty);
}
private static ContactPersonTestBO GetSavedContactPerson(DataStoreInMemory dataStore)
{
ContactPersonTestBO contactPersonCompositeKey = GetUnsavedContactPerson();
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(contactPersonCompositeKey);
committer.CommitTransaction();
return contactPersonCompositeKey;
}
public void TestDeleteRelated_WhenCircularDelete_ShouldResolve()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
Entity.LoadDefaultClassDef_WithCircularDeleteRelatedToSelf();
Entity entity1 = new Entity();
Entity entity2 = new Entity();
entity1.Relationships.SetRelatedObject("RelatedEntity", entity2);
entity2.Relationships.SetRelatedObject("RelatedEntity", entity1);
entity1.Save();
entity2.Save();
entity1.MarkForDelete();
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(entity1);
//---------------Execute Test ----------------------
committer.CommitTransaction();
//---------------Test Result -----------------------
AssertBOStateIsValidAfterDelete(entity1);
AssertBOStateIsValidAfterDelete(entity2);
AssertBusinessObjectNotInDataStore(entity1);
AssertBusinessObjectNotInDataStore(entity2);
}
public void TestDeleteRelated()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
AddressTestBO address;
ContactPersonTestBO contactPersonTestBO =
ContactPersonTestBO.CreateContactPersonWithOneAddress_CascadeDelete(out address, TestUtil.GetRandomString());
contactPersonTestBO.MarkForDelete();
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(contactPersonTestBO);
//---------------Execute Test ----------------------
committer.CommitTransaction();
//---------------Test Result -----------------------
AssertBOStateIsValidAfterDelete(contactPersonTestBO);
AssertBOStateIsValidAfterDelete(address);
AssertBusinessObjectNotInDataStore(contactPersonTestBO);
AssertBusinessObjectNotInDataStore(address);
}
public void TestCheckForDuplicate()
{
DataStoreInMemory dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
ContactPersonTestBO.LoadClassDefWithCompositeAlternateKey();
ContactPersonTestBO contactPerson = GetSavedContactPerson(dataStore);
ContactPersonTestBO duplicateContactPerson = new ContactPersonTestBO();
duplicateContactPerson.Surname = contactPerson.Surname;
duplicateContactPerson.FirstName = contactPerson.FirstName;
TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore);
committer.AddBusinessObject(duplicateContactPerson);
//---------------Execute Test ----------------------
try
{
committer.CommitTransaction();
Assert.Fail("Commit should have failed due to duplicate key violation");
}
//---------------Test Result -----------------------
catch (BusObjDuplicateConcurrencyControlException ex)
{
StringAssert.Contains("Surname", ex.Message);
StringAssert.Contains("FirstName", ex.Message);
}
}
public void TestPreventDelete()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStoreInMemory = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStoreInMemory);
AddressTestBO address;
ContactPersonTestBO contactPersonTestBO =
ContactPersonTestBO.CreateContactPersonWithOneAddress_PreventDelete(out address);
// contactPersonTestBO.MarkForDelete();
ReflectionUtilities.SetPropertyValue(contactPersonTestBO.Status, "IsDeleted", true);
ITransactionCommitter committer = new TransactionCommitterInMemory(dataStoreInMemory);
committer.AddBusinessObject(contactPersonTestBO);
//---------------Execute Test ----------------------
try
{
committer.CommitTransaction();
Assert.Fail("Expected to throw an BusObjPersistException");
}
//---------------Test Result -----------------------
catch (BusObjPersistException ex)
{
StringAssert.Contains("You cannot delete ContactPersonTestBO", ex.Message);
}
}
