Use utf8 encoding for reading stdout & stderr when invoking Bicep (#23409)

anthony-c-martin · web-flow · commit 05b89d46bc15 · 2023-11-17T08:45:22.000+08:00
* Add BicepUtility test

* Address PR feedback
diff --git a/src/Resources/ResourceManager/Implementation/Bicep/PublishAzureBicepModuleCmdlet.cs b/src/Resources/ResourceManager/Implementation/Bicep/PublishAzureBicepModuleCmdlet.cs
@@ -12,6 +12,7 @@
 // limitations under the License.
 // ----------------------------------------------------------------------------------
 
+using Microsoft.Azure.Commands.Common.Authentication.Abstractions;
 using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Utilities;
 using Microsoft.Azure.Commands.ResourceManager.Common;
 using Microsoft.WindowsAzure.Commands.Utilities.Common;
@@ -41,7 +42,7 @@ public class PublishAzureBicepModuleCmdlet : AzureRMCmdlet
 
         public override void ExecuteCmdlet()
         {
-            BicepUtility.PublishFile(this.TryResolvePath(this.FilePath), this.Target, this.DocumentationUri, this.Force.IsPresent, this.WriteVerbose, this.WriteWarning);
+            BicepUtility.Create().PublishFile(this.TryResolvePath(this.FilePath), this.Target, this.DocumentationUri, this.Force.IsPresent, this.WriteVerbose, this.WriteWarning);
 
             if (this.PassThru.IsPresent)
             {
diff --git a/src/Resources/ResourceManager/Implementation/CmdletBase/DeploymentCmdletBase.cs b/src/Resources/ResourceManager/Implementation/CmdletBase/DeploymentCmdletBase.cs
@@ -475,7 +475,7 @@ protected string[] GetStaticParameterNames()
 
         protected void BuildAndUseBicepTemplate()
         {
-            TemplateFile = BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
+            TemplateFile = BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
         }
 
         private IReadOnlyDictionary<string, object> GetDynamicParametersDictionary()
@@ -490,8 +490,8 @@ private IReadOnlyDictionary<string, object> GetDynamicParametersDictionary()
         protected void BuildAndUseBicepParameters(bool emitWarnings)
         {
             BicepUtility.OutputCallback nullCallback = null;
-            var output = BicepUtility.BuildParams(this.ResolvePath(TemplateParameterFile), GetDynamicParametersDictionary(), this.WriteVerbose, emitWarnings ? this.WriteWarning : nullCallback);
-            bicepparamFileParameters = GetParametersFromJson(output.parametersJson);
+            var output = BicepUtility.Create().BuildParams(this.ResolvePath(TemplateParameterFile), GetDynamicParametersDictionary(), this.WriteVerbose, emitWarnings ? this.WriteWarning : nullCallback);
+            bicepparamFileParameters = TemplateUtility.ParseTemplateParameterJson(output.parametersJson);
 
             if (TemplateObject == null && 
                 string.IsNullOrEmpty(TemplateFile) && 
@@ -545,13 +545,5 @@ private Hashtable GetCombinedTemplateParameterObject()
 
             return TemplateParameterObject;
         }
-
-        private IReadOnlyDictionary<string, TemplateParameterFileParameter> GetParametersFromJson(string parametersJson)
-        {
-            using (var reader = new StringReader(parametersJson))
-            {
-                return TemplateUtility.ParseTemplateParameterJson(reader);
-            }
-        }
     }
 }
diff --git a/src/Resources/ResourceManager/Implementation/CmdletBase/DeploymentStacksCmdletBase.cs b/src/Resources/ResourceManager/Implementation/CmdletBase/DeploymentStacksCmdletBase.cs
@@ -60,7 +60,7 @@ protected string ResolveBicepFile(string TemplateFile)
         {
             if (BicepUtility.IsBicepFile(TemplateFile))
             {
-                return BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
+                return BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
             }
             else
                 return TemplateFile;
@@ -71,7 +71,7 @@ protected BicepBuildParamsStdout ResolveBicepParameterFile(string TemplateParame
         {
             if (BicepUtility.IsBicepparamFile(TemplateParameterFile))
             {
-                return BicepUtility.BuildParams(this.ResolvePath(TemplateParameterFile), new Dictionary<string, object>(), this.WriteVerbose, this.WriteWarning);
+                return BicepUtility.Create().BuildParams(this.ResolvePath(TemplateParameterFile), new Dictionary<string, object>(), this.WriteVerbose, this.WriteWarning);
             }
 
             return null;
diff --git a/src/Resources/ResourceManager/Implementation/TemplateSpecs/NewAzTemplateSpec.cs b/src/Resources/ResourceManager/Implementation/TemplateSpecs/NewAzTemplateSpec.cs
@@ -166,7 +166,7 @@ public override void ExecuteCmdlet()
 
                         if (BicepUtility.IsBicepFile(TemplateFile))
                         {
-                            filePath = BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
+                            filePath = BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
                         }
 
                         // Note: We set uiFormDefinitionFilePath to null below because we process the UIFormDefinition
diff --git a/src/Resources/ResourceManager/Implementation/TemplateSpecs/SetAzTemplateSpec.cs b/src/Resources/ResourceManager/Implementation/TemplateSpecs/SetAzTemplateSpec.cs
@@ -204,7 +204,7 @@ public override void ExecuteCmdlet()
                             }
                             if (BicepUtility.IsBicepFile(TemplateFile))
                             {
-                                filePath = BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
+                                filePath = BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);
                             }
 
                             // Note: We set uiFormDefinitionFilePath to null below because we process the UIFormDefinition
diff --git a/src/Resources/ResourceManager/Utilities/BicepUtility.cs b/src/Resources/ResourceManager/Utilities/BicepUtility.cs
@@ -23,6 +23,7 @@ namespace Microsoft.Azure.Commands.ResourceManager.Cmdlets.Utilities
     using System.Collections.Generic;
     using System.IO;
     using System.Text.RegularExpressions;
+    using Microsoft.Azure.Commands.Common.Authentication;
 
     public class BicepBuildParamsStdout
     {
@@ -33,22 +34,10 @@ public class BicepBuildParamsStdout
         public string templateSpecId { get; set; }
     }
 
-    internal static class BicepUtility
+    internal class BicepUtility
     {
-        private static Lazy<string> BicepVersionLazy = new Lazy<string>(() => {
-            var processInvoker = ProcessInvoker.Create();
-            if (!processInvoker.CheckExecutableExists(BicepExecutable))
-            {
-                return null;
-            }
-
-            var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = "-v" });            
-            
-            var pattern = new Regex("\\d+(\\.\\d+)+");
-            return pattern.Match(output.Stdout)?.Value;
-        });
-
-        private static string BicepVersion => BicepVersionLazy.Value;
+        public static BicepUtility Create()
+            => new BicepUtility(ProcessInvoker.Create(), FileUtilities.DataStore);
 
         /// <summary>
         /// The Bicep executable to use. By default, this'll be resolved from the system PATH.
@@ -72,15 +61,38 @@ internal static class BicepUtility
 
         public delegate void OutputCallback(string msg);
 
+        private readonly IProcessInvoker processInvoker;
+        private readonly IDataStore dataStore;
+        private readonly Lazy<string> bicepVersionLazy;
+
+        public BicepUtility(IProcessInvoker processInvoker, IDataStore dataStore)
+        {
+            this.processInvoker = processInvoker;
+            this.dataStore = dataStore;
+            this.bicepVersionLazy = new Lazy<string>(() => {
+                if (!processInvoker.CheckExecutableExists(BicepExecutable))
+                {
+                    return null;
+                }
+
+                var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = "-v" });            
+                
+                var pattern = new Regex("\\d+(\\.\\d+)+");
+                return pattern.Match(output.Stdout)?.Value;
+            });
+        }
+
+        private string BicepVersion => bicepVersionLazy.Value;
+
         public static bool IsBicepFile(string templateFilePath) =>
             ".bicep".Equals(Path.GetExtension(templateFilePath), StringComparison.OrdinalIgnoreCase);
 
         public static bool IsBicepparamFile(string parametersFilePath) =>
             ".bicepparam".Equals(Path.GetExtension(parametersFilePath), StringComparison.OrdinalIgnoreCase);
 
