public void TestDatabaseDeleteByInstance()
{
var testModel = TestModel.MakeTestModel();
Func <int> countKeys = () => _databaseInstance.Query <TestModel, int>().Count();
Func <int> countIndex =
() => _databaseInstance.Query <TestModel, string, int>(TestDatabaseInstance.DATAINDEX).Count();
Assert.Equal(0, countKeys()); //,"Database initialized with invalid key count.");
Assert.Equal(0, countIndex()); //Database initialized with invalid index count.");
var key = _databaseInstance.SaveAsync(testModel).Result;
Assert.Equal(1, countKeys()); //Keys not updated with save.");
Assert.Equal(1, countIndex()); //Index count not updated with save.");
var actual = _databaseInstance.LoadAsync <TestModel>(key).Result;
Assert.NotNull(actual); //Test model did not re-load.");
_databaseInstance.DeleteAsync(actual).Wait();
Assert.Equal(0, countKeys()); //Database updated with invalid key count after delete.");
Assert.Equal(0, countIndex()); //Database updated with invalid index count after delete.");
actual = _databaseInstance.LoadAsync <TestModel>(key).Result;
Assert.Null(actual); //Delete failed: loaded actual value after delete.");
}
public void TestCycleNegativeCase()
{
var test = new CycleClass {
Id = 1, Value = 1
};
var child = new CycleClass {
Id = 2, Value = 5
};
test.ChildCycle = child;
_databaseInstance.SaveAsync(test).Wait();
var actual = _databaseInstance.LoadAsync <CycleClass>(1).Result;
Assert.Equal(test.Id, actual.Id); //Failed to load cycle with non-null child: key mismatch.");
Assert.Equal(test.Value, actual.Value); //Failed to load cycle with non-null child: value mismatch.");
Assert.NotNull(test.ChildCycle); //Failed to load cycle with non-null child: child is null.");
Assert.Equal(child.Id,
actual.ChildCycle.Id); //Failed to load cycle with non-null child: child key mismatch.");
Assert.Equal(child.Value,
actual.ChildCycle.Value); //Failed to load cycle with non-null child: value mismatch.");
actual = _databaseInstance.LoadAsync <CycleClass>(2).Result;
Assert.Equal(child.Id,
actual.Id); //Failed to load cycle with non-null child: key mismatch on direct child load.");
Assert.Equal(child.Value,
actual.Value); //Failed to load cycle with non-null child: value mismatch on direct child load.");
}
public void TestTriggerBeforeSaveWithFailure()
{
var handled = false;
try
{
_databaseInstance.SaveAsync <TriggerClass, int>(new TriggerClass
{
Id = TriggerClassTestTrigger.BADSAVE, Data = Guid.NewGuid().ToString()
}).Wait();
}
catch (AggregateException ex)
{
if (ex.InnerExceptions.Single() is SterlingTriggerException)
{
handled = true;
}
}
Assert.True(handled); //Save failed: trigger did not throw exception");
var actual = _databaseInstance.LoadAsync <TriggerClass>(TriggerClassTestTrigger.BADSAVE).Result;
Assert.Null(actual); //Trigger failed: instance was saved.");
}
public async Task Does_not_fail_on_nonexistent_key()
{
// Arrange
var key = new PrimaryCacheKey("https://localhost/test", "POST").ToString();
// Act
var result = await Database.LoadAsync <SterlingCacheEntry>(key);
// Assert
Assert.Null(result);
}
public void TestNotNull()
{
var test = new NullableClass {
Id = 1, Value = 1
};
_databaseInstance.SaveAsync(test).Wait();
var actual = _databaseInstance.LoadAsync <NullableClass>(1).Result;
Assert.AreEqual(test.Id, actual.Id, "Failed to load nullable with nullable set: key mismatch.");
Assert.AreEqual(test.Value, actual.Value, "Failed to load nullable with nullable set: value mismatch.");
}
public void TestNullDictionary()
{
var expected = TestClassWithDictionary.MakeTestClassWithDictionary();
expected.DictionaryWithBaseClassAsValue = null;
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestClassWithDictionary>(key).Result;
Assert.IsNotNull(actual, "Save/load failed: model is null.");
Assert.AreEqual(expected.ID, actual.ID, "Save/load failed: key mismatch.");
Assert.IsNull(actual.DictionaryWithBaseClassAsValue, "Save/load failed: dictionary is not null.");
}
public void TestNullList()
{
var expected = TestListModel.MakeTestListModel();
expected.Children = null;
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestListModel>(key).Result;
Assert.IsNotNull(actual, "Save/load failed: model is null.");
Assert.AreEqual(expected.ID, actual.ID, "Save/load failed: key mismatch.");
Assert.IsNull(actual.Children, "Save/load failed: list should be null.");
}
public void TestEmptyList()
{
var expected = TestAggregateListModel.MakeTestAggregateListModel();
expected.Children.Clear();
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestAggregateListModel>(key).Result;
Assert.NotNull(actual); //, "Save/load failed: model is null.");
Assert.Equal(expected.ID, actual.ID); //, "Save/load failed: key mismatch.");
Assert.NotNull(actual.Children); //, "Save/load failed: list not initialized.");
Assert.Empty(actual.Children); //, "Save/load failed: list size mismatch.");
}
public void TestEnumSaveAndLoad()
{
var test = new EnumClass {
Id = 1, Value = TestEnums.Value2, ValueLong = TestEnumsLong.LongerValue
};
_databaseInstance.SaveAsync(test).Wait();
var actual = _databaseInstance.LoadAsync <EnumClass>(1).Result;
Assert.Equal(test.Id, actual.Id); //Failed to load enum: key mismatch.");
Assert.Equal(test.Value, actual.Value); //Failed to load enum: value mismatch.");
Assert.Equal(test.ValueLong, actual.ValueLong); //Failed to load enum: value mismatch.");
}
public void TestNullArray()
{
var expected = TestClassWithArray.MakeTestClassWithArray();
expected.BaseClassArray = null;
expected.ClassArray = null;
expected.ValueTypeArray = null;
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestClassWithArray>(key).Result;
Assert.IsNotNull(actual, "Save/load failed: model is null.");
Assert.AreEqual(expected.ID, actual.ID, "Save/load failed: key mismatch.");
Assert.IsNull(actual.BaseClassArray, "Save/load: array should be null");
Assert.IsNull(actual.ClassArray, "Save/load: array should be null");
Assert.IsNull(actual.ValueTypeArray, "Save/load: array should be null");
}
public void TestSave()
{
var random = new Random();
// test saving and reloading
var list = new List <TestCompositeClass>();
for (var x = 0; x < 100; x++)
{
var testClass = new TestCompositeClass
{
Key1 = random.Next(),
Key2 = random.Next().ToString(),
Key3 = Guid.NewGuid(),
Key4 = DateTime.Now.AddMinutes(-1 * random.Next(100)),
Data = Guid.NewGuid().ToString()
};
list.Add(testClass);
_databaseInstance.SaveAsync(testClass).Wait();
}
for (var x = 0; x < 100; x++)
{
var actual = _databaseInstance.LoadAsync <TestCompositeClass>(new TestCompositeKeyClass(list[x].Key1,
list[x].Key2, list[x].Key3, list[x].Key4)).Result;
Assert.NotNull(actual); //Load failed.");
Assert.Equal(list[x].Data, actual.Data); //Load failed: data mismatch.");
}
}
public void TestCustomSaveAndLoad()
{
var expectedList = new[] { TestModel.MakeTestModel(), TestModel.MakeTestModel(), TestModel.MakeTestModel() };
var expected = new NotSupportedClass {
Id = 1
};
expected.InnerList.Add(expectedList);
var key = DatabaseInstance.SaveAsync(expected).Result;
// confirm the test models were saved as "foreign keys"
var count = DatabaseInstance.Query <TestModel, int>().Count();
Assert.AreEqual(expectedList.Length, count, "Load failed: test models were not saved independently.");
var actual = DatabaseInstance.LoadAsync <NotSupportedClass>(key).Result;
Assert.IsNotNull(actual, "Load failed: instance is null.");
Assert.AreEqual(expected.Id, actual.Id, "Load failed: key mismatch.");
// cast to list
var actualList = new List <TestModel>(actual.InnerList);
Assert.AreEqual(expectedList.Length, actualList.Count, "Load failed: mismatch in list.");
foreach (var matchingItem in
expectedList.Select(item => (from i in actualList where i.Key.Equals(item.Key) select i.Key).FirstOrDefault()).Where(matchingItem => matchingItem < 1))
{
Assert.Fail("Test failed: matching models not loaded.");
}
}
public void TestSave()
{
const int LISTSIZE = 20;
var random = new Random();
// test saving and reloading
var list = new TestCompositeClass[LISTSIZE];
for (var x = 0; x < LISTSIZE; x++)
{
var testClass = new TestCompositeClass
{
Key1 = random.Next(),
Key2 = random.Next().ToString(),
Key3 = Guid.NewGuid(),
Key4 = DateTime.Now.AddMinutes(-1 * random.Next(100)),
Data = Guid.NewGuid().ToString()
};
list[x] = testClass;
_databaseInstance.SaveAsync(testClass).Wait();
}
for (var x = 0; x < LISTSIZE; x++)
{
var compositeKey = TestDatabaseInstance.GetCompositeKey(list[x]);
var actual = _databaseInstance.LoadAsync <TestCompositeClass>(compositeKey).Result;
Assert.NotNull(actual); //Load failed.");
Assert.Equal(compositeKey,
TestDatabaseInstance.GetCompositeKey(actual)); //Load failed: key mismatch.");
Assert.Equal(list[x].Data, actual.Data); //Load failed: data mismatch.");
}
}
public void TestSave()
{
// test saving and reloading
var expected = TestModel.MakeTestModel();
_databaseInstance.SaveAsync(expected).Wait();
var actual = _databaseInstance.LoadAsync <TestModel>(expected.Key).Result;
Assert.IsNotNull(actual, "Load failed.");
Assert.AreEqual(expected.Key, actual.Key, "Load failed: key mismatch.");
Assert.AreEqual(expected.Data, actual.Data, "Load failed: data mismatch.");
Assert.IsNull(actual.Data2, "Load failed: suppressed data property not valid on de-serialize.");
Assert.IsNotNull(actual.SubClass, "Load failed: sub class is null.");
Assert.IsNull(actual.SubClass2, "Load failed: supressed sub class should be null.");
Assert.AreEqual(expected.SubClass.NestedText, actual.SubClass.NestedText, "Load failed: sub class text mismtach.");
Assert.AreEqual(expected.SubStruct.NestedId, actual.SubStruct.NestedId, "Load failed: sub struct id mismtach.");
Assert.AreEqual(expected.SubStruct.NestedString, actual.SubStruct.NestedString, "Load failed: sub class string mismtach.");
}
public void TestArray()
{
var expected = TestClassWithArray.MakeTestClassWithArray();
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestClassWithArray>(key).Result;
Assert.NotNull(actual); //, "Save/load failed: model is null.");
Assert.Equal(expected.ID, actual.ID); //, "Save/load failed: key mismatch.");
Assert.NotNull(actual.BaseClassArray); //, "Save/load failed: array not initialized.");
Assert.NotNull(actual.ClassArray); //, "Save/load failed: array not initialized.");
Assert.NotNull(actual.ValueTypeArray); //, "Save/load failed: array not initialized.");
Assert.Equal(expected.BaseClassArray.Length,
actual.BaseClassArray.Length); //, "Save/load failed: array size mismatch.");
Assert.Equal(expected.ClassArray.Length,
actual.ClassArray.Length); //, "Save/load failed: array size mismatch.");
Assert.Equal(expected.ValueTypeArray.Length,
actual.ValueTypeArray.Length); //, "Save/load failed: array size mismatch.");
for (var x = 0; x < expected.BaseClassArray.Length; x++)
{
Assert.Equal(expected.BaseClassArray[x].Key,
actual.BaseClassArray[x].Key); //, "Save/load failed: key mismatch.");
Assert.Equal(expected.BaseClassArray[x].BaseProperty,
actual.BaseClassArray[x].BaseProperty); //, "Save/load failed: data mismatch.");
}
for (var x = 0; x < expected.ClassArray.Length; x++)
{
Assert.Equal(expected.ClassArray[x].Key,
actual.ClassArray[x].Key); //, "Save/load failed: key mismatch.");
Assert.Equal(expected.ClassArray[x].Data,
actual.ClassArray[x].Data); //, "Save/load failed: data mismatch.");
}
for (var x = 0; x < expected.ValueTypeArray.Length; x++)
{
Assert.Equal(expected.ValueTypeArray[x],
actual.ValueTypeArray[x]); //, "Save/load failed: value mismatch.");
}
}
public void TestNullList()
{
var expected = TestClassWithStruct.MakeTestClassWithStruct();
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestClassWithStruct>(key).Result;
Assert.IsNotNull(actual, "Save/load failed: model is null.");
Assert.AreEqual(expected.ID, actual.ID, "Save/load failed: key mismatch.");
Assert.IsNotNull(actual.Structs, "Save/load failed: list not initialized.");
Assert.AreEqual(expected.Structs.Count, actual.Structs.Count, "Save/load failed: list size mismatch.");
Assert.AreEqual(expected.Structs[0].Date, actual.Structs[0].Date, "Save/load failed: date mismatch.");
Assert.AreEqual(expected.Structs[0].Value, actual.Structs[0].Value, "Save/load failed: value mismatch.");
}
public void TestDirtyFlagFalse()
{
var expected = TestListModel.MakeTestListModel();
// first save is to generate the keys
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestListModel>(key).Result;
foreach (var model in actual.Children)
{
model.ResetAccess();
}
((DirtyDatabase)_databaseInstance).Predicate = model => true;
// now check that all were accessed
_databaseInstance.SaveAsync(actual).Wait();
var accessed = (from t in actual.Children where !t.Accessed select 1).Any();
Assert.IsFalse(accessed, "Dirty flag on save failed: some children were not accessed.");
}
public void TestData()
{
const string DATA = "Data to be intercepted";
var byteStreamData = new ByteStreamData {
Id = "data", Data = DATA
};
_databaseInstance.RegisterInterceptor <ByteInterceptor>();
_databaseInstance.RegisterInterceptor <ByteInterceptor2>();
_databaseInstance.SaveAsync(byteStreamData).Wait();
var loadedByteStreamData = _databaseInstance.LoadAsync <ByteStreamData>("data").Result;
Assert.AreEqual(DATA, loadedByteStreamData.Data, "Byte interceptor test failed: data does not match");
_databaseInstance.UnRegisterInterceptor <ByteInterceptor2>();
try
{
loadedByteStreamData = _databaseInstance.LoadAsync <ByteStreamData>("data").Result;
}
catch
{
loadedByteStreamData = null;
}
Assert.IsTrue(loadedByteStreamData == null || !(DATA.Equals(loadedByteStreamData.Data)),
"Byte interceptor test failed: Sterling deserialized intercepted data without interceptor.");
_databaseInstance.RegisterInterceptor <ByteInterceptor2>();
loadedByteStreamData = _databaseInstance.LoadAsync <ByteStreamData>("data").Result;
Assert.AreEqual(DATA, loadedByteStreamData.Data, "Byte interceptor test failed: data does not match");
}
public void TestData()
{
var testNull = new TestObjectField {
Key = 1, Data = "data"
};
_databaseInstance.SaveAsync(testNull).Wait();
var loadedTestNull = _databaseInstance.LoadAsync <TestObjectField>(1).Result;
// The values in the deserialized class should be populated.
Assert.IsNotNull(loadedTestNull);
Assert.IsNotNull(loadedTestNull.Data);
Assert.IsNotNull(loadedTestNull.Key);
}
public void TestSaveLateBoundTable()
{
// test saving and reloading
var expected = new TestLateBoundTable {
Id = 1, Data = Guid.NewGuid().ToString()
};
_databaseInstance.RegisterTableDefinition(
_databaseInstance.CreateTableDefinition <TestLateBoundTable, int>(t => t.Id));
_databaseInstance.SaveAsync(expected).Wait();
var actual = _databaseInstance.LoadAsync <TestLateBoundTable>(expected.Id).Result;
Assert.NotNull(actual); //Load failed.");
Assert.Equal(expected.Id, actual.Id); //Load failed: key mismatch.");
Assert.Equal(expected.Data, actual.Data); //Load failed: data mismatch.");
_databaseInstance.FlushAsync().Wait();
_engine.Dispose();
var driver = _databaseInstance.Driver;
_databaseInstance = null;
// bring it back up
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance =
_engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, driver);
// do this in a different order
_databaseInstance.RegisterTableDefinition(
_databaseInstance.CreateTableDefinition <TestSecondLateBoundTable, int>(t => t.Id));
_databaseInstance.RegisterTableDefinition(
_databaseInstance.CreateTableDefinition <TestLateBoundTable, int>(t => t.Id));
actual = _databaseInstance.LoadAsync <TestLateBoundTable>(expected.Id).Result;
Assert.NotNull(actual); //Load failed after restart.");
Assert.Equal(expected.Id, actual.Id); //Load failed: key mismatch after restart.");
Assert.Equal(expected.Data, actual.Data); //Load failed: data mismatch after restart.");
}
public void TestInterface()
{
var test = new TargetClass {
Id = 1, SubInterface = new InterfaceClass {
Id = 5, Value = 6
}
};
_databaseInstance.SaveAsync(test).Wait();
var actual = _databaseInstance.LoadAsync <TargetClass>(1).Result;
Assert.AreEqual(test.Id, actual.Id, "Failed to load class with interface property: key mismatch.");
Assert.IsNotNull(test.SubInterface, "Failed to load class with interface property: interface property is null.");
Assert.AreEqual(test.SubInterface.Id, actual.SubInterface.Id, "Failed to load class with interface property: interface id mismatch.");
Assert.AreEqual(test.SubInterface.Value, actual.SubInterface.Value, "Failed to load class with interface property: value mismatch.");
}
public void TestTruncateAction()
{
// save a few objects
var sample = TestModel.MakeTestModel();
_databaseInstance.SaveAsync(sample).Wait();
_databaseInstance.SaveAsync(TestModel.MakeTestModel()).Wait();
_databaseInstance.SaveAsync(TestModel.MakeTestModel()).Wait();
_databaseInstance.TruncateAsync(typeof(TestModel)).Wait();
// query should be empty
Assert.IsFalse(_databaseInstance.Query <TestModel, int>().Any(), "Truncate failed: key list still exists.");
// load should be empty
var actual = _databaseInstance.LoadAsync <TestModel>(sample.Key).Result;
Assert.IsNull(actual, "Truncate failed: was able to load item.");
}
public void TestSaveLateBoundTable()
{
// test saving and reloading
var expected = new TestLateBoundTable {Id = 1, Data = Guid.NewGuid().ToString()};
_databaseInstance.RegisterTableDefinition(_databaseInstance.CreateTableDefinition<TestLateBoundTable,int>(t=>t.Id));
_databaseInstance.SaveAsync( expected ).Wait();
var actual = _databaseInstance.LoadAsync<TestLateBoundTable>( expected.Id ).Result;
Assert.IsNotNull(actual, "Load failed.");
Assert.AreEqual(expected.Id, actual.Id, "Load failed: key mismatch.");
Assert.AreEqual(expected.Data, actual.Data, "Load failed: data mismatch.");
_databaseInstance.FlushAsync().Wait();
_engine.Dispose();
var driver = _databaseInstance.Driver;
_databaseInstance = null;
// bring it back up
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>(TestContext.TestName, driver);
// do this in a different order
_databaseInstance.RegisterTableDefinition(_databaseInstance.CreateTableDefinition<TestSecondLateBoundTable,int>(t=>t.Id));
_databaseInstance.RegisterTableDefinition(_databaseInstance.CreateTableDefinition<TestLateBoundTable, int>(t => t.Id));
actual = _databaseInstance.LoadAsync<TestLateBoundTable>( expected.Id ).Result;
Assert.IsNotNull(actual, "Load failed after restart.");
Assert.AreEqual(expected.Id, actual.Id, "Load failed: key mismatch after restart.");
Assert.AreEqual(expected.Data, actual.Data, "Load failed: data mismatch after restart.");
}
public void TestDictionarySaveAndLoad()
{
var expected = TestClassWithDictionary.MakeTestClassWithDictionary();
var key = _databaseInstance.SaveAsync(expected).Result;
var actual = _databaseInstance.LoadAsync <TestClassWithDictionary>(key).Result;
Assert.NotNull(actual); //Save/load failed: model is null.");
Assert.Equal(expected.ID, actual.ID); //Save/load failed: key mismatch.");
Assert.NotNull(actual.DictionaryWithBaseClassAsValue); //Save/load failed: dictionary not initialized.");
Assert.NotNull(actual.DictionaryWithClassAsValue); //Save/load failed: dictionary not initialized.");
Assert.NotNull(actual.DictionaryWithListAsValue); //Save/load failed: dictionary not initialized.");
Assert.NotNull(actual.BaseDictionary); //Save/load failed: dictionary not initialized.");
foreach (var v in expected.BaseDictionary)
{
Assert.True(actual.BaseDictionary.ContainsKey(v.Key)); //Save/load failed: key not found.");
Assert.Equal(expected.BaseDictionary[v.Key],
actual.BaseDictionary[v.Key]); //Save/load failed: key mismatch.");
}
foreach (var v in expected.DictionaryWithBaseClassAsValue)
{
Assert.True(actual.DictionaryWithBaseClassAsValue
.ContainsKey(v.Key)); //Save/load failed: key not found.");
Assert.Equal(expected.DictionaryWithBaseClassAsValue[v.Key].Key,
actual.DictionaryWithBaseClassAsValue[v.Key].Key); //Save/load failed: key mismatch.");
Assert.Equal(expected.DictionaryWithBaseClassAsValue[v.Key].BaseProperty,
actual.DictionaryWithBaseClassAsValue[v.Key].BaseProperty); //Save/load failed: data mismatch.");
Assert.Equal(expected.DictionaryWithBaseClassAsValue[v.Key].GetType(),
actual.DictionaryWithBaseClassAsValue[v.Key].GetType()); //Save/load failed: type mismatch.");
}
foreach (var v in expected.DictionaryWithClassAsValue)
{
Assert.True(actual.DictionaryWithClassAsValue.ContainsKey(v.Key)); //Save/load failed: key not found.");
Assert.Equal(expected.DictionaryWithClassAsValue[v.Key].Key,
actual.DictionaryWithClassAsValue[v.Key].Key); //Save/load failed: key mismatch.");
Assert.Equal(expected.DictionaryWithClassAsValue[v.Key].Data,
actual.DictionaryWithClassAsValue[v.Key].Data); //Save/load failed: data mismatch.");
Assert.Equal(expected.DictionaryWithClassAsValue[v.Key].Date,
actual.DictionaryWithClassAsValue[v.Key].Date); //Save/load failed: date mismatch.");
Assert.Equal(expected.DictionaryWithClassAsValue[v.Key].GetType(),
actual.DictionaryWithClassAsValue[v.Key].GetType()); //Save/load failed: type mismatch.");
}
foreach (var v in expected.DictionaryWithListAsValue)
{
Assert.True(actual.DictionaryWithListAsValue.ContainsKey(v.Key)); //Save/load failed: key not found.");
Assert.NotNull(actual.DictionaryWithListAsValue[v.Key]); //Save/load failed: list not initialized.");
Assert.Equal(expected.DictionaryWithListAsValue[v.Key].Count,
actual.DictionaryWithListAsValue[v.Key].Count); //Save/load failed: list size mismatch.");
for (var x = 0; x < expected.DictionaryWithListAsValue[v.Key].Count; x++)
{
Assert.Equal(expected.DictionaryWithListAsValue[v.Key][x].Key,
actual.DictionaryWithListAsValue[v.Key][x].Key); //Save/load failed: key mismatch.");
Assert.Equal(expected.DictionaryWithListAsValue[v.Key][x].Data,
actual.DictionaryWithListAsValue[v.Key][x].Data); //Save/load failed: data mismatch.");
Assert.Equal(expected.DictionaryWithListAsValue[v.Key][x].Date,
actual.DictionaryWithListAsValue[v.Key][x].Date); //Save/load failed: date mismatch.");
}
}
}
public void TestSaveShutdownReInitialize()
{
_databaseInstance.PurgeAsync().Wait();
// test saving and reloading
var expected1 = TestModel.MakeTestModel();
var expected2 = TestModel.MakeTestModel();
expected2.GuidNullable = null;
var expectedComplex = new TestComplexModel
{
Id = 5,
Dict = new Dictionary <string, string>(),
Models = new ObservableCollection <TestModel>()
};
for (var x = 0; x < 10; x++)
{
expectedComplex.Dict.Add(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
expectedComplex.Models.Add(TestModel.MakeTestModel());
}
_databaseInstance.SaveAsync(expected1).Wait();
_databaseInstance.SaveAsync(expected2).Wait();
_databaseInstance.SaveAsync(expectedComplex).Wait();
_databaseInstance.FlushAsync().Wait();
// shut it down
_engine.Dispose();
var driver = _databaseInstance.Driver;
_databaseInstance = null;
// bring it back up
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance =
_engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, driver);
var actual1 = _databaseInstance.LoadAsync <TestModel>(expected1.Key).Result;
var actual2 = _databaseInstance.LoadAsync <TestModel>(expected2.Key).Result;
Assert.NotNull(actual1); //Load failed for 1.");
Assert.Equal(expected1.Key, actual1.Key); //Load failed (1): key mismatch.");
Assert.Equal(expected1.Data, actual1.Data); //Load failed(1): data mismatch.");
Assert.NotNull(actual1.SubClass); //Load failed (1): sub class is null.");
Assert.Equal(expected1.SubClass.NestedText,
actual1.SubClass.NestedText); //Load failed (1): sub class text mismtach.");
Assert.Equal(expected1.GuidNullable, actual1.GuidNullable); //Load failed (1): nullable Guid mismtach.");
Assert.NotNull(actual2); //Load failed for 2.");
Assert.Equal(expected2.Key, actual2.Key); //Load failed (2): key mismatch.");
Assert.Equal(expected2.Data, actual2.Data); //Load failed (2): data mismatch.");
Assert.NotNull(actual2.SubClass); //Load failed (2): sub class is null.");
Assert.Equal(expected2.SubClass.NestedText,
actual2.SubClass.NestedText); //Load failed (2): sub class text mismatch.");
Assert.Null(expected2.GuidNullable); //Load failed (2): nullable Guid was not loaded as null.");
//insert a third
var expected3 = TestModel.MakeTestModel();
_databaseInstance.SaveAsync(expected3).Wait();
actual1 = _databaseInstance.LoadAsync <TestModel>(expected1.Key).Result;
actual2 = _databaseInstance.LoadAsync <TestModel>(expected2.Key).Result;
var actual3 = _databaseInstance.LoadAsync <TestModel>(expected3.Key).Result;
Assert.NotNull(actual1); //Load failed for 1.");
Assert.Equal(expected1.Key, actual1.Key); //Load failed (1): key mismatch.");
Assert.Equal(expected1.Data, actual1.Data); //Load failed(1): data mismatch.");
Assert.NotNull(actual1.SubClass); //Load failed (1): sub class is null.");
Assert.Equal(expected1.SubClass.NestedText,
actual1.SubClass.NestedText); //Load failed (1): sub class text mismtach.");
Assert.NotNull(actual2); //Load failed for 2.");
Assert.Equal(expected2.Key, actual2.Key); //Load failed (2): key mismatch.");
Assert.Equal(expected2.Data, actual2.Data); //Load failed (2): data mismatch.");
Assert.NotNull(actual2.SubClass); //Load failed (2): sub class is null.");
Assert.Equal(expected2.SubClass.NestedText,
actual2.SubClass.NestedText); //Load failed (2): sub class text mismtach.");
Assert.NotNull(actual3); //Load failed for 3.");
Assert.Equal(expected3.Key, actual3.Key); //Load failed (3): key mismatch.");
Assert.Equal(expected3.Data, actual3.Data); //Load failed (3): data mismatch.");
Assert.NotNull(actual3.SubClass); //Load failed (3): sub class is null.");
Assert.Equal(expected3.SubClass.NestedText,
actual3.SubClass.NestedText); //Load failed (3): sub class text mismtach.");
// load the complex
var actualComplex = _databaseInstance.LoadAsync <TestComplexModel>(5).Result;
Assert.NotNull(actualComplex); //Load failed (complex): object is null.");
Assert.Equal(5, actualComplex.Id); //Load failed: id mismatch.");
Assert.NotNull(actualComplex.Dict); //Load failed: dictionary is null.");
foreach (var key in expectedComplex.Dict.Keys)
{
var value = expectedComplex.Dict[key];
Assert.True(actualComplex.Dict.Contains(key)); //Load failed: dictionary is missing key.");
Assert.Equal(value, actualComplex.Dict[key]); //Load failed: dictionary has invalid value.");
}
Assert.NotNull(actualComplex.Models); //Load failed: complex missing the model collection.");
foreach (var model in expectedComplex.Models)
{
var targetModel = actualComplex.Models.Where(m => m.Key.Equals(model.Key)).FirstOrDefault();
Assert.NotNull(targetModel); //Load failed for nested model.");
Assert.Equal(model.Key, targetModel.Key); //Load failed for nested model: key mismatch.");
Assert.Equal(model.Data, targetModel.Data); //Load failed for nested model: data mismatch.");
Assert.NotNull(targetModel.SubClass); //Load failed for nested model: sub class is null.");
Assert.Equal(model.SubClass.NestedText,
targetModel.SubClass.NestedText); //Load failed for nested model: sub class text mismtach.");
}
}
public void TestBackupAndRestore()
{
var driver = GetDriver();
// activate the engine and store the data
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, driver);
// test saving and reloading
var expected = TestModel.MakeTestModel();
_databaseInstance.SaveAsync(expected).Wait();
// now back it up
var memStream = new MemoryStream();
byte[] databaseBuffer;
using (var binaryWriter = new BinaryWriter(memStream))
{
_engine.SterlingDatabase.BackupAsync <TestDatabaseInstance>(binaryWriter).Wait();
binaryWriter.Flush();
databaseBuffer = memStream.ToArray();
}
// now purge the database
_databaseInstance.PurgeAsync().Wait();
var actual = _databaseInstance.LoadAsync <TestModel>(expected.Key).Result;
// confirm the database is gone
Assert.IsNull(actual, "Purge failed, was able to load the test model.");
_databaseInstance = null;
// shut it all down
_engine.Dispose();
_engine = null;
// get a new engine
_engine = Factory.NewEngine();
// activate it and grab the database again
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, driver);
// restore it
_engine.SterlingDatabase.RestoreAsync <TestDatabaseInstance>(new BinaryReader(new MemoryStream(databaseBuffer))).Wait();
_engine.Dispose();
_engine = null;
// get a new engine
_engine = Factory.NewEngine();
// activate it and grab the database again
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, driver);
actual = _databaseInstance.LoadAsync <TestModel>(expected.Key).Result;
Assert.IsNotNull(actual, "Load failed.");
Assert.AreEqual(expected.Key, actual.Key, "Load failed: key mismatch.");
Assert.AreEqual(expected.Data, actual.Data, "Load failed: data mismatch.");
Assert.IsNull(actual.Data2, "Load failed: suppressed data property not valid on de-serialize.");
Assert.IsNotNull(actual.SubClass, "Load failed: sub class is null.");
Assert.IsNull(actual.SubClass2, "Load failed: supressed sub class should be null.");
Assert.AreEqual(expected.SubClass.NestedText, actual.SubClass.NestedText,
"Load failed: sub class text mismtach.");
Assert.AreEqual(expected.SubStruct.NestedId, actual.SubStruct.NestedId,
"Load failed: sub struct id mismtach.");
Assert.AreEqual(expected.SubStruct.NestedString, actual.SubStruct.NestedString,
"Load failed: sub class string mismtach.");
}
public void TestBackupAndRestore()
{
var driver = GetDriver();
// activate the engine and store the data
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>( TestContext.TestName, driver);
// test saving and reloading
var expected = TestModel.MakeTestModel();
_databaseInstance.SaveAsync(expected).Wait();
// now back it up
var memStream = new MemoryStream();
byte[] databaseBuffer;
using (var binaryWriter = new BinaryWriter(memStream))
{
_engine.SterlingDatabase.BackupAsync<TestDatabaseInstance>(binaryWriter).Wait();
binaryWriter.Flush();
databaseBuffer = memStream.ToArray();
}
// now purge the database
_databaseInstance.PurgeAsync().Wait();
var actual = _databaseInstance.LoadAsync<TestModel>( expected.Key ).Result;
// confirm the database is gone
Assert.IsNull(actual, "Purge failed, was able to load the test model.");
_databaseInstance = null;
// shut it all down
_engine.Dispose();
_engine = null;
// get a new engine
_engine = Factory.NewEngine();
// activate it and grab the database again
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>(TestContext.TestName, driver);
// restore it
_engine.SterlingDatabase.RestoreAsync<TestDatabaseInstance>(new BinaryReader(new MemoryStream(databaseBuffer))).Wait();
_engine.Dispose();
_engine = null;
// get a new engine
_engine = Factory.NewEngine();
// activate it and grab the database again
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>(TestContext.TestName, driver);
actual = _databaseInstance.LoadAsync<TestModel>(expected.Key).Result;
Assert.IsNotNull(actual, "Load failed.");
Assert.AreEqual(expected.Key, actual.Key, "Load failed: key mismatch.");
Assert.AreEqual(expected.Data, actual.Data, "Load failed: data mismatch.");
Assert.IsNull(actual.Data2, "Load failed: suppressed data property not valid on de-serialize.");
Assert.IsNotNull(actual.SubClass, "Load failed: sub class is null.");
Assert.IsNull(actual.SubClass2, "Load failed: supressed sub class should be null.");
Assert.AreEqual(expected.SubClass.NestedText, actual.SubClass.NestedText,
"Load failed: sub class text mismtach.");
Assert.AreEqual(expected.SubStruct.NestedId, actual.SubStruct.NestedId,
"Load failed: sub struct id mismtach.");
Assert.AreEqual(expected.SubStruct.NestedString, actual.SubStruct.NestedString,
"Load failed: sub class string mismtach.");
}
public void TestSaveShutdownReInitialize()
{
_databaseInstance.PurgeAsync().Wait();
// test saving and reloading
var expected1 = TestModel.MakeTestModel();
var expected2 = TestModel.MakeTestModel();
expected2.GuidNullable = null;
var expectedComplex = new TestComplexModel
{
Id = 5,
Dict = new Dictionary<string, string>(),
Models = new ObservableCollection<TestModel>()
};
for (var x = 0; x < 10; x++)
{
expectedComplex.Dict.Add(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
expectedComplex.Models.Add(TestModel.MakeTestModel());
}
_databaseInstance.SaveAsync( expected1 ).Wait();
_databaseInstance.SaveAsync( expected2 ).Wait();
_databaseInstance.SaveAsync( expectedComplex ).Wait();
_databaseInstance.FlushAsync().Wait();
// shut it down
_engine.Dispose();
var driver = _databaseInstance.Driver;
_databaseInstance = null;
// bring it back up
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>(TestContext.TestName, driver);
var actual1 = _databaseInstance.LoadAsync<TestModel>( expected1.Key ).Result;
var actual2 = _databaseInstance.LoadAsync<TestModel>( expected2.Key ).Result;
Assert.IsNotNull(actual1, "Load failed for 1.");
Assert.AreEqual(expected1.Key, actual1.Key, "Load failed (1): key mismatch.");
Assert.AreEqual(expected1.Data, actual1.Data, "Load failed(1): data mismatch.");
Assert.IsNotNull(actual1.SubClass, "Load failed (1): sub class is null.");
Assert.AreEqual(expected1.SubClass.NestedText, actual1.SubClass.NestedText, "Load failed (1): sub class text mismtach.");
Assert.AreEqual(expected1.GuidNullable, actual1.GuidNullable, "Load failed (1): nullable Guid mismtach.");
Assert.IsNotNull(actual2, "Load failed for 2.");
Assert.AreEqual(expected2.Key, actual2.Key, "Load failed (2): key mismatch.");
Assert.AreEqual(expected2.Data, actual2.Data, "Load failed (2): data mismatch.");
Assert.IsNotNull(actual2.SubClass, "Load failed (2): sub class is null.");
Assert.AreEqual(expected2.SubClass.NestedText, actual2.SubClass.NestedText, "Load failed (2): sub class text mismatch.");
Assert.IsNull(expected2.GuidNullable, "Load failed (2): nullable Guid was not loaded as null.");
//insert a third
var expected3 = TestModel.MakeTestModel();
_databaseInstance.SaveAsync( expected3 ).Wait();
actual1 = _databaseInstance.LoadAsync<TestModel>( expected1.Key ).Result;
actual2 = _databaseInstance.LoadAsync<TestModel>( expected2.Key ).Result;
var actual3 = _databaseInstance.LoadAsync<TestModel>( expected3.Key ).Result;
Assert.IsNotNull(actual1, "Load failed for 1.");
Assert.AreEqual(expected1.Key, actual1.Key, "Load failed (1): key mismatch.");
Assert.AreEqual(expected1.Data, actual1.Data, "Load failed(1): data mismatch.");
Assert.IsNotNull(actual1.SubClass, "Load failed (1): sub class is null.");
Assert.AreEqual(expected1.SubClass.NestedText, actual1.SubClass.NestedText, "Load failed (1): sub class text mismtach.");
Assert.IsNotNull(actual2, "Load failed for 2.");
Assert.AreEqual(expected2.Key, actual2.Key, "Load failed (2): key mismatch.");
Assert.AreEqual(expected2.Data, actual2.Data, "Load failed (2): data mismatch.");
Assert.IsNotNull(actual2.SubClass, "Load failed (2): sub class is null.");
Assert.AreEqual(expected2.SubClass.NestedText, actual2.SubClass.NestedText, "Load failed (2): sub class text mismtach.");
Assert.IsNotNull(actual3, "Load failed for 3.");
Assert.AreEqual(expected3.Key, actual3.Key, "Load failed (3): key mismatch.");
Assert.AreEqual(expected3.Data, actual3.Data, "Load failed (3): data mismatch.");
Assert.IsNotNull(actual3.SubClass, "Load failed (3): sub class is null.");
Assert.AreEqual(expected3.SubClass.NestedText, actual3.SubClass.NestedText, "Load failed (3): sub class text mismtach.");
// load the complex
var actualComplex = _databaseInstance.LoadAsync<TestComplexModel>( 5 ).Result;
Assert.IsNotNull(actualComplex, "Load failed (complex): object is null.");
Assert.AreEqual(5, actualComplex.Id, "Load failed: id mismatch.");
Assert.IsNotNull(actualComplex.Dict, "Load failed: dictionary is null.");
foreach(var key in expectedComplex.Dict.Keys)
{
var value = expectedComplex.Dict[key];
Assert.IsTrue(actualComplex.Dict.Contains(key), "Load failed: dictionary is missing key.");
Assert.AreEqual(value, actualComplex.Dict[key], "Load failed: dictionary has invalid value.");
}
Assert.IsNotNull(actualComplex.Models, "Load failed: complex missing the model collection.");
foreach(var model in expectedComplex.Models)
{
var targetModel = actualComplex.Models.Where(m => m.Key.Equals(model.Key)).FirstOrDefault();
Assert.IsNotNull(targetModel, "Load failed for nested model.");
Assert.AreEqual(model.Key, targetModel.Key, "Load failed for nested model: key mismatch.");
Assert.AreEqual(model.Data, targetModel.Data, "Load failed for nested model: data mismatch.");
Assert.IsNotNull(targetModel.SubClass, "Load failed for nested model: sub class is null.");
Assert.AreEqual(model.SubClass.NestedText, targetModel.SubClass.NestedText, "Load failed for nested model: sub class text mismtach.");
}
}