fix: MultiPartBody: Add Support for multiple Body Parts with the same name (#530)

* Add Support for multiple Body Parts with the same name

- change MultiPartbody internal dictionary key from string to Tuple<string, string?)
- Add additional method overloads for GetPartValue<T> RemovePart
- Add EqualityComparer fro Tuple<string, string?>
- Add failing Test showcasing the imminent breaking change
- Add passing Test verifying the new intened behaviour

* use ValueTuple instead of Tuple

* add TODO for outdated methods

* Make comparsions case sensitive

* Make existing Methods compatible

* fix Test assuming breaking behaviour

---------

Co-authored-by: Roman Ettlinger <roman.ettlinger@zbfs.bayern.de>

Author: romanett

src/abstractions/MultipartBody.cs

@@ -47,25 +47,52 @@ public void AddOrReplacePart<T>(string partName, string contentType, T partValue
         {
             throw new ArgumentNullException(nameof(partValue));
         }
+        var key = (partName, fileName ?? "");
         var value = new Part(partName, partValue, contentType, fileName);
-        if(!_parts.TryAdd(partName, value))
+        if(!_parts.TryAdd(key, value))
         {
-            _parts[partName] = value;
+            _parts[key] = value;
         }
     }
+    // TODO: Remove with next major release
     /// <summary>
     /// Gets the value of a part from the multipart body.
     /// </summary>
     /// <typeparam name="T">The type of the part value.</typeparam>
     /// <param name="partName">The name of the part.</param>
     /// <returns>The value of the part.</returns>
     public T? GetPartValue<T>(string partName)
+    {
+        var value = GetPartValue<T>(partName, null);
+
+        if(EqualityComparer<T?>.Default.Equals(value, default))
+        {
+            foreach(var key in _parts.Keys)
+            {
+                if(key.Item1 == partName)
+                {
+                    value = GetPartValue<T>(partName, key.Item2);
+                    break;
+                }
+            }
+        }
+
+        return value;
+    }
+    /// <summary>
+    /// Gets the value of a part from the multipart body.
+    /// </summary>
+    /// <typeparam name="T">The type of the part value.</typeparam>
+    /// <param name="partName">The name of the part.</param>
+    /// <param name="fileName">An optional file name for the part.</param>
+    /// <returns>The value of the part.</returns>
+    public T? GetPartValue<T>(string partName, string? fileName)
     {
         if(string.IsNullOrEmpty(partName))
         {
             throw new ArgumentNullException(nameof(partName));
         }
-        if(_parts.TryGetValue(partName, out var value))
+        if(_parts.TryGetValue((partName, fileName ?? ""), out var value))
         {
             if(value == null)
                 return default;
@@ -74,21 +101,47 @@ public void AddOrReplacePart<T>(string partName, string contentType, T partValue
         }
         return default;
     }
+    // TODO: Remove with next major release
     /// <summary>
     /// Removes a part from the multipart body.
     /// </summary>
     /// <param name="partName">The name of the part.</param>
     /// <returns>True if the part was removed, false otherwise.</returns>   
     public bool RemovePart(string partName)
+    {
+        bool success = RemovePart(partName, null);
+
+        if(!success)
+        {
+            foreach(var key in _parts.Keys)
+            {
+                if(key.Item1 == partName)
+                {
+                    success = RemovePart(partName, key.Item2);
+                    break;
+                }
+            }
+        }
+
+        return success;
+    }
+
+    /// <summary>
+    /// Removes a part from the multipart body.
+    /// </summary>
+    /// <param name="partName">The name of the part.</param>
+    /// <param name="fileName">An optional file name for the part.</param>
+    /// <returns>True if the part was removed, false otherwise.</returns>   
+    public bool RemovePart(string partName, string? fileName)
     {
         if(string.IsNullOrEmpty(partName))
         {
             throw new ArgumentNullException(nameof(partName));
         }
-        return _parts.Remove(partName);
+        return _parts.Remove((partName, fileName ?? ""));
     }
 
-    private readonly Dictionary<string, Part> _parts = new Dictionary<string, Part>(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<ValueTuple<string, string>, Part> _parts = new Dictionary<ValueTuple<string, string>, Part>(new ValueTupleComparer());
     /// <inheritdoc />
     public IDictionary<string, Action<IParseNode>> GetFieldDeserializers() => throw new NotImplementedException();
     private const char DoubleQuote = '"';
@@ -196,4 +249,20 @@ private sealed class Part(string name, object content, string contentType, strin
         public string ContentType { get; } = contentType;
         public string? FileName { get; } = fileName;
     }
+
+    private sealed class ValueTupleComparer : IEqualityComparer<ValueTuple<string, string>>
+    {
+        public bool Equals((string, string) x, (string, string) y)
+        {
+            return StringComparer.Ordinal.Equals(x.Item1, y.Item1) &&
+                   StringComparer.Ordinal.Equals(x.Item2, y.Item2);
+        }
+
+        public int GetHashCode(ValueTuple<string, string?> obj)
+        {
+            int hash1 = StringComparer.Ordinal.GetHashCode(obj.Item1);
+            int hash2 = obj.Item2 != null ? StringComparer.Ordinal.GetHashCode(obj.Item2) : 0;
+            return hash1 ^ hash2;
+        }
+    }
 }

tests/abstractions/MultipartBodyTests.cs

@@ -90,4 +90,39 @@ public void WorksWithoutFilename()
         requestAdapterMock.VerifyAll();
         serializationFactoryMock.VerifyAll();
     }
+
+
+    [Fact]
+    public void AllowsDuplicateEntries()
+    {
+        var body = new MultipartBody();
+
+        body.AddOrReplacePart("file", "application/json", "fileContent", "file.json");
+        body.AddOrReplacePart("file", "application/json", "fileContent2", "file2.json");
+
+        //Assert both files are stored in the body
+        Assert.Equal("fileContent", body.GetPartValue<string>("file", "file.json"));
+        Assert.Equal("fileContent2", body.GetPartValue<string>("file", "file2.json"));
+
+        //Assert part can be removed if fileName is specified
+        Assert.True(body.RemovePart("file", "file.json"));
+
+        //Assert file.json is removed and file2.json is still accessible
+        Assert.Null(body.GetPartValue<string>("file", "file.json"));
+        Assert.Equal("fileContent2", body.GetPartValue<string>("file", "file2.json"));
+    }
+
+    [Fact]
+    public void MultiPartBodyExistingGetAndRemoveStillWork()
+    {
+        var body = new MultipartBody();
+
+        body.AddOrReplacePart("file", "application/json", "fileContent", "file.json");
+
+        // existing usecase, file should still be able to be retreived
+        Assert.Equal("fileContent", body.GetPartValue<string>("file"));
+
+        // existing usecase, file should be sucesfully removed
+        Assert.True(body.RemovePart("file"));
+    }
 }