Add initial compatibility and serializer tests for the updates to BaseObjectStorage

Author: michael-hawker

GazeInputTest/GazeInputTest.csproj

@@ -12,7 +12,7 @@
     <DefaultLanguage>en-US</DefaultLanguage>
     <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
     <TargetPlatformVersion Condition=" '$(TargetPlatformVersion)' == '' ">10.0.19041.0</TargetPlatformVersion>
-    <TargetPlatformMinVersion>10.0.17134.0</TargetPlatformMinVersion>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
     <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>

UnitTests/UnitTests.UWP/Helpers/JsonObjectSerializer.cs

@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Reflection;
+using Microsoft.Toolkit.Uwp.Helpers;
+using Newtonsoft.Json;
+
+namespace UnitTests.UWP.Helpers
+{
+    /// <summary>
+    /// This is a Serializer which should mimic the previous functionality of 6.1.1 release of the Toolkit with Newtonsoft.Json.
+    /// </summary>
+    internal class JsonObjectSerializer : IObjectSerializer
+    {
+        public T Deserialize<T>(object value)
+        {
+            var type = typeof(T);
+            var typeInfo = type.GetTypeInfo();
+
+            // Note: If you're creating a new app, you could just use the serializer directly.
+            // This if/return combo is to maintain compatibility with 6.1.1
+            if (typeInfo.IsPrimitive || type == typeof(string))
+            {
+                return (T)Convert.ChangeType(value, type);
+            }
+
+            return JsonConvert.DeserializeObject<T>((string)value);
+        }
+
+        public object Serialize<T>(T value)
+        {
+            var type = typeof(T);
+            var typeInfo = type.GetTypeInfo();
+
+            // Note: If you're creating a new app, you could just use the serializer directly.
+            // This if/return combo is to maintain compatibility with 6.1.1
+            if (typeInfo.IsPrimitive || type == typeof(string))
+            {
+                return value;
+            }
+
+            return JsonConvert.SerializeObject(value);
+        }
+    }
+}

UnitTests/UnitTests.UWP/Helpers/SystemTextJsonSerializer.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Text.Json;
+using Microsoft.Toolkit.Uwp.Helpers;
+
+namespace UnitTests.UWP.Helpers
+{
+    /// <summary>
+    /// Example class of writing a new <see cref="IObjectSerializer"/> that uses System.Text.Json.
+    /// </summary>
+    internal class SystemTextJsonSerializer : IObjectSerializer
+    {
+        public T Deserialize<T>(object value) => JsonSerializer.Deserialize<T>(value as string);
+
+        public object Serialize<T>(T value) => JsonSerializer.Serialize(value);
+    }
+}

UnitTests/UnitTests.UWP/Helpers/Test_StorageHelper.cs

@@ -5,15 +5,32 @@
 using Microsoft.Toolkit.Uwp.Helpers;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
