From cf00fb5575ab552e62c59d8a9f6660ecdc76ddb5 Mon Sep 17 00:00:00 2001 From: Diego Krupitza Date: Fri, 1 Oct 2021 14:47:42 +0200 Subject: [PATCH 1/2] Simplified the Env class that links to Env enum Since the Env class in portal/environment is a class representation of the enum Env in the apollo core project I linked them better together. This means if important changes happen in the enum it is automatically reflected to the class representation. Additionall I simplified the `transformEnv` method inside the Env class. The switch will be never reached since all those values are already matched in the `Env.valueOf(envName)`. Further more I added more javadoc and tests to boost up the coverage --- .../apollo/portal/environment/Env.java | 388 +++++++++--------- .../apollo/portal/environment/EnvTest.java | 79 +++- 2 files changed, 277 insertions(+), 190 deletions(-) diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java index 7ddf13bc1ff..f3057069dce 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java @@ -18,213 +18,233 @@ import com.ctrip.framework.apollo.core.utils.StringUtils; import com.google.common.base.Preconditions; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - import java.util.Map; import java.util.Objects; import java.util.concurrent.ConcurrentHashMap; +import org.apache.logging.log4j.util.Strings; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** + * This class provides functionalities to manage and hold all environments of the portal. + * By default all the Env from {@link com.ctrip.framework.apollo.core.enums.Env} are included. + * * @author wxq + * @author Diego Krupitza(info@diegokrupitza.com) */ public class Env { - - private static final Logger logger = LoggerFactory.getLogger(Env.class); - - // name of environment, cannot be null - private final String name; - - // use to cache Env - private static final Map STRING_ENV_MAP = new ConcurrentHashMap<>(); - - // default environments - public static final Env LOCAL = addEnvironment("LOCAL"); - public static final Env DEV = addEnvironment("DEV"); - public static final Env FWS = addEnvironment("FWS"); - public static final Env FAT = addEnvironment("FAT"); - public static final Env UAT = addEnvironment("UAT"); - public static final Env LPT = addEnvironment("LPT"); - public static final Env PRO = addEnvironment("PRO"); - public static final Env TOOLS = addEnvironment("TOOLS"); - public static final Env UNKNOWN = addEnvironment("UNKNOWN"); - - /** - * Cannot create by other - * @param name - */ - private Env(String name) { - this.name = name; - } - /** - * add some change to environment name - * trim and to upper - * @param environmentName - * @return - */ - private static String getWellFormName(String environmentName) { - return environmentName.trim().toUpperCase(); + private static final Logger logger = LoggerFactory.getLogger(Env.class); + // use to cache Env + private static final Map STRING_ENV_MAP = new ConcurrentHashMap<>(); + // default environments + public static final Env LOCAL = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.LOCAL.name()); + public static final Env DEV = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.DEV.name()); + public static final Env FWS = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.FWS.name()); + public static final Env FAT = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.FAT.name()); + public static final Env UAT = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.UAT.name()); + public static final Env LPT = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.LPT.name()); + public static final Env PRO = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.PRO.name()); + public static final Env TOOLS = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.TOOLS.name()); + public static final Env UNKNOWN = addEnvironment( + com.ctrip.framework.apollo.core.enums.Env.UNKNOWN.name()); + // name of environment, cannot be null + private final String name; + + /** + * Cannot create by other + * + * @param name + */ + private Env(String name) { + this.name = name; + } + + /** + * add some change to environment name trim and to upper + * + * @param envName + * @return + */ + private static String getWellFormName(String envName) { + if (Strings.isBlank(envName)) { + return ""; } - - /** - * logic same as - * @see com.ctrip.framework.apollo.core.enums.EnvUtils transformEnv - * @param envName - * @return - */ - public static Env transformEnv(String envName) { - if(Env.exists(envName)) { - return Env.valueOf(envName); - } - if (StringUtils.isBlank(envName)) { - return Env.UNKNOWN; - } - switch (envName.trim().toUpperCase()) { - case "LPT": - return Env.LPT; - case "FAT": - case "FWS": - return Env.FAT; - case "UAT": - return Env.UAT; - case "PRO": - case "PROD": //just in case - return Env.PRO; - case "DEV": - return Env.DEV; - case "LOCAL": - return Env.LOCAL; - case "TOOLS": - return Env.TOOLS; - default: - return Env.UNKNOWN; - } - } - - /** - * a environment name exist or not - * @param name - * @return - */ - public static boolean exists(String name) { - name = getWellFormName(name); - return STRING_ENV_MAP.containsKey(name); + return envName.trim().toUpperCase(); + } + + /** + * logic same as + * + * @param envName the name we want to transform + * @return the env object matching the envName + * @see com.ctrip.framework.apollo.core.enums.EnvUtils transformEnv + */ + public static Env transformEnv(String envName) { + if (StringUtils.isBlank(envName)) { + + // cannot be found or blank name + return Env.UNKNOWN; } - /** - * add an environment - * @param name - * @return - */ - public static Env addEnvironment(String name) { - if (StringUtils.isBlank(name)) { - throw new RuntimeException("Cannot add a blank environment: " + "[" + name + "]"); - } - - name = getWellFormName(name); - if(STRING_ENV_MAP.containsKey(name)) { - // has been existed - logger.debug("{} already exists.", name); - } else { - // not existed - STRING_ENV_MAP.put(name, new Env(name)); - } - return STRING_ENV_MAP.get(name); + // special case for production in case of typo + if (envName.equalsIgnoreCase("PROD")) { + return Env.PRO; } - /** - * replace valueOf in enum - * But what would happened if environment not exist? - * - * @param name - * @throws IllegalArgumentException if this existed environment has no Env with the specified name - * @return - */ - public static Env valueOf(String name) { - name = getWellFormName(name); - if(exists(name)) { - return STRING_ENV_MAP.get(name); - } else { - throw new IllegalArgumentException(name + " not exist"); - } + // special case that FAT & FWS should map to FAT + if (envName.equalsIgnoreCase("FWS")) { + return Env.FAT; } - /** - * Please use {@code Env.valueOf} instead this method - * @param env - * @return - */ - @Deprecated - public static Env fromString(String env) { - Env environment = transformEnv(env); - Preconditions.checkArgument(environment != UNKNOWN, String.format("Env %s is invalid", env)); - return environment; + if (!Env.exists(envName)) { + return Env.UNKNOWN; } - /** - * Not just name in Env, - * the address of Env must be same, - * or it will throw {@code RuntimeException} - * @param o - * @throws RuntimeException When same name but different address - * @return - */ - @Override - public boolean equals(Object o) { - if (this == o) return true; - if (o == null || getClass() != o.getClass()) return false; - Env env = (Env) o; - if(getName().equals(env.getName())) { - throw new RuntimeException(getName() + " is same environment name, but their Env not same"); - } else { - return false; - } + return Env.valueOf(envName); + } + + /** + * a environment name exist or not + * + * @param name the name we want to check if it exists + * @return does the env name exists or not + */ + public static boolean exists(String name) { + name = getWellFormName(name); + return STRING_ENV_MAP.containsKey(name); + } + + /** + * add an environment + * + * @param name the name of the environment to add + * @return the newly created environment + */ + public static Env addEnvironment(String name) { + if (StringUtils.isBlank(name)) { + throw new RuntimeException("Cannot add a blank environment: " + "[" + name + "]"); } - @Override - public int hashCode() { - return Objects.hash(getName()); + name = getWellFormName(name); + if (STRING_ENV_MAP.containsKey(name)) { + // has been existed + logger.debug("{} already exists.", name); + } else { + // not existed + STRING_ENV_MAP.put(name, new Env(name)); } - - /** - * a Env convert to string, ie its name. - * @return - */ - @Override - public String toString() { - return name; + return STRING_ENV_MAP.get(name); + } + + /** + * replace valueOf in enum But what would happened if environment not exist? + * + * @param name + * @return + * @throws IllegalArgumentException if this existed environment has no Env with the specified + * name + */ + public static Env valueOf(String name) { + name = getWellFormName(name); + if (exists(name)) { + return STRING_ENV_MAP.get(name); + } else { + throw new IllegalArgumentException(name + " not exist"); } - - /** - * Backward compatibility with enum's name method - * @Deprecated please use {@link #getName()} instead of - */ - @Deprecated - public String name() { - return name; + } + + /** + * Please use {@code Env.valueOf} instead this method + * + * @param env + * @return + */ + @Deprecated + public static Env fromString(String env) { + Env environment = transformEnv(env); + Preconditions.checkArgument(environment != UNKNOWN, String.format("Env %s is invalid", env)); + return environment; + } + + /** + * conversion key from {@link String} to {@link Env} + * + * @param metaServerAddresses key is environment, value is environment's meta server address + * @return relationship between {@link Env} and meta server address + */ + static Map transformToEnvMap(Map metaServerAddresses) { + // add to domain + Map map = new ConcurrentHashMap<>(); + for (Map.Entry entry : metaServerAddresses.entrySet()) { + // add new environment + Env env = Env.addEnvironment(entry.getKey()); + // get meta server address value + String value = entry.getValue(); + // put pair (Env, meta server address) + map.put(env, value); } - - public String getName() { - return name; + return map; + } + + /** + * Not just name in Env, the address of Env must be same, or it will throw {@code + * RuntimeException} + * + * @param o + * @return + * @throws RuntimeException When same name but different address + */ + @Override + public boolean equals(Object o) { + if (this == o) { + return true; } - - /** - * conversion key from {@link String} to {@link Env} - * @param metaServerAddresses key is environment, value is environment's meta server address - * @return relationship between {@link Env} and meta server address - */ - static Map transformToEnvMap(Map metaServerAddresses) { - // add to domain - Map map = new ConcurrentHashMap<>(); - for(Map.Entry entry : metaServerAddresses.entrySet()) { - // add new environment - Env env = Env.addEnvironment(entry.getKey()); - // get meta server address value - String value = entry.getValue(); - // put pair (Env, meta server address) - map.put(env, value); - } - return map; + if (o == null || getClass() != o.getClass()) { + return false; + } + Env env = (Env) o; + if (getName().equals(env.getName())) { + throw new RuntimeException(getName() + " is same environment name, but their Env not same"); + } else { + return false; } + } + + @Override + public int hashCode() { + return Objects.hash(getName()); + } + + /** + * a Env convert to string, ie its name. + * + * @return + */ + @Override + public String toString() { + return name; + } + + /** + * Backward compatibility with enum's name method + * + * @Deprecated please use {@link #getName()} instead of + */ + @Deprecated + public String name() { + return name; + } + + public String getName() { + return name; + } } diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java index 74a3bca72b4..ba3a2252acd 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java @@ -54,7 +54,7 @@ public void testEquals() { assertEquals(Env.DEV, Env.valueOf("dEv")); String name = "someEEEE"; Env.addEnvironment(name); - assertFalse(Env.valueOf(name).equals(Env.DEV)); + assertNotEquals(Env.valueOf(name), Env.DEV); } @Test(expected = RuntimeException.class) @@ -75,10 +75,10 @@ public void testEqualsWithRuntimeException() @Test public void testEqualWithoutException() { - assertTrue(Env.DEV.equals(Env.DEV)); - assertTrue(Env.DEV.equals(Env.valueOf("dEV"))); - assertFalse(Env.PRO.equals(Env.DEV)); - assertFalse(Env.DEV.equals(Env.valueOf("uaT"))); + assertEquals(Env.DEV, Env.DEV); + assertEquals(Env.DEV, Env.valueOf("dEV")); + assertNotEquals(Env.PRO, Env.DEV); + assertNotEquals(Env.DEV, Env.valueOf("uaT")); } @Test @@ -97,4 +97,71 @@ public void getName() { Env.addEnvironment(name); assertEquals(name.trim().toUpperCase(), Env.valueOf(name).toString()); } -} \ No newline at end of file + + @Test + public void transformEnvBlankTest() { + assertEquals(Env.UNKNOWN,Env.transformEnv("")); + assertEquals(Env.UNKNOWN,Env.transformEnv(null)); + assertEquals(Env.UNKNOWN,Env.transformEnv(" ")); + } + + @Test + public void transformEnvSpecialCaseTest() { + // Prod/Pro + assertEquals(Env.PRO,Env.transformEnv("prod")); + assertEquals(Env.PRO,Env.transformEnv("PROD")); + + //FAT/FWS + assertEquals(Env.FAT,Env.transformEnv("FWS")); + assertEquals(Env.FAT,Env.transformEnv("fws")); + } + + @Test + public void transformEnvNotExistTest() { + assertEquals(Env.UNKNOWN,Env.transformEnv("notexisting")); + assertEquals(Env.LOCAL,Env.transformEnv("LOCAL")); + } + + @Test + public void transformEnvValidTest() { + assertEquals(Env.UNKNOWN,Env.transformEnv("UNKNOWN")); + assertEquals(Env.LOCAL,Env.transformEnv("LOCAL")); + assertEquals(Env.FAT,Env.transformEnv("FAT")); + assertEquals(Env.FAT,Env.transformEnv("FWS")); + assertEquals(Env.PRO,Env.transformEnv("PRO")); + assertEquals(Env.PRO,Env.transformEnv("PROD")); + assertEquals(Env.DEV,Env.transformEnv("DEV")); + assertEquals(Env.LPT,Env.transformEnv("LPT")); + assertEquals(Env.TOOLS,Env.transformEnv("TOOLS")); + assertEquals(Env.UAT,Env.transformEnv("UAT")); + + String testEnvName = "testEnv"; + + Env.addEnvironment(testEnvName); + Env expected = Env.valueOf(testEnvName); + + assertEquals(expected,Env.transformEnv(testEnvName)); + } + + @Test(expected = RuntimeException.class) + public void addEnvironmentBlankStringTest() { + Env.addEnvironment(""); + } + + @Test(expected = RuntimeException.class) + public void addEnvironmentNullStringTest() { + Env.addEnvironment(null); + } + + @Test(expected = RuntimeException.class) + public void addEnvironmentSpacesStringTest() { + Env.addEnvironment(" "); + } + + @Test + public void existsForBlankNameTest() { + assertFalse(Env.exists("")); + assertFalse(Env.exists(" ")); + assertFalse(Env.exists(null)); + } +} From 1781809e1f53665e42c5ced95519b5ee67a7a266 Mon Sep 17 00:00:00 2001 From: Diego Krupitza Date: Thu, 7 Oct 2021 20:12:35 +0200 Subject: [PATCH 2/2] Implemented the suggestions made by @Anilople --- .../apollo/portal/environment/Env.java | 29 +- .../apollo/portal/environment/EnvTest.java | 316 ++++++++++-------- 2 files changed, 185 insertions(+), 160 deletions(-) diff --git a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java index f3057069dce..644560d1542 100644 --- a/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java +++ b/apollo-portal/src/main/java/com/ctrip/framework/apollo/portal/environment/Env.java @@ -21,13 +21,12 @@ import java.util.Map; import java.util.Objects; import java.util.concurrent.ConcurrentHashMap; -import org.apache.logging.log4j.util.Strings; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * This class provides functionalities to manage and hold all environments of the portal. - * By default all the Env from {@link com.ctrip.framework.apollo.core.enums.Env} are included. + * This class provides functionalities to manage and hold all environments of the portal. By default + * all the Env from {@link com.ctrip.framework.apollo.core.enums.Env} are included. * * @author wxq * @author Diego Krupitza(info@diegokrupitza.com) @@ -75,41 +74,35 @@ private Env(String name) { * @return */ private static String getWellFormName(String envName) { - if (Strings.isBlank(envName)) { + if (StringUtils.isBlank(envName)) { return ""; } return envName.trim().toUpperCase(); } /** - * logic same as + * logic same as {@link com.ctrip.framework.apollo.core.enums.EnvUtils#transformEnv} * * @param envName the name we want to transform * @return the env object matching the envName - * @see com.ctrip.framework.apollo.core.enums.EnvUtils transformEnv */ public static Env transformEnv(String envName) { - if (StringUtils.isBlank(envName)) { - - // cannot be found or blank name - return Env.UNKNOWN; - } - + final String envWellFormName = getWellFormName(envName); // special case for production in case of typo - if (envName.equalsIgnoreCase("PROD")) { + if ("PROD".equalsIgnoreCase(envWellFormName)) { return Env.PRO; } // special case that FAT & FWS should map to FAT - if (envName.equalsIgnoreCase("FWS")) { + if ("FWS".equalsIgnoreCase(envWellFormName)) { return Env.FAT; } - if (!Env.exists(envName)) { - return Env.UNKNOWN; + if (Env.exists(envWellFormName)) { + return Env.valueOf(envWellFormName); } - - return Env.valueOf(envName); + // cannot be found or blank name + return Env.UNKNOWN; } /** diff --git a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java index ba3a2252acd..595a40c7782 100644 --- a/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java +++ b/apollo-portal/src/test/java/com/ctrip/framework/apollo/portal/environment/EnvTest.java @@ -16,152 +16,184 @@ */ package com.ctrip.framework.apollo.portal.environment; -import org.junit.Test; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertTrue; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; - -import static org.junit.Assert.*; +import java.util.ArrayList; +import org.junit.Test; public class EnvTest { - @Test - public void exist() { - assertFalse(Env.exists("xxxyyy234")); - assertTrue(Env.exists("local")); - assertTrue(Env.exists("dev")); - } - - @Test - public void addEnv() { - String name = "someEEEE"; - assertFalse(Env.exists(name)); - Env.addEnvironment(name); - assertTrue(Env.exists(name)); - } - - @Test(expected = IllegalArgumentException.class) - public void valueOf() { - String name = "notexist"; - assertFalse(Env.exists(name)); - assertEquals(Env.valueOf(name), Env.UNKNOWN); - assertEquals(Env.valueOf("dev"), Env.DEV); - assertEquals(Env.valueOf("UAT"), Env.UAT); - } - - @Test - public void testEquals() { - assertEquals(Env.DEV, Env.valueOf("dEv")); - String name = "someEEEE"; - Env.addEnvironment(name); - assertNotEquals(Env.valueOf(name), Env.DEV); - } - - @Test(expected = RuntimeException.class) - public void testEqualsWithRuntimeException() - throws NoSuchMethodException, - IllegalAccessException, - InvocationTargetException, - InstantiationException { - // get private constructor - Constructor envConstructor = Env.class.getDeclaredConstructor(String.class); - // make private constructor accessible - envConstructor.setAccessible(true); - // make a fake Env - Env fakeDevEnv = envConstructor.newInstance(Env.DEV.toString()); - // compare, then a RuntimeException will invoke - fakeDevEnv.equals(Env.DEV); - } - - @Test - public void testEqualWithoutException() { - assertEquals(Env.DEV, Env.DEV); - assertEquals(Env.DEV, Env.valueOf("dEV")); - assertNotEquals(Env.PRO, Env.DEV); - assertNotEquals(Env.DEV, Env.valueOf("uaT")); - } - - @Test - public void testToString() { - assertEquals("DEV", Env.DEV.toString()); - } - - @Test - public void name() { - assertEquals("DEV", Env.DEV.name()); - } - - @Test - public void getName() { - String name = "getName"; - Env.addEnvironment(name); - assertEquals(name.trim().toUpperCase(), Env.valueOf(name).toString()); - } - - @Test - public void transformEnvBlankTest() { - assertEquals(Env.UNKNOWN,Env.transformEnv("")); - assertEquals(Env.UNKNOWN,Env.transformEnv(null)); - assertEquals(Env.UNKNOWN,Env.transformEnv(" ")); - } - - @Test - public void transformEnvSpecialCaseTest() { - // Prod/Pro - assertEquals(Env.PRO,Env.transformEnv("prod")); - assertEquals(Env.PRO,Env.transformEnv("PROD")); - - //FAT/FWS - assertEquals(Env.FAT,Env.transformEnv("FWS")); - assertEquals(Env.FAT,Env.transformEnv("fws")); - } - - @Test - public void transformEnvNotExistTest() { - assertEquals(Env.UNKNOWN,Env.transformEnv("notexisting")); - assertEquals(Env.LOCAL,Env.transformEnv("LOCAL")); - } - - @Test - public void transformEnvValidTest() { - assertEquals(Env.UNKNOWN,Env.transformEnv("UNKNOWN")); - assertEquals(Env.LOCAL,Env.transformEnv("LOCAL")); - assertEquals(Env.FAT,Env.transformEnv("FAT")); - assertEquals(Env.FAT,Env.transformEnv("FWS")); - assertEquals(Env.PRO,Env.transformEnv("PRO")); - assertEquals(Env.PRO,Env.transformEnv("PROD")); - assertEquals(Env.DEV,Env.transformEnv("DEV")); - assertEquals(Env.LPT,Env.transformEnv("LPT")); - assertEquals(Env.TOOLS,Env.transformEnv("TOOLS")); - assertEquals(Env.UAT,Env.transformEnv("UAT")); - - String testEnvName = "testEnv"; - - Env.addEnvironment(testEnvName); - Env expected = Env.valueOf(testEnvName); - - assertEquals(expected,Env.transformEnv(testEnvName)); - } - - @Test(expected = RuntimeException.class) - public void addEnvironmentBlankStringTest() { - Env.addEnvironment(""); - } - - @Test(expected = RuntimeException.class) - public void addEnvironmentNullStringTest() { - Env.addEnvironment(null); - } - - @Test(expected = RuntimeException.class) - public void addEnvironmentSpacesStringTest() { - Env.addEnvironment(" "); - } - - @Test - public void existsForBlankNameTest() { - assertFalse(Env.exists("")); - assertFalse(Env.exists(" ")); - assertFalse(Env.exists(null)); - } + @Test + public void exist() { + assertFalse(Env.exists("xxxyyy234")); + assertTrue(Env.exists("local")); + assertTrue(Env.exists("dev")); + } + + @Test + public void addEnv() { + String name = "someEEEE"; + assertFalse(Env.exists(name)); + Env.addEnvironment(name); + assertTrue(Env.exists(name)); + } + + @Test(expected = IllegalArgumentException.class) + public void valueOf() { + String name = "notexist"; + assertFalse(Env.exists(name)); + assertEquals(Env.valueOf(name), Env.UNKNOWN); + assertEquals(Env.valueOf("dev"), Env.DEV); + assertEquals(Env.valueOf("UAT"), Env.UAT); + } + + @Test + public void testEquals() { + assertEquals(Env.DEV, Env.valueOf("dEv")); + String name = "someEEEE"; + Env.addEnvironment(name); + assertNotEquals(Env.valueOf(name), Env.DEV); + } + + @Test(expected = RuntimeException.class) + public void testEqualsWithRuntimeException() + throws NoSuchMethodException, + IllegalAccessException, + InvocationTargetException, + InstantiationException { + // get private constructor + Constructor envConstructor = Env.class.getDeclaredConstructor(String.class); + // make private constructor accessible + envConstructor.setAccessible(true); + // make a fake Env + Env fakeDevEnv = envConstructor.newInstance(Env.DEV.toString()); + // compare, then a RuntimeException will invoke + fakeDevEnv.equals(Env.DEV); + } + + @Test + public void testEqualWithoutException() { + assertEquals(Env.DEV, Env.DEV); + assertEquals(Env.DEV, Env.valueOf("dEV")); + assertNotEquals(Env.PRO, Env.DEV); + assertNotEquals(Env.DEV, Env.valueOf("uaT")); + } + + @Test + public void testToString() { + assertEquals("DEV", Env.DEV.toString()); + } + + @Test + public void name() { + assertEquals("DEV", Env.DEV.name()); + } + + @Test + public void getName() { + String name = "getName"; + Env.addEnvironment(name); + assertEquals(name.trim().toUpperCase(), Env.valueOf(name).toString()); + } + + @Test + public void testTransformEnvBlank() { + assertEquals(Env.UNKNOWN, Env.transformEnv("")); + assertEquals(Env.UNKNOWN, Env.transformEnv(null)); + assertEquals(Env.UNKNOWN, Env.transformEnv(" ")); + } + + @Test + public void testTransformEnvSpecialCase() { + // Prod/Pro + assertEquals(Env.PRO, Env.transformEnv("prod")); + assertEquals(Env.PRO, Env.transformEnv("PROD")); + + //FAT/FWS + assertEquals(Env.FAT, Env.transformEnv("FWS")); + assertEquals(Env.FAT, Env.transformEnv("fws")); + } + + @Test + public void testTransformEnvNotExist() { + assertEquals(Env.UNKNOWN, Env.transformEnv("notexisting")); + assertEquals(Env.LOCAL, Env.transformEnv("LOCAL")); + } + + @Test + public void testTransformEnvValid() { + assertEquals(Env.UNKNOWN, Env.transformEnv("UNKNOWN")); + assertEquals(Env.LOCAL, Env.transformEnv("LOCAL")); + assertEquals(Env.FAT, Env.transformEnv("FAT")); + assertEquals(Env.FAT, Env.transformEnv("FWS")); + assertEquals(Env.PRO, Env.transformEnv("PRO")); + assertEquals(Env.PRO, Env.transformEnv("PROD")); + assertEquals(Env.DEV, Env.transformEnv("DEV")); + assertEquals(Env.LPT, Env.transformEnv("LPT")); + assertEquals(Env.TOOLS, Env.transformEnv("TOOLS")); + assertEquals(Env.UAT, Env.transformEnv("UAT")); + + String testEnvName = "testEnv"; + + Env.addEnvironment(testEnvName); + Env expected = Env.valueOf(testEnvName); + + assertEquals(expected, Env.transformEnv(testEnvName)); + } + + @Test + public void testTransformEnvWithTrailingAndLeadingBlankValid() { + ArrayList specialChars = new ArrayList<>(); + specialChars.add(" "); + specialChars.add("\t"); + specialChars.add(" \t"); + specialChars.add(" \t "); + specialChars.add("\t "); + + for (String specialChar : specialChars) { + assertEquals(Env.UNKNOWN, Env.transformEnv(specialChar + "UNKNOWN")); + assertEquals(Env.LOCAL, Env.transformEnv(specialChar + "LOCAL" + specialChar)); + assertEquals(Env.FAT, Env.transformEnv(specialChar + "FAT" + specialChar)); + assertEquals(Env.FAT, Env.transformEnv(specialChar + "FWS" + specialChar)); + assertEquals(Env.PRO, Env.transformEnv(specialChar + "PRO" + specialChar)); + assertEquals(Env.PRO, Env.transformEnv(specialChar + "PROD" + specialChar)); + assertEquals(Env.DEV, Env.transformEnv(specialChar + "DEV" + specialChar)); + assertEquals(Env.LPT, Env.transformEnv(specialChar + "LPT" + specialChar)); + assertEquals(Env.TOOLS, Env.transformEnv(specialChar + "TOOLS" + specialChar)); + assertEquals(Env.UAT, Env.transformEnv(specialChar + "UAT" + specialChar)); + + String testEnvName = "testEnv"; + Env.addEnvironment(testEnvName); + Env expected = Env.valueOf(testEnvName); + assertEquals(expected, Env.transformEnv(specialChar + testEnvName + specialChar)); + + } + } + + @Test(expected = RuntimeException.class) + public void testAddEnvironmentBlankString() { + Env.addEnvironment(""); + } + + @Test(expected = RuntimeException.class) + public void testAddEnvironmentNullString() { + Env.addEnvironment(null); + } + + @Test(expected = RuntimeException.class) + public void testAddEnvironmentSpacesString() { + Env.addEnvironment(" "); + } + + @Test + public void testExistsForBlankName() { + assertFalse(Env.exists("")); + assertFalse(Env.exists(" ")); + assertFalse(Env.exists(null)); + } }