test: Test PreviewProcessArguments

Make GetArgumentIndex and IsArgMatch methods internal and add unit tests for argument processing

AzureLiquid.Preview/PreviewProcessArguments.cs

@@ -21,7 +21,7 @@ public class PreviewProcessArguments
     /// <param name="args">The arguments.</param>
     /// <param name="key">The key.</param>
     /// <returns>The index of the argument.</returns>
-    private static int GetArgumentIndex(string[] args, string key)
+    internal static int GetArgumentIndex(string[] args, string key)
     {
         for (int i = 0; i < args.Length; i++)
         {
@@ -42,7 +42,7 @@ private static int GetArgumentIndex(string[] args, string key)
     /// <returns>
     /// <c>true</c> if argument found; otherwise, <c>false</c>.
     /// </returns>
-    private static bool IsArgMatch(string arg, string key)
+    internal static bool IsArgMatch(string arg, string key)
     {
         return string.CompareOrdinal(arg, "--" + key) == 0;
     }

AzureLiquid.Preview/Program.cs

@@ -2,8 +2,9 @@
 // Licensed under the open source Apache License, Version 2.0.
 // </copyright>
 
-// deepcode ignore XXE: All input is returned to original source and is not used internally
-
+using System.Runtime.CompilerServices;
 using AzureLiquid.Preview;
 
+[assembly: InternalsVisibleTo("AzureLiquid.Tests")]
+
 PreviewProcess.Create(args);

AzureLiquid.Tests/PreviewProcessArgumentsTests.cs

@@ -0,0 +1,70 @@
+using System.IO;
+using Xunit;
+using FluentAssertions;
+
+namespace AzureLiquid.Preview.Tests
+{
+    public class PreviewProcessArgumentsTests
+    {
+        [Theory]
+        [InlineData(new string[] { "--template", "template.liquid" }, "template", 0)]
+        [InlineData(new string[] { "--content", "content.json" }, "content", 0)]
+        [InlineData(new string[] { "--output", "output.txt" }, "output", 0)]
+        [InlineData(new string[] { "--watch" }, "watch", 0)]
+        [InlineData(new string[] { "--template", "template.liquid" }, "content", -1)]
+        public void GetArgumentIndex_ShouldReturnCorrectIndex(string[] args, string key, int expectedIndex)
+        {
+            // Act
+            var index = PreviewProcessArguments.GetArgumentIndex(args, key);
+
+            // Assert
+            index.Should().Be(expectedIndex);
+        }
+
+        [Theory]
+        [InlineData("--template", "template", true)]
+        [InlineData("--content", "content", true)]
+        [InlineData("--output", "output", true)]
+        [InlineData("--watch", "watch", true)]
+        [InlineData("--template", "content", false)]
+        public void IsArgMatch_ShouldReturnCorrectResult(string arg, string key, bool expectedResult)
+        {
+            // Act
+            var result = PreviewProcessArguments.IsArgMatch(arg, key);
+
+            // Assert
+            result.Should().Be(expectedResult);
+        }
+
+        [Theory]
+        [InlineData(new string[] { "--template", "template.liquid" }, "template", true)]
+        [InlineData(new string[] { "--content", "content.json" }, "content", true)]
+        [InlineData(new string[] { "--output", "output.txt" }, "output", true)]
+        [InlineData(new string[] { "--watch" }, "watch", true)]
+        [InlineData(new string[] { "--template", "template.liquid" }, "content", false)]
+        public void HasArgument_ShouldReturnCorrectResult(string[] args, string key, bool expectedResult)
+        {
+            // Act
+            var result = PreviewProcessArguments.HasArgument(args, key);
+
+            // Assert
+            result.Should().Be(expectedResult);
+        }
+
+        [Theory]
+        [InlineData(new string[] { "--template", "template.liquid" }, "template", "template.liquid")]
+        [InlineData(new string[] { "--content", "content.json" }, "content", "content.json")]
+        [InlineData(new string[] { "--output", "output.txt" }, "output", "output.txt")]
+        public void ParsePath_ShouldReturnCorrectPath(string[] args, string key, string expectedPath)
+        {
+            // Arrange
+            var previewArgs = new PreviewProcessArguments();
+
+            // Act
+            var path = previewArgs.ParsePath(args, key);
+
+            // Assert
+            path.Should().Contain(expectedPath);
+        }
+    }
+}