#1347 Adapt tests for new change password architecture

src/main/java/fr/xephi/authme/command/executable/authme/ChangePasswordAdminCommand.java

@@ -1,11 +1,7 @@
 package fr.xephi.authme.command.executable.authme;
 
 import fr.xephi.authme.command.ExecutableCommand;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.process.Management;
-import fr.xephi.authme.security.PasswordSecurity;
-import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.ValidationService;
 import fr.xephi.authme.service.ValidationService.ValidationResult;
@@ -19,18 +15,6 @@ import java.util.List;
  */
 public class ChangePasswordAdminCommand implements ExecutableCommand {
 
-    @Inject
-    private PasswordSecurity passwordSecurity;
-
-    @Inject
-    private PlayerCache playerCache;
-
-    @Inject
-    private DataSource dataSource;
-
-    @Inject
-    private BukkitService bukkitService;
-
     @Inject
     private ValidationService validationService;
 
@@ -41,7 +25,7 @@ public class ChangePasswordAdminCommand implements ExecutableCommand {
     private Management management;
 
     @Override
-    public void executeCommand(final CommandSender sender, List<String> arguments) {
+    public void executeCommand(CommandSender sender, List<String> arguments) {
         // Get the player and password
         final String playerName = arguments.get(0);
         final String playerPass = arguments.get(1);
@@ -50,10 +34,8 @@ public class ChangePasswordAdminCommand implements ExecutableCommand {
         ValidationResult validationResult = validationService.validatePassword(playerPass, playerName);
         if (validationResult.hasError()) {
             commonService.send(sender, validationResult.getMessageKey(), validationResult.getArgs());
-            return;
+        } else {
+            management.performPasswordChangeAsAdmin(sender, playerName, playerPass);
         }
-
-        // Set the password
-        management.performPasswordChangeAsAdmin(sender, playerName, playerPass);
     }
 }

src/main/java/fr/xephi/authme/process/changepassword/AsyncChangePassword.java

@@ -68,7 +68,7 @@ public class AsyncChangePassword implements AsynchronousProcess {
     public void changePasswordAsAdmin(CommandSender sender, final String playerName, String newPassword) {
         final String lowerCaseName = playerName.toLowerCase();
         if (!(playerCache.isAuthenticated(lowerCaseName) || dataSource.isAuthAvailable(lowerCaseName))) {
-            if(sender == null) {
+            if (sender == null) {
                 ConsoleLogger.warning("Tried to change password for user " + lowerCaseName + " but it doesn't exist!");
             } else {
                 commonService.send(sender, MessageKey.UNKNOWN_USER);
@@ -78,14 +78,14 @@ public class AsyncChangePassword implements AsynchronousProcess {
 
         HashedPassword hashedPassword = passwordSecurity.computeHash(newPassword, lowerCaseName);
         if (dataSource.updatePassword(lowerCaseName, hashedPassword)) {
-            if(sender != null) {
+            if (sender != null) {
                 commonService.send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
                 ConsoleLogger.info(sender.getName() + " changed password of " + lowerCaseName);
             } else {
                 ConsoleLogger.info("Changed password of " + lowerCaseName);
             }
         } else {
-            if(sender != null) {
+            if (sender != null) {
                 commonService.send(sender, MessageKey.ERROR);
             }
             ConsoleLogger.warning("An error occurred while changing password for user " + lowerCaseName + "!");

src/test/java/fr/xephi/authme/api/v3/AuthMeApiTest.java

@@ -280,6 +280,19 @@ public class AuthMeApiTest {
         verify(management).performUnregisterByAdmin(null, name, player);
     }
 
+    @Test
+    public void shouldChangePassword() {
+        // given
+        String name = "Bobby12";
+        String password = "resetPw!";
+
+        // when
+        api.changePassword(name, password);
+
+        // then
+        verify(management).performPasswordChangeAsAdmin(null, name, password);
+    }
+
     private static Player mockPlayerWithName(String name) {
         Player player = mock(Player.class);
         given(player.getName()).willReturn(name);

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

@@ -1,19 +1,11 @@
 package fr.xephi.authme.command.executable.authme;
 
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.Management;
-import fr.xephi.authme.security.PasswordSecurity;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.ValidationService;
 import fr.xephi.authme.service.ValidationService.ValidationResult;
 import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.InjectMocks;
@@ -22,11 +14,8 @@ import org.mockito.junit.MockitoJUnitRunner;
 
 import java.util.Arrays;
 
-import static fr.xephi.authme.TestHelper.runOptionallyAsyncTask;
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.verifyZeroInteractions;
 
@@ -40,19 +29,7 @@ public class ChangePasswordAdminCommandTest {
     private ChangePasswordAdminCommand command;
 
     @Mock
-    private CommonService service;
+    private CommonService commonService;
-
-    @Mock
-    private PasswordSecurity passwordSecurity;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private BukkitService bukkitService;
 
     @Mock
     private ValidationService validationService;
@@ -60,112 +37,37 @@ public class ChangePasswordAdminCommandTest {
     @Mock
     private Management management;
 
-    @BeforeClass
+    @Test
-    public static void setUpLogger() {
+    public void shouldForwardRequestToManagement() {
-        TestHelper.setupLogger();
+        // given
+        String name = "theUser";
+        String pass = "newPassword";
+        given(validationService.validatePassword(pass, name)).willReturn(new ValidationResult());
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Arrays.asList(name, pass));
+
+        // then
+        verify(validationService).validatePassword(pass, name);
+        verify(management).performPasswordChangeAsAdmin(sender, name, pass);
     }
 
     @Test
-    public void shouldRejectInvalidPassword() {
+    public void shouldSendErrorToCommandSender() {
         // given
+        String name = "theUser";
+        String pass = "newPassword";
+        given(validationService.validatePassword(pass, name)).willReturn(
+            new ValidationResult(MessageKey.INVALID_PASSWORD_LENGTH, "7"));
         CommandSender sender = mock(CommandSender.class);
-        given(validationService.validatePassword("Bobby", "bobby")).willReturn(
-            new ValidationResult(MessageKey.PASSWORD_IS_USERNAME_ERROR));
 
         // when
-        command.executeCommand(sender, Arrays.asList("bobby", "Bobby"));
+        command.executeCommand(sender, Arrays.asList(name, pass));
 
         // then
-        verify(validationService).validatePassword("Bobby", "bobby");
+        verify(validationService).validatePassword(pass, name);
-        verify(service).send(sender, MessageKey.PASSWORD_IS_USERNAME_ERROR, new String[0]);
+        verify(commonService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH, "7");
-        verifyZeroInteractions(dataSource);
+        verifyZeroInteractions(management);
     }
-
-    @Test
-    public void shouldRejectCommandForUnknownUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "player";
-        String password = "password";
-        given(playerCache.isAuthenticated(player)).willReturn(false);
-        given(validationService.validatePassword(password, player)).willReturn(new ValidationResult());
-
-        // when
-        command.executeCommand(sender, Arrays.asList(player, password));
-
-        // then
-        verify(service).send(sender, MessageKey.UNKNOWN_USER);
-        verify(dataSource, never()).updatePassword(any(PlayerAuth.class));
-    }
-
-    @Test
-    public void shouldUpdatePasswordOfLoggedInUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "my_user12";
-        String password = "passPass";
-        given(playerCache.isAuthenticated(player)).willReturn(true);
-
-        HashedPassword hashedPassword = mock(HashedPassword.class);
-        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
-        given(dataSource.updatePassword(player, hashedPassword)).willReturn(true);
-        given(validationService.validatePassword(password, player)).willReturn(new ValidationResult());
-
-        // when
-        command.executeCommand(sender, Arrays.asList(player, password));
-
-        // then
-        verify(validationService).validatePassword(password, player);
-        verify(service).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
-        verify(passwordSecurity).computeHash(password, player);
-        verify(dataSource).updatePassword(player, hashedPassword);
-    }
-
-    @Test
-    public void shouldUpdatePasswordOfOfflineUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "my_user12";
-        String password = "passPass";
-        given(playerCache.isAuthenticated(player)).willReturn(false);
-        given(dataSource.isAuthAvailable(player)).willReturn(true);
-        given(validationService.validatePassword(password, player)).willReturn(new ValidationResult());
-
-        HashedPassword hashedPassword = mock(HashedPassword.class);
-        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
-        given(dataSource.updatePassword(player, hashedPassword)).willReturn(true);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(player, password));
-
-        // then
-        verify(validationService).validatePassword(password, player);
-        verify(service).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
-        verify(passwordSecurity).computeHash(password, player);
-        verify(dataSource).updatePassword(player, hashedPassword);
-    }
-
-    @Test
-    public void shouldReportWhenSaveFailed() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "my_user12";
-        String password = "passPass";
-        given(playerCache.isAuthenticated(player)).willReturn(true);
-        given(validationService.validatePassword(password, player)).willReturn(new ValidationResult());
-
-        HashedPassword hashedPassword = mock(HashedPassword.class);
-        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
-        given(dataSource.updatePassword(player, hashedPassword)).willReturn(false);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(player, password));
-
-        // then
-        verify(validationService).validatePassword(password, player);
-        verify(service).send(sender, MessageKey.ERROR);
-        verify(passwordSecurity).computeHash(password, player);
-        verify(dataSource).updatePassword(player, hashedPassword);
-    }
-
 }

src/test/java/fr/xephi/authme/process/changepassword/AsyncChangePasswordTest.java

@@ -0,0 +1,127 @@
+package fr.xephi.authme.process.changepassword;
+
+import fr.xephi.authme.TestHelper;
+import fr.xephi.authme.data.auth.PlayerCache;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.security.PasswordSecurity;
+import fr.xephi.authme.security.crypts.HashedPassword;
+import fr.xephi.authme.service.CommonService;
+import org.bukkit.command.CommandSender;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.only;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link AsyncChangePassword}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class AsyncChangePasswordTest {
+
+    @InjectMocks
+    private AsyncChangePassword asyncChangePassword;
+
+    @Mock
+    private CommonService commonService;
+    @Mock
+    private DataSource dataSource;
+    @Mock
+    private PlayerCache playerCache;
+    @Mock
+    private PasswordSecurity passwordSecurity;
+
+    @Before
+    public void setUpLogger() {
+        TestHelper.setupLogger();
+    }
+
+    @Test
+    public void shouldRejectCommandForUnknownUser() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        String player = "player";
+        String password = "password";
+        given(playerCache.isAuthenticated(player)).willReturn(false);
+        given(dataSource.isAuthAvailable(player)).willReturn(false);
+
+        // when
+        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
+
+        // then
+        verify(commonService).send(sender, MessageKey.UNKNOWN_USER);
+        verify(dataSource, only()).isAuthAvailable(player);
+    }
+
+    @Test
+    public void shouldUpdatePasswordOfLoggedInUser() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        String player = "my_user12";
+        String password = "passPass";
+        given(playerCache.isAuthenticated(player)).willReturn(true);
+
+        HashedPassword hashedPassword = mock(HashedPassword.class);
+        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
+        given(dataSource.updatePassword(player, hashedPassword)).willReturn(true);
+
+        // when
+        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
+
+        // then
+        verify(commonService).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
+        verify(passwordSecurity).computeHash(password, player);
+        verify(dataSource).updatePassword(player, hashedPassword);
+    }
+
+    @Test
+    public void shouldUpdatePasswordOfOfflineUser() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        String player = "my_user12";
+        String password = "passPass";
+        given(playerCache.isAuthenticated(player)).willReturn(false);
+        given(dataSource.isAuthAvailable(player)).willReturn(true);
+
+        HashedPassword hashedPassword = mock(HashedPassword.class);
+        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
+        given(dataSource.updatePassword(player, hashedPassword)).willReturn(true);
+
+        // when
+        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
+
+        // then
+        verify(commonService).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
+        verify(passwordSecurity).computeHash(password, player);
+        verify(dataSource).updatePassword(player, hashedPassword);
+    }
+
+    @Test
+    public void shouldReportWhenSaveFailed() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        String player = "my_user12";
+        String password = "passPass";
+        given(playerCache.isAuthenticated(player)).willReturn(true);
+
+        HashedPassword hashedPassword = mock(HashedPassword.class);
+        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
+        given(dataSource.updatePassword(player, hashedPassword)).willReturn(false);
+
+        // when
+        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
+
+        // then
+        verify(commonService).send(sender, MessageKey.ERROR);
+        verify(passwordSecurity).computeHash(password, player);
+        verify(dataSource).updatePassword(player, hashedPassword);
+    }
+
+}