Create tests for admin commands

src/test/java/fr/xephi/authme/TestHelper.java

@@ -1,10 +1,15 @@
 package fr.xephi.authme;
 
+import fr.xephi.authme.command.CommandService;
+import org.mockito.ArgumentCaptor;
+
 import java.io.File;
 import java.net.URL;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 
+import static org.mockito.Mockito.verify;
+
 /**
  * AuthMe test utilities.
  */
@@ -47,4 +52,18 @@ public final class TestHelper {
         return url;
     }
 
+    /**
+     * Execute a {@link Runnable} passed to a mock's {@link CommandService#runTaskAsynchronously} method.
+     * Note that calling this method expects that there be a runnable sent to the method and will fail
+     * otherwise.
+     *
+     * @param service The mock service
+     */
+    public static void runInnerRunnable(CommandService service) {
+        ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
+        verify(service).runTaskAsynchronously(captor.capture());
+        Runnable runnable = captor.getValue();
+        runnable.run();
+    }
+
 }

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

@@ -13,6 +13,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
+import static fr.xephi.authme.TestHelper.runInnerRunnable;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.mockito.BDDMockito.given;
@@ -156,13 +157,6 @@ public class AccountsCommandTest {
         assertThat(messages[1], containsString("Tester, Lester, Taster"));
     }
 
-    private static void runInnerRunnable(CommandService service) {
-        ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);
-        verify(service).runTaskAsynchronously(captor.capture());
-        Runnable runnable = captor.getValue();
-        runnable.run();
-    }
-
     private static String[] getMessagesSentToSender(CommandSender sender, int expectedCount) {
         ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
         verify(sender, times(expectedCount)).sendMessage(captor.capture());

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

@@ -0,0 +1,38 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import org.bukkit.command.CommandSender;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Collections;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link AuthMeCommand}.
+ */
+public class AuthMeCommandTest {
+
+    @Test
+    public void shouldDisplayInformation() {
+        // given
+        ExecutableCommand command = new AuthMeCommand();
+        CommandSender sender = mock(CommandSender.class);
+        CommandService service = mock(CommandService.class);
+
+        // when
+        command.executeCommand(sender, Collections.EMPTY_LIST, service);
+
+        // then
+        ArgumentCaptor<String> messagesCaptor = ArgumentCaptor.forClass(String.class);
+        verify(sender, times(3)).sendMessage(messagesCaptor.capture());
+        assertThat(messagesCaptor.getAllValues().get(1), containsString("/authme help"));
+        assertThat(messagesCaptor.getAllValues().get(2), containsString("/authme about"));
+    }
+}

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

