NH-3919 - More timestamp tests

Author: fredericDelaporte

src/NHibernate.Test/TypesTest/TimestampClass.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace NHibernate.Test.TypesTest
+{
+	public class TimestampClass
+	{
+		public int Id { get; set; }
+		public DateTime Value { get; set; }
+		public DateTime Revision { get; protected set; }
+		public DateTime? NullableValue { get; set; }
+	}
+}

src/NHibernate.Test/TypesTest/TimestampClass.hbm.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<hibernate-mapping xmlns="urn:nhibernate-mapping-2.2" default-lazy="false">
+  <class
+    name="NHibernate.Test.TypesTest.TimestampClass, NHibernate.Test"
+    table="bc_timestamp">
+    <id name="Id" column="id">
+      <generator class="assigned"/>
+    </id>
+    <version name="Revision" column="`Revision`" type="Timestamp"/>
+    <property name="Value" column="`Value`" type="Timestamp"/>
+    <property name="NullableValue" type="Timestamp"/>
+  </class>
+</hibernate-mapping>

src/NHibernate.Test/TypesTest/TimestampTypeFixture.cs

@@ -4,29 +4,111 @@
 
 namespace NHibernate.Test.TypesTest
 {
-	/// <summary>
-	/// Summary description for TimestampTypeFixture.
-	/// </summary>
 	[TestFixture]
-	public class TimestampTypeFixture
+	public class TimestampTypeFixture : TypeFixtureBase
 	{
+		protected override string TypeName => "Timestamp";
+		private readonly TimestampType _type = NHibernateUtil.Timestamp;
+
+		protected override void OnTearDown()
+		{
+			base.OnTearDown();
+
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				s.CreateQuery("delete from TimestampClass").ExecuteUpdate();
+				t.Commit();
+			}
+		}
+
 		[Test]
 		public void Next()
 		{
-			TimestampType type = (TimestampType) NHibernateUtil.Timestamp;
-			object current = DateTime.Parse("2004-01-01");
-			object next = type.Next(current, null);
+			var current = DateTime.Parse("2004-01-01");
+			var next = _type.Next(current, null);
 
-			Assert.IsTrue(next is DateTime, "Next should be DateTime");
-			Assert.IsTrue((DateTime) next > (DateTime) current,
-			              "next should be greater than current (could be equal depending on how quickly this occurs)");
+			Assert.That(next, Is.TypeOf<DateTime>(), "Next should be DateTime");
+			Assert.That(
+				next,
+				Is.GreaterThan(current),
+				"next should be greater than current");
 		}
 
 		[Test]
 		public void Seed()
 		{
-			TimestampType type = (TimestampType) NHibernateUtil.Timestamp;
-			Assert.IsTrue(type.Seed(null) is DateTime, "seed should be DateTime");
+			Assert.That(_type.Seed(null), Is.TypeOf<DateTime>(), "seed should be DateTime");
+		}
+
+		[Test]
+		[TestCase(DateTimeKind.Unspecified)]
+		[TestCase(DateTimeKind.Local)]
+		[TestCase(DateTimeKind.Utc)]
+		public void ReadWrite(DateTimeKind kind)
+		{
+			var entity = new TimestampClass
+			{
+				Id = 1,
+				Value = RoundForDialect(
+						kind == DateTimeKind.Utc ? DateTime.UtcNow : DateTime.SpecifyKind(DateTime.Now, kind))
+					// Take another date than now for checking the value do not get overridden by seeding.
+					.AddDays(1)
+			};
+
+			DateTime beforeNow, afterNow;
+
+			// Save
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				// Account db accuracy
+				beforeNow = DateTime.Now.AddTicks(-Dialect.TimestampResolutionInTicks);
+				s.Save(entity);
+				t.Commit();
+				afterNow = DateTime.Now.AddTicks(Dialect.TimestampResolutionInTicks);
+			}
+
+			Assert.That(entity.Revision, Is.GreaterThan(beforeNow).And.LessThan(afterNow), "Revision not correctly seeded.");
+			Assert.That(entity.NullableValue, Is.Null, "NullableValue unexpectedly seeded.");
+
+			// Retrieve, compare then update
+			TimestampClass retrieved;
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				retrieved = s.Get<TimestampClass>(entity.Id);
+
+				Assert.That(retrieved, Is.Not.Null, "Entity not saved or cannot be retrieved by its key.");
+				Assert.That(retrieved.Value, Is.EqualTo(entity.Value), "Value should be the same.");
+				Assert.That(retrieved.Revision, Is.EqualTo(entity.Revision), "Revision should be the same.");
+				Assert.That(retrieved.NullableValue, Is.EqualTo(entity.NullableValue), "NullableValue should be the same.");
+
+				retrieved.NullableValue = retrieved.Value;
+				retrieved.Value = retrieved.Value.AddMonths(-1);
+
+				beforeNow = DateTime.Now.AddTicks(-Dialect.TimestampResolutionInTicks);
+				t.Commit();
+				afterNow = DateTime.Now.AddTicks(Dialect.TimestampResolutionInTicks);
+			}
+
+			Assert.That(
+				retrieved.Revision,
+				Is.GreaterThan(beforeNow).And.LessThan(afterNow).And.GreaterThanOrEqualTo(entity.Revision),
+				"Revision not correctly incremented.");
+
+			// Retrieve and compare again
+			using (var s = OpenSession())
+			using (var t = s.BeginTransaction())
+			{
+				var retrievedAgain = s.Get<TimestampClass>(entity.Id);
+
+				Assert.That(retrievedAgain, Is.Not.Null, "Entity deleted or cannot be retrieved again by its key.");
+				Assert.That(retrievedAgain.Value, Is.EqualTo(retrieved.Value), "Value should be the same again.");
+				Assert.That(retrievedAgain.Revision, Is.EqualTo(retrieved.Revision), "Revision should be the same again.");
+				Assert.That(retrievedAgain.NullableValue, Is.EqualTo(retrieved.NullableValue), "NullableValue should be the same again.");
+				t.Commit();
+			}
 		}
 	}
