Add some tests, minor Checkstyle fixes

src/test/java/fr/xephi/authme/command/CommandUtilsTest.java

@@ -22,7 +22,7 @@ public class CommandUtilsTest {
 
     @BeforeClass
     public static void setUpTestCommands() {
-        commands = TestCommandsUtil.generateCommands();
+        commands = Collections.unmodifiableCollection(TestCommandsUtil.generateCommands());
     }
 
     @Test
@@ -49,10 +49,6 @@ public class CommandUtilsTest {
         assertThat(commandPath, equalTo("/authme help"));
     }
 
-
-    // ------
-    // min / max arguments
-    // ------
     @Test
     public void shouldComputeMinAndMaxOnEmptyCommand() {
         // given

src/test/java/fr/xephi/authme/command/executable/authme/BackupCommandTest.java

@@ -0,0 +1,39 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.service.BackupService;
+import org.bukkit.command.CommandSender;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Collections;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link BackupCommand}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class BackupCommandTest {
+
+    @InjectMocks
+    private BackupCommand command;
+
+    @Mock
+    private BackupService backupService;
+
+    @Test
+    public void shouldStartBackup() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Collections.emptyList());
+
+        // then
+        verify(backupService).doBackup(BackupService.BackupCause.COMMAND, sender);
+    }
+}

src/test/java/fr/xephi/authme/command/executable/authme/debug/DataStatisticsTest.java

@@ -0,0 +1,116 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import com.google.common.cache.LoadingCache;
+import fr.xephi.authme.ReflectionTestUtils;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.data.limbo.LimboPlayer;
+import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.datasource.CacheDataSource;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.initialization.HasCleanup;
+import fr.xephi.authme.initialization.Reloadable;
+import fr.xephi.authme.initialization.SettingsDependent;
+import fr.xephi.authme.initialization.factory.SingletonStore;
+import org.bukkit.command.CommandSender;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import static org.hamcrest.Matchers.containsInAnyOrder;
+import static org.hamcrest.Matchers.hasItem;
+import static org.junit.Assert.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link DataStatistics}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class DataStatisticsTest {
+
+    @InjectMocks
+    private DataStatistics dataStatistics;
+
+    @Mock
+    private DataSource dataSource;
+    @Mock
+    private PlayerCache playerCache;
+    @Mock
+    private LimboService limboService;
+    @Mock
+    private SingletonStore<Object> singletonStore;
+
+    @Before
+    public void setUpLimboCacheMap() {
+        Map<String, LimboPlayer> limboMap = new HashMap<>();
+        limboMap.put("test", mock(LimboPlayer.class));
+        ReflectionTestUtils.setField(LimboService.class, limboService, "entries", limboMap);
+    }
+
+    @Test
+    public void shouldOutputStatistics() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        given(singletonStore.retrieveAllOfType()).willReturn(mockListOfSize(Object.class, 7));
+        given(singletonStore.retrieveAllOfType(Reloadable.class)).willReturn(mockListOfSize(Reloadable.class, 4));
+        given(singletonStore.retrieveAllOfType(SettingsDependent.class)).willReturn(mockListOfSize(SettingsDependent.class, 3));
+        given(singletonStore.retrieveAllOfType(HasCleanup.class)).willReturn(mockListOfSize(HasCleanup.class, 2));
+        given(dataSource.getAccountsRegistered()).willReturn(219);
+        given(playerCache.getLogged()).willReturn(12);
+
+
+        // when
+        dataStatistics.execute(sender, Collections.emptyList());
+
+        // then
+        ArgumentCaptor<String> stringCaptor = ArgumentCaptor.forClass(String.class);
+        verify(sender, atLeastOnce()).sendMessage(stringCaptor.capture());
+        assertThat(stringCaptor.getAllValues(), containsInAnyOrder(
+            "Singleton Java classes: 7 (Reloadable: 4 / SettingsDependent: 3 / HasCleanup: 2)",
+            "LimboPlayers in memory: 1",
+            "Total players in DB: 219",
+            "PlayerCache size: 12 (= logged in players)"));
+    }
+
+    @Test
+    public void shouldOutputCachedDataSourceStatistics() {
+        // given
+        CacheDataSource cacheDataSource = mock(CacheDataSource.class);
+        LoadingCache<String, Optional<PlayerAuth>> cache = mock(LoadingCache.class);
+        given(cache.size()).willReturn(11L);
+        given(cacheDataSource.getCachedAuths()).willReturn(cache);
+        ReflectionTestUtils.setField(DataStatistics.class, dataStatistics, "dataSource", cacheDataSource);
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        dataStatistics.execute(sender, Collections.emptyList());
+
+        // then
+        ArgumentCaptor<String> stringCaptor = ArgumentCaptor.forClass(String.class);
+        verify(sender, atLeastOnce()).sendMessage(stringCaptor.capture());
+        assertThat(stringCaptor.getAllValues(), hasItem("Cached PlayerAuth objects: 11"));
+    }
+
+    private static <T> List<T> mockListOfSize(Class<T> mockClass, int size) {
+        T mock = mock(mockClass);
+        List<T> mocks = new ArrayList<>(size);
+        for (int i = 0; i < size; ++i) {
+            mocks.add(mock);
+        }
+        return mocks;
+    }
+}

