Merge pull request #55 from microsoft/feature/multi-valued-headers

andrueastman · web-flow · commit b41c0435dfcc · 2022-12-13T16:38:13.000+03:00
- adds support for multi-valued headers
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+	"cSpell.words": [
+		"Kiota"
+	]
+}
diff --git a/.vscode/tasks.json b/.vscode/tasks.json
@@ -17,6 +17,21 @@
 			],
 			"group": "build",
 			"problemMatcher": "$msCompile"
+		},
+		{
+			"label": "test",
+			"command": "dotnet",
+			"type": "process",
+			"args": [
+				"test",
+                "${workspaceFolder}/Microsoft.Kiota.Abstractions.sln",
+				// Ask dotnet build to generate full paths for file names.
+				"/property:GenerateFullPaths=true",
+				// Do not generate summary otherwise it leads to duplicate errors in Problems panel
+				"/consoleloggerparameters:NoSummary"
+			],
+			"group": "test",
+			"problemMatcher": "$msCompile"
 		}
 	]
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -11,6 +11,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+## [1.0.0-preview.19] - 2022-12-13
+
+### Changed
+
+- Added support for multi-valued request headers
+
 ## [1.0.0-preview.18] - 2022-11-22
 
 ### Changed
diff --git a/Microsoft.Kiota.Abstractions.Tests/Authentication/AuthenticationTests.cs b/Microsoft.Kiota.Abstractions.Tests/Authentication/AuthenticationTests.cs
@@ -20,13 +20,13 @@ public async Task AnonymousAuthenticationProviderReturnsSameRequestAsync()
             HttpMethod = Method.GET,
             URI = new Uri("http://localhost")
         };
-        Assert.Empty(testRequest.Headers); // header collection is empty
+        Assert.Empty(testRequest.Headers.Keys); // header collection is empty
 
         // Act
         await anonymousAuthenticationProvider.AuthenticateRequestAsync(testRequest);
 
         // Assert
-        Assert.Empty(testRequest.Headers); // header collection is still empty
+        Assert.Empty(testRequest.Headers.Keys); // header collection is still empty
 
     }
 
@@ -43,15 +43,15 @@ public async Task BaseBearerTokenAuthenticationProviderSetsBearerHeader()
             HttpMethod = Method.GET,
             URI = new Uri("http://localhost")
         };
-        Assert.Empty(testRequest.Headers); // header collection is empty
+        Assert.Empty(testRequest.Headers.Keys); // header collection is empty
 
         // Act
         await testAuthProvider.AuthenticateRequestAsync(testRequest);
 
         // Assert
-        Assert.NotEmpty(testRequest.Headers); // header collection is longer empty
-        Assert.Equal("Authorization", testRequest.Headers.First().Key); // First element is Auth header
-        Assert.Equal($"Bearer {expectedToken}", testRequest.Headers.First().Value); // First element is Auth header
+        Assert.NotEmpty(testRequest.Headers.Keys); // header collection is longer empty
+        Assert.True(testRequest.Headers.ContainsKey("Authorization")); // First element is Auth header
+        Assert.Equal($"Bearer {expectedToken}", testRequest.Headers["Authorization"].First()); // First element is Auth header
     }
 
     [Theory]
