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 SetupTest() { ClassDef.ClassDefs.Clear(); DataStoreInMemory dataStore = new DataStoreInMemory(); DataAccessorInMemory dataAccessor = new DataAccessorInMemory(dataStore); BORegistry.DataAccessor = dataAccessor; }
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_Success_WhenAddingObjectsOfDifferentTypesWithSameDataAccessors() { //---------------Set up test pack------------------- IDataAccessor defaultDataAccessor = new DataAccessorInMemory(); DataStoreInMemory dataStore1 = new DataStoreInMemory(); DataAccessorInMemory dataAccessorInMemory1 = new DataAccessorInMemory(dataStore1); MyBO.LoadDefaultClassDef(); MyRelatedBo.LoadClassDef(); MyBO bo1 = new MyBO(); MyRelatedBo bo2 = new MyRelatedBo(); Dictionary <Type, IDataAccessor> dataAccessors = new Dictionary <Type, IDataAccessor>(); dataAccessors.Add(typeof(MyBO), dataAccessorInMemory1); dataAccessors.Add(typeof(MyRelatedBo), dataAccessorInMemory1); //---------------Execute Test ---------------------- ITransactionCommitter transactionCommitter1 = new TransactionCommitterMultiSource(defaultDataAccessor, dataAccessors); transactionCommitter1.AddBusinessObject(bo1); transactionCommitter1.AddBusinessObject(bo2); transactionCommitter1.CommitTransaction(); //---------------Test Result ----------------------- Assert.IsNotNull(dataStore1.Find <MyBO>(bo1.ID)); Assert.IsNotNull(dataStore1.Find <MyRelatedBo>(bo2.ID)); //---------------Tear down ------------------------- }
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 Test_LoadingFromMultipleSources() { //---------------Set up test pack------------------- DataStoreInMemory dataStore1 = new DataStoreInMemory(); MyBO bo1 = CreateMyBO(dataStore1); BusinessObjectLoaderInMemory loader1 = new BusinessObjectLoaderInMemory(dataStore1); DataStoreInMemory dataStore2 = new DataStoreInMemory(); MyRelatedBo bo2 = CreateMyRelatedBO(dataStore2); BusinessObjectLoaderInMemory loader2 = new BusinessObjectLoaderInMemory(dataStore2); BusinessObjectLoaderInMemory defaultBusinessObjectLoader = new BusinessObjectLoaderInMemory(new DataStoreInMemory()); BusinessObjectLoaderMultiSource businessObjectLoaderMultiSource = new BusinessObjectLoaderMultiSource(defaultBusinessObjectLoader); //---------------Execute Test ---------------------- businessObjectLoaderMultiSource.AddBusinessObjectLoader(typeof(MyBO), loader1); businessObjectLoaderMultiSource.AddBusinessObjectLoader(typeof(MyRelatedBo), loader2); var loadedBo1 = businessObjectLoaderMultiSource.GetBusinessObject <MyBO>(bo1.ID); var loadedBo2 = businessObjectLoaderMultiSource.GetBusinessObject <MyRelatedBo>(bo2.ID); //---------------Tear down ------------------------- Assert.AreSame(loadedBo1, bo1); Assert.AreSame(loadedBo2, bo2); }
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 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 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 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 TestUsingPropWithBOLookupList() { //---------------Set up test pack------------------- DataStoreInMemory store = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(store); IComboBox cmbox = GetControlFactory().CreateComboBox(); const string propName = "SampleLookup2ID"; LookupComboBoxMapper mapper = new LookupComboBoxMapper(cmbox, propName, false, GetControlFactory()); Dictionary <string, string> collection = getLookupList(); Sample sample = new Sample(); sample.Save(); string boId = collection[LOOKUP_ITEM_2]; Assert.AreEqual(4, store.Count); IBusinessObject businessObject = BORegistry.DataAccessor.BusinessObjectLoader.GetBusinessObjectByValue <Sample>(boId); Sample sampleToSelect = (Sample)businessObject; sample.SetPropertyValue(propName, sampleToSelect); //--------------Assert Preconditions ------------- Assert.AreEqual(3, collection.Count); Assert.AreEqual(4, store.Count); //---------------Execute Test ---------------------- mapper.LookupList = collection; mapper.BusinessObject = sample; //---------------Test Result ----------------------- Assert.AreEqual(4, cmbox.Items.Count); Assert.AreEqual(LOOKUP_ITEM_2, cmbox.SelectedItem); Assert.AreEqual(sampleToSelect.ToString(), cmbox.SelectedValue); }
protected virtual IQueryResultLoader CreateResultSetLoader() { var dataStoreInMemory = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(dataStoreInMemory); return(new QueryResultLoaderInMemory(dataStoreInMemory)); }
private static ContactPersonTestBO GetSavedContactPerson(DataStoreInMemory dataStore) { ContactPersonTestBO contactPersonCompositeKey = GetUnsavedContactPerson(); TransactionCommitterInMemory committer = new TransactionCommitterInMemory(dataStore); committer.AddBusinessObject(contactPersonCompositeKey); committer.CommitTransaction(); return(contactPersonCompositeKey); }
public void TestFixtureSetup() { //Code that is executed before any test is run in this class. If multiple tests // are executed then it will still only be called once. ClassDef.ClassDefs.Clear(); _dataStore = new DataStoreInMemory(); _dataAccessor = new DataAccessorInMemory(_dataStore); BORegistry.DataAccessor = _dataAccessor; ContactPersonTestBO.LoadDefaultClassDef(); }
public void Test_Constructor_UsesPassedInDataStore() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = MockRepository.GenerateMock <DataStoreInMemory>(); //---------------Execute Test ---------------------- DataAccessorInMemory dataAccessorInMemory = new DataAccessorInMemory(dataStore); //---------------Test Result ----------------------- Assert.AreSame(dataStore, dataAccessorInMemory.DataStoreInMemory); }
private MyBO CreateMyBO(DataStoreInMemory dataStore1) { MyBO.LoadDefaultClassDef(); TransactionCommitterInMemory committer1 = new TransactionCommitterInMemory(dataStore1); var bo1 = new MyBO(); committer1.AddBusinessObject(bo1); committer1.CommitTransaction(); return(bo1); }
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 SetupTest() { //Runs every time that any testmethod is executed //base.SetupTest(); ClassDef.ClassDefs.Clear(); _dataStore = new DataStoreInMemory(); _dataAccessor = new DataAccessorInMemory(_dataStore); BORegistry.DataAccessor = _dataAccessor; ContactPersonTestBO.LoadClassDefOrganisationTestBORelationship_MultipleReverse(); OrganisationTestBO.LoadDefaultClassDef(); }
public void Test_Construct() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); //---------------Assert PreConditions--------------- //---------------Execute Test ---------------------- DataStoreInMemoryBinaryWriter writer = new DataStoreInMemoryBinaryWriter(new MemoryStream()); //---------------Test Result ----------------------- //---------------Tear Down ------------------------- }
public void TestDataStoreConstructor() { //---------------Set up test pack------------------- //--------------Assert PreConditions---------------- //---------------Execute Test ---------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); //---------------Test Result ----------------------- Assert.AreEqual(0, dataStore.Count); //---------------Tear Down ------------------------- }
public void TestDataStoreAdd() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); ContactPersonTestBO.LoadDefaultClassDef(); //--------------Assert PreConditions---------------- //---------------Execute Test ---------------------- dataStore.Add(new ContactPersonTestBO()); //---------------Test Result ----------------------- Assert.AreEqual(1, dataStore.Count); //---------------Tear Down ------------------------- }
public void Test_LoadingWithDefaultOnly() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); MyBO bo1 = CreateMyBO(dataStore); BusinessObjectLoaderInMemory defaultBusinessObjectLoader = new BusinessObjectLoaderInMemory(dataStore); //---------------Execute Test ---------------------- BusinessObjectLoaderMultiSource businessObjectLoaderMultiSource = new BusinessObjectLoaderMultiSource(defaultBusinessObjectLoader); var loadedBo1 = businessObjectLoaderMultiSource.GetBusinessObject<MyBO>(bo1.ID); //---------------Test Result ----------------------- Assert.AreSame(loadedBo1, bo1); //---------------Tear down ------------------------- }
public void Test_LoadingWithDefaultOnly() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); MyBO bo1 = CreateMyBO(dataStore); BusinessObjectLoaderInMemory defaultBusinessObjectLoader = new BusinessObjectLoaderInMemory(dataStore); //---------------Execute Test ---------------------- BusinessObjectLoaderMultiSource businessObjectLoaderMultiSource = new BusinessObjectLoaderMultiSource(defaultBusinessObjectLoader); var loadedBo1 = businessObjectLoaderMultiSource.GetBusinessObject <MyBO>(bo1.ID); //---------------Test Result ----------------------- Assert.AreSame(loadedBo1, bo1); //---------------Tear down ------------------------- }
public void Test_DefaultDataAccessor_OneObject() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); IDataAccessor defaultDataAccessor = new DataAccessorInMemory(dataStore); MyBO.LoadDefaultClassDef(); MyBO bo = new MyBO(); //---------------Execute Test ---------------------- ITransactionCommitter transactionCommitter = new TransactionCommitterMultiSource(defaultDataAccessor, new Dictionary<Type, IDataAccessor>()); transactionCommitter.AddBusinessObject(bo); transactionCommitter.CommitTransaction(); //---------------Test Result ----------------------- Assert.IsNotNull(dataStore.Find<MyBO>(bo.ID)); //---------------Tear down ------------------------- }
public void Test_Write() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); dataStore.Add(new Car()); MemoryStream stream = new MemoryStream(); DataStoreInMemoryBinaryWriter writer = new DataStoreInMemoryBinaryWriter(stream); //---------------Assert Precondition---------------- Assert.AreEqual(1, dataStore.Count); Assert.AreEqual(0, stream.Length); //---------------Execute Test ---------------------- writer.Write(dataStore); //---------------Test Result ----------------------- Assert.AreNotEqual(0, stream.Length); }
public void Write() { //---------------Set up test pack------------------- var dataStore = new DataStoreInMemory(); dataStore.Add(new Car()); var stream = new MemoryStream(); var writer = new DataStoreInMemoryXmlWriter(); //---------------Assert Precondition---------------- Assert.AreEqual(1, dataStore.Count); Assert.AreEqual(0, stream.Length); //---------------Execute Test ---------------------- writer.Write(stream, dataStore); //---------------Test Result ----------------------- Assert.AreNotEqual(0, stream.Length); }
public void Test_Write_WithConcurrentDictionary() { //---------------Set up test pack------------------- var dataStore = new DataStoreInMemory(); dataStore.Add(new Car()); var businessObjects = dataStore.AllObjects; var stream = new MemoryStream(); var writer = new DataStoreInMemoryBinaryWriter(stream); //---------------Assert Precondition---------------- Assert.AreEqual(1, dataStore.Count); Assert.AreEqual(0, stream.Length); //---------------Execute Test ---------------------- writer.Write(businessObjects); //---------------Test Result ----------------------- Assert.AreNotEqual(0, stream.Length); }
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_DefaultDataAccessor_OneObject() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); IDataAccessor defaultDataAccessor = new DataAccessorInMemory(dataStore); MyBO.LoadDefaultClassDef(); MyBO bo = new MyBO(); //---------------Execute Test ---------------------- ITransactionCommitter transactionCommitter = new TransactionCommitterMultiSource(defaultDataAccessor, new Dictionary <Type, IDataAccessor>()); transactionCommitter.AddBusinessObject(bo); transactionCommitter.CommitTransaction(); //---------------Test Result ----------------------- Assert.IsNotNull(dataStore.Find <MyBO>(bo.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 Write_WithXmlWriterSettings() { //---------------Set up test pack------------------- var dataStore = new DataStoreInMemory(); dataStore.Add(new Car()); var stream = new MemoryStream(); var xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.ConformanceLevel = ConformanceLevel.Auto; xmlWriterSettings.NewLineOnAttributes = true; var writer = new DataStoreInMemoryXmlWriter(xmlWriterSettings); //---------------Assert Precondition---------------- Assert.AreEqual(1, dataStore.Count); Assert.AreEqual(0, stream.Length); //---------------Execute Test ---------------------- writer.Write(stream, dataStore); //---------------Test Result ----------------------- Assert.AreNotEqual(0, stream.Length); }
public void Test_ShouldThrowError_WhenAddingObjectsOfDifferentTypesWithDifferentDataAccessors() { //---------------Set up test pack------------------- IDataAccessor defaultDataAccessor = new DataAccessorInMemory(); DataStoreInMemory dataStore1 = new DataStoreInMemory(); DataStoreInMemory dataStore2 = new DataStoreInMemory(); DataAccessorInMemory dataAccessorInMemory1 = new DataAccessorInMemory(dataStore1); DataAccessorInMemory dataAccessorInMemory2 = new DataAccessorInMemory(dataStore2); MyBO.LoadDefaultClassDef(); MyRelatedBo.LoadClassDef(); MyBO bo1 = new MyBO(); MyRelatedBo bo2 = new MyRelatedBo(); Dictionary <Type, IDataAccessor> dataAccessors = new Dictionary <Type, IDataAccessor>(); dataAccessors.Add(typeof(MyBO), dataAccessorInMemory1); dataAccessors.Add(typeof(MyRelatedBo), dataAccessorInMemory2); //---------------Execute Test ---------------------- try { ITransactionCommitter transactionCommitter1 = new TransactionCommitterMultiSource(defaultDataAccessor, dataAccessors); transactionCommitter1.AddBusinessObject(bo1); transactionCommitter1.AddBusinessObject(bo2); transactionCommitter1.CommitTransaction(); Assert.Fail("Error should have occurred"); } catch (HabaneroDeveloperException ex) //---------------Test Result ----------------------- { Assert.IsNull(dataStore1.Find <MyBO>(bo1.ID)); Assert.IsNull(dataStore1.Find <MyRelatedBo>(bo2.ID)); Assert.IsNull(dataStore2.Find <MyBO>(bo1.ID)); Assert.IsNull(dataStore2.Find <MyRelatedBo>(bo2.ID)); StringAssert.Contains("MyRelatedBo", ex.DeveloperMessage); StringAssert.Contains("was added to a TransactionCommitterMultiSource which has been set up with a different source to this type", ex.DeveloperMessage); //correct } //---------------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 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 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"); }
protected virtual IQueryResultLoader CreateResultSetLoader() { var dataStoreInMemory = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(dataStoreInMemory); return new QueryResultLoaderInMemory(dataStoreInMemory); }
/// <summary> /// Writes the datastore's objects to a StringBuilder /// </summary> /// <param name="s"></param> /// <param name="dataStore"></param> public void Write(StringBuilder s, DataStoreInMemory dataStore) { var writer = XmlWriter.Create(s, _settings); Write(writer, dataStore.AllObjects); }
/// <summary> /// Writes the data store's objects to the stream. /// </summary> /// <param name="stream"></param> /// <param name="dataStore"></param> public void Write(Stream stream, DataStoreInMemory dataStore) { Write(stream, dataStore.AllObjects); }
/// <summary> /// /// </summary> /// <param name="dataStore"></param> public NonValidatingDataAccessorInMemory(DataStoreInMemory dataStore) : base(dataStore) { }
/// <summary> /// /// </summary> /// <param name="dataStoreInMemory"></param> public NonValidatingTransactionCommitter(DataStoreInMemory dataStoreInMemory) : base(dataStoreInMemory) { }
public void TestDataStoreRemove() { //---------------Set up test pack------------------- DataStoreInMemory dataStore = new DataStoreInMemory(); ContactPersonTestBO.LoadDefaultClassDef(); ContactPersonTestBO cp = new ContactPersonTestBO(); dataStore.Add(cp); //---------------Execute Test ---------------------- dataStore.Remove(cp); //---------------Test Result ----------------------- Assert.AreEqual(0, dataStore.Count); //---------------Tear Down ------------------------- }
public void TestMutableCompositeKeyObject_TwoObjectsWithSameFieldNameAndValueAsPrimaryKey() { //---------------Set up test pack------------------- ClassDef.ClassDefs.Clear(); BOWithIntID_DifferentType.LoadClassDefWithIntID_CompositeKey(); BOWithIntID.LoadClassDefWithIntID_WithCompositeKey(); DataStoreInMemory dataStore = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(dataStore); new Car(); BOWithIntID boWithIntID = new BOWithIntID {IntID = TestUtil.GetRandomInt()}; boWithIntID.Save(); BOWithIntID_DifferentType intID_DifferentType = new BOWithIntID_DifferentType(); intID_DifferentType.IntID = boWithIntID.IntID; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- intID_DifferentType.Save(); //---------------Test Result ----------------------- Assert.AreEqual(2, dataStore.Count); Assert.IsTrue(dataStore.AllObjects.ContainsKey(boWithIntID.ID.ObjectID)); Assert.IsTrue(dataStore.AllObjects.ContainsKey(intID_DifferentType.ID.ObjectID)); IBusinessObject returnedBOWitID = dataStore.AllObjects[boWithIntID.ID.ObjectID]; IBusinessObject returnedBOWitID_diffType = dataStore.AllObjects[intID_DifferentType.ID.ObjectID]; Assert.AreSame(boWithIntID, returnedBOWitID); Assert.AreSame(intID_DifferentType, returnedBOWitID_diffType); }
/// <summary> /// Sets up the database connection. If not provided, then /// reads the connection from the config file. /// </summary> protected override void SetupDatabaseConnection() { DataStoreInMemory = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(DataStoreInMemory); }
public void Test_GetNextAutoIncrementingNumber_ShouldUseNumberGeneratorForSpecificClassDef() { //---------------Set up test pack------------------- DataStoreInMemory dataStoreInMemory = new DataStoreInMemory(); IClassDef classDef = MockRepository.GenerateStub<IClassDef>(); IClassDef classDef2 = MockRepository.GenerateStub<IClassDef>(); INumberGenerator numberGenerator = MockRepository.GenerateStub<INumberGenerator>(); INumberGenerator numberGenerator2 = MockRepository.GenerateStub<INumberGenerator>(); dataStoreInMemory.AutoIncrementNumberGenerators.Add(classDef, numberGenerator); dataStoreInMemory.AutoIncrementNumberGenerators.Add(classDef2, numberGenerator2); //---------------Assert Precondition---------------- Assert.AreEqual(2, dataStoreInMemory.AutoIncrementNumberGenerators.Count); Assert.AreSame(numberGenerator, dataStoreInMemory.AutoIncrementNumberGenerators[classDef]); Assert.AreSame(numberGenerator2, dataStoreInMemory.AutoIncrementNumberGenerators[classDef2]); //---------------Execute Test ---------------------- long autoIncrementingNumber = dataStoreInMemory.GetNextAutoIncrementingNumber(classDef2); //---------------Test Result ----------------------- numberGenerator2.AssertWasCalled(t => t.NextNumber()); numberGenerator.AssertWasNotCalled(t => t.NextNumber()); }
public TransactionCommitterInMemoryStubErrorRaising(DataStoreInMemory dataStoreInMemory) : base(dataStoreInMemory) { }
public void TestFixtureSetup() { _store = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(_store); // Dictionary<string, string> collection = Sample.BOLookupCollection; }
public void Test_GetNextAutoIncrementingNumber_WhenNoNumberGeneratorForClassDef_ShouldCreateNumberGenerator() { //---------------Set up test pack------------------- DataStoreInMemory dataStoreInMemory = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(dataStoreInMemory); IClassDef classDef = MockRepository.GenerateStub<IClassDef>(); IClassDef classDef2 = MockRepository.GenerateStub<IClassDef>(); INumberGenerator numberGenerator = MockRepository.GenerateStub<INumberGenerator>(); dataStoreInMemory.AutoIncrementNumberGenerators.Add(classDef, numberGenerator); //---------------Assert Precondition---------------- Assert.AreEqual(1, dataStoreInMemory.AutoIncrementNumberGenerators.Count); Assert.AreSame(numberGenerator, dataStoreInMemory.AutoIncrementNumberGenerators[classDef]); Assert.IsFalse(dataStoreInMemory.AutoIncrementNumberGenerators.ContainsKey(classDef2)); //---------------Execute Test ---------------------- long defaultNumber = dataStoreInMemory.GetNextAutoIncrementingNumber(classDef2); //---------------Test Result ----------------------- Assert.AreEqual(2, dataStoreInMemory.AutoIncrementNumberGenerators.Count); numberGenerator.AssertWasNotCalled(t => t.NextNumber()); Assert.AreEqual(1, defaultNumber); INumberGenerator createdNumberGenerator = dataStoreInMemory.AutoIncrementNumberGenerators[classDef2]; Assert.IsNotNull(createdNumberGenerator); TestUtil.AssertIsInstanceOf<NumberGenerator>(createdNumberGenerator); }
protected override void SetupDataAccessor() { _dataStore = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(_dataStore); }
public void Test_AutoIncrementNumberGenerators_IsNotNull() { //---------------Set up test pack------------------- //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- DataStoreInMemory dataStoreInMemory = new DataStoreInMemory(); //---------------Test Result ----------------------- Assert.IsNotNull(dataStoreInMemory.AutoIncrementNumberGenerators); }
public void Write_ToString() { //---------------Set up test pack------------------- var dataStore = new DataStoreInMemory(); dataStore.Add(new Car()); var writer = new DataStoreInMemoryXmlWriter(); var sb = new StringBuilder(); //---------------Assert Precondition---------------- Assert.AreEqual(1, dataStore.Count); Assert.AreEqual(0, sb.Length); //---------------Execute Test ---------------------- writer.Write(sb, dataStore); //---------------Test Result ----------------------- Assert.AreNotEqual(0, sb.Length); }
public void Test_GetNextAutoIncrementingNumber_ShouldCreateNumberGenerators_BUGFIX_ShouldBeThreadSafe() { //---------------Set up test pack------------------- var dataStoreInMemory = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(dataStoreInMemory); var classDef1 = MockRepository.GenerateStub<IClassDef>(); var classDef2 = MockRepository.GenerateStub<IClassDef>(); //---------------Assert Precondition---------------- Assert.AreEqual(0, dataStoreInMemory.AutoIncrementNumberGenerators.Count); Assert.IsFalse(dataStoreInMemory.AutoIncrementNumberGenerators.ContainsKey(classDef1)); Assert.IsFalse(dataStoreInMemory.AutoIncrementNumberGenerators.ContainsKey(classDef2)); //---------------Execute Test ---------------------- var exceptions = new List<Exception>(); TestUtil.ExecuteInParallelThreads(2, () => { try { dataStoreInMemory.GetNextAutoIncrementingNumber(classDef1); } catch (Exception ex) { exceptions.Add(ex); } }); //---------------Test Result ----------------------- if (exceptions.Count > 0) { Assert.Fail(exceptions[0].ToString()); } Assert.AreEqual(1, dataStoreInMemory.AutoIncrementNumberGenerators.Count); }
public void Test_GetNextAutoIncrementingNumber_ShouldUseNumberGenerator() { //---------------Set up test pack------------------- DataStoreInMemory dataStoreInMemory = new DataStoreInMemory(); IClassDef classDef = MockRepository.GenerateStub<IClassDef>(); INumberGenerator numberGenerator = MockRepository.GenerateStub<INumberGenerator>(); long numberFromNumberGenerator = TestUtil.GetRandomInt(); numberGenerator.Stub(t => t.NextNumber()).Return(numberFromNumberGenerator); dataStoreInMemory.AutoIncrementNumberGenerators.Add(classDef,numberGenerator); //---------------Assert Precondition---------------- Assert.AreEqual(1, dataStoreInMemory.AutoIncrementNumberGenerators.Count); Assert.AreSame(numberGenerator, dataStoreInMemory.AutoIncrementNumberGenerators[classDef]); //---------------Execute Test ---------------------- long autoIncrementingNumber = dataStoreInMemory.GetNextAutoIncrementingNumber(classDef); //---------------Test Result ----------------------- Assert.AreEqual(numberFromNumberGenerator, autoIncrementingNumber); numberGenerator.AssertWasCalled(t => t.NextNumber()); }
public void TestFixtureSetup() { _store = new DataStoreInMemory(); BORegistry.DataAccessor = new DataAccessorInMemory(_store); Dictionary <string, string> collection = Sample.BOLookupCollection; }