-        public static string BuildFile(string bicepTemplateFilePath, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
+        public string BuildFile(string bicepTemplateFilePath, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
         {
-            if (!FileUtilities.DataStore.FileExists(bicepTemplateFilePath))
+            if (!dataStore.FileExists(bicepTemplateFilePath))
             {
                 throw new AzPSArgumentException(Properties.Resources.InvalidBicepFilePath, "TemplateFile");
             }
@@ -91,17 +103,17 @@ public static string BuildFile(string bicepTemplateFilePath, OutputCallback writ
             RunBicepCommand($"build {GetQuotedFilePath(bicepTemplateFilePath)} --outdir {GetQuotedFilePath(tempDirectory)}", MinimalVersionRequirement, writeVerbose, writeWarning);
 
             string buildResultPath = Path.Combine(tempDirectory, Path.GetFileName(bicepTemplateFilePath)).Replace(".bicep", ".json");
-            if (!FileUtilities.DataStore.FileExists(buildResultPath))
+            if (!dataStore.FileExists(buildResultPath))
             {
                 throw new AzPSApplicationException(string.Format(Properties.Resources.BuildBicepFileToJsonFailed, bicepTemplateFilePath));
             }
 
             return buildResultPath;
         }
 
-        public static BicepBuildParamsStdout BuildParams(string bicepParamFilePath, IReadOnlyDictionary<string, object> overrideParams, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
+        public BicepBuildParamsStdout BuildParams(string bicepParamFilePath, IReadOnlyDictionary<string, object> overrideParams, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
         {
-            if (!FileUtilities.DataStore.FileExists(bicepParamFilePath))
+            if (!dataStore.FileExists(bicepParamFilePath))
             {
                 throw new AzPSArgumentException(Properties.Resources.InvalidBicepparamFilePath, "TemplateParameterFile");
             }
@@ -124,9 +136,9 @@ public static BicepBuildParamsStdout BuildParams(string bicepParamFilePath, IRea
             return JsonConvert.DeserializeObject<BicepBuildParamsStdout>(stdout);
         }
 
-        public static void PublishFile(string bicepFilePath, string target, string documentationUri = null, bool force = false, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
+        public void PublishFile(string bicepFilePath, string target, string documentationUri = null, bool force = false, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
         {
-            if (!FileUtilities.DataStore.FileExists(bicepFilePath))
+            if (!dataStore.FileExists(bicepFilePath))
             {
                 throw new AzPSArgumentException(Properties.Resources.InvalidBicepFilePath, "File");
             }
@@ -148,15 +160,15 @@ public static void PublishFile(string bicepFilePath, string target, string docum
             RunBicepCommand(bicepPublishCommand, MinimalVersionRequirementForBicepPublish, writeVerbose, writeWarning);
         }
 
-        private static void CheckBicepExecutable()
+        private void CheckBicepExecutable()
         {
             if (BicepVersion == null)
             {
                 throw new AzPSApplicationException(Properties.Resources.BicepNotFound);
             }
         }
 
-        private static string CheckMinimalVersionRequirement(string minimalVersionRequirement)
+        private string CheckMinimalVersionRequirement(string minimalVersionRequirement)
         {
             CheckBicepExecutable();
 
@@ -168,14 +180,13 @@ private static string CheckMinimalVersionRequirement(string minimalVersionRequir
             return BicepVersion;
         }
 
-        private static string RunBicepCommandWithStdoutCapture(string arguments, string minimalVersionRequirement, Dictionary<string, string> envVars = null, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
+        private string RunBicepCommandWithStdoutCapture(string arguments, string minimalVersionRequirement, Dictionary<string, string> envVars = null, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
         {
             string currentBicepVersion = CheckMinimalVersionRequirement(minimalVersionRequirement);
             writeVerbose?.Invoke($"Using Bicep v{currentBicepVersion}");
 
             writeVerbose?.Invoke($"Calling Bicep with arguments: {arguments}");
 
-            var processInvoker = ProcessInvoker.Create();
             var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = arguments, EnvVars = envVars });
 
             if (output.ExitCode != 0)
@@ -192,14 +203,13 @@ private static string RunBicepCommandWithStdoutCapture(string arguments, string
             return output.Stdout;
         }
 
-        private static void RunBicepCommand(string arguments, string minimalVersionRequirement, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
+        private void RunBicepCommand(string arguments, string minimalVersionRequirement, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)
         {
             string currentBicepVersion = CheckMinimalVersionRequirement(minimalVersionRequirement);
             writeVerbose?.Invoke($"Using Bicep v{currentBicepVersion}");
 
             writeVerbose?.Invoke($"Calling Bicep with arguments: {arguments}");
 
-            var processInvoker = ProcessInvoker.Create();
             var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = arguments });
 
             writeVerbose?.Invoke(output.Stdout);
diff --git a/src/Resources/ResourceManager/Utilities/ProcessInvoker.cs b/src/Resources/ResourceManager/Utilities/ProcessInvoker.cs
@@ -17,6 +17,7 @@ namespace Microsoft.Azure.Commands.ResourceManager.Cmdlets.Utilities
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.Management.Automation;
+    using System.Text;
 
     public class ProcessOutput
     {
@@ -84,6 +85,8 @@ public ProcessOutput Invoke(ProcessInput input)
                     UseShellExecute = false,
                     RedirectStandardOutput = true,
                     RedirectStandardError = true,
+                    StandardOutputEncoding = Encoding.UTF8,
+                    StandardErrorEncoding = Encoding.UTF8,
                     CreateNoWindow = true,
                 }
             };
diff --git a/src/Resources/ResourceManager/Utilities/TemplateUtility.cs b/src/Resources/ResourceManager/Utilities/TemplateUtility.cs
@@ -100,6 +100,14 @@ public static Dictionary<string, TemplateParameterFileParameter> ParseTemplatePa
             }
         }
 
+        public static Dictionary<string, TemplateParameterFileParameter> ParseTemplateParameterJson(string json)
+        {
+            using (var reader = new StringReader(json))
+            {
+                return TemplateUtility.ParseTemplateParameterJson(reader);
+            }
+        }
+
         public static Dictionary<string, TemplateParameterFileParameter> ParseTemplateParameterJson(TextReader reader)
         {
             // Read once to avoid having to rewind the stream
diff --git a/src/Resources/Resources.Test/UnitTests/Utilities/BicepUtilityTests.cs b/src/Resources/Resources.Test/UnitTests/Utilities/BicepUtilityTests.cs
diff --git a/src/Resources/Resources.Test/UnitTests/Utilities/TestBicepUtility.cs b/src/Resources/Resources.Test/UnitTests/Utilities/TestBicepUtility.cs
diff --git a/src/Resources/Resources/ChangeLog.md b/src/Resources/Resources/ChangeLog.md

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`// limitations under the License.`
`13`	`13`	`// ----------------------------------------------------------------------------------`
`14`	`14`
	`15`	`+using Microsoft.Azure.Commands.Common.Authentication.Abstractions;`
`15`	`16`	`using Microsoft.Azure.Commands.ResourceManager.Cmdlets.Utilities;`
`16`	`17`	`using Microsoft.Azure.Commands.ResourceManager.Common;`
`17`	`18`	`using Microsoft.WindowsAzure.Commands.Utilities.Common;`
`@@ -41,7 +42,7 @@ public class PublishAzureBicepModuleCmdlet : AzureRMCmdlet`
`41`	`42`
`42`	`43`	`public override void ExecuteCmdlet()`
`43`	`44`	`{`
`44`		`- BicepUtility.PublishFile(this.TryResolvePath(this.FilePath), this.Target, this.DocumentationUri, this.Force.IsPresent, this.WriteVerbose, this.WriteWarning);`
	`45`	`+ BicepUtility.Create().PublishFile(this.TryResolvePath(this.FilePath), this.Target, this.DocumentationUri, this.Force.IsPresent, this.WriteVerbose, this.WriteWarning);`
`45`	`46`
`46`	`47`	`if (this.PassThru.IsPresent)`
`47`	`48`	`{`
Original file line number	Diff line number	Diff line change
`@@ -475,7 +475,7 @@ protected string[] GetStaticParameterNames()`
`475`	`475`
`476`	`476`	`protected void BuildAndUseBicepTemplate()`
`477`	`477`	`{`
`478`		`- TemplateFile = BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
	`478`	`+ TemplateFile = BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
`479`	`479`	`}`
`480`	`480`
`481`	`481`	`private IReadOnlyDictionary<string, object> GetDynamicParametersDictionary()`
`@@ -490,8 +490,8 @@ private IReadOnlyDictionary<string, object> GetDynamicParametersDictionary()`
`490`	`490`	`protected void BuildAndUseBicepParameters(bool emitWarnings)`
`491`	`491`	`{`
`492`	`492`	`BicepUtility.OutputCallback nullCallback = null;`
`493`		`- var output = BicepUtility.BuildParams(this.ResolvePath(TemplateParameterFile), GetDynamicParametersDictionary(), this.WriteVerbose, emitWarnings ? this.WriteWarning : nullCallback);`
`494`		`- bicepparamFileParameters = GetParametersFromJson(output.parametersJson);`
	`493`	`+ var output = BicepUtility.Create().BuildParams(this.ResolvePath(TemplateParameterFile), GetDynamicParametersDictionary(), this.WriteVerbose, emitWarnings ? this.WriteWarning : nullCallback);`
	`494`	`+ bicepparamFileParameters = TemplateUtility.ParseTemplateParameterJson(output.parametersJson);`
`495`	`495`
`496`	`496`	`if (TemplateObject == null &&`
`497`	`497`	`string.IsNullOrEmpty(TemplateFile) &&`
`@@ -545,13 +545,5 @@ private Hashtable GetCombinedTemplateParameterObject()`
`545`	`545`
`546`	`546`	`return TemplateParameterObject;`
`547`	`547`	`}`
`548`		`-`
`549`		`- private IReadOnlyDictionary<string, TemplateParameterFileParameter> GetParametersFromJson(string parametersJson)`
`550`		`- {`
`551`		`- using (var reader = new StringReader(parametersJson))`
`552`		`- {`
`553`		`- return TemplateUtility.ParseTemplateParameterJson(reader);`
`554`		`- }`
`555`		`- }`
`556`	`548`	`}`
`557`	`549`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ protected string ResolveBicepFile(string TemplateFile)`
`60`	`60`	`{`
`61`	`61`	`if (BicepUtility.IsBicepFile(TemplateFile))`
`62`	`62`	`{`
`63`		`- return BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
	`63`	`+ return BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
`64`	`64`	`}`
`65`	`65`	`else`
`66`	`66`	`return TemplateFile;`
`@@ -71,7 +71,7 @@ protected BicepBuildParamsStdout ResolveBicepParameterFile(string TemplateParame`
`71`	`71`	`{`
`72`	`72`	`if (BicepUtility.IsBicepparamFile(TemplateParameterFile))`
`73`	`73`	`{`
`74`		`- return BicepUtility.BuildParams(this.ResolvePath(TemplateParameterFile), new Dictionary<string, object>(), this.WriteVerbose, this.WriteWarning);`
	`74`	`+ return BicepUtility.Create().BuildParams(this.ResolvePath(TemplateParameterFile), new Dictionary<string, object>(), this.WriteVerbose, this.WriteWarning);`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -166,7 +166,7 @@ public override void ExecuteCmdlet()`
`166`	`166`
`167`	`167`	`if (BicepUtility.IsBicepFile(TemplateFile))`
`168`	`168`	`{`
`169`		`- filePath = BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
	`169`	`+ filePath = BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`// Note: We set uiFormDefinitionFilePath to null below because we process the UIFormDefinition`
Original file line number	Diff line number	Diff line change
`@@ -204,7 +204,7 @@ public override void ExecuteCmdlet()`
`204`	`204`	`}`
`205`	`205`	`if (BicepUtility.IsBicepFile(TemplateFile))`
`206`	`206`	`{`
`207`		`- filePath = BicepUtility.BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
	`207`	`+ filePath = BicepUtility.Create().BuildFile(this.ResolvePath(TemplateFile), this.WriteVerbose, this.WriteWarning);`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`// Note: We set uiFormDefinitionFilePath to null below because we process the UIFormDefinition`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ namespace Microsoft.Azure.Commands.ResourceManager.Cmdlets.Utilities`
`23`	`23`	`using System.Collections.Generic;`
`24`	`24`	`using System.IO;`
`25`	`25`	`using System.Text.RegularExpressions;`
	`26`	`+ using Microsoft.Azure.Commands.Common.Authentication;`
`26`	`27`
`27`	`28`	`public class BicepBuildParamsStdout`
`28`	`29`	`{`
`@@ -33,22 +34,10 @@ public class BicepBuildParamsStdout`
`33`	`34`	`public string templateSpecId { get; set; }`
`34`	`35`	`}`
`35`	`36`
`36`		`- internal static class BicepUtility`
	`37`	`+ internal class BicepUtility`
`37`	`38`	`{`
`38`		`- private static Lazy<string> BicepVersionLazy = new Lazy<string>(() => {`
`39`		`- var processInvoker = ProcessInvoker.Create();`
`40`		`- if (!processInvoker.CheckExecutableExists(BicepExecutable))`
`41`		`- {`
`42`		`- return null;`
`43`		`- }`
`44`		`-`
`45`		`- var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = "-v" });`
`46`		`-`
`47`		`- var pattern = new Regex("\\d+(\\.\\d+)+");`
`48`		`- return pattern.Match(output.Stdout)?.Value;`
`49`		`- });`
`50`		`-`
`51`		`- private static string BicepVersion => BicepVersionLazy.Value;`
	`39`	`+ public static BicepUtility Create()`
	`40`	`+ => new BicepUtility(ProcessInvoker.Create(), FileUtilities.DataStore);`
`52`	`41`
`53`	`42`	`/// <summary>`
`54`	`43`	`/// The Bicep executable to use. By default, this'll be resolved from the system PATH.`
`@@ -72,15 +61,38 @@ internal static class BicepUtility`
`72`	`61`
`73`	`62`	`public delegate void OutputCallback(string msg);`
`74`	`63`
	`64`	`+ private readonly IProcessInvoker processInvoker;`
	`65`	`+ private readonly IDataStore dataStore;`
	`66`	`+ private readonly Lazy<string> bicepVersionLazy;`
	`67`	`+`
	`68`	`+ public BicepUtility(IProcessInvoker processInvoker, IDataStore dataStore)`
	`69`	`+ {`
	`70`	`+ this.processInvoker = processInvoker;`
	`71`	`+ this.dataStore = dataStore;`
	`72`	`+ this.bicepVersionLazy = new Lazy<string>(() => {`
	`73`	`+ if (!processInvoker.CheckExecutableExists(BicepExecutable))`
	`74`	`+ {`
	`75`	`+ return null;`
	`76`	`+ }`
	`77`	`+`
	`78`	`+ var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = "-v" });`
	`79`	`+`
	`80`	`+ var pattern = new Regex("\\d+(\\.\\d+)+");`
	`81`	`+ return pattern.Match(output.Stdout)?.Value;`
	`82`	`+ });`
	`83`	`+ }`
	`84`	`+`
	`85`	`+ private string BicepVersion => bicepVersionLazy.Value;`
	`86`	`+`
`75`	`87`	`public static bool IsBicepFile(string templateFilePath) =>`
`76`	`88`	`".bicep".Equals(Path.GetExtension(templateFilePath), StringComparison.OrdinalIgnoreCase);`
`77`	`89`
`78`	`90`	`public static bool IsBicepparamFile(string parametersFilePath) =>`
`79`	`91`	`".bicepparam".Equals(Path.GetExtension(parametersFilePath), StringComparison.OrdinalIgnoreCase);`
`80`	`92`
`81`		`- public static string BuildFile(string bicepTemplateFilePath, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
	`93`	`+ public string BuildFile(string bicepTemplateFilePath, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
`82`	`94`	`{`
`83`		`- if (!FileUtilities.DataStore.FileExists(bicepTemplateFilePath))`
	`95`	`+ if (!dataStore.FileExists(bicepTemplateFilePath))`
`84`	`96`	`{`
`85`	`97`	`throw new AzPSArgumentException(Properties.Resources.InvalidBicepFilePath, "TemplateFile");`
`86`	`98`	`}`
`@@ -91,17 +103,17 @@ public static string BuildFile(string bicepTemplateFilePath, OutputCallback writ`
`91`	`103`	`RunBicepCommand($"build {GetQuotedFilePath(bicepTemplateFilePath)} --outdir {GetQuotedFilePath(tempDirectory)}", MinimalVersionRequirement, writeVerbose, writeWarning);`
`92`	`104`
`93`	`105`	`string buildResultPath = Path.Combine(tempDirectory, Path.GetFileName(bicepTemplateFilePath)).Replace(".bicep", ".json");`
`94`		`- if (!FileUtilities.DataStore.FileExists(buildResultPath))`
	`106`	`+ if (!dataStore.FileExists(buildResultPath))`
`95`	`107`	`{`
`96`	`108`	`throw new AzPSApplicationException(string.Format(Properties.Resources.BuildBicepFileToJsonFailed, bicepTemplateFilePath));`
`97`	`109`	`}`
`98`	`110`
`99`	`111`	`return buildResultPath;`
`100`	`112`	`}`
`101`	`113`
`102`		`- public static BicepBuildParamsStdout BuildParams(string bicepParamFilePath, IReadOnlyDictionary<string, object> overrideParams, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
	`114`	`+ public BicepBuildParamsStdout BuildParams(string bicepParamFilePath, IReadOnlyDictionary<string, object> overrideParams, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
`103`	`115`	`{`
`104`		`- if (!FileUtilities.DataStore.FileExists(bicepParamFilePath))`
	`116`	`+ if (!dataStore.FileExists(bicepParamFilePath))`
`105`	`117`	`{`
`106`	`118`	`throw new AzPSArgumentException(Properties.Resources.InvalidBicepparamFilePath, "TemplateParameterFile");`
`107`	`119`	`}`
`@@ -124,9 +136,9 @@ public static BicepBuildParamsStdout BuildParams(string bicepParamFilePath, IRea`
`124`	`136`	`return JsonConvert.DeserializeObject<BicepBuildParamsStdout>(stdout);`
`125`	`137`	`}`
`126`	`138`
`127`		`- public static void PublishFile(string bicepFilePath, string target, string documentationUri = null, bool force = false, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
	`139`	`+ public void PublishFile(string bicepFilePath, string target, string documentationUri = null, bool force = false, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
`128`	`140`	`{`
`129`		`- if (!FileUtilities.DataStore.FileExists(bicepFilePath))`
	`141`	`+ if (!dataStore.FileExists(bicepFilePath))`
`130`	`142`	`{`
`131`	`143`	`throw new AzPSArgumentException(Properties.Resources.InvalidBicepFilePath, "File");`
`132`	`144`	`}`
`@@ -148,15 +160,15 @@ public static void PublishFile(string bicepFilePath, string target, string docum`
`148`	`160`	`RunBicepCommand(bicepPublishCommand, MinimalVersionRequirementForBicepPublish, writeVerbose, writeWarning);`
`149`	`161`	`}`
`150`	`162`
`151`		`- private static void CheckBicepExecutable()`
	`163`	`+ private void CheckBicepExecutable()`
`152`	`164`	`{`
`153`	`165`	`if (BicepVersion == null)`
`154`	`166`	`{`
`155`	`167`	`throw new AzPSApplicationException(Properties.Resources.BicepNotFound);`
`156`	`168`	`}`
`157`	`169`	`}`
`158`	`170`
`159`		`- private static string CheckMinimalVersionRequirement(string minimalVersionRequirement)`
	`171`	`+ private string CheckMinimalVersionRequirement(string minimalVersionRequirement)`
`160`	`172`	`{`
`161`	`173`	`CheckBicepExecutable();`
`162`	`174`
`@@ -168,14 +180,13 @@ private static string CheckMinimalVersionRequirement(string minimalVersionRequir`
`168`	`180`	`return BicepVersion;`
`169`	`181`	`}`
`170`	`182`
`171`		`- private static string RunBicepCommandWithStdoutCapture(string arguments, string minimalVersionRequirement, Dictionary<string, string> envVars = null, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
	`183`	`+ private string RunBicepCommandWithStdoutCapture(string arguments, string minimalVersionRequirement, Dictionary<string, string> envVars = null, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
`172`	`184`	`{`
`173`	`185`	`string currentBicepVersion = CheckMinimalVersionRequirement(minimalVersionRequirement);`
`174`	`186`	`writeVerbose?.Invoke($"Using Bicep v{currentBicepVersion}");`
`175`	`187`
`176`	`188`	`writeVerbose?.Invoke($"Calling Bicep with arguments: {arguments}");`
`177`	`189`
`178`		`- var processInvoker = ProcessInvoker.Create();`
`179`	`190`	`var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = arguments, EnvVars = envVars });`
`180`	`191`
`181`	`192`	`if (output.ExitCode != 0)`
`@@ -192,14 +203,13 @@ private static string RunBicepCommandWithStdoutCapture(string arguments, string`
`192`	`203`	`return output.Stdout;`
`193`	`204`	`}`
`194`	`205`
`195`		`- private static void RunBicepCommand(string arguments, string minimalVersionRequirement, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
	`206`	`+ private void RunBicepCommand(string arguments, string minimalVersionRequirement, OutputCallback writeVerbose = null, OutputCallback writeWarning = null)`
`196`	`207`	`{`
`197`	`208`	`string currentBicepVersion = CheckMinimalVersionRequirement(minimalVersionRequirement);`
`198`	`209`	`writeVerbose?.Invoke($"Using Bicep v{currentBicepVersion}");`
`199`	`210`
`200`	`211`	`writeVerbose?.Invoke($"Calling Bicep with arguments: {arguments}");`
`201`	`212`
`202`		`- var processInvoker = ProcessInvoker.Create();`
`203`	`213`	`var output = processInvoker.Invoke(new ProcessInput { Executable = BicepExecutable, Arguments = arguments });`
`204`	`214`
`205`	`215`	`writeVerbose?.Invoke(output.Stdout);`
Original file line number	Diff line number	Diff line change
`@@ -100,6 +100,14 @@ public static Dictionary<string, TemplateParameterFileParameter> ParseTemplatePa`
`100`	`100`	`}`
`101`	`101`	`}`
`102`	`102`
	`103`	`+ public static Dictionary<string, TemplateParameterFileParameter> ParseTemplateParameterJson(string json)`
	`104`	`+ {`
	`105`	`+ using (var reader = new StringReader(json))`
	`106`	`+ {`
	`107`	`+ return TemplateUtility.ParseTemplateParameterJson(reader);`
	`108`	`+ }`
	`109`	`+ }`
	`110`	`+`
`103`	`111`	`public static Dictionary<string, TemplateParameterFileParameter> ParseTemplateParameterJson(TextReader reader)`
`104`	`112`	`{`
`105`	`113`	`// Read once to avoid having to rewind the stream`