@@ -0,0 +1,253 @@
+package fr.xephi.authme.command.executable.authme;
+
+import com.google.common.base.Strings;
+import fr.xephi.authme.ConsoleLoggerTestInitializer;
+import fr.xephi.authme.cache.auth.PlayerAuth;
+import fr.xephi.authme.cache.auth.PlayerCache;
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.output.MessageKey;
+import fr.xephi.authme.security.PasswordSecurity;
+import fr.xephi.authme.security.crypts.HashedPassword;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
+import fr.xephi.authme.settings.properties.SecuritySettings;
+import org.bukkit.command.CommandSender;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Arrays;
+
+import static fr.xephi.authme.TestHelper.runInnerRunnable;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link ChangePasswordAdminCommand}.
+ */
+public class ChangePasswordAdminCommandTest {
+
+    private CommandService service;
+
+    @BeforeClass
+    public static void setUpLogger() {
+        ConsoleLoggerTestInitializer.setupLogger();
+    }
+
+    @Before
+    public void setUpServiceMock() {
+        service = mock(CommandService.class);
+        given(service.getProperty(RestrictionSettings.ALLOWED_PASSWORD_REGEX)).willReturn("[a-zA-Z]+");
+        given(service.getProperty(SecuritySettings.MIN_PASSWORD_LENGTH)).willReturn(3);
+        given(service.getProperty(SecuritySettings.MAX_PASSWORD_LENGTH)).willReturn(20);
+        given(service.getProperty(SecuritySettings.UNSAFE_PASSWORDS))
+            .willReturn(Arrays.asList("unsafe", "otherUnsafe"));
+    }
+
+    @Test
+    public void shouldRejectPasswordSameAsUsername() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Arrays.asList("bobby", "Bobby"), service);
+
+        // then
+        verify(service).send(sender, MessageKey.PASSWORD_IS_USERNAME_ERROR);
+        verify(service, never()).getDataSource();
+    }
+
+    @Test
+    public void shouldRejectPasswordNotMatchingPattern() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+        // service mock returns pattern a-zA-Z -> numbers should not be accepted
+        String invalidPassword = "invalid1234";
+
+        // when
+        command.executeCommand(sender, Arrays.asList("myPlayer123", invalidPassword), service);
+
+        // then
+        verify(service).send(sender, MessageKey.PASSWORD_MATCH_ERROR);
+        verify(service, never()).getDataSource();
+    }
+
+    @Test
+    public void shouldRejectTooShortPassword() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Arrays.asList("player", "ab"), service);
+
+        // then
+        verify(service).send(sender, MessageKey.INVALID_PASSWORD_LENGTH);
+        verify(service, never()).getDataSource();
+    }
+
+    @Test
+    public void shouldRejectTooLongPassword() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Arrays.asList("player", Strings.repeat("a", 30)), service);
+
+        // then
+        verify(service).send(sender, MessageKey.INVALID_PASSWORD_LENGTH);
+        verify(service, never()).getDataSource();
+    }
+
+    @Test
+    public void shouldRejectUnsafePassword() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Arrays.asList("player", "unsafe"), service);
+
+        // then
+        verify(service).send(sender, MessageKey.PASSWORD_UNSAFE_ERROR);
+        verify(service, never()).getDataSource();
+    }
+
+    @Test
+    public void shouldRejectCommandForUnknownUser() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+        String player = "player";
+
+        PlayerCache playerCache = mock(PlayerCache.class);
+        given(playerCache.isAuthenticated(player)).willReturn(false);
+        given(service.getPlayerCache()).willReturn(playerCache);
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(player)).willReturn(null);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        // when
+        command.executeCommand(sender, Arrays.asList(player, "password"), service);
+        runInnerRunnable(service);
+
+        // then
+        verify(service).send(sender, MessageKey.UNKNOWN_USER);
+        verify(dataSource, never()).updatePassword(any(PlayerAuth.class));
+    }
+
+    @Test
+    public void shouldUpdatePasswordOfLoggedInUser() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        String player = "my_user12";
+        String password = "passPass";
+        PlayerAuth auth = mock(PlayerAuth.class);
+
+        PlayerCache playerCache = mock(PlayerCache.class);
+        given(playerCache.isAuthenticated(player)).willReturn(true);
+        given(playerCache.getAuth(player)).willReturn(auth);
+        given(service.getPlayerCache()).willReturn(playerCache);
+
+        PasswordSecurity passwordSecurity = mock(PasswordSecurity.class);
+        HashedPassword hashedPassword = mock(HashedPassword.class);
+        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
+        given(service.getPasswordSecurity()).willReturn(passwordSecurity);
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.updatePassword(auth)).willReturn(true);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        // when
+        command.executeCommand(sender, Arrays.asList(player, password), service);
+        runInnerRunnable(service);
+
+        // then
+        verify(service).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
+        verify(passwordSecurity).computeHash(password, player);
+        verify(auth).setPassword(hashedPassword);
+        verify(dataSource).updatePassword(auth);
+    }
+
+    @Test
+    public void shouldUpdatePasswordOfOfflineUser() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        String player = "my_user12";
+        String password = "passPass";
+        PlayerAuth auth = mock(PlayerAuth.class);
+
+        PlayerCache playerCache = mock(PlayerCache.class);
+        given(playerCache.isAuthenticated(player)).willReturn(false);
+        given(service.getPlayerCache()).willReturn(playerCache);
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.isAuthAvailable(player)).willReturn(true);
+        given(dataSource.getAuth(player)).willReturn(auth);
+        given(dataSource.updatePassword(auth)).willReturn(true);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        PasswordSecurity passwordSecurity = mock(PasswordSecurity.class);
+        HashedPassword hashedPassword = mock(HashedPassword.class);
+        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
+        given(service.getPasswordSecurity()).willReturn(passwordSecurity);
+
+        // when
+        command.executeCommand(sender, Arrays.asList(player, password), service);
+        runInnerRunnable(service);
+
+        // then
+        verify(service).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
+        verify(passwordSecurity).computeHash(password, player);
+        verify(auth).setPassword(hashedPassword);
+        verify(dataSource).updatePassword(auth);
+    }
+
+    @Test
+    public void shouldReportWhenSaveFailed() {
+        // given
+        ExecutableCommand command = new ChangePasswordAdminCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        String player = "my_user12";
+        String password = "passPass";
+        PlayerAuth auth = mock(PlayerAuth.class);
+
+        PlayerCache playerCache = mock(PlayerCache.class);
+        given(playerCache.isAuthenticated(player)).willReturn(true);
+        given(playerCache.getAuth(player)).willReturn(auth);
+        given(service.getPlayerCache()).willReturn(playerCache);
+
+        PasswordSecurity passwordSecurity = mock(PasswordSecurity.class);
+        HashedPassword hashedPassword = mock(HashedPassword.class);
+        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
+        given(service.getPasswordSecurity()).willReturn(passwordSecurity);
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.updatePassword(auth)).willReturn(false);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        // when
+        command.executeCommand(sender, Arrays.asList(player, password), service);
+        runInnerRunnable(service);
+
+        // then
+        verify(service).send(sender, MessageKey.ERROR);
+        verify(passwordSecurity).computeHash(password, player);
+        verify(auth).setPassword(hashedPassword);
+        verify(dataSource).updatePassword(auth);
+    }
+
+}

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

