SystemTextJsonSerializer: Adds Default STJ Serializer

Microsoft.Azure.Cosmos/src/Serializer/CosmosSystemTextJsonSerializer.cs

@@ -0,0 +1,83 @@
+// ------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+// ------------------------------------------------------------
+
+namespace Microsoft.Azure.Cosmos
+{
+    using System;
+    using System.IO;
+    using System.Reflection;
+    using System.Text.Json;
+    using System.Text.Json.Serialization;
+    using global::Azure.Core.Serialization;
+
+    /// <summary>
+    /// This class provides a way to configure Linq Serialization Properties
+    /// </summary>
+    public class CosmosSystemTextJsonSerializer : CosmosLinqSerializer
+    {
+        private readonly JsonObjectSerializer systemTextJsonSerializer;
+
+        /// <summary>
+        /// Create an instance of <see cref="CosmosSystemTextJsonSerializer"/>
+        /// with the default values for the Cosmos SDK
+        /// </summary>
+        /// <param name="jsonSerializerOptions">options.</param>
+        public CosmosSystemTextJsonSerializer(JsonSerializerOptions jsonSerializerOptions)
+        {
+            this.systemTextJsonSerializer = new JsonObjectSerializer(jsonSerializerOptions);
+        }
+
+        /// <inheritdoc/>
+        public override T FromStream<T>(Stream stream)
+        {
+            if (stream == null)
+                throw new ArgumentNullException(nameof(stream));
+
+            using (stream)
+            {
+                if (stream.CanSeek && stream.Length == 0)
+                {
+                    return default;
+                }
+
+                if (typeof(Stream).IsAssignableFrom(typeof(T)))
+                {
+                    return (T)(object)stream;
+                }
+
+                return (T)this.systemTextJsonSerializer.Deserialize(stream, typeof(T), default);
+            }
+        }
+
+        /// <inheritdoc/>
+        public override Stream ToStream<T>(T input)
+        {
+            MemoryStream streamPayload = new MemoryStream();
+            this.systemTextJsonSerializer.Serialize(streamPayload, input, input.GetType(), default);
+            streamPayload.Position = 0;
+            return streamPayload;
+        }
+
+        /// <inheritdoc/>
+        public override string SerializeMemberName(MemberInfo memberInfo)
+        {
+            JsonExtensionDataAttribute jsonExtensionDataAttribute =
+                 memberInfo.GetCustomAttribute<JsonExtensionDataAttribute>(true);
+            if (jsonExtensionDataAttribute != null)
+            {
+                return null;
+            }
+
+            JsonPropertyNameAttribute jsonPropertyNameAttribute = memberInfo.GetCustomAttribute<JsonPropertyNameAttribute>(true);
+
+            string memberName = !string.IsNullOrEmpty(jsonPropertyNameAttribute?.Name)
+                ? jsonPropertyNameAttribute.Name
+                : memberInfo.Name;
+
+            // Users must add handling for any additional attributes here
+
+            return memberName;
+        }
+    }
+}

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Tests/Json/CosmosSystemTextJsonSerializerTest.cs