src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionUtilsTest.java

@@ -5,6 +5,7 @@ import fr.xephi.authme.TestHelper;
 import fr.xephi.authme.data.limbo.LimboPlayer;
 import fr.xephi.authme.data.limbo.LimboService;
 import org.bukkit.Location;
+import org.junit.Before;
 import org.junit.Test;
 
 import java.util.HashMap;
@@ -12,6 +13,7 @@ import java.util.Map;
 import java.util.function.Function;
 
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
@@ -21,6 +23,11 @@ import static org.mockito.Mockito.mock;
  */
 public class DebugSectionUtilsTest {
 
+    @Before
+    public void initMockLogger() {
+        TestHelper.setupLogger();
+    }
+
     @Test
     public void shouldFormatLocation() {
         // given / when
@@ -66,4 +73,20 @@ public class DebugSectionUtilsTest {
         // then
         assertThat(map, sameInstance(limboMap));
     }
+
+    @Test
+    public void shouldHandleErrorGracefully() {
+        // given
+        LimboService limboService = mock(LimboService.class);
+        Map<String, LimboPlayer> limboMap = new HashMap<>();
+        ReflectionTestUtils.setField(LimboService.class, limboService, "entries", limboMap);
+
+        // when
+        Object result = DebugSectionUtils.applyToLimboPlayersMap(limboService, map -> {
+           throw new IllegalStateException();
+        });
+
+        // then
+        assertThat(result, nullValue());
+    }
 }

src/test/java/fr/xephi/authme/command/executable/changepassword/ChangePasswordCommandTest.java

@@ -19,6 +19,8 @@ import java.util.Arrays;
 import java.util.Collections;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.any;
 import static org.mockito.Mockito.eq;
@@ -106,11 +108,16 @@ public class ChangePasswordCommandTest {
         verify(management).performPasswordChange(player, oldPass, newPass);
     }
 
+    @Test
+    public void shouldDefineArgumentMismatchMessage() {
+        // given / when / then
+        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_CHANGE_PASSWORD));
+    }
+
     private Player initPlayerWithName(String name, boolean loggedIn) {
         Player player = mock(Player.class);
         when(player.getName()).thenReturn(name);
         when(playerCache.isAuthenticated(name)).thenReturn(loggedIn);
         return player;
     }
-
 }

src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java

@@ -15,6 +15,8 @@ import org.mockito.junit.MockitoJUnitRunner;
 import java.util.Arrays;
 import java.util.Collections;
 
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
@@ -73,4 +75,9 @@ public class AddEmailCommandTest {
         verify(commandService).send(sender, MessageKey.CONFIRM_EMAIL_MESSAGE);
     }
 
+    @Test
+    public void shouldDefineArgumentMismatchMessage() {
+        // given / when / then
+        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_ADD_EMAIL));
+    }
 }

src/test/java/fr/xephi/authme/command/executable/email/ChangeEmailCommandTest.java

@@ -1,5 +1,6 @@
 package fr.xephi.authme.command.executable.email;
 
+import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.Management;
 import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.CommandSender;
@@ -10,9 +11,11 @@ import org.mockito.InjectMocks;
 import org.mockito.Mock;
 import org.mockito.junit.MockitoJUnitRunner;
 
-import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
@@ -36,7 +39,7 @@ public class ChangeEmailCommandTest {
         CommandSender sender = mock(BlockCommandSender.class);
 
         // when
-        command.executeCommand(sender, new ArrayList<String>());
+        command.executeCommand(sender, Collections.emptyList());
 
         // then
         verifyZeroInteractions(management);
@@ -54,4 +57,9 @@ public class ChangeEmailCommandTest {
         verify(management).performChangeEmail(sender, "new.mail@example.org", "old_mail@example.org");
     }
 
+    @Test
+    public void shouldDefineArgumentMismatchMessage() {
+        // given / when / then
+        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_CHANGE_EMAIL));
+    }
 }

