Added Configurator findStringMatchMultiMap overload that takes a preserveOrder flag (#1062)

Author: drivenflywheel

src/main/java/emissary/config/Configurator.java

@@ -81,13 +81,22 @@ public interface Configurator {
     Map<String, String> findStringMatchMap(String param, boolean preserveCase, boolean preserveOrder);
 
     /**
-     * Find all entry keys that begin with the specified string Remaining key portion is upper cased
+     * Find all entry keys that begin with the specified string Remaining key portion is upper-cased
      *
      * @param theParameter the parameter the leading key startsWith
      * @return map with remaining key portion as key, value as a set of multiple values
      */
     Map<String, Set<String>> findStringMatchMultiMap(final String theParameter);
 
+    /**
+     * Find all entry keys that begin with the specified string Remaining key portion is upper-cased
+     *
+     * @param theParameter the parameter the leading key startsWith
+     * @param preserveOrder ordering of keys is preserved
+     * @return map with remaining key portion as key, value as a set of multiple values
+     */
+    Map<String, Set<String>> findStringMatchMultiMap(final String theParameter, boolean preserveOrder);
+
 
     String findRequiredStringEntry(String theParameter);
 

src/main/java/emissary/config/ServiceConfigGuide.java

@@ -26,6 +26,7 @@
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -829,12 +830,44 @@ public Map<String, String> findStringMatchMap(@Nullable final String theParamete
      */
     @Override
     public Map<String, Set<String>> findStringMatchMultiMap(@Nullable final String param) {
+        if (param == null) {
+            return Map.of();
+        }
+
+        return findStringMatchMultiMap(param, false);
+    }
+
+    /**
+     * Find entries beginning with the specified string and return a hash keyed on the remainder of the string with the
+     * value of the config line as the value of the hash Multiple values for the same hash are allowed and returned as a
+     * Set.
+     *
+     * <pre>
+     * {@code
+     * Example config entries
+     *    FOO_ONE: AAA
+     *    FOO_TWO: BBB
+     *    FOO_TWO: CCC
+     * Calling findStringMatchMap("FOO_",true)
+     * will yield a map with Sets
+     *     ONE -> {AAA}
+     *     TWO -> {BBB,CCC}
+     * }
+     * </pre>
+     *
+     * @param param the key to look for in the config file
+     * @param preserveOrder ordering of keys is preserved
+     * @return map where key is remainder after match and value is a Set of all found config values, or an empty map if none
+     *         found
+     */
+    @Override
+    public Map<String, Set<String>> findStringMatchMultiMap(@Nullable final String param, final boolean preserveOrder) {
 
         if (param == null) {
             return Map.of();
         }
 
-        final Map<String, Set<String>> theHash = new HashMap<>();
+        final Map<String, Set<String>> theHash = preserveOrder ? new LinkedHashMap<>() : new HashMap<>();
         final List<ConfigEntry> parameters = this.findStringMatchEntries(param);
 
         for (final ConfigEntry el : parameters) {
@@ -843,12 +876,13 @@ public Map<String, Set<String>> findStringMatchMultiMap(@Nullable final String p
             if (theHash.containsKey(key)) {
                 theHash.get(key).add(el.getValue());
             } else {
-                final Set<String> values = new HashSet<>();
+                final Set<String> values = preserveOrder ? new LinkedHashSet<>() : new HashSet<>();
                 values.add(el.getValue());
                 theHash.put(key, values);
             }
         }
         return theHash;
+
     }
 
     /**

src/test/java/emissary/config/ServiceConfigGuideTest.java

@@ -19,7 +19,10 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.stream.Stream;
@@ -645,4 +648,53 @@ void testFindRequiredStringEntry() {
         assertNotNull(ex.getMessage(), "Exception message should not be null");
         assertTrue(ex.getMessage().contains(missingProp), "Exception message should name the missing config entry");
     }
+
+    @Test
+    void testFindStringMatchMultiMapOrdered() {
+        // this test fails if ORDERED is set to false due to results ordering
+        final boolean ORDERED = true;
+
+        final ServiceConfigGuide config = new ServiceConfigGuide();
+
+        final String prefix = "MM_";
+        final String key1 = "key1";
+        final String key2 = "key2";
+        final String key3 = "key3";
+        final String value1 = "_value1";
+        final String value2 = "_value2";
+        final String value3 = "_value3";
+        List<String> suffixes = List.of(value1, value2, value3);
+        List<String> keys = List.of(key1, key2, key3);
+
+
+        Map<String, Set<String>> expected = new LinkedHashMap<>();
+        for (String k : keys) {
+            for (String s : suffixes) {
+                String key = prefix + k;
+                String value = k + s;
+                // add prefixed entry to config
+                config.addEntry(key, value);
+                // add non-prefixed entry to expected map (prefix gets stripped during findStringMatchMultiMap call)
+                // UPPERCASE the key to match findStringMatchMultiMap retrieval behavior
+                expected.computeIfAbsent(k.toUpperCase(Locale.getDefault()), v -> new LinkedHashSet<>()).add(value);
+            }
+        }
+        Map<String, Set<String>> actual = config.findStringMatchMultiMap(prefix, ORDERED);
+        assertFalse(actual.isEmpty(), "did not find any multi-map entries");
+        assertEquals(expected.size(), actual.size(), "should have the same number of keys");
+        var actualsIterator = actual.entrySet().iterator();
+        var expectedIterator = expected.entrySet().iterator();
+        int i = 0;
+        while (expectedIterator.hasNext()) {
+            assertTrue(actualsIterator.hasNext());
+
+            i++;
+            var expectedEntry = expectedIterator.next();
+            var actualEntry = actualsIterator.next();
+            assertEquals(expectedEntry.getKey(), actualEntry.getKey(), "failed on key #" + i);
+            assertEquals(expectedEntry.getValue(), actualEntry.getValue(), "value mismatch for key '" + actualEntry.getKey() + "'");
+        }
+
+    }
+
 }