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 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 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()
{
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 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()
{
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 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 TestTriggerAfterSave()
{
var target = new TriggerClass {
Data = Guid.NewGuid().ToString(), IsDirty = true
};
_databaseInstance.SaveAsync <TriggerClass, int>(target).Wait();
Assert.False(target.IsDirty); //Trigger failed: is dirty flag was not reset.");
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, GetDriver());
_modelList = new List <TestModel>();
for (var i = 0; i < 10; i++)
{
_modelList.Add(TestModel.MakeTestModel());
_databaseInstance.SaveAsync(_modelList[i]).Wait();
}
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>( TestContext.TestName, GetDriver() );
_modelList = new List<TestModel>();
for (var i = 0; i < 10; i++)
{
_modelList.Add(TestModel.MakeTestModel());
_databaseInstance.SaveAsync(_modelList[i]).Wait();
}
}
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 async Task TestSaveExceptions()
{
var raiseException = false;
try
{
await _databaseInstance.SaveAsync(this);
}
catch (SterlingTableNotFoundException)
{
raiseException = true;
}
Assert.IsTrue(raiseException, "Sterling did not raise exception for unknown type.");
}
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 TestTriggerBeforeSaveWithSuccess()
{
var key1 = _databaseInstance.SaveAsync <TriggerClass, int>(new TriggerClass {
Data = Guid.NewGuid().ToString()
}).Result;
var key2 = _databaseInstance.SaveAsync <TriggerClass, int>(new TriggerClass {
Data = Guid.NewGuid().ToString()
}).Result;
Assert.IsTrue(key1 > 0, "Trigger failed: key is not greater than 0.");
Assert.IsTrue(key2 > 0, "Save failed: second key is not greater than 0.");
Assert.IsTrue(key2 - key1 == 1, "Save failed: second key isn't one greater than first key.");
}
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 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 static void PopulateDatabase(ISterlingDatabaseInstance db)
{
var colors = new[] { "Red", "Orange", "Yellow", "Blue", "Green", "Indigo", "Violet" };
var cats = new[] { "Panther", "Cougar", "Lynx", "Jaguar", "Leopard", "Cheetah", "Lion" };
var planets = new[] { "Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune", "Pluto" };
var colorItemList = colors.Select(c => new CoolColor {
Name = c
}).ToList();
Console.WriteLine("Saving colors (doesn't really take a second, but we'll wait anyway)...");
db.SaveAsync <CoolColor>(colorItemList);
Thread.Sleep(1000); // just pause a bit because we're not monitoring the background worker
Console.WriteLine("Creating combinations...");
var planetId = 1;
var comboCount = 0;
foreach (var colorItem in colorItemList)
{
foreach (var cat in cats)
{
var catItem = new Cat {
Key = $"CAT-{cat}", Name = cat
};
db.Save(catItem);
foreach (var planet in planets)
{
comboCount++;
var planetItem = new Planet {
Id = planetId++, Name = planet
};
db.Save(planetItem);
var comboItem = new Combo {
Id = comboCount, Cat = catItem, Planet = planetItem, Color = colorItem
};
db.Save(comboItem);
}
}
}
Console.WriteLine($"Generated and saved {comboCount} combinations.");
}
public void TestSave()
{
// test saving and reloading
var expected = TestModel.MakeTestModel();
_databaseInstance.SaveAsync(expected).Wait();
var actual = _databaseInstance.LoadAsync <TestModel>(expected.Key).Result;
Assert.NotNull(actual); //Load failed.");
Assert.Equal(expected.Key, actual.Key); //Load failed: key mismatch.");
Assert.Equal(expected.Data, actual.Data); //Load failed: data mismatch.");
Assert.Null(actual.Data2); //Load failed: suppressed data property not valid on de-serialize.");
Assert.NotNull(actual.SubClass); //Load failed: sub class is null.");
Assert.Null(actual.SubClass2); //Load failed: supressed sub class should be null.");
Assert.Equal(expected.SubClass.NestedText,
actual.SubClass.NestedText); //Load failed: sub class text mismtach.");
Assert.Equal(expected.SubStruct.NestedId,
actual.SubStruct.NestedId); //Load failed: sub struct id mismtach.");
Assert.Equal(expected.SubStruct.NestedString,
actual.SubStruct.NestedString); //Load failed: sub class string mismtach.");
}
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 TestAddBill()
{
_database.PurgeAsync().Wait();
var bill = new Bill
{
Id = Guid.NewGuid(),
Name = "Test"
};
_database.SaveAsync(bill).Wait();
var person1 = new Person
{
Id = Guid.NewGuid(),
Name = "Martin"
};
_database.SaveAsync(person1).Wait();
var partaker1 = new Partaker
{
Id = Guid.NewGuid(),
Paid = 42,
Person = person1
};
bill.Partakers.Add(partaker1);
_database.SaveAsync(bill).Wait();
var person2 = new Person
{
Id = Guid.NewGuid(),
Name = "Jeremy"
};
_database.SaveAsync(person2).Wait();
var partaker2 = new Partaker
{
Id = Guid.NewGuid(),
Paid = 0,
Person = person2
};
bill.Partakers.Add(partaker2);
_database.SaveAsync(bill).Wait();
var partaker3 = new Partaker()
{
Id = Guid.NewGuid(),
Paid = 1,
Person = person1
};
bill.Partakers.Add(partaker3);
_database.SaveAsync(bill).Wait();
_database.FlushAsync().Wait();
var billKeys = _database.Query <Bill, Guid>();
Assert.IsTrue(billKeys.Count == 1);
Assert.AreEqual(billKeys[0].Key, bill.Id);
var freshBill = billKeys[0].LazyValue.Value;
Assert.IsTrue(freshBill.Partakers.Count == 3, "Bill should have exactly 3 partakers.");
var personKeys = _database.Query <Person, Guid>();
Assert.IsTrue(personKeys.Count == 2, "Failed to save exactly 2 persons.");
// Compare loaded instances and verify they are equal
var persons = (from p in freshBill.Partakers where p.Person.Id.Equals(person1.Id) select p.Person).ToList();
// should be two of these
Assert.AreEqual(2, persons.Count, "Failed to grab two instances of the same person.");
Assert.AreEqual(persons[0], persons[1], "Instances were not equal.");
}
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 TestConcurrentSaveAndLoad()
{
var saveEvent = new ManualResetEvent(false);
var loadEvent = new ManualResetEvent(false);
// Initialize the DB with some data.
foreach (var item in _modelList)
{
_databaseInstance.SaveAsync(item).Wait();
}
var savedCount = 0;
var errorMsg = string.Empty;
var save = new Task(() =>
{
try
{
foreach (var item in _modelList)
{
_databaseInstance.SaveAsync(item).Wait();
savedCount++;
}
if (MODELS != savedCount)
{
throw new Exception("Save failed: Not all models were saved.");
}
}
catch (Exception ex)
{
errorMsg = ex.AsExceptionString();
}
finally
{
saveEvent.Set();
}
});
var load = new Task(() =>
{
try
{
var query = from key in _databaseInstance.Query <TestModel, int>()
select key.LazyValue.Value;
query.Count();
var list = new List <TestModel>(query);
if (list.Count < 1)
{
throw new Exception("Test failed: did not load any items.");
}
}
catch (Exception ex)
{
errorMsg = ex.AsExceptionString();
}
finally
{
loadEvent.Set();
}
});
save.Start();
load.Start();
saveEvent.WaitOne(60000);
loadEvent.WaitOne(60000);
Assert.True(string.IsNullOrEmpty(errorMsg), string.Format("Failed concurrent load: {0}", errorMsg));
}
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.");
}
}