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 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 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);
}
protected override void SetupDataAccessor()
{
_dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(_dataStore);
}
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;
}