diff --git a/Microsoft.Kiota.Abstractions.Tests/RequestHeadersTests.cs b/Microsoft.Kiota.Abstractions.Tests/RequestHeadersTests.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using Xunit;
+
+namespace Microsoft.Kiota.Abstractions.Tests;
+
+public class RequestHeadersTests {
+    [Fact]
+    public void Defensive() {
+        var instance = new RequestHeaders();
+        Assert.Throws<ArgumentNullException>(() => instance.Add(null, "value"));
+        Assert.Throws<ArgumentNullException>(() => instance.Add("name", (string[])null));
+        instance.Add("name", Array.Empty<string>());
+        instance.Add("name", new List<string>());
+        instance.Add(new KeyValuePair<string, IEnumerable<string>>("name", Array.Empty<string>()));
+        Assert.Throws<ArgumentNullException>(() => instance[null]);
+        Assert.Throws<ArgumentNullException>(() => instance.Remove(null));
+        Assert.Throws<ArgumentNullException>(() => instance.Remove(null, "value"));
+        Assert.Throws<ArgumentNullException>(() => instance.Remove("name", null));
+        Assert.Throws<ArgumentNullException>(() => instance.AddAll(null));
+        instance.ContainsKey(null);
+    }
+    [Fact]
+    public void AddsToNonExistent() {
+        var instance = new RequestHeaders();
+        instance.Add("name", "value");
+        Assert.Equal(new [] { "value" }, instance["name"]);
+    }
+    [Fact]
+    public void AddsToExistent() {
+        var instance = new RequestHeaders();
+        instance.Add("name", "value");
+        instance.Add("name", "value2");
+        Assert.Equal(new [] { "value", "value2" }, instance["name"]);
+    }
+    [Fact]
+    public void RemovesValue() {
+        var instance = new RequestHeaders();
+        instance.Remove("name", "value");
+        instance.Add("name", "value");
+        instance.Add("name", "value2");
+        instance.Remove("name", "value");
+        Assert.Equal(new [] { "value2" }, instance["name"]);
+        instance.Remove("name", "value2");
+        Assert.Null(instance["name"]);
+    }
+    [Fact]
+    public void Removes() {
+        var instance = new RequestHeaders();
+        instance.Add("name", "value");
+        instance.Add("name", "value2");
+        Assert.True(instance.Remove("name"));
+        Assert.Null(instance["name"]);
+        Assert.False(instance.Remove("name"));
+    }
+    [Fact]
+    public void RemovesKVP() {
+        var instance = new RequestHeaders();
+        instance.Add("name", "value");
+        instance.Add("name", "value2");
+        Assert.True(instance.Remove(new KeyValuePair<string, IEnumerable<string>>("name", new [] { "value", "value2" })));
+        Assert.Null(instance["name"]);
+        Assert.False(instance.Remove("name"));
+    }
+    [Fact]
+    public void Clears() {
+        var instance = new RequestHeaders();
+        instance.Add("name", "value");
+        instance.Add("name", "value2");
+        instance.Clear();
+        Assert.Null(instance["name"]);
+    }
+    [Fact]
+    public void GetsEnumerator() {
+        var instance = new RequestHeaders();
+        instance.Add("name", "value");
+        instance.Add("name", "value2");
+        using var enumerator = instance.GetEnumerator();
+        Assert.True(enumerator.MoveNext());
+        Assert.Equal("name", enumerator.Current.Key);
+        Assert.Equal(new [] { "value", "value2" }, enumerator.Current.Value);
+        Assert.False(enumerator.MoveNext());
+    }
+    [Fact]
+    public void Updates() {
+        var instance = new RequestHeaders();
+        instance.Add("name", "value");
+        instance.Add("name", "value2");
+        var instance2 = new RequestHeaders();
+        instance2.AddAll(instance);
+        Assert.NotEmpty(instance["name"]);
+    }
+}
diff --git a/src/Microsoft.Kiota.Abstractions.csproj b/src/Microsoft.Kiota.Abstractions.csproj
@@ -14,7 +14,7 @@
     <EmbedUntrackedSources>true</EmbedUntrackedSources>
     <Deterministic>true</Deterministic>
     <VersionPrefix>1.0.0</VersionPrefix>
-    <VersionSuffix>preview.18</VersionSuffix>
+    <VersionSuffix>preview.19</VersionSuffix>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <SignAssembly>false</SignAssembly>
     <DelaySign>false</DelaySign>
@@ -23,7 +23,7 @@
     <!-- Enable this line once we go live to prevent breaking changes -->
     <!-- <PackageValidationBaselineVersion>1.0.0</PackageValidationBaselineVersion> -->
     <PackageReleaseNotes>
-        - Bumps Tavis.UriTemplates to strongly name binary version
+        - Adds support for multi-valued headers
     </PackageReleaseNotes>
     <PackageRequireLicenseAcceptance>true</PackageRequireLicenseAcceptance>
     <PackageLicenseFile>LICENSE</PackageLicenseFile>
