public void TestInit()
{
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<NullableDatabase>( TestContext.TestName, GetDriver() );
_databaseInstance.PurgeAsync().Wait();
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, GetDriver());
_databaseInstance.PurgeAsync().Wait();
}
/// <summary>
/// Asynchronous version of ISterlingDatabaseInstance Save method (Begin part).
/// </summary>
public static IAsyncResult BeginSave <T>(
this ISterlingDatabaseInstance sterling,
T instance,
AsyncCallback callback,
Object state) where T : class, new()
{
// Create IAsyncResult Object identifying the asynchronous operation.
AsyncResult ar = new AsyncResult(callback, state);
// Use a thread pool thread to perform the operation.
ThreadPool.QueueUserWorkItem((obj) =>
{
var asyncResult = (AsyncResult)obj;
try
{
// Perform the operation.
sterling.Save <T>(instance);
asyncResult.SetAsCompleted(null, false);
}
catch (Exception e)
{
// If operation fails, set the exception.
asyncResult.SetAsCompleted(e, false);
}
}, ar);
return(ar); // Return the IAsyncResult to the caller.
}
public SterlingContentStore(ISterlingDatabase db, ISterlingDriver driver)
{
Contract.Requires <ArgumentNullException>(db != null, "db");
Contract.Requires <ArgumentNullException>(driver != null, "driver");
Instance = db.RegisterDatabase <ContentStoreDB>("ContentStore", driver);
}
/// <summary>
/// Activate the database instance
/// </summary>
public void Activate()
{
if (DesignerProperties.IsInDesignTool)
{
return;
}
if (Debugger.IsAttached)
{
this.sterlingDefaultLogger = new SterlingDefaultLogger(SterlingLogLevel.Verbose);
}
this.sterlingEngine = new SterlingEngine();
// custom serializer for types
this.sterlingEngine.SterlingDatabase.RegisterSerializer <TypeSerializer>();
// change this for more verbose messages
this.sterlingDefaultLogger = new SterlingDefaultLogger(SterlingLogLevel.Information);
this.sterlingEngine.Activate();
this.Database = this.sterlingEngine.SterlingDatabase.RegisterDatabase <VBForumsMetroDatabase>(new IsolatedStorageDriver());
// see if we need to load it
VBForumsMetroDatabase.CheckAndCreate(this.Database);
}
/// <summary>
/// Handles the application startup event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Windows.StartupEventArgs"/>
/// instance containing the event data.</param>
private static void HandleApplicationStartup(Object sender, StartupEventArgs e)
{
s_engine = new SterlingEngine();
s_logger = new SterlingDefaultLogger(SterlingLogLevel.Information);
s_engine.Activate();
s_database = s_engine.SterlingDatabase.RegisterDatabase<AppDatabase>();
}
/// <summary>
/// Handles the application end event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.EventArgs"/>
/// instance containing the event data.</param>
private static void HandleApplicationEnd(Object sender, EventArgs e)
{
s_logger.Detach();
s_engine.Dispose();
s_database = null;
s_engine = null;
}
/// <summary>
/// Handles the application startup event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.Windows.StartupEventArgs"/>
/// instance containing the event data.</param>
private static void HandleApplicationStartup(Object sender, StartupEventArgs e)
{
s_engine = new SterlingEngine();
s_logger = new SterlingDefaultLogger(SterlingLogLevel.Information);
s_engine.Activate();
s_database = s_engine.SterlingDatabase.RegisterDatabase <AppDatabase>();
}
/// <summary>
/// Handles the application end event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="System.EventArgs"/>
/// instance containing the event data.</param>
private static void HandleApplicationEnd(Object sender, EventArgs e)
{
s_logger.Detach();
s_engine.Dispose();
s_database = null;
s_engine = null;
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.SterlingDatabase.RegisterSerializer <TestSerializer>();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>(TestContext.TestName, GetDriver());
}
/// <summary>
/// Initializes a new instance of the <see cref="IdentityTrigger{T}"/> class.
/// </summary>
/// <param name="database">
/// The instance of the Sterling Database that is to be assigned with an IdentityTrigger
/// </param>
public IdentityTrigger(ISterlingDatabaseInstance database)
{
if (database.Query <T, int>().Any())
{
idx = database.Query <T, int>().Max(key => key.Key) + 1;
}
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.SterlingDatabase.RegisterSerializer<TestSerializer>();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>( TestContext.TestName, GetDriver() );
}
internal static void Activate()
{
if (!DesignerProperties.IsInDesignTool)
{
_engine = new SterlingEngine();
try
{
// engine could be already activated (in main application or some referenced dll);
_engine.Activate();
}
catch (SterlingActivationException ex)
{
}
_driver = new IsolatedStorageDriver("EPubReader/");
try
{
_database = _engine.SterlingDatabase.GetDatabase("EPubReader Database");
}
catch (SterlingDatabaseNotFoundException ex)
{
_database = _engine.SterlingDatabase.RegisterDatabase <Database>(_driver);
}
}
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.SterlingDatabase.RegisterSerializer <SupportSerializer>();
_engine.Activate();
DatabaseInstance = _engine.SterlingDatabase.RegisterDatabase <CustomSerializerDatabase>(TestContext.TestName, GetDriver());
DatabaseInstance.PurgeAsync().Wait();
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <DirtyDatabase>(TestContext.TestName, GetDriver());
((DirtyDatabase)_databaseInstance).Predicate = model => true;
_databaseInstance.PurgeAsync().Wait();
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<DirtyDatabase>( TestContext.TestName, GetDriver() );
( (DirtyDatabase) _databaseInstance ).Predicate = model => true;
_databaseInstance.PurgeAsync().Wait();
}
public IdentityTrigger(ISterlingDatabaseInstance database)
{
// if a record exists, set it to the highest value plus 1
if (database.Query <T, int>().Any())
{
_idx = database.Query <T, int>().Max(key => key.Key) + 1;
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="database">Database this is a helper for</param>
/// <param name="serializer">The serializer</param>
/// <param name="logManager">The logger</param>
/// <param name="typeResolver"></param>
/// <param name="typeIndexer"></param>
public SerializationHelper(ISterlingDatabaseInstance database, ISterlingSerializer serializer,
LogManager logManager, Func <string, int> typeResolver, Func <int, string> typeIndexer)
{
_database = database;
_serializer = serializer;
_logManager = logManager;
_typeResolver = typeResolver;
_typeIndexer = typeIndexer;
}
public override void Cleanup()
{
if (_engine == null)
{
return;
}
_engine.Dispose();
_database = null;
}
public void Shutdown()
{
if (_engine == null)
{
return;
}
_engine.Dispose();
_engine = null;
_database = null;
}
internal static void Deactivate()
{
if (_engine != null)
{
_engine.Dispose();
}
_engine = null;
_driver = null;
_database = null;
}
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()
{
//_startTime = DateTime.Now;
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase<TestDatabaseInstance>( "async" );
_modelList = new List<TestModel>();
for (var i = 0; i < MODELS; i++)
{
_modelList.Add(TestModel.MakeTestModel());
}
}
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();
}
}
/// <summary>
/// Deactivate the database instance
/// </summary>
public void Deactivate()
{
if (Debugger.IsAttached && this.sterlingDefaultLogger != null)
{
this.sterlingDefaultLogger.Detach();
}
this.sterlingEngine.Dispose();
this.Database = null;
this.sterlingEngine = null;
}
public void TestInit()
{
//_startTime = DateTime.Now;
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TestDatabaseInstance>("async");
_modelList = new List <TestModel>();
for (var i = 0; i < MODELS; i++)
{
_modelList.Add(TestModel.MakeTestModel());
}
}
public void TestInit()
{
_engine = Factory.NewEngine();
_engine.Activate();
_databaseInstance = _engine.SterlingDatabase.RegisterDatabase <TriggerDatabase>(TestContext.TestName, GetDriver());
_databaseInstance.PurgeAsync().Wait();
// get the next key in the database for auto-assignment
var nextKey = _databaseInstance.Query <TriggerClass, int>().Any() ?
(from keys in _databaseInstance.Query <TriggerClass, int>()
select keys.Key).Max() + 1 : 1;
_databaseInstance.RegisterTrigger(new TriggerClassTestTrigger(nextKey));
}
/// <summary>
/// 服务启动
/// </summary>
public void Starting()
{
if (DesignerProperties.IsInDesignTool)
{
return;
}
if (Debugger.IsAttached)
{
sdlogger = new SterlingDefaultLogger(SterlingLogLevel.Verbose);
}
sengine.Activate();
Database = sengine.SterlingDatabase.RegisterDatabase <SMTLacalDB>();
}
/// <summary>
/// 服务启动
/// </summary>
public void Starting()
{
if (DesignerProperties.IsInDesignTool)
{
return;
}
if (Debugger.IsAttached)
{
sdlogger = new SterlingDefaultLogger(SterlingLogLevel.Verbose);
}
sengine.Activate();
Database = sengine.SterlingDatabase.RegisterDatabase<SMTLacalDB>();
}
public void StartService()
{
_engine = new SterlingEngine();
if (Debugger.IsAttached)
{
_logger = new SterlingDefaultLogger(SterlingLogLevel.Verbose);
}
_engine.Activate();
Database = _engine.SterlingDatabase.RegisterDatabase<BizcardDatabase>(_driver);
Database.RegisterTrigger(new IdentityTrigger<Contact>(Database));
Database.RegisterTrigger(new IdentityTrigger<Group>(Database));
Current = this;
}
public void ActivateEngine()
{
_engine = new SterlingEngine();
_engine.SterlingDatabase.RegisterSerializer<DefaultSerializer>();
_logger = new SterlingDefaultLogger(SterlingLogLevel.Information);
_engine.Activate();
_database = _engine.SterlingDatabase.RegisterDatabase<CoachesDatabase>(new IsolatedStorageDriver());
_database.RegisterTrigger(new IdentityTrigger<EventDto>(_database));
_database.RegisterTrigger(new IdentityTrigger<PracticeDrillDto>(_database));
_database.RegisterTrigger(new IdentityTrigger<TeamDto>(_database));
_database.RegisterTrigger(new IdentityTrigger<LocationDto>(_database));
_database.RegisterTrigger(new IdentityTrigger<PlayerDto>(_database));
_database.RegisterTrigger(new IdentityTrigger<SportDto>(_database));
}
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.");
}
/// <summary>
/// Check to see if the database has been populated. If not, populate it.
/// </summary>
/// <param name="database">The database instance</param>
public static void CheckAndCreate(ISterlingDatabaseInstance database)
{
// register the triggers
database.RegisterTrigger(new IdentityTrigger <ReputationModel>(database));
database.RegisterTrigger(new IdentityTrigger <LoginCredentialModel>(database));
database.RegisterTrigger(new IdentityTrigger <ProfileModel>(database));
// if any are here we've already set things up because users can't delete these
if (database.Query <ReputationModel, int>().Any())
{
return;
}
// get rid of old data
database.Truncate(typeof(ReputationModel));
database.Truncate(typeof(LoginCredentialModel));
database.Flush();
}
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 TestCleanup()
{
//var duration = DateTime.Now - _startTime;
//var dispatcher = Deployment.Current.Dispatcher;
//Action action = () => MessageBox.Show(duration.ToString());
//if (dispatcher.CheckAccess())
//{
// action();
//}
//else
//{
// dispatcher.BeginInvoke(action);
//}
_databaseInstance.PurgeAsync().Wait();
_engine.Dispose();
_databaseInstance = null;
}
public void TestCleanup()
{
//var duration = DateTime.Now - _startTime;
//var dispatcher = Deployment.Current.Dispatcher;
//Action action = () => MessageBox.Show(duration.ToString());
//if (dispatcher.CheckAccess())
//{
// action();
//}
//else
//{
// dispatcher.BeginInvoke(action);
//}
_databaseInstance.PurgeAsync().Wait();
_engine.Dispose();
_databaseInstance = null;
}
public SterlingDuplicateDatabaseException(ISterlingDatabaseInstance instance) : base(
string.Format(Exceptions.SterlingDuplicateDatabaseException, instance.GetType().FullName))
{
}
public SterlingDuplicateDatabaseException(ISterlingDatabaseInstance instance) : base(
instance.GetType().FullName)
{
}
public void TestCleanup()
{
DatabaseInstance.PurgeAsync().Wait();
_engine.Dispose();
DatabaseInstance = null;
}
/// <summary>
/// Activate the database instance
/// </summary>
public void Activate()
{
if (DesignerProperties.IsInDesignTool)
{
return;
}
if (Debugger.IsAttached)
{
this.sterlingDefaultLogger = new SterlingDefaultLogger(SterlingLogLevel.Verbose);
}
this.sterlingEngine = new SterlingEngine();
// custom serializer for types
this.sterlingEngine.SterlingDatabase.RegisterSerializer<TypeSerializer>();
// change this for more verbose messages
this.sterlingDefaultLogger = new SterlingDefaultLogger(SterlingLogLevel.Information);
this.sterlingEngine.Activate();
this.Database = this.sterlingEngine.SterlingDatabase.RegisterDatabase<VBForumsMetroDatabase>(new IsolatedStorageDriver());
// see if we need to load it
VBForumsMetroDatabase.CheckAndCreate(this.Database);
}
public void Init()
{
_engine = Factory.NewEngine();
_engine.Activate();
_database = _engine.SterlingDatabase.RegisterDatabase<NestedInstancesDatabase>(TestContext.TestName, GetDriver());
}
/// <summary>
/// Deactivate the database instance
/// </summary>
public void Deactivate()
{
if (Debugger.IsAttached && this.sterlingDefaultLogger != null)
{
this.sterlingDefaultLogger.Detach();
}
this.sterlingEngine.Dispose();
this.Database = null;
this.sterlingEngine = null;
}
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.");
}
}
private static void _ActivateEngine()
{
_engine = new SterlingEngine();
_engine.Activate();
_database = _engine.SterlingDatabase.RegisterDatabase<TodoStore>();
}
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 TestCleanup()
{
_databaseInstance.PurgeAsync().Wait();
_engine.Dispose();
_databaseInstance = null;
}
public SterlingTest()
{
Database = TestHelper.CreateDatabase();
}
/// <summary>
/// Called by an application immediately before the <see cref="E:System.Windows.Application.Startup"/> event occurs.
/// </summary>
public void Starting()
{
DateTime start = DateTime.Now;
if (DesignerProperties.IsInDesignTool) return;
_engine.Activate();
// Put the type of the Database Class after RegisterDatabase<
Database = _engine.SterlingDatabase.RegisterDatabase<ToDoDatabase>();
SterlingService.Current.Database.RegisterTrigger(new IdentityTrigger<Project>(SterlingService.Current.Database));
SterlingService.Current.Database.RegisterTrigger(new IdentityTrigger<Task>(SterlingService.Current.Database));
SterlingService.Current.Database.RegisterTrigger(new IdentityTrigger<TaskCategory>(SterlingService.Current.Database));
}
private static void _DeactivateEngine()
{
_engine.Dispose();
_database = null;
_engine = null;
}
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 Shutdown()
{
if (_engine == null) return;
_engine.Dispose();
_engine = null;
_database = null;
}
public SterlingTest()
{
Database = TestHelper.CreateDatabase();
}
public void DeactivateEngine()
{
_logger.Detach();
_engine.Dispose();
_database = null;
_engine = null;
}
public override void Cleanup()
{
_databaseInstance.PurgeAsync().Wait();
_engine.Dispose();
_databaseInstance = null;
}
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.");
}
