[Internal] Binary Encoding: Fixes DateTime Parsing Issue with Trailing Zeros in the Milli-Seconds Precision.

Microsoft.Azure.Cosmos/src/Json/Interop/CosmosDBToNewtonsoftWriter.cs

@@ -3,7 +3,8 @@
 //------------------------------------------------------------
 namespace Microsoft.Azure.Cosmos.Json.Interop
 {
-    using System;
+    using System;
+    using System.Globalization;
     using System.IO;
     using System.Text;
 
@@ -314,17 +315,18 @@ public override void WriteValue(sbyte value)
         public override void WriteValue(decimal value)
         {
             this.WriteValue((double)value);
-        }
-
+        }
+
         /// <summary>
         /// Writes a <see cref="DateTime"/> value.
         /// </summary>
-        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
-        public override void WriteValue(DateTime value)
-        {
-            this.WriteValue(value.ToString("O"));
-        }
-
+        /// <param name="value">The <see cref="DateTime"/> value to write.</param>
+        public override void WriteValue(DateTime value)
+        {
+            // Use rount trip format for datetime parsing and trim the additional trailing zeros to maintain milliseconds precision .
+            this.WriteValue(value.ToString("O").Trim('0').Trim('.'));
+        }
+
         /// <summary>
         /// Writes a <see cref="byte"/>[] value.
         /// </summary>

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.EmulatorTests/CosmosItemIntegrationTests.cs

