fix(configuration): Improve recursive dictionary merging and cloning

Ensures nested dictionaries merge correctly and incoming dictionaries are cloned to prevent unintended external mutations.

Author: arturcic

src/GitVersion.Configuration.Tests/Configuration/ConfigurationHelperTests.cs

@@ -0,0 +1,82 @@
+namespace GitVersion.Configuration.Tests;
+
+[TestFixture]
+public class ConfigurationHelperTests
+{
+    [Test]
+    public void Override_Replaces_Nested_Dictionary_With_Scalar_Value()
+    {
+        Dictionary<object, object?> original =
+            new()
+            {
+                ["key"] = new Dictionary<object, object?> { ["nested"] = "value" }
+            };
+        var helper = new ConfigurationHelper(original);
+
+        IReadOnlyDictionary<object, object?> source =
+            new Dictionary<object, object?>
+            {
+                ["key"] = "override"
+            };
+
+        helper.Override(source);
+
+        helper.Dictionary["key"].ShouldBe("override");
+    }
+
+    [Test]
+    public void Override_Merges_Nested_Dictionaries_Recursively()
+    {
+        Dictionary<object, object?> original =
+            new()
+            {
+                ["key"] = new Dictionary<object, object?>
+                {
+                    ["a"] = 1,
+                    ["b"] = 2
+                }
+            };
+        var helper = new ConfigurationHelper(original);
+
+        IReadOnlyDictionary<object, object?> source =
+            new Dictionary<object, object?>
+            {
+                ["key"] = new Dictionary<object, object?>
+                {
+                    ["b"] = 3,
+                    ["c"] = 4
+                }
+            };
+
+        helper.Override(source);
+
+        var nested = (IDictionary<object, object?>)helper.Dictionary["key"]!;
+        nested["a"].ShouldBe(1);
+        nested["b"].ShouldBe(3);
+        nested["c"].ShouldBe(4);
+    }
+
+    [Test]
+    public void Override_Clones_New_Nested_Dictionaries()
+    {
+        Dictionary<object, object?> original = [];
+        var helper = new ConfigurationHelper(original);
+
+        Dictionary<object, object?> sourceNested =
+            new()
+            {
+                ["a"] = 1
+            };
+        IReadOnlyDictionary<object, object?> source =
+            new Dictionary<object, object?>
+            {
+                ["key"] = sourceNested
+            };
+
+        helper.Override(source);
+        sourceNested["a"] = 2;
+
+        var nested = (IDictionary<object, object?>)helper.Dictionary["key"]!;
+        nested["a"].ShouldBe(1);
+    }
+}

src/GitVersion.Configuration/ConfigurationHelper.cs

@@ -45,54 +45,33 @@ public void Override(IReadOnlyDictionary<object, object?> value)
 
     private static void Merge(IDictionary<object, object?> dictionary, IReadOnlyDictionary<object, object?> anotherDictionary)
     {
-        foreach (var item in dictionary)
+        foreach (var (key, sourceValue) in anotherDictionary)
         {
-            switch (item.Value)
+            if (dictionary.TryGetValue(key, out var currentValue)
+                && currentValue is IDictionary<object, object?> currentDictionary
+                && sourceValue is IReadOnlyDictionary<object, object?> sourceDictionary)
             {
-                case IDictionary<object, object?> anotherDictionaryValue:
-                    {
-                        if (anotherDictionary.TryGetValue(item.Key, out var value) && value is IReadOnlyDictionary<object, object?> dictionaryValue)
-                        {
-                            Merge(anotherDictionaryValue, dictionaryValue);
-                        }
-
-                        break;
-                    }
-                default:
-                    {
-                        if (anotherDictionary.TryGetValue(item.Key, out var value))
-                        {
-                            dictionary[item.Key] = value;
-                        }
-
-                        break;
-                    }
+                Merge(currentDictionary, sourceDictionary);
+                continue;
             }
+
+            dictionary[key] = sourceValue is IReadOnlyDictionary<object, object?> nestedDictionary
+                ? CloneDictionary(nestedDictionary)
+                : sourceValue;
         }
+    }
 
-        foreach (var item in anotherDictionary)
-        {
-            switch (item.Value)
-            {
-                case IReadOnlyDictionary<object, object?> when dictionary.ContainsKey(item.Key):
-                    continue;
-                case IReadOnlyDictionary<object, object?> dictionaryValue:
-                    {
-                        Dictionary<object, object?> anotherDictionaryValue = [];
-                        Merge(anotherDictionaryValue, dictionaryValue);
-                        dictionary.Add(item.Key, anotherDictionaryValue);
-                        break;
-                    }
-                default:
-                    {
-                        if (!dictionary.ContainsKey(item.Key))
-                        {
-                            dictionary.Add(item.Key, item.Value);
-                        }
+    private static Dictionary<object, object?> CloneDictionary(IReadOnlyDictionary<object, object?> dictionary)
+    {
+        Dictionary<object, object?> cloned = [];
 
-                        break;
-                    }
-            }
+        foreach (var (key, value) in dictionary)
+        {
+            cloned[key] = value is IReadOnlyDictionary<object, object?> nestedDictionary
+                ? CloneDictionary(nestedDictionary)
+                : value;
         }
+
+        return cloned;
     }
 }