@@ -0,0 +1,65 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.settings.SpawnLoader;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.Assert.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link FirstSpawnCommand}.
+ */
+public class FirstSpawnCommandTest {
+
+    @Test
+    public void shouldTeleportToFirstSpawn() {
+        // given
+        Location firstSpawn = mock(Location.class);
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.getFirstSpawn()).willReturn(firstSpawn);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+        Player player = mock(Player.class);
+        ExecutableCommand command = new FirstSpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(player).teleport(firstSpawn);
+        verify(spawnLoader, atLeastOnce()).getFirstSpawn();
+    }
+
+    @Test
+    public void shouldHandleMissingFirstSpawn() {
+        // given
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.getFirstSpawn()).willReturn(null);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+        Player player = mock(Player.class);
+        ExecutableCommand command = new FirstSpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(player).sendMessage(captor.capture());
+        assertThat(captor.getValue(), containsString("spawn has failed"));
+        verify(player, never()).teleport(any(Location.class));
+    }
+}

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

@@ -0,0 +1,68 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.cache.auth.PlayerAuth;
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.output.MessageKey;
+import org.bukkit.command.CommandSender;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.Assert.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link GetEmailCommand}.
+ */
+public class GetEmailCommandTest {
+
+    @Test
+    public void shouldReportUnknownUser() {
+        // given
+        String user = "myTestUser";
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(user)).willReturn(null);
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        CommandSender sender = mock(CommandSender.class);
+        ExecutableCommand command = new GetEmailCommand();
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(user), service);
+
+        // then
+        verify(service).send(sender, MessageKey.UNKNOWN_USER);
+    }
+
+    @Test
+    public void shouldReturnEmail() {
+        // given
+        String user = "userToView";
+        String email = "user.email@example.org";
+        PlayerAuth auth = mock(PlayerAuth.class);
+        given(auth.getEmail()).willReturn(email);
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(user)).willReturn(auth);
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        CommandSender sender = mock(CommandSender.class);
+        ExecutableCommand command = new GetEmailCommand();
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(user), service);
+
+        // then
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender).sendMessage(captor.capture());
+        assertThat(captor.getValue(), containsString(email));
+    }
+}

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

