#347 Create consistency and integration tests for NewSetting

- Ensure that the project's config.yml contains all settings that NewSetting is aware of
- Add extensive, more generic integration tests

src/main/java/fr/xephi/authme/settings/custom/HooksSettings.java

@@ -19,7 +19,7 @@ public class HooksSettings implements SettingsClass {
 
 	@Comment("Send player to this BungeeCord server after register/login")
     public static final Property<String> BUNGEECORD_SERVER =
-        newProperty(PropertyType.STRING, "bungeecord.server", "");
+        newProperty(PropertyType.STRING, "Hooks.sendPlayerTo", "");
 
 	@Comment("Do we need to disable Essentials SocialSpy on join?")
     public static final Property<Boolean> DISABLE_SOCIAL_SPY =

src/main/java/fr/xephi/authme/settings/custom/NewSetting.java

@@ -24,6 +24,12 @@ public class NewSetting {
     private File file;
     private YamlConfiguration configuration;
 
+    /**
+     * Constructor.
+     * Loads the file as YAML and checks its integrity.
+     *
+     * @param file The configuration file
+     */
     public NewSetting(File file) {
         this.configuration = YamlConfiguration.loadConfiguration(file);
         this.file = file;
@@ -34,12 +40,33 @@ public class NewSetting {
         }
     }
 
+    /**
+     * Simple constructor for testing purposes. Does not check for all properties and
+     * never saves to the file.
+     *
+     * @param yamlConfiguration The YamlConfiguration object to use
+     * @param file The file to write to
+     * @param propertyMap The property map whose properties should be verified for presence, or null to skip this
+     */
     @VisibleForTesting
-    NewSetting(YamlConfiguration yamlConfiguration, String file) {
+    NewSetting(YamlConfiguration yamlConfiguration, File file, PropertyMap propertyMap) {
         this.configuration = yamlConfiguration;
-        this.file = new File(file);
+        this.file = file;
+
+        if (propertyMap != null) {
+            if (!containsAllSettings(propertyMap)) {
+                save(propertyMap);
+            }
+        }
     }
 
+    /**
+     * Get the given property from the configuration.
+     *
+     * @param property The property to retrieve
+     * @param <T> The property's type
+     * @return The property's value
+     */
     public <T> T getOption(Property<T> property) {
         return property.getFromFile(configuration);
     }
@@ -105,7 +132,8 @@ public class NewSetting {
         }
     }
 
-    private boolean containsAllSettings(PropertyMap propertyMap) {
+    @VisibleForTesting
+    boolean containsAllSettings(PropertyMap propertyMap) {
         for (Property<?> property : propertyMap.keySet()) {
             if (!property.isPresent(configuration)) {
                 return false;

src/main/java/fr/xephi/authme/settings/custom/PurgeSettings.java

@@ -25,7 +25,7 @@ public class PurgeSettings implements SettingsClass {
 
 	@Comment("Do we need to remove the Essentials/users/player.yml file during purge process?")
     public static final Property<Boolean> REMOVE_ESSENTIALS_FILES =
-        newProperty(BOOLEAN, "Purge.removeEssentialsFiles", false);
+        newProperty(BOOLEAN, "Purge.removeEssentialsFile", false);
 
 	@Comment("World where are players.dat stores")
     public static final Property<String> DEFAULT_WORLD =

src/main/resources/config.yml

@@ -355,6 +355,8 @@ Email:
     emailWhitelisted: []
     # Do we need to send new password draw in an image?
     generateImage: false
+    # The email OAuth 2 token (leave empty if not used)
+    emailOauth2Token: ''
 Hooks:
     # Do we need to hook with multiverse for spawn checking?
     multiverse: true

src/test/java/fr/xephi/authme/settings/custom/ConfigFileConsistencyTest.java

@@ -0,0 +1,35 @@
+package fr.xephi.authme.settings.custom;
+
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assume.assumeThat;
+
+/**
+ * Test for {@link NewSetting} and the project's config.yml,
+ * verifying that no settings are missing from the file.
+ */
+public class ConfigFileConsistencyTest {
+
+    @Test
+    public void shouldHaveAllConfigs() throws IOException {
+        URL url = this.getClass().getResource("/config.yml");
+        File configFile = new File(url.getFile());
+
+        // given
+        assumeThat(configFile.exists(), equalTo(true));
+        NewSetting settings = new NewSetting(configFile);
+
+        // when
+        boolean result = settings.containsAllSettings(SettingsFieldRetriever.getAllPropertyFields());
+
+        // then
+        assertThat(result, equalTo(true));
+    }
+
+}

src/test/java/fr/xephi/authme/settings/custom/NewSettingIntegrationTest.java

@@ -0,0 +1,113 @@
+package fr.xephi.authme.settings.custom;
+
+import com.google.common.collect.ImmutableMap;
+import fr.xephi.authme.ReflectionTestUtils;
+import fr.xephi.authme.settings.domain.Property;
+import fr.xephi.authme.settings.propertymap.PropertyMap;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.net.URL;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assume.assumeThat;
+
+/**
+ * Integration test for {@link NewSetting}.
+ */
+public class NewSettingIntegrationTest {
+
+    /** File name of the sample config including all {@link TestConfiguration} values. */
+    private static final String COMPLETE_FILE = "config-sample-values.yml";
+    /** File name of the sample config missing certain {@link TestConfiguration} values. */
+    private static final String INCOMPLETE_FILE = "config-incomplete-sample.yml";
+
+    private static PropertyMap propertyMap;
+
+    @BeforeClass
+    public static void generatePropertyMap() {
+        propertyMap = new PropertyMap();
+        for (Field field : TestConfiguration.class.getDeclaredFields()) {
+            Property<?> property =
+                (Property<?>) ReflectionTestUtils.getFieldValue(TestConfiguration.class, null, field.getName());
+            String[] comments = new String[]{"Comment for '" + property.getPath() + "'"};
+            propertyMap.put(property, comments);
+        }
+    }
+
+    @Test
+    public void shouldLoadAndReadAllProperties() {
+        // given
+        YamlConfiguration configuration = YamlConfiguration.loadConfiguration(getConfigFile(COMPLETE_FILE));
+        File file = new File("unused");
+        assumeThat(file.exists(), equalTo(false));
+
+        // when / then
+        NewSetting settings = new NewSetting(configuration, file, propertyMap);
+        Map<Property<?>, Object> expectedValues = ImmutableMap.<Property<?>, Object>builder()
+            .put(TestConfiguration.DURATION_IN_SECONDS, 22)
+            .put(TestConfiguration.SYSTEM_NAME, "Custom sys name")
+            .put(TestConfiguration.RATIO_LIMIT, -4.1)
+            .put(TestConfiguration.RATIO_FIELDS, Arrays.asList("Australia", "Burundi", "Colombia"))
+            .put(TestConfiguration.VERSION_NUMBER, 2492)
+            .put(TestConfiguration.SKIP_BORING_FEATURES, false)
+            .put(TestConfiguration.BORING_COLORS, Arrays.asList("beige", "gray"))
+            .put(TestConfiguration.DUST_LEVEL, 0.81)
+            .put(TestConfiguration.USE_COOL_FEATURES, true)
+            .put(TestConfiguration.COOL_OPTIONS, Arrays.asList("Dinosaurs", "Explosions", "Big trucks"))
+            .build();
+        for (Map.Entry<Property<?>, Object> entry : expectedValues.entrySet()) {
+            assertThat("Property '" + entry.getKey().getPath() + "' has expected value",
+                settings.getOption(entry.getKey()), equalTo(entry.getValue()));
+        }
+        assertThat(file.exists(), equalTo(false));
+    }
+
+    @Test
+    public void shouldWriteMissingProperties() {
+        // given/when
+        File file = getConfigFile(INCOMPLETE_FILE);
+        YamlConfiguration configuration = YamlConfiguration.loadConfiguration(file);
+        assumeThat(configuration.contains(TestConfiguration.BORING_COLORS.getPath()), equalTo(false));
+        // Expectation: File is rewritten to since it does not have all configurations
+        new NewSetting(configuration, file, propertyMap);
+
+        // Load the settings again -> checks that what we wrote can be loaded again
+        configuration = YamlConfiguration.loadConfiguration(file);
+
+        // then
+        NewSetting settings = new NewSetting(configuration, file, propertyMap);
+        Map<Property<?>, Object> expectedValues = ImmutableMap.<Property<?>, Object>builder()
+            .put(TestConfiguration.DURATION_IN_SECONDS, 22)
+            .put(TestConfiguration.SYSTEM_NAME, "[TestDefaultValue]")
+            .put(TestConfiguration.RATIO_LIMIT, 3.0)
+            .put(TestConfiguration.RATIO_FIELDS, Arrays.asList("Australia", "Burundi", "Colombia"))
+            .put(TestConfiguration.VERSION_NUMBER, 32046)
+            .put(TestConfiguration.SKIP_BORING_FEATURES, false)
+            .put(TestConfiguration.BORING_COLORS, Collections.EMPTY_LIST)
+            .put(TestConfiguration.DUST_LEVEL, 0.2)
+            .put(TestConfiguration.USE_COOL_FEATURES, false)
+            .put(TestConfiguration.COOL_OPTIONS, Arrays.asList("Dinosaurs", "Explosions", "Big trucks"))
+            .build();
+        for (Map.Entry<Property<?>, Object> entry : expectedValues.entrySet()) {
+            assertThat("Property '" + entry.getKey().getPath() + "' has expected value",
+                settings.getOption(entry.getKey()), equalTo(entry.getValue()));
+        }
+    }
+
+    private File getConfigFile(String file) {
+        URL url = getClass().getClassLoader().getResource(file);
+        if (url == null) {
+            throw new IllegalStateException("File '" + file + "' could not be loaded");
+        }
+        return new File(url.getFile());
+    }
+
+}

src/test/java/fr/xephi/authme/settings/custom/NewSettingTest.java

@@ -1,114 +1,84 @@
 package fr.xephi.authme.settings.custom;
 
-import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.settings.domain.Property;
-import fr.xephi.authme.settings.domain.PropertyType;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.junit.Test;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
 import java.io.File;
-import java.net.URL;
-import java.util.List;
 
-import static fr.xephi.authme.settings.domain.Property.newProperty;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
 import static org.hamcrest.Matchers.equalTo;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Matchers.anyBoolean;
+import static org.mockito.Matchers.anyDouble;
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
 
+/**
+ * Test for {@link NewSetting}.
+ */
 public class NewSettingTest {
 
-    private static final String CONFIG_FILE = "437-config-test.yml";
-
-    @Test
-    public void shouldReturnIntegerFromFile() {
-        // given
-        YamlConfiguration file = mock(YamlConfiguration.class);
-        Property<Integer> config = TestConfiguration.DURATION_IN_SECONDS;
-        given(file.getInt("test.duration", 4)).willReturn(18);
-        NewSetting settings = new NewSetting(file, "conf.txt");
-
-        // when
-        int retrieve = settings.getOption(config);
-
-        // then
-        assertThat(retrieve, equalTo(18));
-    }
-
     @Test
     public void shouldLoadAllConfigs() {
         // given
         YamlConfiguration file = mock(YamlConfiguration.class);
+        given(file.getString(anyString(), anyString())).willAnswer(withDefaultArgument());
+        given(file.getBoolean(anyString(), anyBoolean())).willAnswer(withDefaultArgument());
+        given(file.getDouble(anyString(), anyDouble())).willAnswer(withDefaultArgument());
+        given(file.getInt(anyString(), anyInt())).willAnswer(withDefaultArgument());
 
-        given(file.getString(anyString(), anyString())).willAnswer(new Answer<String>() {
+        setReturnValue(file, TestConfiguration.VERSION_NUMBER, 20);
-            @Override
+        setReturnValue(file, TestConfiguration.SKIP_BORING_FEATURES, true);
-            public String answer(InvocationOnMock invocation) throws Throwable {
+        setReturnValue(file, TestConfiguration.RATIO_LIMIT, 4.25);
-                // Return the second parameter -> the default
+        setReturnValue(file, TestConfiguration.SYSTEM_NAME, "myTestSys");
-                return (String) invocation.getArguments()[1];
-            }
-        });
 
-        given(file.getInt(eq(EmailSettings.RECOVERY_PASSWORD_LENGTH.getPath()), anyInt()))
+        // when / then
-            .willReturn(20);
+        NewSetting settings = new NewSetting(file, new File("conf.txt"), null);
-        given(file.getBoolean(eq(SecuritySettings.REMOVE_PASSWORD_FROM_CONSOLE.getPath()), anyBoolean()))
-            .willReturn(false);
 
-        // when
+        assertThat(settings.getOption(TestConfiguration.VERSION_NUMBER), equalTo(20));
-        NewSetting settings = new NewSetting(file, "conf.txt");
+        assertThat(settings.getOption(TestConfiguration.SKIP_BORING_FEATURES), equalTo(true));
+        assertThat(settings.getOption(TestConfiguration.RATIO_LIMIT), equalTo(4.25));
+        assertThat(settings.getOption(TestConfiguration.SYSTEM_NAME), equalTo("myTestSys"));
 
-        // then
+        assertDefaultValue(TestConfiguration.DURATION_IN_SECONDS, settings);
-        // Expect the value we told the YAML mock to return:
+        assertDefaultValue(TestConfiguration.DUST_LEVEL, settings);
-        assertThat(settings.getOption(EmailSettings.RECOVERY_PASSWORD_LENGTH), equalTo(20));
+        assertDefaultValue(TestConfiguration.COOL_OPTIONS, settings);
-        // Expect the default:
-        assertThat(settings.getOption(EmailSettings.SMTP_HOST), equalTo(EmailSettings.SMTP_HOST.getDefaultValue()));
-        // Expect the value we told the YAML mock to return:
-        assertThat(settings.getOption(SecuritySettings.REMOVE_PASSWORD_FROM_CONSOLE), equalTo(false));
     }
 
-    @Test
+    private static <T> void setReturnValue(YamlConfiguration config, Property<T> property, T value) {
-    public void executeIntegrationTest() {
+        if (value instanceof String) {
-        // given
+            when(config.getString(eq(property.getPath()), anyString())).thenReturn((String) value);
-        YamlConfiguration yamlFile = YamlConfiguration.loadConfiguration(getConfigFile());
+        } else if (value instanceof Integer) {
-        NewSetting settings = new NewSetting(yamlFile, "conf.txt");
+            when(config.getInt(eq(property.getPath()), anyInt())).thenReturn((Integer) value);
-
+        } else if (value instanceof Boolean) {
-        // when
+            when(config.getBoolean(eq(property.getPath()), anyBoolean())).thenReturn((Boolean) value);
-        int result = settings.getOption(TestConfiguration.DURATION_IN_SECONDS);
+        } else if (value instanceof Double) {
-        String systemName = settings.getOption(TestConfiguration.SYSTEM_NAME);
+            when(config.getDouble(eq(property.getPath()), anyDouble())).thenReturn((Double) value);
-        String helpHeader = settings.getOption(newProperty("settings.helpHeader", ""));
+        } else {
-        List<String> unsafePasswords = settings.getOption(
+            throw new UnsupportedOperationException("Value has unsupported type '"
-            newProperty(PropertyType.STRING_LIST, "Security.unsafePasswords"));
+                + (value == null ? "null" : value.getClass().getSimpleName()) + "'");
-        DataSource.DataSourceType dataSourceType = settings.getOption(DatabaseSettings.BACKEND);
-
-        // then
-        assertThat(result, equalTo(22));
-        assertThat(systemName, equalTo(TestConfiguration.SYSTEM_NAME.getDefaultValue()));
-        assertThat(helpHeader, equalTo("AuthMeReloaded"));
-        assertThat(unsafePasswords, contains("123456", "qwerty", "54321"));
-        assertThat(dataSourceType, equalTo(DataSource.DataSourceType.MYSQL));
-    }
-
-    private File getConfigFile() {
-        URL url = getClass().getClassLoader().getResource(CONFIG_FILE);
-        if (url == null) {
-            throw new RuntimeException("File '" + CONFIG_FILE + "' could not be loaded");
         }
-        return new File(url.getFile());
     }
 
-    private static class TestConfiguration {
+    private static void assertDefaultValue(Property<?> property, NewSetting setting) {
+        assertThat(property.getPath() + " has default value",
+            setting.getOption(property).equals(property.getDefaultValue()), equalTo(true));
+    }
 
-        public static final Property<Integer> DURATION_IN_SECONDS =
+    private static <T> Answer<T> withDefaultArgument() {
-            newProperty("test.duration", 4);
+        return new Answer<T>() {
-
+            @Override
-        public static final Property<String> SYSTEM_NAME =
+            public T answer(InvocationOnMock invocation) throws Throwable {
-            newProperty("test.systemName", "[TestDefaultValue]");
+                // Return the second parameter -> the default
+                return (T) invocation.getArguments()[1];
+            }
+        };
     }
 
 }

src/test/java/fr/xephi/authme/settings/custom/NewSettingsWriteTest.java

@@ -1,41 +0,0 @@
-package fr.xephi.authme.settings.custom;
-
-import org.junit.Test;
-
-import java.io.File;
-import java.net.URL;
-
-import static org.junit.Assert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
-
-/**
- * Test for the save() function of new settings
- */
-public class NewSettingsWriteTest {
-
-    private static final String CONFIG_FILE = "437-write-test.yml";
-
-    @Test
-    public void shouldWriteProperties() {
-        File file = getConfigFile();
-        NewSetting setting = new NewSetting(file);
-        setting.save();
-
-        // assert that we can load the file again -- i.e. that it's valid YAML!
-        NewSetting newSetting = new NewSetting(file);
-        assertThat(newSetting.getOption(SecuritySettings.CAPTCHA_LENGTH),
-            equalTo(SecuritySettings.CAPTCHA_LENGTH.getDefaultValue()));
-        assertThat(newSetting.getOption(ProtectionSettings.COUNTRIES_BLACKLIST),
-            equalTo(ProtectionSettings.COUNTRIES_BLACKLIST.getDefaultValue()));
-    }
-
-
-    private File getConfigFile() {
-        URL url = getClass().getClassLoader().getResource(CONFIG_FILE);
-        if (url == null) {
-            throw new RuntimeException("File '" + CONFIG_FILE + "' could not be loaded");
-        }
-        return new File(url.getFile());
-    }
-
-}

src/test/java/fr/xephi/authme/settings/custom/TestConfiguration.java

@@ -0,0 +1,46 @@
+package fr.xephi.authme.settings.custom;
+
+import fr.xephi.authme.settings.domain.Property;
+import fr.xephi.authme.settings.domain.PropertyType;
+import fr.xephi.authme.settings.domain.SettingsClass;
+
+import java.util.List;
+
+import static fr.xephi.authme.settings.domain.Property.newProperty;
+
+/**
+ * Sample properties for testing purposes.
+ */
+class TestConfiguration implements SettingsClass {
+
+    public static final Property<Integer> DURATION_IN_SECONDS =
+        newProperty("test.duration", 4);
+
+    public static final Property<String> SYSTEM_NAME =
+        newProperty("test.systemName", "[TestDefaultValue]");
+
+    public static final Property<Double> RATIO_LIMIT =
+        newProperty(PropertyType.DOUBLE, "sample.ratio.limit", 3.0);
+
+    public static final Property<List<String>> RATIO_FIELDS =
+        newProperty(PropertyType.STRING_LIST, "sample.ratio.fields", "a", "b", "c");
+
+    public static final Property<Integer> VERSION_NUMBER =
+        newProperty("version", 32046);
+
+    public static final Property<Boolean> SKIP_BORING_FEATURES =
+        newProperty("features.boring.skip", false);
+
+    public static final Property<List<String>> BORING_COLORS =
+        newProperty(PropertyType.STRING_LIST, "features.boring.colors");
+
+    public static final Property<Double> DUST_LEVEL =
+        newProperty(PropertyType.DOUBLE, "features.boring.dustLevel", 0.2);
+
+    public static final Property<Boolean> USE_COOL_FEATURES =
+        newProperty("features.cool.enabled", false);
+
+    public static final Property<List<String>> COOL_OPTIONS =
+        newProperty(PropertyType.STRING_LIST, "features.cool.options", "Sparks", "Sprinkles");
+
+}

src/test/resources/437-config-test.yml

@@ -1,44 +0,0 @@
-test:
-    duration: 22
-DataSource:
-    # What type of database do you want to use?
-    # Valid values: sqlite, mysql
-    backend: mysql
-    # Enable database caching, should improve database performance
-    caching: true
-settings:
-    # The name shown in the help messages.
-    helpHeader: AuthMeReloaded
-    GameMode:
-        # ForceSurvivalMode to player when join ?
-        ForceSurvivalMode: false
-Security:
-    SQLProblem:
-        # Stop the server if we can't contact the sql database
-        # Take care with this, if you set that to false,
-        # AuthMe automatically disable and the server is not protected!
-        stopServer: true
-    ReloadCommand:
-        # /reload support
-        useReloadCommandSupport: true
-    console:
-        # Remove spam console
-        noConsoleSpam: false
-        # Replace passwords in the console when player type a command like /login
-        removePassword: true
-    captcha:
-        # Player need to put a captcha when he fails too lot the password
-        useCaptcha: false
-        # Max allowed tries before request a captcha
-        maxLoginTry: 5
-        # Captcha length
-        captchaLength: 5
-    unsafePasswords:
-        - '123456'
-        - 'qwerty'
-        - '54321'
-Email:
-    # Email SMTP server host
-    mailSMTP: smtp.gmail.com
-    # Email SMTP server port
-    mailPort: 465

src/test/resources/437-write-test.yml

@@ -1,172 +0,0 @@
-
-
-Converter:
-    Rakamak:
-        # Rakamak file name
-        fileName: 'users.rak'
-        # Rakamak use IP?
-        useIP: false
-        # Rakamak IP file name
-        ipFileName: 'UsersIp.rak'
-    CrazyLogin:
-        # CrazyLogin database file name
-        fileName: 'accounts.db'
-
-DataSource:
-    # What type of database do you want to use?
-    # Valid values: sqlite, mysql
-    backend: 'sqlite'
-    # Enable database caching, should improve database performance
-    caching: true
-    # Database host address
-    mySQLHost: '127.0.0.1'
-    # Database port
-    mySQLPort: '3306'
-    # Username about Database Connection Infos
-    mySQLUsername: 'authme'
-    # Password about Database Connection Infos
-    mySQLPassword: '123456'
-    # Database Name, use with converters or as SQLITE database name
-    mySQLDatabase: 'authme'
-    # Table of the database
-    mySQLTablename: 'authme'
-    # Column of IDs to sort data
-    mySQLColumnId: 'id'
-    # Column for storing or checking players nickname
-    mySQLColumnName: 'username'
-    # Column for storing or checking players RealName
-    mySQLRealName: 'realname'
-    # Column for storing players passwords
-    mySQLColumnPassword: 'password'
-    # Column for storing players emails
-    mySQLColumnEmail: 'email'
-    # Column for storing if a player is logged in or not
-    mySQLColumnLogged: 'email'
-    # Column for storing players ips
-    mySQLColumnIp: 'ip'
-    # Column for storing players lastlogins
-    mySQLColumnLastLogin: 'lastlogin'
-    # Column for storing player LastLocation - X
-    mySQLlastlocX: 'x'
-    # Column for storing player LastLocation - Y
-    mySQLlastlocY: 'y'
-    # Column for storing player LastLocation - Z
-    mySQLlastlocZ: 'z'
-    # Column for storing player LastLocation - World Name
-    mySQLlastlocWorld: 'world'
-    # Enable this when you allow registration through a website
-    mySQLWebsite: false
-
-ExternalBoardOptions:
-    # Column for storing players passwords salts
-    mySQLColumnSalt: ''
-    # Column for storing players groups
-    mySQLColumnGroup: ''
-
-Email:
-    # Email SMTP server host
-    mailSMTP: 'smtp.gmail.com'
-    # Email SMTP server port
-    mailPort: 465
-    # Email account which sends the mails
-    mailAccount: ''
-    # Email account password
-    mailPassword: ''
-    # Recovery password length
-    RecoveryPasswordLength: 8
-    # Mail Subject
-    mailSubject: 'Your new AuthMe password'
-    # Like maxRegPerIP but with email
-    maxRegPerEmail: 1
-    # Recall players to add an email?
-    recallPlayers: false
-    # Delay in minute for the recall scheduler
-    delayRecall: 5
-    # Blacklist these domains for emails
-    emailBlacklisted:
-        - '10minutemail.com'
-    # Whitelist ONLY these domains for emails
-    emailWhitelisted: []
-    # Send the new password drawn in an image?
-    generateImage: false
-    # The OAuth2 token
-    emailOauth2Token: ''
-
-Hooks:
-    # Do we need to hook with multiverse for spawn checking?
-    multiverse: true
-    # Do we need to hook with BungeeCord?
-    bungeecord: false
-    # Do we need to disable Essentials SocialSpy on join?
-    disableSocialSpy: false
-    # Do we need to force /motd Essentials command on join?
-    useEssentialsMotd: false
-    # Do we need to cache custom Attributes?
-    customAttributes: false
-
-bungeecord:
-    # Send player to this BungeeCord server after register/login
-    server: ''
-
-Protection:
-    # Enable some servers protection (country based login, antibot)
-    enableProtection: false
-    # Countries allowed to join the server and register, see http://dev.bukkit.org/bukkit-plugins/authme-reloaded/pages/countries-codes/ for countries' codes
-    # PLEASE USE QUOTES!
-    countries:
-        - 'US'
-        - 'GB'
-        - 'A1'
-    # Countries not allowed to join the server and register
-    # PLEASE USE QUOTES!
-    countriesBlacklist: []
-    # Do we need to enable automatic antibot system?
-    enableAntiBot: false
-    # Max number of player allowed to login in 5 secs before enable AntiBot system automatically
-    antiBotSensibility: 5
-    # Duration in minutes of the antibot automatic system
-    antiBotDuration: 10
-
-Purge:
-    # If enabled, AuthMe automatically purges old, unused accounts
-    useAutoPurge: false
-    # Number of Days an account become Unused
-    daysBeforeRemovePlayer: 60
-    # Do we need to remove the player.dat file during purge process?
-    removePlayerDat: false
-    # Do we need to remove the Essentials/users/player.yml file during purge process?
-    removeEssentialsFiles: false
-    # World where are players.dat stores
-    defaultWorld: 'world'
-    # Do we need to remove LimitedCreative/inventories/player.yml, player_creative.yml files during purge process ?
-    removeLimitedCreativesInventories: false
-    # Do we need to remove the AntiXRayData/PlayerData/player file during purge process?
-    removeAntiXRayFile: false
-    # Do we need to remove permissions?
-    removePermissions: false
-
-Security:
-    SQLProblem:
-        # Stop the server if we can't contact the sql database
-        # Take care with this, if you set this to false,
-        # AuthMe will automatically disable and the server won't be protected!
-        stopServer: true
-    ReloadCommand:
-        # /reload support
-        useReloadCommandSupport: true
-    console:
-        # Remove spam from console?
-        noConsoleSpam: false
-        # Remove passwords from console?
-        removePassword: true
-    captcha:
-        # Player need to put a captcha when he fails too lot the password
-        useCaptcha: false
-        # Max allowed tries before request a captcha
-        maxLoginTry: 5
-        # Captcha length
-        captchaLength: 5
-    stop:
-        # Kick players before stopping the server, that allow us to save position of players
-        # and all needed information correctly without any corruption.
-        kickPlayersBeforeStopping: true

src/test/resources/config-incomplete-sample.yml

@@ -0,0 +1,27 @@
+# Test config file with missing options from TestConfiguration
+# Notice the commented out lines!
+
+test:
+    duration: 22
+#    systemName: 'Custom sys name'
+sample:
+    ratio:
+#        limit: 3.0
+        fields:
+            - 'Australia'
+            - 'Burundi'
+            - 'Colombia'
+#version: 2492
+features:
+#    boring:
+#        skip: false
+#        colors:
+#            - 'beige'
+#            - 'gray'
+#        dustLevel: 0.81
+    cool:
+#        enabled: true
+        options:
+            - 'Dinosaurs'
+            - 'Explosions'
+            - 'Big trucks'

src/test/resources/config-sample-values.yml

@@ -0,0 +1,27 @@
+# Test config file with all options
+# defined in the TestConfiguration class
+
+test:
+    duration: 22
+    systemName: 'Custom sys name'
+sample:
+    ratio:
+        limit: -4.1
+        fields:
+            - 'Australia'
+            - 'Burundi'
+            - 'Colombia'
+version: 2492
+features:
+    boring:
+        skip: false
+        colors:
+            - 'beige'
+            - 'gray'
+        dustLevel: 0.81
+    cool:
+        enabled: true
+        options:
+            - 'Dinosaurs'
+            - 'Explosions'
+            - 'Big trucks'