/// <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 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 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;
}
}
public void TestDescendingQuery()
{
var descending = from k in _databaseInstance.Query <TestModel, int>() orderby k.Key descending select k.Key;
var idx = _modelList.Count - 1;
foreach (var key in descending)
{
Assert.Equal(_modelList[idx--].Key, key); //Descending query failed: key mismatch.");
}
}
public void TestSequentialQuery()
{
// set up queries
var sequential = from k in _databaseInstance.Query <TestModel, int>() orderby k.Key select k.Key;
var idx = 0;
foreach (var key in sequential)
{
Assert.AreEqual(_modelList[idx++].Key, key, "Sequential query failed: key mismatch.");
}
}
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));
}
public void TestSequentialQuery()
{
// set up queries
var sequential = from k in _databaseInstance.Query <TestModel, string, int>(TestDatabaseInstance.DATAINDEX) orderby k.Index select k.Key;
_modelList.Sort((m1, m2) => m1.Data.CompareTo(m2.Data));
var idx = 0;
foreach (var key in sequential)
{
Assert.AreEqual(_modelList[idx++].Key, key, "Sequential query failed: key mismatch.");
}
Assert.AreEqual(idx, _modelList.Count, "Error in query: wrong number of rows.");
}
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 TestDescendingQuery()
{
var descending = from k in _databaseInstance.Query <TestModel, string, int>(TestDatabaseInstance.DATAINDEX)
orderby k.Index descending
select k.Key;
_modelList.Sort((m1, m2) => m2.Data.CompareTo(m1.Data));
var idx = 0;
foreach (var key in descending)
{
Assert.Equal(_modelList[idx++].Key, key); //Descending query failed: key mismatch.");
}
Assert.Equal(idx, _modelList.Count); //Error in query: wrong number of rows.");
}
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.");
}
/// <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 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 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.");
}