Chore: Future-proofed ConfigFileFormat

apollo-core/src/main/java/com/ctrip/framework/apollo/core/enums/ConfigFileFormat.java

@@ -17,44 +17,91 @@
 package com.ctrip.framework.apollo.core.enums;
 
 import com.ctrip.framework.apollo.core.utils.StringUtils;
+import java.util.stream.Stream;
 
 /**
+ * This enum represents all the possible Configuration file formats apollo currently supports.
+ * <p>
+ * Currently the following formats are supported:
+ * <ul>
+ *   <li>{@link ConfigFileFormat#Properties}</li>
+ *   <li>{@link ConfigFileFormat#XML}</li>
+ *   <li>{@link ConfigFileFormat#JSON}</li>
+ *   <li>{@link ConfigFileFormat#YML}</li>
+ *   <li>{@link ConfigFileFormat#YAML}</li>
+ *   <li>{@link ConfigFileFormat#TXT}</li>
+ * </ul>
+ *
  * @author Jason Song(song_s@ctrip.com)
+ * @author Diego Krupitza(info@diegokrupitza.com)
  */
 public enum ConfigFileFormat {
   Properties("properties"), XML("xml"), JSON("json"), YML("yml"), YAML("yaml"), TXT("txt");
 
-  private String value;
+  private final String value;
 
   ConfigFileFormat(String value) {
     this.value = value;
   }
 
-  public String getValue() {
-    return value;
+  /**
+   * Cleans a given configFilename so it does not contain leading or trailing spaces and is always
+   * lowercase.
+   * <p>
+   * For example:
+   *
+   * <table border="1" cellspacing="1">
+   *   <tr>
+   *   <th>Before</th>
+   *   <th>After</th>
+   *   </tr>
+   *   <tr>
+   *     <td>"Properties "</td>
+   *     <td>"properties"</td>
+   *   </tr>
+   *   <tr>
+   *    <td>"    "</td>
+   *    <td>""</td>
+   *    </tr>
+   * </table>
+   *
+   * @param configFileName the name we want to clean
+   * @return the cleansed configFileName
+   */
+  private static String getWellFormedName(String configFileName) {
+    if (StringUtils.isBlank(configFileName)) {
+      return "";
+    }
+    return configFileName.trim().toLowerCase();
   }
 
+  /**
+   * Transforms a given string to its matching {@link ConfigFileFormat}.
+   *
+   * @param value the string that matches
+   * @return the matching {@link ConfigFileFormat}
+   * @throws IllegalArgumentException in case the <code>value</code> is empty or there is no
+   *                                  matching {@link ConfigFileFormat}
+   */
   public static ConfigFileFormat fromString(String value) {
     if (StringUtils.isEmpty(value)) {
       throw new IllegalArgumentException("value can not be empty");
     }
-    switch (value.toLowerCase()) {
-      case "properties":
-        return Properties;
-      case "xml":
-        return XML;
-      case "json":
-        return JSON;
-      case "yml":
-        return YML;
-      case "yaml":
-        return YAML;
-      case "txt":
-        return TXT;
-    }
-    throw new IllegalArgumentException(value + " can not map enum");
+
+    final String cleansedName = getWellFormedName(value);
+
+    return Stream.of(ConfigFileFormat.values())
+        .filter(item -> cleansedName.equalsIgnoreCase(item.getValue()))
+        .findFirst()
+        .orElseThrow(() -> new IllegalArgumentException(value + " can not map enum"));
   }
 
+  /**
+   * Checks if a given string is a valid {@link ConfigFileFormat}.
+   *
+   * @param value the string to check on
+   * @return is it a valid format
+   */
   public static boolean isValidFormat(String value) {
     try {
       fromString(value);
@@ -64,7 +111,24 @@ public static boolean isValidFormat(String value) {
     }
   }
 
+  /**
+   * Checks whether a given {@link ConfigFileFormat} is compatible with {@link
+   * ConfigFileFormat#Properties}
+   * <p>
+   * <b>Note: </b> if you call this method with {@link ConfigFileFormat#Properties} it will return
+   * <code>false</code>.
+   *
+   * @param format the format to check its compatibility
+   * @return is it compatible with {@link ConfigFileFormat#Properties}
+   */
   public static boolean isPropertiesCompatible(ConfigFileFormat format) {
     return format == YAML || format == YML;
   }
+
+  /**
+   * @return The string representation of the given {@link ConfigFileFormat}
+   */
+  public String getValue() {
+    return value;
+  }
 }

apollo-core/src/test/java/com/ctrip/framework/apollo/core/enums/ConfigFileFormatTest.java

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2021 Apollo Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License 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.
+ *
+ */
+package com.ctrip.framework.apollo.core.enums;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import java.util.ArrayList;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+/**
+ * Tests the {@link ConfigFileFormat} enum.
+ *
+ * @author Diego Krupitza(info@diegokrupitza.com)
+ */
+public class ConfigFileFormatTest {
+
+  @Rule
+  public ExpectedException expectedEx = ExpectedException.none();
+
+  @Test
+  public void testFromStringEqualsOriginal() {
+    assertEquals(ConfigFileFormat.Properties,
+        ConfigFileFormat.fromString(ConfigFileFormat.Properties.getValue()));
+    assertEquals(ConfigFileFormat.XML,
+        ConfigFileFormat.fromString(ConfigFileFormat.XML.getValue()));
+    assertEquals(ConfigFileFormat.JSON,
+        ConfigFileFormat.fromString(ConfigFileFormat.JSON.getValue()));
+    assertEquals(ConfigFileFormat.YML,
+        ConfigFileFormat.fromString(ConfigFileFormat.YML.getValue()));
+    assertEquals(ConfigFileFormat.YAML,
+        ConfigFileFormat.fromString(ConfigFileFormat.YAML.getValue()));
+    assertEquals(ConfigFileFormat.TXT,
+        ConfigFileFormat.fromString(ConfigFileFormat.TXT.getValue()));
+  }
+
+  @Test
+  public void testNonExistingValueFromString() {
+    expectedEx.expect(IllegalArgumentException.class);
+    expectedEx.expectMessage("thisShouldNotExistPropertiesXML can not map enum");
+
+    ConfigFileFormat.fromString("thisShouldNotExistPropertiesXML");
+  }
+
+  @Test
+  public void testEmptyValueFromString() {
+    expectedEx.expect(IllegalArgumentException.class);
+    expectedEx.expectMessage("value can not be empty");
+
+    ConfigFileFormat.fromString("");
+  }
+
+  @Test
+  public void testSpacedValueFromString() {
+    expectedEx.expect(IllegalArgumentException.class);
+    expectedEx.expectMessage(" can not map enum");
+
+    ConfigFileFormat.fromString("    ");
+  }
+
+  @Test
+  public void testSpecialCharsValueFromString() {
+    ArrayList<String> specialChars = new ArrayList<>();
+    specialChars.add(" ");
+    specialChars.add("\t");
+    specialChars.add(" \t");
+    specialChars.add(" \t ");
+    specialChars.add("\t ");
+
+    specialChars.forEach(item -> {
+      assertEquals(ConfigFileFormat.Properties,
+          ConfigFileFormat.fromString(item + ConfigFileFormat.Properties.getValue() + item));
+      assertEquals(ConfigFileFormat.XML,
+          ConfigFileFormat.fromString(item + ConfigFileFormat.XML.getValue() + item));
+      assertEquals(ConfigFileFormat.JSON,
+          ConfigFileFormat.fromString(item + ConfigFileFormat.JSON.getValue() + item));
+      assertEquals(ConfigFileFormat.YML,
+          ConfigFileFormat.fromString(item + ConfigFileFormat.YML.getValue() + item));
+      assertEquals(ConfigFileFormat.YAML,
+          ConfigFileFormat.fromString(item + ConfigFileFormat.YAML.getValue() + item));
+      assertEquals(ConfigFileFormat.TXT,
+          ConfigFileFormat.fromString(item + ConfigFileFormat.TXT.getValue() + item));
+    });
+  }
+
+  @Test
+  public void testIsValidFormatForOriginalContent() {
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.Properties.getValue()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.XML.getValue()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.JSON.getValue()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.YML.getValue()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.YAML.getValue()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.TXT.getValue()));
+
+    assertTrue(
+        ConfigFileFormat.isValidFormat(ConfigFileFormat.Properties.getValue().toUpperCase()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.XML.getValue().toUpperCase()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.JSON.getValue().toUpperCase()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.YML.getValue().toUpperCase()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.YAML.getValue().toUpperCase()));
+    assertTrue(ConfigFileFormat.isValidFormat(ConfigFileFormat.TXT.getValue().toUpperCase()));
+  }
+
+  @Test
+  public void testIsValidFormatForInvalid() {
+    assertFalse(ConfigFileFormat.isValidFormat("thisshouldnotexist"));
+  }
+
+  @Test
+  public void testIfPropertiesCompatible() {
+    assertTrue(ConfigFileFormat.isPropertiesCompatible(ConfigFileFormat.YAML));
+    assertTrue(ConfigFileFormat.isPropertiesCompatible(ConfigFileFormat.YML));
+  }
+}