@@ -0,0 +1,119 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.cache.auth.PlayerAuth;
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.output.MessageKey;
+import org.bukkit.command.CommandSender;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Collections;
+import java.util.Date;
+
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.Assert.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link LastLoginCommand}.
+ */
+public class LastLoginCommandTest {
+
+    private static final long HOUR_IN_MSEC = 3600 * 1000;
+    private static final long DAY_IN_MSEC = 24 * HOUR_IN_MSEC;
+
+    @Test
+    public void shouldRejectNonExistentUser() {
+        // given
+        String player = "tester";
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(player)).willReturn(null);
+
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        CommandSender sender = mock(CommandSender.class);
+        ExecutableCommand command = new LastLoginCommand();
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(player), service);
+
+        // then
+        verify(dataSource).getAuth(player);
+        verify(service).send(sender, MessageKey.USER_NOT_REGISTERED);
+    }
+
+    @Test
+    public void shouldDisplayLastLoginOfUser() {
+        // given
+        String player = "SomePlayer";
+        long lastLogin = System.currentTimeMillis() -
+            (412 * DAY_IN_MSEC + 10 * HOUR_IN_MSEC - 9000);
+        PlayerAuth auth = mock(PlayerAuth.class);
+        given(auth.getLastLogin()).willReturn(lastLogin);
+        given(auth.getIp()).willReturn("123.45.66.77");
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(player)).willReturn(auth);
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        CommandSender sender = mock(CommandSender.class);
+        ExecutableCommand command = new LastLoginCommand();
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(player), service);
+
+        // then
+        verify(dataSource).getAuth(player);
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender, times(3)).sendMessage(captor.capture());
+        String lastLoginString = new Date(lastLogin).toString();
+        assertThat(captor.getAllValues().get(0),
+            allOf(containsString(player), containsString(lastLoginString)));
+        assertThat(captor.getAllValues().get(1), containsString("412 days 9 hours"));
+        assertThat(captor.getAllValues().get(2), containsString("123.45.66.77"));
+    }
+
+    @Test
+    public void shouldDisplayLastLoginOfCommandSender() {
+        // given
+        String name = "CommandSender";
+        CommandSender sender = mock(CommandSender.class);
+        given(sender.getName()).willReturn(name);
+
+        long lastLogin = System.currentTimeMillis() -
+            (412 * DAY_IN_MSEC + 10 * HOUR_IN_MSEC - 9000);
+        PlayerAuth auth = mock(PlayerAuth.class);
+        given(auth.getLastLogin()).willReturn(lastLogin);
+        given(auth.getIp()).willReturn("123.45.66.77");
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(name)).willReturn(auth);
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+
+        ExecutableCommand command = new LastLoginCommand();
+
+        // when
+        command.executeCommand(sender, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(dataSource).getAuth(name);
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender, times(3)).sendMessage(captor.capture());
+        String lastLoginString = new Date(lastLogin).toString();
+        assertThat(captor.getAllValues().get(0),
+            allOf(containsString(name), containsString(lastLoginString)));
+        assertThat(captor.getAllValues().get(1), containsString("412 days 9 hours"));
+        assertThat(captor.getAllValues().get(2), containsString("123.45.66.77"));
+    }
+
+}

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

