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_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);
}
public void Test_MutableKeyObject_TwoObjectsWithSameFieldNameAndValueAsPrimaryKey()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
BOWithIntID_DifferentType.LoadClassDefWithIntID();
BOWithIntID.LoadClassDefWithIntID();
DataStoreInMemory dataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(dataStore);
new Car();
BOWithIntID boWithIntID = new BOWithIntID();
boWithIntID.IntID = TestUtil.GetRandomInt();
boWithIntID.Save();
BOWithIntID_DifferentType intID_DifferentType = new BOWithIntID_DifferentType();
intID_DifferentType.IntID = TestUtil.GetRandomInt();
intID_DifferentType.Save();
//---------------Assert Precondition----------------
Assert.AreEqual(2, dataStore.Count);
//---------------Execute Test ----------------------
// dataStore.Add(intID_DifferentType);
// // in the save process the ID is updated to the persisted field values, so the hash of the ID changes
// // this is why the object is removed and re-added to the BusinessObjectManager (to ensure the dictionary
// // of objects is hashed on the correct, updated value.
// intID_DifferentType.Save();
IBusinessObject returnedBOWitID = dataStore.AllObjects[boWithIntID.ID.ObjectID];
IBusinessObject returnedBOWitID_diffType = dataStore.AllObjects[intID_DifferentType.ID.ObjectID];
//---------------Test Result -----------------------
Assert.AreSame(boWithIntID, returnedBOWitID);
Assert.AreSame(intID_DifferentType, returnedBOWitID_diffType);
}
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);
}
public void Test_Read()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadClassDefsNoUIDef();
DataStoreInMemory savedDataStore = new DataStoreInMemory();
savedDataStore.Add(new MyBO());
MemoryStream writeStream = new MemoryStream();
DataStoreInMemoryBinaryWriter writer = new DataStoreInMemoryBinaryWriter(writeStream);
writer.Write(savedDataStore);
BORegistry.BusinessObjectManager = new BusinessObjectManager();
DataStoreInMemory loadedDataStore = new DataStoreInMemory();
writeStream.Seek(0, SeekOrigin.Begin);
DataStoreInMemoryBinaryReader reader = new DataStoreInMemoryBinaryReader(writeStream);
//---------------Assert Precondition----------------
Assert.AreEqual(1, savedDataStore.Count);
//---------------Execute Test ----------------------
loadedDataStore.AllObjects = reader.Read();
//---------------Test Result -----------------------
Assert.AreEqual(1, loadedDataStore.Count);
}
public void TestCompositeKeyObject()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
//Ther are two datastores so that you can manually add an item to a datastore without
// the save effecting the datastore you are testing.
DataStoreInMemory dataStore = new DataStoreInMemory();
DataStoreInMemory otherDataStore = new DataStoreInMemory();
BORegistry.DataAccessor = new DataAccessorInMemory(otherDataStore);
new Car();
ContactPersonCompositeKey contactPerson = new ContactPersonCompositeKey();
contactPerson.Save();
//---------------Assert Precondition----------------
Assert.IsFalse(dataStore.AllObjects.ContainsKey(contactPerson.ID.ObjectID));
//---------------Execute Test ----------------------
dataStore.Add(contactPerson);
//In the save process the ID is updated to the persisted field values, so the hash of the ID changes
// this is why the object is removed and re-added to the BusinessObjectManager (to ensure the dictionary
// of objects is hashed on the correct, updated value.
contactPerson.PK1Prop1 = TestUtil.GetRandomString();
contactPerson.Save();
//---------------Test Result -----------------------
Assert.IsTrue(dataStore.AllObjects.ContainsKey(contactPerson.ID.ObjectID));
}
public void Test_Read_WhenWrittenWithListOfKeyValuePairs_ShouldStillReturnEquivalentConcurrentDictionary()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
MyBO.LoadClassDefsNoUIDef();
var myBo = new MyBO();
var businessObjects = new List <KeyValuePair <Guid, IBusinessObject> > {
new KeyValuePair <Guid, IBusinessObject>(myBo.ID.GetAsGuid(), myBo)
};
var writeStream = new MemoryStream();
new BinaryFormatter().Serialize(writeStream, businessObjects);
BORegistry.BusinessObjectManager = new BusinessObjectManager();
var loadedDataStore = new DataStoreInMemory();
writeStream.Seek(0, SeekOrigin.Begin);
var reader = new DataStoreInMemoryBinaryReader(writeStream);
//---------------Assert Precondition----------------
Assert.AreEqual(1, businessObjects.Count);
//---------------Execute Test ----------------------
loadedDataStore.AllObjects = reader.Read();
//---------------Test Result -----------------------
Assert.AreEqual(1, loadedDataStore.Count);
}
public void TestFindAll_UsingClassDef()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory());
ClassDef.ClassDefs.Clear();
ContactPersonTestBO.LoadDefaultClassDef();
OrganisationTestBO.LoadDefaultClassDef();
DataStoreInMemory dataStore = new DataStoreInMemory();
DateTime now = DateTime.Now;
ContactPersonTestBO cp1 = new ContactPersonTestBO();
cp1.DateOfBirth = now;
cp1.Surname = TestUtil.GetRandomString();
cp1.Save();
dataStore.Add(cp1);
ContactPersonTestBO cp2 = new ContactPersonTestBO();
cp2.DateOfBirth = now;
cp2.Surname = TestUtil.GetRandomString();
cp2.Save();
dataStore.Add(cp2);
Criteria criteria = new Criteria("DateOfBirth", Criteria.ComparisonOp.Equals, now);
dataStore.Add(OrganisationTestBO.CreateSavedOrganisation());
//---------------Execute Test ----------------------
IBusinessObjectCollection col = dataStore.FindAll(ClassDef.Get <ContactPersonTestBO>(), criteria);
//---------------Test Result -----------------------
Assert.AreEqual(2, col.Count);
Assert.Contains(cp1, col);
Assert.Contains(cp2, col);
}
public void TestFind_UsingGuidCriteriaString_Typed()
{
//---------------Set up test pack-------------------
BORegistry.DataAccessor = new DataAccessorInMemory(new DataStoreInMemory());
ClassDef.ClassDefs.Clear();
ContactPersonTestBO.LoadDefaultClassDef_WOrganisationID();
OrganisationTestBO.LoadDefaultClassDef();
ContactPersonTestBO cp = new ContactPersonTestBO {
Surname = Guid.NewGuid().ToString("N")
};
cp.OrganisationID = OrganisationTestBO.CreateSavedOrganisation().OrganisationID;
cp.Save();
DataStoreInMemory dataStore = new DataStoreInMemory();
dataStore.Add(cp);
Criteria criteria = CriteriaParser.CreateCriteria("OrganisationID = " + cp.OrganisationID);
//---------------Assert Precondtions---------------
Assert.IsNotNull(cp.OrganisationID);
//---------------Execute Test ----------------------
ContactPersonTestBO loadedCP = dataStore.Find <ContactPersonTestBO>(criteria);
//---------------Test Result -----------------------
Assert.IsNotNull(loadedCP);
Assert.AreSame(cp.ID, loadedCP.ID);
}
public void Read_MultipleObjects()
{
//---------------Set up test pack-------------------
LoadMyBOClassDefsWithNoUIDefs();
var savedDataStore = new DataStoreInMemory();
var bo1 = new MyBO();
var bo2 = new Car();
savedDataStore.Add(bo1);
savedDataStore.Add(bo2);
var stream = GetStreamForDataStore(savedDataStore);
var xmlReader = GetXmlReader(stream);
var reader = new BusinessObjectXmlReader();
//---------------Assert Precondition----------------
Assert.AreEqual(2, savedDataStore.Count);
//---------------Execute Test ----------------------
var loadedObjects = reader.Read(xmlReader);
//---------------Test Result -----------------------
var businessObjects = loadedObjects.ToList();
Assert.AreEqual(2, businessObjects.Count);
Assert.IsNotNull(businessObjects.Find(o => o.ID.Equals(bo1.ID)));
Assert.IsNotNull(businessObjects.Find(o => o.ID.Equals(bo2.ID)));
}
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");
}
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_SavingToMultipleSources()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore1 = new DataStoreInMemory();
DataStoreInMemory dataStore2 = new DataStoreInMemory();
DataAccessorInMemory dataAccessorInMemory1 = new DataAccessorInMemory(dataStore1);
DataAccessorInMemory dataAccessorInMemory2 = new DataAccessorInMemory(dataStore2);
DataAccessorMultiSource dataAccessor = new DataAccessorMultiSource(new DataAccessorInMemory());
dataAccessor.AddDataAccessor(typeof(MyBO), dataAccessorInMemory1);
dataAccessor.AddDataAccessor(typeof(MyRelatedBo), dataAccessorInMemory2);
MyBO.LoadDefaultClassDef();
MyRelatedBo.LoadClassDef();
var bo1 = new MyBO();
var bo2 = new MyRelatedBo();
//---------------Execute Test ----------------------
ITransactionCommitter committer1 = dataAccessor.CreateTransactionCommitter();
committer1.AddBusinessObject(bo1);
committer1.CommitTransaction();
ITransactionCommitter committer2 = dataAccessor.CreateTransactionCommitter();
committer2.AddBusinessObject(bo2);
committer2.CommitTransaction();
//---------------Test Result -----------------------
Assert.IsNotNull(dataStore1.Find <MyBO>(bo1.ID));
Assert.IsNotNull(dataStore2.Find <MyRelatedBo>(bo2.ID));
//---------------Tear down -------------------------
}
private MemoryStream GetStreamForDataStore(DataStoreInMemory dataStore)
{
var writeStream = new MemoryStream();
var writer = new DataStoreInMemoryXmlWriter();
writer.Write(writeStream, dataStore);
writeStream.Seek(0, SeekOrigin.Begin);
return(writeStream);
}
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 Test_AutoIncrementNumberGenerators_IsNotNull()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
DataStoreInMemory dataStoreInMemory = new DataStoreInMemory();
//---------------Test Result -----------------------
Assert.IsNotNull(dataStoreInMemory.AutoIncrementNumberGenerators);
}
private MemoryStream GetStreamForBusinessObject(MyBO businessObject)
{
var savedDataStore = new DataStoreInMemory();
savedDataStore.Add(businessObject);
var writeStream = new MemoryStream();
var writer = new DataStoreInMemoryXmlWriter();
writer.Write(writeStream, savedDataStore);
writeStream.Seek(0, SeekOrigin.Begin);
return(writeStream);
}
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();
//--------------Assert PreConditions----------------
//---------------Execute Test ----------------------
dataStore.Add(new ContactPerson());
//---------------Test Result -----------------------
Assert.AreEqual(1, dataStore.Count);
//---------------Tear Down -------------------------
}
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 Test_ClearAll()
{
//---------------Set up test pack-------------------
DataStoreInMemory dataStore = new DataStoreInMemory();
ContactPersonTestBO.LoadDefaultClassDef();
dataStore.Add(new ContactPersonTestBO());
//---------------Assert Precondition----------------
Assert.AreEqual(1, dataStore.Count);
//---------------Execute Test ----------------------
dataStore.ClearAllBusinessObjects();
//---------------Test Result -----------------------
Assert.AreEqual(0, dataStore.Count);
}
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 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 TestGetBusinessObjectWhenNotExists()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
DataStoreInMemory dataStore = new DataStoreInMemory();
ContactPersonTestBO.LoadDefaultClassDef();
BusinessObjectLoaderInMemory loader = new BusinessObjectLoaderInMemory(dataStore);
//--------------Assert PreConditions----------------
//---------------Execute Test ----------------------
ContactPersonTestBO loadedCP =
loader.GetBusinessObject <ContactPersonTestBO>(new ContactPersonTestBO().PrimaryKey);
//---------------Test Result -----------------------
Assert.IsNull(loadedCP);
//---------------Tear Down -------------------------
}
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 TestFind_PrimaryKey()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
ContactPersonTestBO.LoadDefaultClassDef();
ContactPersonTestBO cp = new ContactPersonTestBO();
cp.Surname = Guid.NewGuid().ToString("N");
DataStoreInMemory dataStore = new DataStoreInMemory();
dataStore.Add(cp);
//---------------Execute Test ----------------------
ContactPersonTestBO loadedCP = dataStore.Find <ContactPersonTestBO>(cp.ID);
//---------------Test Result -----------------------
Assert.AreSame(cp.ID, loadedCP.ID);
//---------------Tear Down -------------------------
}
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 TestFindAll_NullCriteria()
{
//---------------Set up test pack-------------------
ClassDef.ClassDefs.Clear();
ContactPersonTestBO.LoadDefaultClassDef();
OrganisationTestBO.LoadDefaultClassDef();
DataStoreInMemory dataStore = new DataStoreInMemory();
DateTime now = DateTime.Now;
ContactPersonTestBO cp1 = new ContactPersonTestBO();
cp1.DateOfBirth = now;
dataStore.Add(cp1);
dataStore.Add(OrganisationTestBO.CreateSavedOrganisation());
//---------------Execute Test ----------------------
BusinessObjectCollection <ContactPersonTestBO> col = dataStore.FindAll <ContactPersonTestBO>(null);
//---------------Test Result -----------------------
Assert.AreEqual(1, col.Count);
Assert.Contains(cp1, col);
Assert.IsNull(col.SelectQuery.Criteria);
}
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);
}