@@ -1,9 +1,11 @@
 namespace Microsoft.Azure.Cosmos.SDK.EmulatorTests
 {
     using System;
-    using System.Collections.Generic;
+    using System.Collections.Generic;
+    using System.IO;
     using System.Linq;
-    using System.Net;
+    using System.Net;
+    using System.Text;
     using System.Text.Json;
     using System.Text.Json.Serialization;
     using System.Threading;
@@ -31,8 +33,8 @@ public class CosmosItemIntegrationTests
 
         [TestInitialize]
         public async Task TestInitAsync()
-        {
-            this.connectionString = ConfigurationManager.GetEnvironmentVariable<string>("COSMOSDB_MULTI_REGION", null);
+        {
+            this.connectionString = ConfigurationManager.GetEnvironmentVariable<string>("COSMOSDB_MULTI_REGION", null);
 
             JsonSerializerOptions jsonSerializerOptions = new JsonSerializerOptions()
             {
@@ -148,7 +150,95 @@ public async Task ReadMany2UnreachablePartitionsTest()
                 rule.Disable();
                 fiClient.Dispose();
             }
-        }
+        }
+
+        [TestMethod]
+        [TestCategory("MultiRegion")]
+        public async Task DateTimeArrayRoundtrip_BinaryEncoding_CompareExtraDates_IntegrationTest()
+        {
+            string binaryEncodingEnabled = "binaryEncodingEnabled" + Guid.NewGuid().ToString("N");
+            string binaryEncodingDisabled = "binaryEncodingDisabled" + Guid.NewGuid().ToString("N");
+            string pk = "pk";
+            string testId = Guid.NewGuid().ToString();
+
+            string[] dateStrings =
+            {
+                "12/25/2023","2023-12-25","12-25-2023","25.12.2023","25/12/2023",
+                "Dec 25, 2023","Dec 25 2023","2023-12-25T10:00:00","2023-12-25T10:00:00.123",
+                "12/25/2023 10:00 AM","12/25/2023 10:00:00 AM","12/25/2023 10:00:00.123 AM","9999-12-31T23:59:59",
+                "2023-12-25T10:00:00.1","2023-12-25T10:00:00.12",
+                "2023-12-25T10:00:00.1234","2023-12-25T10:00:00.1234567"
+            };
+            string[] formats =
+            {
+                "MM/dd/yyyy","yyyy-MM-dd","MM-dd-yyyy","dd.MM.yyyy","dd/MM/yyyy",
+                "MMM dd, yyyy","MMM dd yyyy","yyyy-MM-ddTHH:mm:ss","yyyy-MM-ddTHH:mm:ss.fff",
+                "yyyy-MM-ddTHH:mm:ss.f","yyyy-MM-ddTHH:mm:ss.ff","yyyy-MM-ddTHH:mm:ss.ffff",
+                "yyyy-MM-ddTHH:mm:ss.fffffff","MM/dd/yyyy hh:mm tt","MM/dd/yyyy hh:mm:ss tt",
+                "MM/dd/yyyy hh:mm:ss.fff tt"
+            };
+            DateTime[] parsedDates = dateStrings
+                .Select(s => DateTime.ParseExact(s, formats, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None))
+                .ToArray();
+
+            TestCosmosItem testItem = new TestCosmosItem(
+                id: testId,
+                pk: pk,
+                title: "title",
+                email: "[email protected]",
+                body: "Binary encoding test document.",
+                createdUtc: DateTime.UtcNow,
+                modifiedUtc: DateTime.Parse("2025-03-26T20:22:20Z", null, System.Globalization.DateTimeStyles.AdjustToUniversal),
+                extraDates: parsedDates);
+
+            Database db = this.database;
+            ContainerResponse containerBEEnabledResponse = await db.CreateContainerAsync(binaryEncodingEnabled, "/pk");
+            ContainerResponse containerBEDisabledResponse = await db.CreateContainerAsync(binaryEncodingDisabled, "/pk");
+
+            string originalValue = Environment.GetEnvironmentVariable("Cosmos.BinaryEncodingEnabled");
+
+            try
+            {
+                // BinaryEncodingEnabled = True
+                Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, "True");
+                string rawJsonBEEnabled;
+                string rawJsonBEDisabled;
+                using (CosmosClient clientBinaryEncodingEnabled = new CosmosClient(this.connectionString))
+                {
+                    Container containerBinaryEncodingEnabled = clientBinaryEncodingEnabled.GetDatabase(db.Id).GetContainer(binaryEncodingEnabled);
+                    await containerBinaryEncodingEnabled.CreateItemAsync(testItem, new Microsoft.Azure.Cosmos.PartitionKey(pk));
+                    using ResponseMessage response = await containerBinaryEncodingEnabled.ReadItemStreamAsync(testId, new Microsoft.Azure.Cosmos.PartitionKey(pk));
+                    using StreamReader reader = new StreamReader(response.Content, Encoding.UTF8);
+                    rawJsonBEEnabled = await reader.ReadToEndAsync();
+
+                }
+
+                // BinaryEncodingEnabled = False
+                Environment.SetEnvironmentVariable(ConfigurationManager.BinaryEncodingEnabled, "False");
+                using (CosmosClient clientBinaryEncodingDisabled = new CosmosClient(this.connectionString))
+                {
+                    Container containerBinaryEncodingDisabled = clientBinaryEncodingDisabled.GetDatabase(db.Id).GetContainer(binaryEncodingDisabled);
+                    await containerBinaryEncodingDisabled.CreateItemAsync(testItem, new Microsoft.Azure.Cosmos.PartitionKey(pk));
+                    using ResponseMessage response = await containerBinaryEncodingDisabled.ReadItemStreamAsync(testId, new Microsoft.Azure.Cosmos.PartitionKey(pk));
+                    using StreamReader reader = new StreamReader(response.Content, Encoding.UTF8);
+                    rawJsonBEDisabled = await reader.ReadToEndAsync();
+                }
+
+                using JsonDocument docTrue = JsonDocument.Parse(rawJsonBEEnabled);
+                using JsonDocument docFalse = JsonDocument.Parse(rawJsonBEDisabled);
+
+                string extraDatesTrue = docTrue.RootElement.GetProperty("ExtraDates").GetRawText();
+                string extraDatesFalse = docFalse.RootElement.GetProperty("ExtraDates").GetRawText();
+
+                Assert.AreEqual(extraDatesTrue, extraDatesFalse, $"ExtraDates JSON mismatch:\nTrue: {extraDatesTrue}\nFalse: {extraDatesFalse}");
+            }
+            finally
+            {
+                Environment.SetEnvironmentVariable("Cosmos.BinaryEncodingEnabled", originalValue);
+                await containerBEEnabledResponse.Container.DeleteContainerAsync();
+                await containerBEDisabledResponse.Container.DeleteContainerAsync();
+            }
+        }
 
         [TestMethod]
         [TestCategory("MultiRegion")]
@@ -1376,6 +1466,41 @@ await this.container.DeleteItemAsync<CosmosIntegrationTestObject>(
             {
                 // Ignore
             }
+        }
+
+        public sealed class TestCosmosItem
+        {
+            [JsonConstructor]
+            public TestCosmosItem(
+                string id,
+                string pk,
+                string title,
+                string email,
+                string body,
+                DateTime createdUtc,
+                DateTime modifiedUtc,
+                DateTime[] extraDates)
+            {
+                this.id = id;
+                this.pk = pk;
+                this.title = title;
+                this.email = email;
+                this.body = body;
+                this.CreatedUtc = createdUtc;
+                this.ModifiedUtc = modifiedUtc;
+                this.ExtraDates = extraDates;
+            }
+
+#pragma warning disable IDE1006
+            public string id { get; }
+            public string pk { get; }
+            public string title { get; }
+            public string email { get; }
+            public string body { get; }
+#pragma warning restore IDE1006 // Naming Styles
+            public DateTime CreatedUtc { get; }
+            public DateTime ModifiedUtc { get; }
+            public DateTime[] ExtraDates { get; }
         }
     }
 }