-}
+}

src/NHibernate.Test/TypesTest/TimestampUtcTypeFixture.cs

@@ -14,22 +14,17 @@ public class TimestampUtcTypeFixture : TypeFixtureBase
 		readonly DateTime _utc = new DateTime(1976, 11, 30, 10, 0, 0, 300, DateTimeKind.Utc);
 		readonly DateTime _local = new DateTime(1976, 11, 30, 10, 0, 0, 300, DateTimeKind.Local);
 		readonly DateTime _unspecified = new DateTime(1976, 11, 30, 10, 0, 0, 300, DateTimeKind.Unspecified);
-
-		/// <summary>
-		/// 1976-11-30T10:00:00.3000000
-		/// </summary>
-		const long DateInTicks = 623537928003000000;
 
 		protected override string TypeName => "TimestampUtc";
 
 		[Test]
 		public void Next()
 		{
 			var current = DateTime.Parse("2004-01-01");
-			var next = (DateTime)_type.Next(current, null);
+			var next = (DateTime) _type.Next(current, null);
 
-			Assert.AreEqual(DateTimeKind.Utc, next.Kind, "Kind is not Utc");
-			Assert.IsTrue(next > current, "next should be greater than current (could be equal depending on how quickly this occurs)");
+			Assert.That(next.Kind, Is.EqualTo(DateTimeKind.Utc), "Kind is not Utc");
+			Assert.That(next, Is.GreaterThan(current), "next should be greater than current");
 		}
 
 		/// <summary>
@@ -38,11 +33,10 @@ public void Next()
 		[Test]
 		public void Seed()
 		{
-			var type = NHibernateUtil.TimestampUtc;
-			Assert.IsTrue(type.Seed(null) is DateTime, "Seed should be DateTime");
+			Assert.That(_type.Seed(null), Is.TypeOf<DateTime>(), "Seed should be DateTime");
 
-			var value = (DateTime)type.Seed(null);
-			Assert.AreEqual(DateTimeKind.Utc, value.Kind, "Kind should be Utc");
+			var value = (DateTime) _type.Seed(null);
+			Assert.That(value.Kind, Is.EqualTo(DateTimeKind.Utc), "Kind should be Utc");
 		}
 
 		/// <summary>
@@ -83,8 +77,8 @@ public void UtcReadWrite_Success()
 			using(var tx = session.BeginTransaction())
 			{
 				// Create a new datetime value and round it to the precision that the database supports. This
-				// code basically the same as in the implementation but here to guard posible changes.
-				var resolution = session.GetSessionImplementation().Factory.Dialect.TimestampResolutionInTicks;
+				// code basically the same as in the implementation but here to guard possible changes.
+				var resolution = Dialect.TimestampResolutionInTicks;
 				var next = DateTime.UtcNow;
 				next = next.AddTicks(-(next.Ticks % resolution));