diff --git a/src/RequestHeaders.cs b/src/RequestHeaders.cs
@@ -0,0 +1,129 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.Kiota.Abstractions;
+
+/// <summary>Represents a collection of request headers.</summary>
+public class RequestHeaders : IDictionary<string,IEnumerable<string>> {
+    private readonly Dictionary<string, HashSet<string>> _headers = new Dictionary<string, HashSet<string>>(StringComparer.OrdinalIgnoreCase);
+    /// <summary>
+    /// Adds values to the header with the specified name.
+    /// </summary>
+    /// <param name="headerName">The name of the header to add values to.</param>
+    /// <param name="headerValues">The values to add to the header.</param>
+    public void Add(string headerName, params string[] headerValues) {
+        if(string.IsNullOrEmpty(headerName))
+            throw new ArgumentNullException(nameof(headerName));
+        if(headerValues == null)
+            throw new ArgumentNullException(nameof(headerValues));
+        if(!headerValues.Any())
+            return;
+        if(_headers.TryGetValue(headerName, out var values))
+            foreach(var headerValue in headerValues)
+                values.Add(headerValue);
+        else
+            _headers.Add(headerName, new HashSet<string>(headerValues));
+    }
+    /// <inheritdoc/>
+    public ICollection<string> Keys => _headers.Keys;
+    /// <inheritdoc/>
+    public ICollection<IEnumerable<string>> Values => _headers.Values.Cast<IEnumerable<string>>().ToList();
+    /// <inheritdoc/>
+    public int Count => _headers.Count;
+    /// <inheritdoc/>
+    public bool IsReadOnly => false;
+    /// <inheritdoc/>
+    public IEnumerable<string> this[string key] { get => TryGetValue(key, out var result) ? result : null; set => Add(key, value); }
+
+    /// <summary>
+    /// Removes the specified value from the header with the specified name.
+    /// </summary>
+    /// <param name="headerName">The name of the header to remove the value from.</param>
+    /// <param name="headerValue">The value to remove from the header.</param>
+    public bool Remove(string headerName, string headerValue) {
+        if(string.IsNullOrEmpty(headerName))
+            throw new ArgumentNullException(nameof(headerName));
+        if(headerValue == null)
+            throw new ArgumentNullException(nameof(headerValue));
+        if(_headers.TryGetValue(headerName, out var values)) {
+            var result = values.Remove(headerValue);
+            if (!values.Any())
+                _headers.Remove(headerName);
+            return result;
+        }
+        return false;
+    }
+    /// <summary>
+    /// Adds all the headers values from the specified headers collection.
+    /// </summary>
+    /// <param name="headers">The headers to update the current headers with.</param>
+    public void AddAll(RequestHeaders headers) {
+        if(headers == null)
+            throw new ArgumentNullException(nameof(headers));
+        foreach(var header in headers)
+            foreach(var value in header.Value)
+                Add(header.Key, value);
+    }
+    /// <summary>
+    /// Removes all headers.
+    /// </summary>
+    public void Clear() {
+        _headers.Clear();
+    }
+    /// <inheritdoc/>
+    public bool ContainsKey(string key) => !string.IsNullOrEmpty(key) && _headers.ContainsKey(key);
+    /// <inheritdoc/>
+    public void Add(string key, IEnumerable<string> value) => Add(key, value?.ToArray());
+    /// <inheritdoc/>
+    public bool Remove(string key) {
+        if(string.IsNullOrEmpty(key))
+            throw new ArgumentNullException(nameof(key));
+        return _headers.Remove(key);
+    }
+    /// <inheritdoc/>
+    public bool TryGetValue(string key, out IEnumerable<string> value) {
+        if(string.IsNullOrEmpty(key))
+            throw new ArgumentNullException(nameof(key));
+        if(_headers.TryGetValue(key, out var values)) {
+            value = values;
+            return true;
+        }
+        value = Enumerable.Empty<string>();
+        return false;
+    }
+    /// <inheritdoc/>
+    public void Add(KeyValuePair<string, IEnumerable<string>> item) => Add(item.Key, item.Value);
+    /// <inheritdoc/>
+    public bool Contains(KeyValuePair<string, IEnumerable<string>> item) => TryGetValue(item.Key, out var values) && item.Value.All(x => values.Contains(x)) && values.Count() == item.Value.Count();
+    /// <inheritdoc/>
+    public void CopyTo(KeyValuePair<string, IEnumerable<string>>[] array, int arrayIndex) => throw new NotImplementedException();
+    /// <inheritdoc/>
+    public bool Remove(KeyValuePair<string, IEnumerable<string>> item) {
+        var result = false;
+        foreach (var value in item.Value)
+            result |= Remove(item.Key, value);
+        return result;
+    }
+    /// <inheritdoc/>
+    public IEnumerator<KeyValuePair<string, IEnumerable<string>>> GetEnumerator() => new RequestHeadersEnumerator(_headers.GetEnumerator());
+    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    private sealed class RequestHeadersEnumerator : IEnumerator<KeyValuePair<string, IEnumerable<string>>> {
+        private readonly IEnumerator _enumerator;
+        public RequestHeadersEnumerator(IEnumerator enumerator)
+        {
+            _enumerator = enumerator;
+        }
+        public KeyValuePair<string, IEnumerable<string>> Current => _enumerator.Current is KeyValuePair<string, HashSet<string>> current ? new(current.Key, current.Value) : throw new InvalidOperationException();
+
+        object IEnumerator.Current => Current;
+
+        public void Dispose() {
+            (_enumerator as IDisposable)?.Dispose();
+            GC.SuppressFinalize(this);
+        }
+        public bool MoveNext() => _enumerator.MoveNext();
+        public void Reset() => _enumerator.Reset();
+    }
+}
diff --git a/src/RequestInformation.cs b/src/RequestInformation.cs
@@ -113,22 +113,19 @@ public void AddQueryParameters(object source)
         /// <summary>
         /// The Request Headers.
         /// </summary>
-        public IDictionary<string, string> Headers { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        public RequestHeaders Headers { get; private set; } = new ();
         /// <summary>
-        /// Adds request headers to the request.
+        /// Vanity method to add the headers to the request headers dictionary.
         /// </summary>
-        /// <param name="source">The request headers to add.</param>
-        public void AddHeaders(IDictionary<string, string> source)
-        {
-            if(source == null) return;
-            foreach(var header in source)
-                Headers.AddOrReplace(header.Key, header.Value);
+        public void AddHeaders(RequestHeaders headers) {
+            if(headers == null) return;
+            Headers.AddAll(headers);
         }
         /// <summary>
         /// The Request Body.
         /// </summary>
         public Stream Content { get; set; }
-        private Dictionary<string, IRequestOption> _requestOptions = new Dictionary<string, IRequestOption>(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, IRequestOption> _requestOptions = new Dictionary<string, IRequestOption>(StringComparer.OrdinalIgnoreCase);
         /// <summary>
         /// Gets the options for this request. Options are unique by type. If an option of the same type is added twice, the last one wins.
         /// </summary>

-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +{
 +	"cSpell.words": [
 +		"Kiota"
 +	]
 +}