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