Read new wwwauth[] input from Git 2.41 (#1288)

Author: Matthew John Cheetham

src/shared/Core.Tests/InputArgumentsTests.cs

@@ -9,19 +9,25 @@ public class InputArgumentsTests
         [Fact]
         public void InputArguments_Ctor_Null_ThrowsArgNullException()
         {
-            Assert.Throws<ArgumentNullException>(() => new InputArguments(null));
+            Assert.Throws<ArgumentNullException>(() => new InputArguments((IDictionary<string, string>)null));
+            Assert.Throws<ArgumentNullException>(() => new InputArguments((IDictionary<string, IList<string>>)null));
         }
 
         [Fact]
         public void InputArguments_CommonArguments_ValuePresent_ReturnsValues()
         {
-            var dict = new Dictionary<string, string>
+            var dict = new Dictionary<string, IList<string>>
             {
-                ["protocol"] = "https",
-                ["host"]     = "example.com",
-                ["path"]     = "an/example/path",
-                ["username"] = "john.doe",
-                ["password"] = "password123"
+                ["protocol"] = new[] { "https" },
+                ["host"]     = new[] { "example.com" },
+                ["path"]     = new[] { "an/example/path" },
+                ["username"] = new[] { "john.doe" },
+                ["password"] = new[] { "password123" },
+                ["wwwauth"]  = new[]
+                {
+                    "basic realm=\"example.com\"",
+                    "bearer authorize_uri=https://id.example.com p=1 q=0"
+                }
             };
 
             var inputArgs = new InputArguments(dict);
@@ -31,10 +37,16 @@ public void InputArguments_CommonArguments_ValuePresent_ReturnsValues()
             Assert.Equal("an/example/path", inputArgs.Path);
             Assert.Equal("john.doe",        inputArgs.UserName);
             Assert.Equal("password123",     inputArgs.Password);
+            Assert.Equal(new[]
+                {
+                    "basic realm=\"example.com\"",
+                    "bearer authorize_uri=https://id.example.com p=1 q=0"
+                },
+                inputArgs.WwwAuth);
         }
 
         [Fact]
-        public void InputArguments_CommonArguments_ValueMissing_ReturnsNull()
+        public void InputArguments_CommonArguments_ValueMissing_ReturnsNullOrEmptyCollection()
         {
             var dict = new Dictionary<string, string>();
 
@@ -45,20 +57,23 @@ public void InputArguments_CommonArguments_ValueMissing_ReturnsNull()
             Assert.Null(inputArgs.Path);
             Assert.Null(inputArgs.UserName);
             Assert.Null(inputArgs.Password);
+            Assert.Empty(inputArgs.WwwAuth);
         }
 
         [Fact]
         public void InputArguments_OtherArguments()
         {
-            var dict = new Dictionary<string, string>
+            var dict = new Dictionary<string, IList<string>>
             {
-                ["foo"] = "bar"
+                ["foo"] = new[] { "bar" },
+                ["multi"] = new[] { "val1", "val2", "val3" },
             };
 
             var inputArgs = new InputArguments(dict);
 
             Assert.Equal("bar", inputArgs["foo"]);
             Assert.Equal("bar", inputArgs.GetArgumentOrDefault("foo"));
+            Assert.Equal(new[] { "val1", "val2", "val3" }, inputArgs.GetMultiArgumentOrDefault("multi"));
         }
 
         [Fact]

src/shared/Core.Tests/StreamExtensionsTests.cs

@@ -11,6 +11,8 @@ public class StreamExtensionsTests
         private const string LF   = "\n";
         private const string CRLF = "\r\n";
 
+        #region Dictionary
+
         [Fact]
         public void StreamExtensions_ReadDictionary_EmptyString_ReturnsEmptyDictionary()
         {
@@ -31,9 +33,9 @@ public void StreamExtensions_ReadDictionary_TerminatedLF_ReturnsDictionary()
 
             Assert.NotNull(output);
             Assert.Equal(3, output.Count);
-            Assert.Contains(KeyValuePair.Create("a", "1"), output);
-            Assert.Contains(KeyValuePair.Create("b", "2"), output);
-            Assert.Contains(KeyValuePair.Create("c", "3"), output);
+            AssertDictionary("1", "a", output);
+            AssertDictionary("2", "b", output);
+            AssertDictionary("3", "c", output);
         }
 
         [Fact]
@@ -45,9 +47,9 @@ public void StreamExtensions_ReadDictionary_TerminatedCRLF_ReturnsDictionary()
 
             Assert.NotNull(output);
             Assert.Equal(3, output.Count);
-            Assert.Contains(KeyValuePair.Create("a", "1"), output);
-            Assert.Contains(KeyValuePair.Create("b", "2"), output);
-            Assert.Contains(KeyValuePair.Create("c", "3"), output);
+            AssertDictionary("1", "a", output);
+            AssertDictionary("2", "b", output);
+            AssertDictionary("3", "c", output);
         }
 
         [Fact]
