[Resources] Use JsonExtensions to serialize and deserialize template and parameter objects (#15552)

* preserve datetime string value

* Update serialization and deserialization code to use JsonExtensions

* Added unit test

* retrieved output from outputs hashtable

* Updated parameter file parsing and added new test

* Update changelog

* remove unneeded file

* Fixed unit test

* Remove comment

* update changelog to avoid merge issue

* nit text update

Co-authored-by: Yeming Liu <[email protected]>

Author: jorgecotillo

src/Resources/ResourceManager/Json/PSJsonSerializer.cs

@@ -52,7 +52,10 @@ public static string Serialize(object value, SerializeContext context)
             {
                 object processed = ProcessValue(value, 0, context);
 
-                return JsonConvert.SerializeObject(processed);
+                // NOTE(jcotillo): JsonExtensions.ToJson() extension uses a custom serialization settings
+                // that preserves DateTime values as string (DateParseHandling = DateParseHandling.None),
+                // plus other custom settings.
+                return processed.ToJson();
             }
             catch (OperationCanceledException)
             {

src/Resources/ResourceManager/SdkClient/ResourceManagerSdkClient.cs

@@ -453,11 +453,16 @@ private Deployment CreateBasicDeployment(PSDeploymentCmdletParameters parameters
             {
                 if (!string.IsNullOrEmpty(parameters.TemplateFile))
                 {
-                    deployment.Properties.Template = JObject.Parse(FileUtilities.DataStore.ReadFileAsText(parameters.TemplateFile));
+                    // NOTE(jcotillo): JsonExtensions.FromJson<> extension uses a custom serialization settings
+                    // that preserves DateTime values as string (DateParseHandling = DateParseHandling.None),
+                    // plus other custom settings (see: JsonExtensions.JsonObjectTypeSerializer)
+                    deployment.Properties.Template =
+                        FileUtilities.DataStore.ReadFileAsStream(parameters.TemplateFile).FromJson<JObject>();
                 }
                 else
                 {
-                    deployment.Properties.Template = JObject.Parse(PSJsonSerializer.Serialize(parameters.TemplateObject));
+                    deployment.Properties.Template = 
+                        PSJsonSerializer.Serialize(parameters.TemplateObject).FromJson<JObject>();
                 }
             }
 
@@ -475,8 +480,9 @@ private Deployment CreateBasicDeployment(PSDeploymentCmdletParameters parameters
                 string parametersContent = parametersDictionary != null
                     ? PSJsonSerializer.Serialize(parametersDictionary)
                     : null;
+                // NOTE(jcotillo): Adding FromJson<> to parameters as well 
                 deployment.Properties.Parameters = !string.IsNullOrEmpty(parametersContent)
-                    ? JObject.Parse(parametersContent)
+                    ? parametersContent.FromJson<JObject>()
                     : null;
             }
 

src/Resources/ResourceManager/Utilities/TemplateUtility.cs

@@ -26,6 +26,7 @@
 using System.Security;
 using Microsoft.WindowsAzure.Commands.Common;
 using Microsoft.Azure.Commands.Common.Authentication.Abstractions;
+using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Extensions;
 
 namespace Microsoft.Azure.Commands.ResourceManager.Cmdlets.Utilities
 {
@@ -88,12 +89,18 @@ public static Dictionary<string, TemplateFileParameterV1> ParseTemplateParameter
             {
                 try
                 {
-                    parameters = JsonConvert.DeserializeObject<Dictionary<string, TemplateFileParameterV1>>(FileUtilities.DataStore.ReadFileAsText(templateParameterFilePath));
+                    // NOTE(jcotillo): We must use JsonExtensions to ensure the proper use of serialization settings.
+                    // otherwise we could get invalid date time serializations.
+                    parameters =
+                        FileUtilities.DataStore.ReadFileAsStream(templateParameterFilePath)
+                        .FromJson<Dictionary<string, TemplateFileParameterV1>>();
                 }
                 catch (JsonSerializationException)
                 {
-                    parameters = new Dictionary<string, TemplateFileParameterV1>(
-                        JsonConvert.DeserializeObject<TemplateFileParameterV2>(FileUtilities.DataStore.ReadFileAsText(templateParameterFilePath)).Parameters);
+                    var parametersv2 =
+                        FileUtilities.DataStore.ReadFileAsStream(templateParameterFilePath)
+                        .FromJson<TemplateFileParameterV2>();
+                    parameters = new Dictionary<string, TemplateFileParameterV1>(parametersv2.Parameters);
                 }
             }
 

src/Resources/Resources.Test/Json/PSJsonSerializerTests.cs

@@ -18,6 +18,7 @@ namespace Microsoft.Azure.Commands.Resources.Test.Json
     using System.Collections;
     using System.Collections.Generic;
     using System.Management.Automation;
+    using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Extensions;
     using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Json;
     using Microsoft.WindowsAzure.Commands.ScenarioTest;
     using Newtonsoft.Json.Linq;
@@ -90,11 +91,15 @@ public void Serialize_Hashtable_Success()
 
             string result = PSJsonSerializer.Serialize(hashtable);
 
-            JToken parsedResult = JToken.Parse(result);
+            JToken parsedResult = result.FromJson<JToken>();
+
+            // NOTE(jcotillo): JsonExtensions is now camelCasing all property keys
+            // therefore even though Bar was set as PascalCase, after serializing it
+            // the key became camelCase.
             JToken expected = JToken.FromObject(new
             {
                 foo = "fooValue",
-                Bar = true,
+                bar = true,
                 nested = new
                 {
                     foo = "4d44fe86-f04a-4ba5-9900-abdec8cb11c1",

src/Resources/Resources.Test/Resources.Test.csproj

@@ -21,6 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <ProjectReference Include="..\ResourceManager\ResourceManager.csproj" />
     <ProjectReference Include="..\Resources\Resources.csproj" />
   </ItemGroup>
 

src/Resources/Resources.Test/ScenarioTests/DeploymentTests.cs

@@ -202,5 +202,19 @@ public void TestWhatIfWithQueryString()
         {
             TestRunner.RunTestScript("Test-WhatIfWithQueryString");
         }
+
+        [Fact]
+        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        public void TestNewDeploymentFromTemplateFileContainingDatetimeOutput()
+        {
+            TestRunner.RunTestScript("Test-NewDeploymentFromTemplateFileContainingDatetimeOutput");
+        }
+
+        [Fact]
+        [Trait(Category.AcceptanceType, Category.CheckIn)]
+        public void TestNewDeploymentFromTemplateAndParameterFileContainingDatetimeOutput()
+        {
+            TestRunner.RunTestScript("Test-NewDeploymentFromTemplateAndParameterFileContainingDatetimeOutput");
+        }
     }
 }

src/Resources/Resources.Test/ScenarioTests/DeploymentTests.ps1

@@ -923,4 +923,90 @@ function Test-WhatIfWithQueryString
 			Clean-ResourceGroup $rgname
 		}
 	}
+}
+
+<#
+.SYNOPSIS
+Tests deployment via template file containing a single datetime string output.
+#>
+function Test-NewDeploymentFromTemplateFileContainingDatetimeOutput
+{
+	# Setup
+	$rgname = Get-ResourceGroupName
+	$rname = Get-ResourceName
+	$rglocation = "West US 2"
+
+	try
+	{
+		# Test
+		New-AzResourceGroup -Name $rgname -Location $rglocation
+
+		$datetime = "2021-07-08T22:56:00"
+		$datetimeFormatted = $datetime | Get-Date
+		$parameters = @{ "date"= $datetime }
+
+		$deployment = New-AzResourceGroupDeployment -Name $rname -ResourceGroupName $rgname -TemplateFile simpleTemplateWithDatetimeOutput.json -TemplateParameterObject $parameters
+
+		# Assert
+		Assert-AreEqual Succeeded $deployment.ProvisioningState
+
+		$subId = (Get-AzContext).Subscription.SubscriptionId
+		$deploymentId = "/subscriptions/$subId/resourcegroups/$rgname/providers/Microsoft.Resources/deployments/$rname"
+		$getById = Get-AzResourceGroupDeployment -Id $deploymentId
+		Assert-AreEqual $getById.DeploymentName $deployment.DeploymentName
+
+		$datetimeOutput = $getById.Outputs.date.Value | Get-Date
+		
+		Assert-AreEqual $datetimeFormatted $datetimeOutput
+	}
+
+	finally
+    {
+        # Cleanup
+        Clean-ResourceGroup $rgname
+    }
+}
+
+<#
+.SYNOPSIS
+Tests deployment via template and parameter file containing a single datetime string output.
+#>
+function Test-NewDeploymentFromTemplateAndParameterFileContainingDatetimeOutput
+{
+	# Setup
+	$rgname = Get-ResourceGroupName
+	$rname = Get-ResourceName
+	$rglocation = "West US 2"
+
+	try
+	{
+		# Test
+		New-AzResourceGroup -Name $rgname -Location $rglocation
+
+		# NOTE(jcotillo): This is the same value as the one from: simpleTemplateWithDatetimeOutputParameters.json
+		# if the parameter file gets updated, please ensure to update this value as well otherwise test will fail.
+		$datetime = "2021-07-08T22:56:00"
+		$datetimeFormatted = $datetime | Get-Date
+		$parameters = @{ "date"= $datetime }
+
+		$deployment = New-AzResourceGroupDeployment -Name $rname -ResourceGroupName $rgname -TemplateFile simpleTemplateWithDatetimeOutput.json -TemplateParameterFile simpleTemplateWithDatetimeOutputParameters.json
+
+		# Assert
+		Assert-AreEqual Succeeded $deployment.ProvisioningState
+
+		$subId = (Get-AzContext).Subscription.SubscriptionId
+		$deploymentId = "/subscriptions/$subId/resourcegroups/$rgname/providers/Microsoft.Resources/deployments/$rname"
+		$getById = Get-AzResourceGroupDeployment -Id $deploymentId
+		Assert-AreEqual $getById.DeploymentName $deployment.DeploymentName
+
+		$datetimeOutput = $getById.Outputs.date.Value | Get-Date
+		
+		Assert-AreEqual $datetimeFormatted $datetimeOutput
+	}
+
+	finally
+    {
+        # Cleanup
+        Clean-ResourceGroup $rgname
+    }
 }