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."); } }