@@ -59,8 +61,8 @@ public void StreamExtensions_ReadDictionary_CaseSensitive_ReturnsDictionaryWithM
 
             Assert.NotNull(output);
             Assert.Equal(2, output.Count);
-            Assert.Contains(KeyValuePair.Create("a", "1"), output);
-            Assert.Contains(KeyValuePair.Create("A", "2"), output);
+            AssertDictionary("1", "a", output);
+            AssertDictionary("2", "A", output);
         }
 
         [Fact]
@@ -72,7 +74,7 @@ public void StreamExtensions_ReadDictionary_CaseInsensitive_ReturnsDictionaryWit
 
             Assert.NotNull(output);
             Assert.Equal(1, output.Count);
-            Assert.Contains(KeyValuePair.Create("a", "2"), output);
+            AssertDictionary("2", "a", output);
         }
 
         [Fact]
@@ -84,9 +86,9 @@ public void StreamExtensions_ReadDictionary_Spaces_ReturnsCorrectKeysAndValues()
 
             Assert.NotNull(output);
             Assert.Equal(3, output.Count);
-            Assert.Contains(KeyValuePair.Create("key a", "value 1"), output);
-            Assert.Contains(KeyValuePair.Create("  key b  ", " 2 "), output);
-            Assert.Contains(KeyValuePair.Create("key\tc\t", "\t3\t"), output);
+            AssertDictionary("value 1", "key a", output);
+            AssertDictionary(" 2 ", "  key b  ", output);
+            AssertDictionary("\t3\t", "key\tc\t", output);
         }
 
         [Fact]
@@ -98,9 +100,9 @@ public void StreamExtensions_ReadDictionary_EqualsInValues_ReturnsCorrectKeysAnd
 
             Assert.NotNull(output);
             Assert.Equal(3, output.Count);
-            Assert.Contains(KeyValuePair.Create("a", "value=1"), output);
-            Assert.Contains(KeyValuePair.Create("b", "value=2"), output);
-            Assert.Contains(KeyValuePair.Create("c", "value=3"), output);
+            AssertDictionary("value=1", "a", output);
+            AssertDictionary("value=2", "b", output);
+            AssertDictionary("value=3", "c", output);
         }
 
         [Fact]
@@ -183,11 +185,204 @@ public void StreamExtensions_WriteDictionary_TextWriterCRLF_EntriesWithSpaces_Wr
             Assert.Equal("key a=value 1\r\n  key b  = value 2 \r\n\tvalue\tc\t=\t3\t\r\n\r\n", output);
         }
 
