Enhancement/1.x datetime serialization

src/Tests/Nest.Tests.Unit/Internals/Serialize/DateTimes/DateTimeHandlingTestsBase.cs

@@ -0,0 +1,89 @@
+using System;
+using System.IO;
+using System.Text;
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using NUnit.Framework;
+
+namespace Nest.Tests.Unit.Internals.Serialize.DateTimes
+{
+	public abstract class DateTimeHandlingTestsBase
+	{
+		protected Flight Flight;
+		protected string LocalOffsetString;
+		protected TimeSpan LocalOffset;
+
+		[SetUp]
+		public void SetUp()
+		{
+			var departureDateLocal = new DateTime(2013, 1, 21, 0, 0, 0, DateTimeKind.Local);
+			LocalOffset = TimeZoneInfo.Local.GetUtcOffset(departureDateLocal);
+
+			var departureDateUtc = new DateTime(2013, 1, 21, 0, 0, 0, DateTimeKind.Utc);
+
+			Flight = new Flight
+			{
+				DepartureDate = new DateTime(2013, 1, 21, 0, 0, 0, DateTimeKind.Unspecified),
+				DepartureDateUtc = departureDateUtc,
+				DepartureDateLocal = departureDateLocal,
+				DepartureDateUtcWithTicks = departureDateUtc.AddTicks(3456789),
+				DepartureDateOffset = new DateTimeOffset(2013, 1, 21, 0, 0, 0, LocalOffset),
+				DepartureDateOffsetZero = new DateTimeOffset(2013, 1, 21, 0, 0, 0, TimeSpan.Zero),
+				DepartureDateOffsetNonLocal = new DateTimeOffset(2013, 1, 21, 0, 0, 0, TimeSpan.FromHours(-6.25)),
+			};
+
+			LocalOffsetString = string.Format("{0}:{1}",
+				LocalOffset.Hours.ToString("+00;-00;"),
+				LocalOffset.Minutes.ToString("00"));
+		}
+
+		protected string SerializeUsing(
+			DateTimeZoneHandling? handling = null,
+			Func<IConnectionSettingsValues, IContractResolver> contractResolver = null)
+		{
+			var settings = new ConnectionSettings();
+
+			settings
+				.SetDefaultPropertyNameInferrer(p => p)
+				.SetJsonSerializerSettingsModifier(s =>
+				{
+					s.Formatting = Formatting.Indented;
+
+					if (handling.HasValue)
+						s.DateTimeZoneHandling = handling.Value;
+
+					if (contractResolver != null)
+						s.ContractResolver = contractResolver(settings);
+				});
+
+			var client = new ElasticClient(settings);
+			return client.Serializer.Serialize(Flight).Utf8String();
+		}
+
+		protected Flight DeserializeUsing(
+			string json, 
+			DateTimeZoneHandling? handling = null, 
+			Func<IConnectionSettingsValues, IContractResolver> contractResolver = null)
+		{
+			var settings = new ConnectionSettings();
+
+			settings
+				.SetDefaultPropertyNameInferrer(p => p)
+				.SetJsonSerializerSettingsModifier(s =>
+				{
+					if (handling.HasValue)
+						s.DateTimeZoneHandling = handling.Value;
+
+					if (contractResolver != null)
+						s.ContractResolver = contractResolver(settings);
+				});
+
+			var client = new ElasticClient(settings);
+			using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(json)))
+			{
+				return client.Serializer.Deserialize<Flight>(stream);
+			}
+		}
+	}
+}

src/Tests/Nest.Tests.Unit/Internals/Serialize/DateTimes/DefaultDateTimeHandlingTests.cs