src/test/java/fr/xephi/authme/command/executable/email/EmailBaseCommandTest.java

@@ -0,0 +1,49 @@
+package fr.xephi.authme.command.executable.email;
+
+import fr.xephi.authme.command.CommandMapper;
+import fr.xephi.authme.command.FoundCommandResult;
+import fr.xephi.authme.command.help.HelpProvider;
+import org.bukkit.command.CommandSender;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Collections;
+
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link EmailBaseCommand}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class EmailBaseCommandTest {
+
+    @InjectMocks
+    private EmailBaseCommand command;
+
+    @Mock
+    private HelpProvider helpProvider;
+    @Mock
+    private CommandMapper commandMapper;
+
+    @Test
+    public void shouldDisplayHelp() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        FoundCommandResult result = mock(FoundCommandResult.class);
+        given(commandMapper.mapPartsToCommand(eq(sender), anyList())).willReturn(result);
+
+        // when
+        command.executeCommand(sender, Collections.emptyList());
+
+        // then
+        verify(commandMapper).mapPartsToCommand(sender, Collections.singletonList("email"));
+        verify(helpProvider).outputHelp(sender, result, HelpProvider.SHOW_CHILDREN);
+    }
+}

src/test/java/fr/xephi/authme/command/executable/email/RecoverEmailCommandTest.java

@@ -22,6 +22,8 @@ import org.mockito.Mock;
 
 import java.util.Collections;
 
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
@@ -208,4 +210,10 @@ public class RecoverEmailCommandTest {
         verify(dataSource).getEmail(name);
         verify(recoveryService).generateAndSendNewPassword(sender, email);
     }
+
+    @Test
+    public void shouldDefineArgumentMismatchMessage() {
+        // given / when / then
+        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_RECOVER_EMAIL));
+    }
 }

src/test/java/fr/xephi/authme/command/executable/login/LoginCommandTest.java

@@ -1,5 +1,6 @@
 package fr.xephi.authme.command.executable.login;
 
+import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.Management;
 import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.CommandSender;
@@ -13,6 +14,8 @@ import org.mockito.junit.MockitoJUnitRunner;
 import java.util.Collections;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
 import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -57,4 +60,9 @@ public class LoginCommandTest {
         verify(management).performLogin(eq(sender), eq("password"));
     }
 
+    @Test
+    public void shouldDefineArgumentMismatchMessage() {
+        // given / when / then
+        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_LOGIN));
+    }
 }

src/test/java/fr/xephi/authme/command/executable/unregister/UnregisterCommandTest.java

@@ -15,6 +15,8 @@ import org.mockito.junit.MockitoJUnitRunner;
 import java.util.Collections;
 
 import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
@@ -87,4 +89,9 @@ public class UnregisterCommandTest {
         verify(sender).sendMessage(argThat(containsString("/authme unregister <player>")));
     }
 
+    @Test
+    public void shouldDefineArgumentMismatchMessage() {
+        // given / when / then
+        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_UNREGISTER));
+    }
 }

src/test/java/fr/xephi/authme/command/help/HelpMessagesServiceTest.java

@@ -10,6 +10,7 @@ import fr.xephi.authme.message.MessageFileHandlerProvider;
 import fr.xephi.authme.permission.DefaultPermission;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 
 import java.util.Collection;
@@ -19,10 +20,13 @@ import static fr.xephi.authme.TestHelper.getJarFile;
 import static fr.xephi.authme.command.TestCommandsUtil.getCommandWithLabel;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.not;
+import static org.hamcrest.Matchers.nullValue;
 import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.Assert.assertThat;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.verify;
 
 /**
  * Test for {@link HelpMessagesService}.
@@ -46,6 +50,17 @@ public class HelpMessagesServiceTest {
         given(messageFileHandlerProvider.initializeHandler(any(Function.class))).willReturn(handler);
     }
 
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldUseExistingFileAsTextFile() {
+        // given / when / then
+        ArgumentCaptor<Function<String, String>> functionCaptor = ArgumentCaptor.forClass(Function.class);
+        verify(messageFileHandlerProvider).initializeHandler(functionCaptor.capture());
+        Function<String, String> helpFilePathBuilder = functionCaptor.getValue();
+        String defaultFilePath = helpFilePathBuilder.apply("en");
+        assertThat(getClass().getClassLoader().getResource(defaultFilePath), not(nullValue()));
+    }
+
     @Test
     public void shouldReturnLocalizedCommand() {
         // given