-using System.Text.Json;
-using UnitTests.UI;
+using Newtonsoft.Json;
+using UnitTests.UWP.Helpers;
+using System.Diagnostics.Contracts;
 
 namespace UnitTests.Helpers
 {
     [TestClass]
     public class Test_StorageHelper
     {
-        private LocalObjectStorageHelper storageHelper = new LocalObjectStorageHelper();
+        private LocalObjectStorageHelper _localStorageHelperSystem = new LocalObjectStorageHelper(new SystemSerializer());
+        private LocalObjectStorageHelper _localStorageHelperJsonCompat = new LocalObjectStorageHelper(new JsonObjectSerializer());
+
+        private LocalObjectStorageHelper _localStorageHelperJsonNew = new LocalObjectStorageHelper(new SystemTextJsonSerializer());
+
+        /// <summary>
+        /// Checks that we're running 10.0.3 version of Newtonsoft.Json package which we used in 6.1.1.
+        /// </summary>
+        [TestCategory("Helpers")]
+        [TestMethod]
+        public void Test_StorageHelper_CheckNewtonsoftVersion()
+        {
+            var version = typeof(JsonSerializer).Assembly.GetName().Version;
+            Assert.AreEqual(10, version.Major);
+            Assert.AreEqual(0, version.Minor);
+            Assert.AreEqual(0, version.Revision); // Apparently the file revision was not updated for the updated package
+        }
 
         [TestCategory("Helpers")]
         [TestMethod]
@@ -23,38 +40,45 @@ public void Test_StorageHelper_LegacyIntTest()
 
             int input = 42;
 
-            // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save<string>(key, jsonInput);
+            // Use our previous Json layer to store value
+            _localStorageHelperJsonCompat.Save(key, input);
 
-            // now read it as int to valid that the change works
-            int output = storageHelper.Read<int>(key, 0);
+            // But try and read from our new system to see if it works
+            int output = _localStorageHelperSystem.Read(key, 0);
 
             Assert.AreEqual(input, output);
         }
 
-        [Ignore]
+        /// <summary>
+        /// If we try and deserialize a complex type with the <see cref="SystemSerializer"/>, we do a check ourselves and will throw our own exception.
+        /// </summary>
         [TestCategory("Helpers")]
         [TestMethod]
-        public void Test_StorageHelper_LegacyDateTest()
+        [ExpectedException(typeof(NotSupportedException))]
+        public void Test_StorageHelper_LegacyDateTestFailure()
         {
             string key = "ChristmasDay";
 
             DateTime input = new DateTime(2017, 12, 25);
 
-            // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save<string>(key, jsonInput);
+            _localStorageHelperJsonCompat.Save(key, input);
 
             // now read it as int to valid that the change works
-            DateTime output = storageHelper.Read<DateTime>(key, DateTime.Today);
+            DateTime output = _localStorageHelperSystem.Read(key, DateTime.Today);
+        }
 
-            Assert.AreEqual(input, output);
+        /// <summary>
+        /// The <see cref="SystemSerializer"/> doesn't support complex types, since it just passes through directly.
+        /// We'll get the argument exception from the <see cref="ApplicationDataContainer"/> API.
+        /// </summary>
+        [TestCategory("Helpers")]
+        [TestMethod]
+        [ExpectedException(typeof(ArgumentException))]
+        public void Test_StorageHelper_DateTestFailure()
+        {
+            _localStorageHelperSystem.Save("Today", DateTime.Today);
         }
 
-        [Ignore]
         [TestCategory("Helpers")]
         [TestMethod]
         public void Test_StorageHelper_LegacyInternalClassTest()
@@ -64,12 +88,10 @@ public void Test_StorageHelper_LegacyInternalClassTest()
             UI.Person input = new UI.Person() { Name = "Joe Bloggs", Age = 42 };
 
             // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save<string>(key, jsonInput);
+            _localStorageHelperJsonCompat.Save(key, input);
 
             // now read it as int to valid that the change works
-            UI.Person output = storageHelper.Read<UI.Person>(key, null);
+            UI.Person output = _localStorageHelperJsonCompat.Read<UI.Person>(key, null);
 
             Assert.IsNotNull(output);
             Assert.AreEqual(input.Name, output.Name);
@@ -82,15 +104,14 @@ public void Test_StorageHelper_LegacyPublicClassTest()
         {
             string key = "Contact";
 
+            // Here's we're serializing a different class which has the same properties as our other class below.
             UI.Person input = new UI.Person() { Name = "Joe Bloggs", Age = 42 };
 
             // simulate previous version by generating json and manually inserting it as string
-            string jsonInput = JsonSerializer.Serialize(input);
-
-            storageHelper.Save(key, jsonInput);
+            _localStorageHelperJsonCompat.Save(key, input);
 
             // now read it as int to valid that the change works
-            Person output = storageHelper.Read<Person>(key, null);
+            Person output = _localStorageHelperJsonCompat.Read<Person>(key, null);
 
             Assert.IsNotNull(output);
             Assert.AreEqual(input.Name, output.Name);
@@ -105,10 +126,10 @@ public void Test_StorageHelper_IntTest()
 
             int input = 42;
 
-            storageHelper.Save<int>(key, input);
+            _localStorageHelperSystem.Save<int>(key, input);
 
             // now read it as int to valid that the change works
-            int output = storageHelper.Read<int>(key, 0);
+            int output = _localStorageHelperSystem.Read<int>(key, 0);
 
             Assert.AreEqual(input, output);
         }
@@ -121,10 +142,10 @@ public void Test_StorageHelper_NewDateTest()
 
             DateTime input = new DateTime(2017, 12, 25);
 
-            storageHelper.Save<DateTime>(key, input);
+            _localStorageHelperJsonNew.Save(key, input);
 
             // now read it as int to valid that the change works
-            DateTime output = storageHelper.Read<DateTime>(key, DateTime.Today);
+            DateTime output = _localStorageHelperJsonNew.Read(key, DateTime.Today);
 
             Assert.AreEqual(input, output);
         }
@@ -137,10 +158,10 @@ public void Test_StorageHelper_NewPersonTest()
 
             Person input = new Person() { Name = "Joe Bloggs", Age = 42 };
 
-            storageHelper.Save<Person>(key, input);
+            _localStorageHelperJsonNew.Save(key, input);
 
             // now read it as int to valid that the change works
-            Person output = storageHelper.Read<Person>(key, null);
+            Person output = _localStorageHelperJsonNew.Read<Person>(key, null);
 
             Assert.IsNotNull(output);
             Assert.AreEqual(input.Name, output.Name);

UnitTests/UnitTests.UWP/UnitTests.UWP.csproj

@@ -119,6 +119,13 @@
     <PackageReference Include="MSTest.TestFramework">
       <Version>2.1.0</Version>
     </PackageReference>
+    <PackageReference Include="Newtonsoft.Json">
+      <Version>10.0.3</Version>
+      <!-- DO NOT UPGRADE THIS PACKAGE FROM 10.0.3, this is used for upgrade testing between 6.1.1 and 7.0.0 for the Object Serializers -->
+    </PackageReference>
+    <PackageReference Include="System.Text.Json">
+      <Version>4.7.2</Version>
+    </PackageReference>
     <PackageReference Include="System.Xml.XPath.XmlDocument">
       <Version>4.3.0</Version>
     </PackageReference>
@@ -141,6 +148,8 @@
     <Compile Include="Extensions\Test_EnumValuesExtension.cs" />
     <Compile Include="Extensions\Test_NullableBoolMarkupExtension.cs" />
     <Compile Include="GlobalSuppressions.cs" />
+    <Compile Include="Helpers\JsonObjectSerializer.cs" />
+    <Compile Include="Helpers\SystemTextJsonSerializer.cs" />
     <Compile Include="Helpers\TestCollectionCapableDeepLinkParser.cs" />
     <Compile Include="Helpers\TestDeepLinkParser.cs" />
     <Compile Include="Extensions\Test_DispatcherQueueExtensions.cs" />