@@ -0,0 +1,40 @@
+using System;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace Nest.Tests.Unit.Internals.Serialize.DateTimes
+{
+	/// <summary>
+	/// Test for the default DateTime and DateTimeOffset serialization within NEST
+	/// </summary>
+	[TestFixture]
+	public class DefaultDateTimeHandlingTests : DateTimeHandlingTestsBase
+	{
+		[Test]
+		public void Default()
+		{
+			var jsonWithRoundtripTimeZone = this.SerializeUsing();
+			var expected = @" {
+			   ""DepartureDate"": ""2013-01-21T00:00:00"",
+			   ""DepartureDateUtc"": ""2013-01-21T00:00:00Z"",
+			   ""DepartureDateLocal"": ""2013-01-21T00:00:00" + LocalOffsetString + @""",
+			   ""DepartureDateUtcWithTicks"": ""2013-01-21T00:00:00.3456789Z"",
+			   ""DepartureDateOffset"": ""2013-01-21T00:00:00" + LocalOffsetString + @""",
+			   ""DepartureDateOffsetZero"": ""2013-01-21T00:00:00+00:00"",
+               ""DepartureDateOffsetNonLocal"": ""2013-01-21T00:00:00-06:15""
+			}";
+			jsonWithRoundtripTimeZone.JsonEquals(expected).Should().BeTrue("{0}", jsonWithRoundtripTimeZone);
+
+			var flight = this.DeserializeUsing(jsonWithRoundtripTimeZone);
+
+			flight.Should().Be(Flight);
+			flight.DepartureDate.Kind.Should().Be(Flight.DepartureDate.Kind);
+			flight.DepartureDateLocal.Kind.Should().Be(Flight.DepartureDateLocal.Kind);
+			flight.DepartureDateUtc.Kind.Should().Be(Flight.DepartureDateUtc.Kind);
+			flight.DepartureDateUtcWithTicks.Kind.Should().Be(Flight.DepartureDateUtcWithTicks.Kind);
+			flight.DepartureDateOffset.Offset.Should().Be(Flight.DepartureDateOffset.Offset);
+			flight.DepartureDateOffsetZero.Offset.Should().Be(Flight.DepartureDateOffsetZero.Offset);
+			flight.DepartureDateOffsetNonLocal.Offset.Should().Be(Flight.DepartureDateOffsetNonLocal.Offset);
+		}
+	}
+}

src/Tests/Nest.Tests.Unit/Internals/Serialize/DateTimes/Flight.cs

@@ -0,0 +1,49 @@
+using System;
+
+namespace Nest.Tests.Unit.Internals.Serialize.DateTimes
+{
+	public class Flight
+    {
+        public DateTime DepartureDate { get; set; }
+        public DateTime DepartureDateUtc { get; set; }
+        public DateTime DepartureDateLocal { get; set; }
+        public DateTime DepartureDateUtcWithTicks { get; set; }
+        public DateTimeOffset DepartureDateOffset { get; set; }
+        public DateTimeOffset DepartureDateOffsetZero { get; set; }
+        public DateTimeOffset DepartureDateOffsetNonLocal { get; set; }
+
+        protected bool Equals(Flight other)
+        {
+            return DepartureDate.Ticks.Equals(other.DepartureDate.Ticks) &&
+                   DepartureDateUtc.Ticks.Equals(other.DepartureDateUtc.Ticks) &&
+                   DepartureDateLocal.Ticks.Equals(other.DepartureDateLocal.Ticks) &&
+				   DepartureDateUtcWithTicks.Ticks.Equals(other.DepartureDateUtcWithTicks.Ticks) &&
+				   DepartureDateOffset.Ticks.Equals(other.DepartureDateOffset.Ticks) &&
+                   DepartureDateOffsetZero.Ticks.Equals(other.DepartureDateOffsetZero.Ticks) &&
+                   DepartureDateOffsetNonLocal.Ticks.Equals(other.DepartureDateOffsetNonLocal.Ticks);
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != this.GetType()) return false;
+            return Equals((Flight)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                var hashCode = DepartureDate.GetHashCode();
+                hashCode = (hashCode * 397) ^ DepartureDateUtc.GetHashCode();
+                hashCode = (hashCode * 397) ^ DepartureDateLocal.GetHashCode();
+                hashCode = (hashCode * 397) ^ DepartureDateUtcWithTicks.GetHashCode();
+                hashCode = (hashCode * 397) ^ DepartureDateOffset.GetHashCode();
+                hashCode = (hashCode * 397) ^ DepartureDateOffsetZero.GetHashCode();
+                hashCode = (hashCode * 397) ^ DepartureDateOffsetNonLocal.GetHashCode();
+                return hashCode;
+            }
+        }
+    }
+}