@@ -0,0 +1,124 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.cache.auth.PlayerAuth;
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.output.MessageKey;
+import org.bukkit.command.CommandSender;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link PurgeLastPositionCommand}.
+ */
+public class PurgeLastPositionCommandTest {
+
+    @Test
+    public void shouldPurgeLastPosOfUser() {
+        // given
+        String player = "_Bobby";
+        PlayerAuth auth = mock(PlayerAuth.class);
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(player)).willReturn(auth);
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        CommandSender sender = mock(CommandSender.class);
+        ExecutableCommand command = new PurgeLastPositionCommand();
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(player), service);
+
+        // then
+        verify(dataSource).getAuth(player);
+        verifyPositionWasReset(auth);
+        verify(sender).sendMessage(argThat(containsString("last position location is now reset")));
+    }
+
+    @Test
+    public void shouldPurgePositionOfCommandSender() {
+        // given
+        String player = "_Bobby";
+        CommandSender sender = mock(CommandSender.class);
+        given(sender.getName()).willReturn(player);
+
+        PlayerAuth auth = mock(PlayerAuth.class);
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAuth(player)).willReturn(auth);
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        ExecutableCommand command = new PurgeLastPositionCommand();
+
+        // when
+        command.executeCommand(sender, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(dataSource).getAuth(player);
+        verifyPositionWasReset(auth);
+        verify(sender).sendMessage(argThat(containsString("position location is now reset")));
+    }
+
+    @Test
+    public void shouldHandleNonExistentUser() {
+        // given
+        DataSource dataSource = mock(DataSource.class);
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        ExecutableCommand command = new PurgeLastPositionCommand();
+        CommandSender sender = mock(CommandSender.class);
+        String name = "invalidPlayer";
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(name), service);
+
+        // then
+        verify(dataSource).getAuth(name);
+        verify(service).send(sender, MessageKey.UNKNOWN_USER);
+    }
+
+    @Test
+    public void shouldResetAllLastPositions() {
+        // given
+        PlayerAuth auth1 = mock(PlayerAuth.class);
+        PlayerAuth auth2 = mock(PlayerAuth.class);
+        PlayerAuth auth3 = mock(PlayerAuth.class);
+
+        DataSource dataSource = mock(DataSource.class);
+        given(dataSource.getAllAuths()).willReturn(Arrays.asList(auth1, auth2, auth3));
+        CommandService service = mock(CommandService.class);
+        given(service.getDataSource()).willReturn(dataSource);
+
+        ExecutableCommand command = new PurgeLastPositionCommand();
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Collections.singletonList("*"), service);
+
+        // then
+        verify(dataSource).getAllAuths();
+        verifyPositionWasReset(auth1);
+        verifyPositionWasReset(auth2);
+        verifyPositionWasReset(auth3);
+        verify(sender).sendMessage(argThat(containsString("last position locations are now reset")));
+    }
+
+
+    private static void verifyPositionWasReset(PlayerAuth auth) {
+        verify(auth).setQuitLocX(0);
+        verify(auth).setQuitLocY(0);
+        verify(auth).setQuitLocZ(0);
+        verify(auth).setWorld("world");
+    }
+}

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

