Merge pull request #10 from Nordstrom/pr/add-parameters-support

Add new Params class, migrated from JUnit Foundation

Author: sbabcoc

src/main/java/com/nordstrom/common/params/Params.java

@@ -0,0 +1,90 @@
+package com.nordstrom.common.params;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+/**
+ * This interface enables implementers to provide methods to support for concisely-defined parameters.
+ */
+public interface Params {
+    
+    /**
+     * Get the defined parameters.
+     * 
+     * @return optional map of named parameters
+     */
+    default Optional<Map<String, Object>> getParameters() {
+        return Optional.empty();
+    }
+    
+    /**
+     * Assemble a map of parameters.
+     * 
+     * @param params array of {@link Param} objects; may be {@code null} or empty
+     * @return optional map of parameters (may be empty)
+     */
+    public static Optional<Map<String, Object>> mapOf(Param... params) {
+        if ((params == null) || (params.length == 0)) {
+            return Optional.empty();
+        }
+        Map<String, Object> paramMap = new HashMap<>();
+        for (Param param : params) {
+            paramMap.put(param.key, param.val);
+        }
+        return Optional.of(Collections.unmodifiableMap(paramMap));
+    }
+    
+    /**
+     * Create a parameter object for the specified key/value pair.
+     * 
+     * @param key parameter key (name)
+     * @param val parameter value
+     * @return parameter object
+     */
+    public static Param param(String key, Object val) {
+        return new Param(key, val);
+    }
+    
+    /**
+     * This class defines a parameter object.
+     */
+    static class Param {
+        
+        private final String key;
+        private final Object val;
+        
+        /**
+         * Constructor for parameter object.
+         * 
+         * @param key parameter key
+         * @param val parameter value
+         */
+        public Param(String key, Object val) {
+            if ((key == null) || key.isEmpty()) {
+                throw new IllegalArgumentException("[key] must be a non-empty string");
+            }
+            this.key = key;
+            this.val = val;
+        }
+        
+        /**
+         * Get key of this parameter.
+         * 
+         * @return parameter key
+         */
+        public String getKey() {
+            return key;
+        }
+        
+        /**
+         * Get value of this parameter.
+         * 
+         * @return parameter value
+         */
+        public Object getVal() {
+            return val;
+        }
+    }
+}

src/test/java/com/nordstrom/common/params/ParamTest.java

@@ -0,0 +1,90 @@
+package com.nordstrom.common.params;
+
+import static com.nordstrom.common.params.Params.param;
+import static org.testng.Assert.assertEquals;
+import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertTrue;
+
+import java.util.Map;
+import java.util.Optional;
+
+import org.testng.annotations.Test;
+
+public class ParamTest implements Params {
+    
+    @Test
+    public void testDefault() {
+        assertFalse(Params.super.getParameters().isPresent());
+    }
+    
+    @Test
+    public void testParam() {
+        Param param = param("boolean", true);
+        assertEquals(param.getKey(), "boolean");
+        verifyBoolean(param.getVal());
+        
+        param = param("int", 1);
+        assertEquals(param.getKey(), "int");
+        verifyInt(param.getVal());
+        
+        param = param("String", "one");
+        assertEquals(param.getKey(), "String");
+        verifyString(param.getVal());
+        
+        param = param("Map", Params.mapOf(param("key", "value")));
+        assertEquals(param.getKey(), "Map");
+        verifyMap(param.getVal());
+    }
+    
+    @Test
+    public void testParams() {
+        Optional<Map<String, Object>> optParameters = getParameters();
+        assertTrue(optParameters.isPresent());
+        Map<String, Object> parameters = optParameters.get();
+        assertFalse(parameters.isEmpty());
+        
+        assertTrue(parameters.containsKey("boolean"));
+        verifyBoolean(parameters.get("boolean"));
+        
+        assertTrue(parameters.containsKey("int"));
+        verifyInt(parameters.get("int"));
+        
+        assertTrue(parameters.containsKey("String"));
+        verifyString(parameters.get("String"));
+        
+        assertTrue(parameters.containsKey("Map"));
+        verifyMap(parameters.get("Map"));
+    }
+    
+    private void verifyBoolean(Object value) {
+        assertTrue(value instanceof Boolean);
+        assertTrue((Boolean) value);
+    }
+    
+    private void verifyInt(Object value) {
+        assertTrue(value instanceof Integer);
+        assertEquals(value, Integer.valueOf(1));
+    }
+    
+    private void verifyString(Object value) {
+        assertTrue(value instanceof String);
+        assertEquals(value, "one");
+    }
+    
+    public void verifyMap(Object value) {
+        assertTrue(value instanceof Optional);
+        Optional<?> optObj = (Optional<?>) value;
+        assertTrue(optObj.isPresent());
+        Object obj = optObj.get();
+        assertTrue(obj instanceof Map);
+        Map<?, ?> map = (Map<?, ?>) obj;
+        assertTrue(map.containsKey("key"));
+        assertEquals(map.get("key"), "value");
+    }
+    
+    @Override
+    public Optional<Map<String, Object>> getParameters() {
+        return Params.mapOf(param("boolean", true), param("int", 1), param("String", "one"),
+                        param("Map", Params.mapOf(param("key", "value"))));
+    }
+}