+        #endregion
+
+        #region MultiDictionary
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_EmptyString_ReturnsEmptyDictionary()
+        {
+            string input = string.Empty;
+
+            var output = ReadStringStream(input, StreamExtensions.ReadMultiDictionary);
+
+            Assert.NotNull(output);
+            Assert.Equal(0, output.Count);
+        }
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_TerminatedLF_ReturnsDictionary()
+        {
+            string input = "a=1\nb=2\nc=3\n\n";
+
+            var output = ReadStringStream(input, StreamExtensions.ReadMultiDictionary);
+
+            Assert.NotNull(output);
+            Assert.Equal(3, output.Count);
+
+            AssertMultiDictionary(new[] { "1" }, "a", output);
+            AssertMultiDictionary(new[] { "2" }, "b", output);
+            AssertMultiDictionary(new[] { "3" }, "c", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_TerminatedCRLF_ReturnsDictionary()
+        {
+            string input = "a=1\r\nb=2\r\nc=3\r\n\r\n";
+
+            var output = ReadStringStream(input, StreamExtensions.ReadMultiDictionary);
+
+            Assert.NotNull(output);
+            Assert.Equal(3, output.Count);
+            AssertMultiDictionary(new[] { "1" }, "a", output);
+            AssertMultiDictionary(new[] { "2" }, "b", output);
+            AssertMultiDictionary(new[] { "3" }, "c", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_CaseSensitive_ReturnsDictionaryWithMultipleEntries()
+        {
+            string input = "a=1\nA=2\n\n";
+
+            var output = ReadStringStream(input, x => StreamExtensions.ReadMultiDictionary(x, StringComparer.Ordinal));
+
+            Assert.NotNull(output);
+            Assert.Equal(2, output.Count);
+            AssertMultiDictionary(new[] { "1" }, "a", output);
+            AssertMultiDictionary(new[] { "2" }, "A", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_CaseInsensitive_ReturnsDictionaryWithLastValue()
+        {
+            string input = "a=1\nA=2\n\n";
+
+            var output = ReadStringStream(input, x => StreamExtensions.ReadMultiDictionary(x, StringComparer.OrdinalIgnoreCase));
+
+            Assert.NotNull(output);
+            Assert.Equal(1, output.Count);
+            AssertMultiDictionary(new[] { "2" }, "a", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_Spaces_ReturnsCorrectKeysAndValues()
+        {
+            string input = "key a=value 1\n  key b  = 2 \nkey\tc\t=\t3\t\n\n";
+
+            var output = ReadStringStream(input, StreamExtensions.ReadMultiDictionary);
+
+            Assert.NotNull(output);
+            Assert.Equal(3, output.Count);
+
+            AssertMultiDictionary(new[] { "value 1" }, "key a", output);
+            AssertMultiDictionary(new[] { " 2 " }, "  key b  ", output);
+            AssertMultiDictionary(new[] { "\t3\t" }, "key\tc\t", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_EqualsInValues_ReturnsCorrectKeysAndValues()
+        {
+            string input = "a=value=1\nb=value=2\nc=value=3\n\n";
+
+            var output = ReadStringStream(input, StreamExtensions.ReadMultiDictionary);
+
+            Assert.NotNull(output);
+            Assert.Equal(3, output.Count);
+            AssertMultiDictionary(new[] { "value=1" }, "a", output);
+            AssertMultiDictionary(new[] { "value=2" }, "b", output);
+            AssertMultiDictionary(new[] { "value=3" }, "c", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_ReadMultiDictionary_MultiValue_ReturnsDictionary()
+        {
+            string input = "odd[]=1\neven[]=2\neven[]=4\nodd[]=3\n\n";
+
+            var output = ReadStringStream(input, StreamExtensions.ReadMultiDictionary);
+
+            Assert.NotNull(output);
+            Assert.Equal(2, output.Count);
+            AssertMultiDictionary(new[] { "1", "3" }, "odd", output);
+            AssertMultiDictionary(new[] { "2", "4" }, "even", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_WriteDictionary_TextWriterLF_EmptyMultiDictionary_WritesLineLF()
+        {
+            var input = new Dictionary<string, IList<string>>();
+
+            string output = WriteStringStream(input, StreamExtensions.WriteDictionary, newLine: LF);
+
+            Assert.Equal(LF, output);
+        }
+
+        [Fact]
+        public void StreamExtensions_WriteDictionary_TextWriterCRLF_EmptyMultiDictionary_WritesLineCRLF()
+        {
+            var input = new Dictionary<string, IList<string>>();
+
+            string output = WriteStringStream(input, StreamExtensions.WriteDictionary, newLine: CRLF);
+
+            Assert.Equal(CRLF, output);
+        }
+
+        [Fact]
+        public void StreamExtensions_WriteDictionary_TextWriterLF_MultiEntries_WritesKVPListsAndLF()
+        {
+            var input = new Dictionary<string, IList<string>>
+            {
+                ["a"] = new[] { "1", "2", "3" },
+                ["b"] = new[] { "4", "5", },
+                ["c"] = new[] { "6" }
+            };
+
+            string output = WriteStringStream(input, StreamExtensions.WriteDictionary, newLine: LF);
+
+            Assert.Equal("a[]=1\na[]=2\na[]=3\nb[]=4\nb[]=5\nc=6\n\n", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_WriteDictionary_TextWriterCRLF_MultiEntries_WritesKVPListsAndCRLF()
+        {
+            var input = new Dictionary<string, IList<string>>
+            {
+                ["a"] = new[] { "1", "2", "3" },
+                ["b"] = new[] { "4", "5", },
+                ["c"] = new[] { "6" }
+            };
+
+            string output = WriteStringStream(input, StreamExtensions.WriteDictionary, newLine: CRLF);
+
+            Assert.Equal("a[]=1\r\na[]=2\r\na[]=3\r\nb[]=4\r\nb[]=5\r\nc=6\r\n\r\n", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_WriteDictionary_NoMultiEntries_WritesKVPsAndLF()
+        {
+            var input = new Dictionary<string, IList<string>>
+            {
+                ["a"] = new[] {"1"},
+                ["b"] = new[] {"2"},
+                ["c"] = new[] {"3"}
+            };
+
+            string output = WriteStringStream(input, StreamExtensions.WriteDictionary, newLine: LF);
+
+            Assert.Equal("a=1\nb=2\nc=3\n\n", output);
+        }
+
+        [Fact]
+        public void StreamExtensions_WriteDictionary_MultiEntriesWithEmpty_WritesKVPListsAndLF()
+        {
+            var input = new Dictionary<string, IList<string>>
+            {
+                ["a"] = new[] {"1", "2", "", "3", "4"},
+                ["b"] = new[] {"5"},
+                ["c"] = new[] {"6", "7", ""}
+            };
+
+            string output = WriteStringStream(input, StreamExtensions.WriteDictionary, newLine: LF);
+
+            Assert.Equal("a[]=3\na[]=4\nb=5\n\n", output);
+        }
+
+        #endregion
+
         #region Helpers
 
-        private static IDictionary<string, string> ReadStringStream(string input, Func<TextReader, IDictionary<string, string>> func)
+        private static T ReadStringStream<T>(string input, Func<TextReader, T> func)
         {
-            IDictionary<string, string> output;
+            T output;
             using (var reader = new StringReader(input))
             {
                 output = func(reader);
@@ -196,7 +391,7 @@ private static IDictionary<string, string> ReadStringStream(string input, Func<T
             return output;
         }
 
-        private static string WriteStringStream(IDictionary<string, string> input, Action<TextWriter, IDictionary<string, string>> action, string newLine)
+        private static string WriteStringStream<T>(T input, Action<TextWriter, T> action, string newLine)
         {
             var output = new StringBuilder();
             using (var writer = new StringWriter(output){NewLine = newLine})
@@ -207,6 +402,20 @@ private static string WriteStringStream(IDictionary<string, string> input, Actio
             return output.ToString();
         }
 
+        private static void AssertDictionary(string expectedValue, string key, IDictionary<string, string> dict)
+        {
+            Assert.True(dict.TryGetValue(key, out string actualValue));
+            Assert.Equal(expectedValue, actualValue);
+        }
+
+        private static void AssertMultiDictionary(IList<string> expectedValues,
+            string key,
+            IDictionary<string, IList<string>> dict)
+        {
+            Assert.True(dict.TryGetValue(key, out IList<string> actualValues));
+            Assert.Equal(expectedValues, actualValues);
+        }
+
         #endregion
     }
 }