public void ModificationTimeOf_Database()
{
using (var container = new RhetosTestContainer())
{
var start = SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>());
container.Resolve <ISqlExecuter>().ExecuteSql(new[]
{
"DELETE FROM TestAuditable.Simple",
"DELETE FROM TestAuditable.Parent",
"INSERT INTO TestAuditable.Parent (ID, Name) VALUES ('" + parentID1 + "', 'par1')",
"INSERT INTO TestAuditable.Parent (ID, Name) VALUES ('" + parentID2 + "', 'par2')",
"INSERT INTO TestAuditable.Simple (Name, ModifiedParentProperty) VALUES ('newInstance', NULL)",
"INSERT INTO TestAuditable.Simple (Name, ParentID, ModifiedParentProperty) VALUES ('explicitTime', '" + parentID1 + "', '2001-2-3')",
"INSERT INTO TestAuditable.Simple (Name, ParentID, ModifiedParentProperty) VALUES ('modifiedParent', '" + parentID1 + "', '2001-2-3')",
"UPDATE TestAuditable.Simple SET ParentID = '" + parentID2 + "' WHERE Name = 'modifiedParent'",
"INSERT INTO TestAuditable.Simple (Name, ParentID, ModifiedParentProperty) VALUES ('modifiedNameX', '" + parentID1 + "', '2001-2-3')",
"UPDATE TestAuditable.Simple SET Name = 'modifiedName' WHERE Name = 'modifiedNameX'"
});
var repository = container.Resolve <Common.DomRepository>();
Func <string, DateTime?> actualModifiedTime = test => repository.TestAuditable.Simple.Query()
.Where(item => item.Name == test).Single().ModifiedParentProperty;
AssertJustAfter(start, actualModifiedTime("newInstance"), "newInstance");
AssertJustAfter(new DateTime(2001, 2, 3), actualModifiedTime("explicitTime"), "explicitTime");
AssertJustAfter(start, actualModifiedTime("modifiedParent"), "modifiedParent");
AssertJustAfter(new DateTime(2001, 2, 3), actualModifiedTime("modifiedName"), "modifiedName");
}
}
public void DeleteIntegerStringDataTime()
{
using (var container = new RhetosTestContainer())
{
var repository = container.Resolve <Common.DomRepository>();
var newItem = new TestLogging.Simple {
ID = Guid.NewGuid(), Count = -2, Name = "abc", Created = DateTime.Now
};
repository.TestLogging.Simple.Insert(new[] { newItem });
var logRecord = repository.Common.Log.Query().Where(log => log.ItemId == newItem.ID && log.Action == "Insert").SingleOrDefault();
Assert.IsNotNull(logRecord, "There should be 'Insert' record in the log.");
Assert.AreEqual("", logRecord.Description);
repository.TestLogging.Simple.Delete(new[] { newItem });
logRecord = repository.Common.Log.Query().Where(log => log.ItemId == newItem.ID && log.Action == "Delete").SingleOrDefault();
Assert.IsNotNull(logRecord, "There should be 'Delete' record in the log.");
Assert.AreEqual(SqlUtility.UserContextInfoText(container.Resolve <IUserInfo>()), logRecord.ContextInfo);
Assert.IsTrue(container.Resolve <IUserInfo>().IsUserRecognized);
TestUtility.AssertContains(logRecord.ContextInfo, container.Resolve <IUserInfo>().UserName);
TestUtility.AssertContains(logRecord.ContextInfo, container.Resolve <IUserInfo>().Workstation);
var now = SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>());
Assert.IsTrue(logRecord.Created.Value.Subtract(now).TotalSeconds < 5);
Assert.AreEqual("TestLogging.Simple", logRecord.TableName);
Assert.IsTrue(!string.IsNullOrWhiteSpace(logRecord.UserName));
Assert.IsTrue(!string.IsNullOrWhiteSpace(logRecord.Workstation));
// Description is XML:
var xmlText = @"<?xml version=""1.0"" encoding=""UTF-16""?>" + Environment.NewLine + logRecord.Description;
Console.WriteLine(xmlText);
var xdoc = XDocument.Parse(xmlText);
Console.WriteLine(string.Join(", ", xdoc.Root.Attributes().Select(a => a.Name + ":" + a.Value)));
var logCount = int.Parse(xdoc.Root.Attribute("Count").Value);
Assert.AreEqual(newItem.Count, logCount);
var logName = xdoc.Root.Attribute("Name").Value;
Assert.AreEqual(newItem.Name, logName);
var logCreated = DateTime.Parse(xdoc.Root.Attribute("Created").Value);
Assert.IsTrue(Math.Abs(newItem.Created.Value.Subtract(logCreated).TotalMilliseconds) <= 1000, "Error made by converting DataTime to XML should be less than a second.");
}
}
public void CreationTime()
{
using (var container = new RhetosTestContainer())
{
container.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestAuditable.Simple" });
var repository = container.Resolve <Common.DomRepository>();
var start = SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>());
repository.TestAuditable.Simple.Insert(new[] { new TestAuditable.Simple {
Name = "app"
} });
var finish = SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>());
CheckCreatedDate(container, start, finish);
}
}
public void CreationTime()
{
using (var scope = TestScope.Create())
{
scope.Resolve <ISqlExecuter>().ExecuteSql(new[] { "DELETE FROM TestAuditable.Simple" });
var repository = scope.Resolve <Common.DomRepository>();
var start = SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>());
repository.TestAuditable.Simple.Insert(new[] { new TestAuditable.Simple {
Name = "app"
} });
var finish = SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>());
CheckCreatedDate(scope, start, finish);
}
}
public void MultiSync_InsertBase()
{
using (var container = new RhetosTestContainer())
{
var deleteTables = new[] { "MultiSync", "Base1", "Base2" };
container.Resolve <ISqlExecuter>().ExecuteSql(deleteTables.Select(t => "DELETE FROM TestComputedFrom." + t));
var repository = container.Resolve <Common.DomRepository>();
Assert.AreEqual("", TestUtility.DumpSorted(repository.TestComputedFrom.MultiSync.Query(), Dump));
var b = new TestComputedFrom.Base1 {
ID = Guid.NewGuid(), Name1 = "b1"
};
repository.TestComputedFrom.Base1.Insert(new[] { b });
container.Resolve <Common.ExecutionContext>().EntityFrameworkContext.ClearCache();
Assert.AreEqual("b1 b1a b1b ", TestUtility.DumpSorted(repository.TestComputedFrom.MultiSync.Query().ToList(), Dump));
var ms = repository.TestComputedFrom.MultiSync.All().Single();
AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()));
AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()));
ms.Start = new DateTime(2001, 2, 3);
ms.LastModifiedName1bx = new DateTime(2001, 2, 3);
repository.TestComputedFrom.MultiSync.Update(new[] { ms });
container.Resolve <Common.ExecutionContext>().EntityFrameworkContext.ClearCache();
ms = repository.TestComputedFrom.MultiSync.All().Single();
AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()), false);
AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()), false);
b.Info = "xxx";
repository.TestComputedFrom.Base1.Update(new[] { b });
container.Resolve <Common.ExecutionContext>().EntityFrameworkContext.ClearCache();
ms = repository.TestComputedFrom.MultiSync.All().Single();
AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()), false);
AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()), false);
b.Name1 = "b1new";
repository.TestComputedFrom.Base1.Update(new[] { b });
container.Resolve <Common.ExecutionContext>().EntityFrameworkContext.ClearCache();
Assert.AreEqual("b1new b1newa b1newb ", TestUtility.DumpSorted(repository.TestComputedFrom.MultiSync.Query().ToList(), Dump));
ms = repository.TestComputedFrom.MultiSync.All().Single();
AssertIsRecently(ms.Start, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()), false);
AssertIsRecently(ms.LastModifiedName1bx, SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()));
}
}
public void GetDatabaseTimeTest()
{
var sqlExecuter = new MockSqlExecuter();
SqlUtility.GetDatabaseTime(sqlExecuter); // First run, might not be cached.
var getNonCachedTime = typeof(SqlUtility).GetMethod("GetDatabaseTimeFromDatabase", BindingFlags.NonPublic | BindingFlags.Static);
Assert.IsNotNull(getNonCachedTime);
var notCachedDatabaseTime = (DateTime)getNonCachedTime.Invoke(null, new[] { sqlExecuter });
var cachedTime = SqlUtility.GetDatabaseTime(sqlExecuter);
Console.WriteLine(notCachedDatabaseTime.ToString("o"));
Console.WriteLine(cachedTime.ToString("o"));
Assert.IsTrue(notCachedDatabaseTime - cachedTime <= TimeSpan.FromSeconds(0.01));
Assert.IsTrue(cachedTime - notCachedDatabaseTime <= TimeSpan.FromSeconds(0.01));
}
public void GetDatabaseTimeTest()
{
// More detailed tests are implemented in the DatabaseTimeCacheTest class.
// This is only a smoke test for SqlUtility.
var sqlExecuter = new MockSqlExecuter();
Enumerable.Range(0, 4).Select(x => SqlUtility.GetDatabaseTime(sqlExecuter)); // Caching initialization.
var notCachedDatabaseTime = MsSqlUtility.GetDatabaseTime(sqlExecuter);
var cachedTime = SqlUtility.GetDatabaseTime(sqlExecuter);
Console.WriteLine(notCachedDatabaseTime.ToString("o"));
Console.WriteLine(cachedTime.ToString("o"));
Assert.IsTrue(notCachedDatabaseTime - cachedTime <= TimeSpan.FromSeconds(0.01));
Assert.IsTrue(cachedTime - notCachedDatabaseTime <= TimeSpan.FromSeconds(0.01));
}
private static void TestModificationTimeOf(Func <TestAuditable.Simple, DateTime?> propertySelector, string insertData, string updateData, string testInfo)
{
using (var container = new RhetosTestContainer())
{
container.Resolve <ISqlExecuter>().ExecuteSql(new[] {
"DELETE FROM TestAuditable.Simple",
"DELETE FROM TestAuditable.Parent",
"INSERT INTO TestAuditable.Parent (ID, Name) VALUES ('" + parentID1 + "', 'par1')",
"INSERT INTO TestAuditable.Parent (ID, Name) VALUES ('" + parentID2 + "', 'par2')"
});
var repository = container.Resolve <Common.DomRepository>();
{
var start = SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>());
repository.TestAuditable.Simple.Insert(new[] { ReadInstance(insertData) });
container.Resolve <Common.ExecutionContext>().EntityFrameworkContext.ClearCache();
DateTime?generatedModificationTime = propertySelector(repository.TestAuditable.Simple.Load().Single());
Assert.IsNotNull(generatedModificationTime, testInfo + " Insert: Generated ModificationTime is null.");
var expectedTime = ReadExpectedResult(insertData, start).Value;
AssertJustAfter(expectedTime, generatedModificationTime, "After insert");
}
if (string.IsNullOrEmpty(updateData))
{
return;
}
{
var start = SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>());
repository.TestAuditable.Simple.Update(new[] { ReadInstance(updateData) });
container.Resolve <Common.ExecutionContext>().EntityFrameworkContext.ClearCache();
DateTime?generatedModificationTime = propertySelector(repository.TestAuditable.Simple.Load().Single());
Assert.IsNotNull(generatedModificationTime, testInfo + " Update: Generated ModificationTime is null.");
var expectedTime = ReadExpectedResult(updateData, start).Value;
AssertJustAfter(expectedTime, generatedModificationTime, "After update");
}
}
}
public void AutoInitialized()
{
using (var scope = TestScope.Create())
{
var repository = scope.Resolve <Common.DomRepository>();
var sqlExecuter = scope.Resolve <ISqlExecuter>();
DateTime start = SqlUtility.GetDatabaseTime(sqlExecuter);
var item = new TestDenyUserEdit.AutoInitialized
{
ID = Guid.NewGuid()
};
repository.TestDenyUserEdit.AutoInitialized.Save(new[] { item }, null, null, checkUserPermissions: true);
DateTime finish = SqlUtility.GetDatabaseTime(sqlExecuter);
item = repository.TestDenyUserEdit.AutoInitialized.Load(new[] { item.ID }).Single();
Console.WriteLine("item.Start: " + item.Start);
Assert.IsTrue(item.Start >= start && item.Start <= finish);
}
}
private static DateTime DbTime(UnitOfWorkScope scope)
{
return(SqlUtility.GetDatabaseTime(scope.Resolve <ISqlExecuter>()));
}
private static DateTime DbTime(RhetosTestContainer container)
{
return(SqlUtility.GetDatabaseTime(container.Resolve <ISqlExecuter>()));
}