@@ -0,0 +1,162 @@
+namespace Microsoft.Azure.Cosmos.Tests.Json
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using Microsoft.Azure.Cosmos.Tests.Poco.STJ;
+    using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+    [TestClass]
+    public sealed class CosmosSystemTextJsonSerializerTest
+    {
+        CosmosSystemTextJsonSerializer stjSerializer;
+
+        [TestInitialize]
+        public void SetUp()
+        {
+            this.stjSerializer = new(
+                new System.Text.Json.JsonSerializerOptions());
+        }
+
+        [TestMethod]
+        public void TestPoco()
+        {
+            // Arrange.
+            Cars car = Cars.GetRandomCar();
+
+            // Act.
+            Stream serializedStream = this.stjSerializer.ToStream<Cars>(car);
+            Cars deserializedValue = this.stjSerializer.FromStream<Cars>(serializedStream);
+
+            // Assert.
+            Assert.AreEqual(car.Name, deserializedValue.Name);
+            Assert.AreEqual(car.ColorCode, deserializedValue.ColorCode);
+            Assert.AreEqual(car.CustomFeatures.Count, deserializedValue.CustomFeatures.Count);
+        }
+
+        [TestMethod]
+        public void TestList()
+        {
+            // Arrange.
+            List<int> list = new List<int> { 1, 2, 3 };
+
+            // Act.
+            Stream serializedStream = this.stjSerializer.ToStream<List<int>>(list);
+            List<int> deserializedList = this.stjSerializer.FromStream<List<int>>(serializedStream);
+
+            // Assert.
+            Assert.AreEqual(list[0], deserializedList[0]);
+            Assert.AreEqual(list[1], deserializedList[1]);
+            Assert.AreEqual(list[2], deserializedList[2]);
+        }
+
+        [TestMethod]
+        [DataRow(true)]
+        [DataRow(false)]
+        public void TestBool(bool booleanValue)
+        {
+            // Arrange and Act.
+            Stream serializedStream = this.stjSerializer.ToStream<bool>(booleanValue);
+            bool deserializedValue= this.stjSerializer.FromStream<bool>(serializedStream);
+
+            // Assert.
+            if (booleanValue)
+            {
+                Assert.IsTrue(deserializedValue);
+            }
+            else
+            {
+                Assert.IsFalse(deserializedValue);
+            }
+        }
+
+        [TestMethod]
+        public void TestNumber()
+        {
+            {
+                short value = 32;
+                Stream serializedStream = this.stjSerializer.ToStream<short>(value);
+                short int16Value = this.stjSerializer.FromStream<short>(serializedStream);
+                Assert.AreEqual(expected: value, actual: int16Value);
+            }
+
+            {
+                int value = 32;
+                Stream serializedStream = this.stjSerializer.ToStream<int>(value);
+                int int32Value = this.stjSerializer.FromStream<int>(serializedStream);
+                Assert.AreEqual(expected: value, actual: int32Value);
+            }
+
+            {
+                long value = 32;
+                Stream serializedStream = this.stjSerializer.ToStream<long>(value);
+                long int64Value = this.stjSerializer.FromStream<long>(serializedStream);
+                Assert.AreEqual(expected: value, actual: int64Value);
+            }
+
+            {
+                uint value = 32;
+                Stream serializedStream = this.stjSerializer.ToStream<uint>(value);
+                uint uintValue = this.stjSerializer.FromStream<uint>(serializedStream);
+                Assert.AreEqual(expected: value, actual: uintValue);
+            }
+
+            {
+                float value = 32.1337f;
+                Stream serializedStream = this.stjSerializer.ToStream<float>(value);
+                float floatValue = this.stjSerializer.FromStream<float>(serializedStream);
+                Assert.AreEqual(expected: value, actual: floatValue);
+            }
+
+            {
+                double value = 32.1337;
+                Stream serializedStream = this.stjSerializer.ToStream<double>(value);
+                double doubleValue = this.stjSerializer.FromStream<double>(serializedStream);
+                Assert.AreEqual(expected: value, actual: doubleValue);
+            }
+        }
+
+        [TestMethod]
+        public void TestString()
+        {
+            // Arrange.
+            string value = "asdf";
+
+            // Act.
+            Stream result = this.stjSerializer.ToStream<string>(value);
+            string cosmosString = this.stjSerializer.FromStream<string>(result);
+
+            // Assert.
+            Assert.AreEqual(expected: value, actual: cosmosString.ToString());
+        }
+
+        [TestMethod]
+        public void TestBinary()
+        {
+            // Arrange.
+            byte[] value = new byte[] { 1, 2, 3 };
+
+            // Act.
+            Stream serializedStream = this.stjSerializer.ToStream<byte[]>(value);
+            byte[] array = this.stjSerializer.FromStream<byte[]>(serializedStream);
+
+            // Assert.
+            Assert.IsTrue(array.SequenceEqual(value.ToArray()));
+        }
+
+        [TestMethod]
+        public void TestGuid()
+        {
+            // Arrange.
+            Guid value = Guid.NewGuid();
+
+            // Act.
+            Stream serializedStream = this.stjSerializer.ToStream<Guid>(value);
+            Guid guidValue = this.stjSerializer.FromStream<Guid>(serializedStream);
+
+            // Assert.
+            Assert.AreEqual(expected: value, actual: guidValue);
+        }
+    }
+}

Microsoft.Azure.Cosmos/tests/Microsoft.Azure.Cosmos.Tests/Poco/STJ/Cars.cs

@@ -0,0 +1,102 @@
+namespace Microsoft.Azure.Cosmos.Tests.Poco.STJ
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Text.Json.Serialization;
+
+    public sealed class Cars
+    {
+        private static readonly Random random = new();
+        private static readonly string[] names = new string[]
+        {
+            "Toyota 4Runner",
+            "Toyota Camry",
+            "Toyota Prius",
+            "Toyota Rav4",
+            "Toyota Avalon",
+            "Honda Civic",
+            "Honda Accord",
+            "Honda CRV",
+            "Honda MRV",
+            "BMW C18",
+            "BMW 328i",
+            "BMW 530i",
+        };
+
+        private static readonly string[] features = new string[]
+        {
+            "all wheel drive",
+            "abs",
+            "apple car play",
+            "power window",
+            "heated seating",
+            "steering mounted control",
+        };
+
+        [JsonConstructor]
+        public Cars(
+            string name,
+            int colorCode,
+            double vin,
+            List<string> customFeatures)
+        {
+            this.Name = name;
+            this.ColorCode = colorCode;
+            this.Vin = vin;
+            this.CustomFeatures = customFeatures;
+        }
+
+        [JsonPropertyName("name")]
+        public string Name { get; }
+
+        [JsonPropertyName("colorCode")]
+        public int ColorCode { get; }
+
+        [JsonPropertyName("vin")]
+        public double Vin { get; }
+
+        [JsonPropertyName("customFeatures")]
+        public List<string> CustomFeatures { get; }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is Cars car))
+            {
+                return false;
+            }
+
+            return this.Equals(car);
+        }
+
+        public bool Equals(Cars other)
+        {
+            return this.Name == other.Name && this.ColorCode == other.ColorCode;
+        }
+
+        public override int GetHashCode()
+        {
+            return 0;
+        }
+
+        public static Cars GetRandomCar()
+        {
+            string name = names[random.Next(0, names.Length)];
+            int colorCode = random.Next(0, 100);
+            double vin = random.NextDouble() * 10000000;
+            List<string> customFeatures = new();
+
+            int numOfFeatures = random.Next(0, 3);
+            for (int i = 0; i < numOfFeatures; i++)
+            {
+                customFeatures.Add(GetRandomFeature());
+            }
+
+            return new Cars(name, colorCode, vin, customFeatures);
+        }
+
+        public static string GetRandomFeature()
+        {
+            return features[random.Next(0, features.Length)];
+        }
+    }
+}