Throw exception if duplicate Systems Manager parameter keys (case insensitive) are detected irrespective of whether the parameter is optional or not.

Author: ashishdhingra

src/Amazon.Extensions.Configuration.SystemsManager/Amazon.Extensions.Configuration.SystemsManager.csproj

@@ -6,7 +6,7 @@
     <AssemblyName>Amazon.Extensions.Configuration.SystemsManager</AssemblyName>
     <RootNamespace>Amazon.Extensions.Configuration.SystemsManager</RootNamespace>
     <OutputType>Library</OutputType>
-    <VersionPrefix>6.1.1</VersionPrefix>
+    <VersionPrefix>6.2.0</VersionPrefix>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
     <PackageId>Amazon.Extensions.Configuration.SystemsManager</PackageId>
     <Title>.NET Configuration Extensions for AWS Systems Manager</Title>

src/Amazon.Extensions.Configuration.SystemsManager/DefaultParameterProcessor.cs

@@ -60,11 +60,29 @@ public virtual IDictionary<string, string> ProcessParameters(IEnumerable<Paramet
             {
                 if (parameter.Type == ParameterType.StringList)
                 {
-                    result.AddRange(ParseStringList(parameter, path));
+                    var parameterList = ParseStringList(parameter, path);
+                    
+                    // Check for duplicate parameter keys.
+                    var stringListKeys = parameterList.Select(p => p.Key);
+                    var duplicateKeys = result.Where(r => stringListKeys.Contains(r.Key, StringComparer.OrdinalIgnoreCase)).Select(r => r.Key);
+                    if (duplicateKeys.Count() > 0)
+                    {
+                        throw new DuplicateParameterException($"Duplicate parameters '{string.Join(";", duplicateKeys)}' found. Parameter keys are case-insensitive.");
+                    }
+                    
+                    result.AddRange(parameterList);
                 }
                 else
                 {
-                    result.Add(new KeyValuePair<string, string>(GetKey(parameter, path), GetValue(parameter, path)));
+                    string parameterKey = GetKey(parameter, path);
+
+                    // Check for duplicate parameter key.
+                    if (result.Any(r => string.Equals(r.Key, parameterKey, StringComparison.OrdinalIgnoreCase)))
+                    {
+                        throw new DuplicateParameterException($"Duplicate parameter '{parameterKey}' found. Parameter keys are case-insensitive.");
+                    }
+
+                    result.Add(new KeyValuePair<string, string>(parameterKey, GetValue(parameter, path)));
                 }
             }
 

src/Amazon.Extensions.Configuration.SystemsManager/DuplicateParameterException.cs

@@ -0,0 +1,55 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at
+ * 
+ *  http://aws.amazon.com/apache2.0
+ * 
+ * or in the "license" file accompanying this file. This file is distributed
+ * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing
+ * permissions and limitations under the License.
+ */
+
+using System;
+
+namespace Amazon.Extensions.Configuration.SystemsManager
+{
+    /// <summary>
+    /// This exception is thrown when duplicate Systems Manager parameter keys (case insensitive) are 
+    /// detected irrespective of whether the parameter is optional or not.
+    /// <para>
+    /// For example, keys <c>/some-path/some-key</c> and <c>/some-path/SOME-KEY</c> are considered as duplicates.
+    /// </para>
+    /// </summary>
+    public class DuplicateParameterException : ArgumentException
+    {
+        /// <summary>
+        /// Initializes a new instance of DuplicateParameterException.
+        /// </summary>
+        public DuplicateParameterException()
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of DuplicateParameterException.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        public DuplicateParameterException(string message)
+            : base(message)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of DuplicateParameterException.
+        /// </summary>
+        /// <param name="message">The message that describes the error.</param>
+        /// <param name="innerException">The exception that is the cause of the current exception, or a null reference if no inner exception is specified.</param>
+        public DuplicateParameterException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}

src/Amazon.Extensions.Configuration.SystemsManager/JsonParameterProcessor.cs

@@ -40,6 +40,13 @@ public override IDictionary<string, string> ProcessParameters(IEnumerable<Parame
                 foreach (var keyValue in parameterDictionary)
                 {
                     string key = (!string.IsNullOrEmpty(prefix) ? ConfigurationPath.Combine(prefix, keyValue.Key) : keyValue.Key);
+
+                    // Check for duplicate parameter key.
+                    if (outputDictionary.ContainsKey(key))
+                    {
+                        throw new DuplicateParameterException($"Duplicate parameter '{key}' found. Parameter keys are case-insensitive.");
+                    }
+
                     outputDictionary.Add(key, keyValue.Value);
                 }
             }

src/Amazon.Extensions.Configuration.SystemsManager/SystemsManagerConfigurationProvider.cs

@@ -120,6 +120,10 @@ private async Task LoadAsync(bool reload)
                     OnReload();
                 }
             }
+            catch (DuplicateParameterException) // Throw duplicate parameter exception irrespective of whether parameter is optional or not.
+            {
+                throw;
+            }
             catch (Exception ex)
             {
                 if (Source.Optional) return;

test/Amazon.Extensions.Configuration.SystemsManager.Tests/DefaultParameterProcessorTests.cs

@@ -71,5 +71,31 @@ public void ProcessParametersRootTest()
 
             Assert.All(data, item => Assert.Equal(item.Value, item.Key));
         }
+
+        [Fact]
+        public void DuplicateSimpleParametersTest()
+        {
+            var parameters = new List<Parameter>
+            {
+                new Parameter {Name = "/start/path/p1", Value = "p1:1"},
+                new Parameter {Name = "/start/path/P1", Value = "p1:2"}
+            };
+
+            const string path = "/start/path";
+            Assert.Throws<DuplicateParameterException>(() => _parameterProcessor.ProcessParameters(parameters, path));
+        }
+
+        [Fact]
+        public void DuplicateStringListParametersTest()
+        {
+            var parameters = new List<Parameter>
+            {
+                new Parameter {Name = "/string-list/multiple", Value = "p1,p2,p3", Type = ParameterType.StringList},
+                new Parameter {Name = "/string-list/MULTIPLE", Value = "p3,p5,p6", Type = ParameterType.StringList}
+            };
+
+            const string path = "/string-list";
+            Assert.Throws<DuplicateParameterException>(() => _parameterProcessor.ProcessParameters(parameters, path));
+        }
     }
 }

test/Amazon.Extensions.Configuration.SystemsManager.Tests/JsonParameterProcessorTests.cs

@@ -44,5 +44,19 @@ public void ProcessParametersTest()
 
             Assert.All(expected, item => Assert.Equal(item.Value, data[item.Key]));
         }
+
+        [Fact]
+        public void DuplicateParametersTest()
+        {
+            var parameters = new List<Parameter>
+            {
+                new Parameter {Name = "/p1", Value = "{\"p1\": \"p1\"}"},
+                new Parameter {Name = "p2", Value = "{\"p2\": \"p2\"}"},
+                new Parameter {Name = "p1", Value = "{\"P1\": \"p1-1\"}"},
+            };
+
+            const string path = "/";
+            Assert.Throws<DuplicateParameterException>(() => _parameterProcessor.ProcessParameters(parameters, path));
+        }
     }
 }