public void TestSingleAdd()
{
Database.RegisterDataObject(typeof(TestTable));
var obj = new TestTable { TestField = "Test Single Add" };
var objId = obj.ObjectId;
Assert.IsFalse(obj.IsPersisted, "Test Object should not have Persisted Flag before adding...");
Assert.IsTrue(obj.Dirty, "Test Object should be Dirty before adding...");
var inserted = Database.AddObject(obj);
Assert.IsTrue(inserted, "Test Object should be inserted successfully, something went wrong...");
Assert.IsTrue(obj.IsPersisted, "Test Object should have Persisted Flag after adding to database...");
Assert.IsFalse(obj.Dirty, "Test Object should not be Dirty after adding to database...");
Assert.AreEqual(objId, obj.ObjectId, "Test Object should have kept its ObjectId from Creation...");
var retrieved = Database.FindObjectByKey<TestTable>(obj.ObjectId);
Assert.IsNotNull(retrieved, "Test Object previously added should be retrieved from database...");
Assert.AreEqual(objId, retrieved.ObjectId, "Test Object previously added and retrieved object should have same ObjectId...");
Assert.AreEqual(obj.TestField, retrieved.TestField, "Test Object previously added and retrieved object should have equals fields...");
}
public void TestTable()
{
// Prepare and Cleanup
Database.RegisterDataObject(typeof(TestTable));
var all = Database.SelectAllObjects<TestTable>();
foreach(var obj in all)
Database.DeleteObject(obj);
var none = Database.SelectAllObjects<TestTable>();
Assert.IsEmpty(none, "Database shouldn't have any record For TestTable.");
var testValues = new [] { "TestValue 1", "TestValue 2", "TestValue 3" };
// Add Some Data
foreach (var values in testValues)
{
var data = new TestTable()
{
TestField = values,
};
var inserted = Database.AddObject(data);
Assert.IsTrue(inserted, "TestTable Entry not Inserted properly for Value {0}.", values);
}
var retrieve = Database.SelectAllObjects<TestTable>();
Assert.AreEqual(testValues.Length, retrieve.Count, "Retrieved Test Table Entries Count is not equals to Test Values Count.");
CollectionAssert.AreEquivalent(testValues, retrieve.Select(o => o.TestField), "Retrieved Test Entries and Test Values should be Equivalent.");
Assert.IsTrue(retrieve.All(o => o.IsPersisted), "All Retrieved Test Entries should be Persisted in database.");
// Modify Some Data
var modObj = retrieve.First(o => o.TestField == testValues.First());
modObj.TestField = "TestValue 4";
Assert.IsTrue(modObj.Dirty, "Test Table Object should be Dirty after Modifications.");
var saved = Database.SaveObject(modObj);
Assert.IsTrue(saved, "Test Table Object could not be saved correctly.");
Assert.IsFalse(modObj.Dirty, "Test Table Object should not be Dirty after Object Save.");
testValues = new [] { modObj.TestField, "TestValue 2", "TestValue 3" };
retrieve = Database.SelectAllObjects<TestTable>();
CollectionAssert.AreEquivalent(testValues, retrieve.Select(o => o.TestField), "Retrieved Test Entries after Modification should be Equivalent to Test Values.");
// Delete Some Data
var delObj = retrieve.First();
var deleted = Database.DeleteObject(delObj);
Assert.IsTrue(deleted, "Test Table Object could not be deleted correctly.");
Assert.IsTrue(delObj.IsDeleted, "Test Table Deleted Object does not have delete flags set correctly.");
testValues = retrieve.Skip(1).Select(o => o.TestField).ToArray();
retrieve = Database.SelectAllObjects<TestTable>();
CollectionAssert.AreEquivalent(testValues, retrieve.Select(o => o.TestField), "Retrieved Test Entries after Deletion should be Equivalent to Test Values.");
// Find Object By Key
var keyObject = retrieve.First();
Assert.IsNotNullOrEmpty(keyObject.ObjectId, "Test Table Retrieved Object should have an Object Id");
var retrieveKeyObj = Database.FindObjectByKey<TestTable>(keyObject.ObjectId);
Assert.IsNotNull(retrieveKeyObj, "Test Table Retrieved Object by Key should not be null.");
Assert.AreEqual(retrieveKeyObj.ObjectId, keyObject.ObjectId, "Test Table Key Object and Retrieved Key Object should have same Object Id.");
Assert.AreEqual(retrieveKeyObj.TestField, keyObject.TestField, "Test Table Key Object and Retrieved Key Object should have same Values.");
}
public void TestSelectObjects()
{
Database.RegisterDataObject(typeof(TestTable));
var objInitial = new TestTable { TestField = "Select Objects Null Where Test" };
Database.AddObject(objInitial);
var allobjects = Database.SelectAllObjects<TestTable>();
Assert.IsNotEmpty(allobjects, "Select Objects Test Need some Data to be Accurate...");
var nullWhere = Database.SelectObjects<TestTable>("", new QueryParameter[] { });
CollectionAssert.AreEqual(allobjects.Select(obj => obj.ObjectId), nullWhere.Select(obj => obj.ObjectId), "Select Objects with Null Where clause should retrieve Objects similar to Select All...");
var dumbWhere = Database.SelectObjects<TestTable>("@whClause", new QueryParameter("@whClause", 1));
CollectionAssert.AreEqual(allobjects.Select(obj => obj.ObjectId), dumbWhere.Select(obj => obj.ObjectId), "Select Objects with Dumb Where clause should retrieve Objects similar to Select All...");
var simpleWhere = Database.SelectObjects<TestTable>("`TestField` = @TestField", new QueryParameter("@TestField", objInitial.TestField));
CollectionAssert.Contains(simpleWhere.Select(obj => obj.ObjectId), objInitial.ObjectId, "Select Objects with Simple Where clause should retrieve Object similar to Created one...");
var complexWhere = Database.SelectObjects<TestTable>("`TestField` = @TestField AND `Test_Table_ID` = @ObjectId", new [] { new QueryParameter("@TestField", objInitial.TestField), new QueryParameter("@ObjectId", objInitial.ObjectId) });
CollectionAssert.Contains(complexWhere.Select(obj => obj.ObjectId.ToLower()), objInitial.ObjectId.ToLower(), "Select Objects with Complex Where clause should retrieve Object similar to Created one...");
var objNull = new TestTable { TestField = null };
var nullAdd = Database.AddObject(objNull);
Assert.IsTrue(nullAdd, "Select Objects null parameter Test Need some null object to be Accurate...");
var nullParam = Database.SelectObjects<TestTable>("`TestField` = @TestField", new QueryParameter("@TestField", null));
CollectionAssert.IsEmpty(nullParam, "Select Objects with Null Parameter Query should not return any record...");
}
public void TestMultipleFindObjectByKeyWithNull()
{
Database.RegisterDataObject(typeof(TestTable));
object key = null;
var dbo = new TestTable { TestField = "Test Searching Object by Key with some Null" };
Database.AddObject(dbo);
var result = Database.FindObjectsByKey<TestTable>(new object[] { key, dbo.ObjectId }).ToArray();
Assert.IsNotEmpty(result, "Searching with multiple keys including null shoud not return an empty collection...");
Assert.IsNull(result[0], "Searching with multiple keys including null should return null data object for null key...");
Assert.IsNotNull(result[1], "Searching with multiple keys including null should return a valid data object for non null key...");
}
public void TestSingleFindObjectByKey()
{
Database.RegisterDataObject(typeof(TestTable));
var obj = new TestTable { TestField = "Test For Single Find Object By Key" };
var inserted = Database.AddObject(obj);
Assert.IsTrue(inserted, "Find Object By Key Test Could not add object in database...");
var retrieve = Database.FindObjectByKey<TestTable>(obj.ObjectId);
Assert.IsNotNull(retrieve, "Find Object By Key Could not retrieve previously added Object...");
Assert.AreEqual(obj.ObjectId, retrieve.ObjectId, "Find Object By Key Should return similar Object to created one...");
Assert.AreEqual(obj.TestField, retrieve.TestField, "Find Object By Key Should return similar Object to created one...");
var retrieveCase = Database.FindObjectByKey<TestTable>(obj.ObjectId.ToUpper());
Assert.IsNotNull(retrieveCase, "Find Object By Key Could not retrieve previously added Object using Case Mismatch...");
Assert.AreEqual(obj.ObjectId, retrieveCase.ObjectId, "Find Object By Key Should return similar Object to created one...");
Assert.AreEqual(obj.TestField, retrieveCase.TestField, "Find Object By Key Should return similar Object to created one...");
}
public void TestSingleDelete()
{
Database.RegisterDataObject(typeof(TestTable));
var obj = new TestTable { TestField = "Test Single Delete" };
var inserted = Database.AddObject(obj);
Assert.IsTrue(obj.IsPersisted, "Added Object should have Persisted Flag...");
var deleted = Database.DeleteObject(obj);
Assert.IsTrue(deleted, "Added Object should be Successfully Deleted from database...");
Assert.IsFalse(obj.IsPersisted, "Deleted Object should not have Persisted Flag");
Assert.IsTrue(obj.IsDeleted, "Deleted Object should have Deleted Flag");
var retrieve = Database.FindObjectByKey<TestTable>(obj.ObjectId);
Assert.IsNull(retrieve, "Retrieving Deleted Object should return null...");
}
public void TestSingleSave()
{
Database.RegisterDataObject(typeof(TestTable));
var obj = new TestTable { TestField = "Test Single Save" };
var inserted = Database.AddObject(obj);
obj.TestField = "Test Single Save New Value";
Assert.IsTrue(obj.Dirty, "Changing TestTable Object should set Dirty Flag...");
var saved = Database.SaveObject(obj);
Assert.IsTrue(saved, "Changed Object Should be Saved Successfully in database...");
Assert.IsFalse(obj.Dirty, "Changed Object should not have Dirty flag after Saving...");
var retrieve = Database.FindObjectByKey<TestTable>(obj.ObjectId);
Assert.IsNotNull(retrieve, "Changed Object Should be retrieved from database...");
Assert.AreEqual(obj.TestField, retrieve.TestField, "Previously Changed Object and newly retrieved Object should have the same field value...");
}