@@ -0,0 +1,65 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.AuthMe;
+import fr.xephi.authme.ConsoleLoggerTestInitializer;
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.output.MessageKey;
+import org.bukkit.command.CommandSender;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Collections;
+
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.matches;
+import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link ReloadCommand}.
+ */
+public class ReloadCommandTest {
+
+    @BeforeClass
+    public static void setUpLogger() {
+        ConsoleLoggerTestInitializer.setupLogger();
+    }
+
+    @Test
+    public void shouldReload() throws Exception {
+        // given
+        AuthMe authMe = mock(AuthMe.class);
+        CommandService service = mock(CommandService.class);
+        given(service.getAuthMe()).willReturn(authMe);
+        CommandSender sender = mock(CommandSender.class);
+        ExecutableCommand command = new ReloadCommand();
+
+        // when
+        command.executeCommand(sender, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(authMe).reload();
+        verify(service).send(sender, MessageKey.CONFIG_RELOAD_SUCCESS);
+    }
+
+    @Test
+    public void shouldHandleReloadError() throws Exception {
+        // given
+        AuthMe authMe = mock(AuthMe.class);
+        doThrow(IllegalStateException.class).when(authMe).reload();
+        CommandService service = mock(CommandService.class);
+        given(service.getAuthMe()).willReturn(authMe);
+        CommandSender sender = mock(CommandSender.class);
+        ExecutableCommand command = new ReloadCommand();
+
+        // when
+        command.executeCommand(sender, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(authMe).reload();
+        verify(sender).sendMessage(matches("Error occurred.*"));
+        verify(authMe).stopOrUnload();
+    }
+}

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

@@ -0,0 +1,66 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.settings.SpawnLoader;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.junit.Test;
+
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link SetFirstSpawnCommand}.
+ */
+public class SetFirstSpawnCommandTest {
+
+    @Test
+    public void shouldSetFirstSpawn() {
+        // given
+        Player player = mock(Player.class);
+        Location location = mock(Location.class);
+        given(player.getLocation()).willReturn(location);
+
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.setFirstSpawn(location)).willReturn(true);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+
+        ExecutableCommand command = new SetFirstSpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(spawnLoader).setFirstSpawn(location);
+        verify(player).sendMessage(argThat(containsString("defined new first spawn")));
+    }
+
+    @Test
+    public void shouldHandleError() {
+        // given
+        Player player = mock(Player.class);
+        Location location = mock(Location.class);
+        given(player.getLocation()).willReturn(location);
+
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.setFirstSpawn(location)).willReturn(false);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+
+        ExecutableCommand command = new SetFirstSpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(spawnLoader).setFirstSpawn(location);
+        verify(player).sendMessage(argThat(containsString("has failed")));
+    }
+}

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

@@ -0,0 +1,66 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.settings.SpawnLoader;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.junit.Test;
+
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link SetSpawnCommand}.
+ */
+public class SetSpawnCommandTest {
+
+    @Test
+    public void shouldSetSpawn() {
+        // given
+        Player player = mock(Player.class);
+        Location location = mock(Location.class);
+        given(player.getLocation()).willReturn(location);
+
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.setSpawn(location)).willReturn(true);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+
+        ExecutableCommand command = new SetSpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(spawnLoader).setSpawn(location);
+        verify(player).sendMessage(argThat(containsString("defined new spawn")));
+    }
+
+    @Test
+    public void shouldHandleError() {
+        // given
+        Player player = mock(Player.class);
+        Location location = mock(Location.class);
+        given(player.getLocation()).willReturn(location);
+
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.setSpawn(location)).willReturn(false);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+
+        ExecutableCommand command = new SetSpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(spawnLoader).setSpawn(location);
+        verify(player).sendMessage(argThat(containsString("has failed")));
+    }
+}

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

@@ -0,0 +1,65 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.command.ExecutableCommand;
+import fr.xephi.authme.settings.SpawnLoader;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.junit.Assert.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link SpawnCommand}.
+ */
+public class SpawnCommandTest {
+
+    @Test
+    public void shouldTeleportToSpawn() {
+        // given
+        Location spawn = mock(Location.class);
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.getSpawn()).willReturn(spawn);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+        Player player = mock(Player.class);
+        ExecutableCommand command = new SpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        verify(player).teleport(spawn);
+        verify(spawnLoader, atLeastOnce()).getSpawn();
+    }
+
+    @Test
+    public void shouldHandleMissingSpawn() {
+        // given
+        SpawnLoader spawnLoader = mock(SpawnLoader.class);
+        given(spawnLoader.getSpawn()).willReturn(null);
+        CommandService service = mock(CommandService.class);
+        given(service.getSpawnLoader()).willReturn(spawnLoader);
+        Player player = mock(Player.class);
+        ExecutableCommand command = new FirstSpawnCommand();
+
+        // when
+        command.executeCommand(player, Collections.EMPTY_LIST, service);
+
+        // then
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(player).sendMessage(captor.capture());
+        assertThat(captor.getValue(), containsString("spawn has failed"));
+        verify(player, never()).teleport(any(Location.class));
+    }
+}