#306 Add tests for CommandHandler and CommandMapper

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

@@ -1,5 +1,6 @@
 package fr.xephi.authme.command;
 
+import fr.xephi.authme.permission.PermissionsManager;
 import org.bukkit.command.CommandSender;
 import org.junit.Before;
 import org.junit.Test;
@@ -7,10 +8,14 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Captor;
 import org.mockito.MockitoAnnotations;
 
+import java.util.Collections;
 import java.util.List;
 
+import static fr.xephi.authme.command.FoundResultStatus.INCORRECT_ARGUMENTS;
+import static fr.xephi.authme.command.FoundResultStatus.MISSING_BASE_COMMAND;
 import static fr.xephi.authme.command.FoundResultStatus.NO_PERMISSION;
 import static fr.xephi.authme.command.FoundResultStatus.SUCCESS;
+import static fr.xephi.authme.command.FoundResultStatus.UNKNOWN_LABEL;
 import static java.util.Arrays.asList;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.contains;
@@ -20,8 +25,10 @@ import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.anyListOf;
 import static org.mockito.Matchers.anyString;
 import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.atLeastOnce;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
 /**
@@ -95,6 +102,135 @@ public class CommandHandlerTest {
         assertThat(captor.getValue(), containsString("don't have permission"));
     }
 
+    @Test
+    public void shouldNotCallExecutableForWrongArguments() {
+        // given
+        String bukkitLabel = "unreg";
+        String[] bukkitArgs = {"testPlayer"};
+        CommandSender sender = mock(CommandSender.class);
+        CommandDescription command = mock(CommandDescription.class);
+        given(serviceMock.mapPartsToCommand(any(CommandSender.class), anyListOf(String.class))).willReturn(
+            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, INCORRECT_ARGUMENTS));
+        PermissionsManager permissionsManager = mock(PermissionsManager.class);
+        given(permissionsManager.hasPermission(sender, command)).willReturn(true);
+        given(serviceMock.getPermissionsManager()).willReturn(permissionsManager);
+
+        // when
+        handler.processCommand(sender, bukkitLabel, bukkitArgs);
+
+        // then
+        verify(serviceMock).mapPartsToCommand(eq(sender), captor.capture());
+        assertThat(captor.getValue(), contains("unreg", "testPlayer"));
+
+        verify(command, never()).getExecutableCommand();
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender, atLeastOnce()).sendMessage(captor.capture());
+        assertThat(captor.getAllValues().get(0), containsString("Incorrect command arguments"));
+    }
+
+    @Test
+    public void shouldNotCallExecutableForWrongArgumentsAndPermissionDenied() {
+        // given
+        String bukkitLabel = "unreg";
+        String[] bukkitArgs = {"testPlayer"};
+        CommandSender sender = mock(CommandSender.class);
+        CommandDescription command = mock(CommandDescription.class);
+        given(serviceMock.mapPartsToCommand(any(CommandSender.class), anyListOf(String.class))).willReturn(
+            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, INCORRECT_ARGUMENTS));
+        PermissionsManager permissionsManager = mock(PermissionsManager.class);
+        given(permissionsManager.hasPermission(sender, command)).willReturn(false);
+        given(serviceMock.getPermissionsManager()).willReturn(permissionsManager);
+
+        // when
+        handler.processCommand(sender, bukkitLabel, bukkitArgs);
+
+        // then
+        verify(serviceMock).mapPartsToCommand(eq(sender), captor.capture());
+        assertThat(captor.getValue(), contains("unreg", "testPlayer"));
+
+        verify(command, never()).getExecutableCommand();
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender).sendMessage(captor.capture());
+        assertThat(captor.getValue(), containsString("You don't have permission"));
+    }
+
+    @Test
+    public void shouldNotCallExecutableForFailedParsing() {
+        // given
+        String bukkitLabel = "unreg";
+        String[] bukkitArgs = {"testPlayer"};
+        CommandSender sender = mock(CommandSender.class);
+        CommandDescription command = mock(CommandDescription.class);
+        given(serviceMock.mapPartsToCommand(any(CommandSender.class), anyListOf(String.class))).willReturn(
+            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, MISSING_BASE_COMMAND));
+
+        // when
+        handler.processCommand(sender, bukkitLabel, bukkitArgs);
+
+        // then
+        verify(serviceMock).mapPartsToCommand(eq(sender), captor.capture());
+        assertThat(captor.getValue(), contains("unreg", "testPlayer"));
+
+        verify(command, never()).getExecutableCommand();
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender).sendMessage(captor.capture());
+        assertThat(captor.getValue(), containsString("Failed to parse"));
+    }
+
+    @Test
+    public void shouldNotCallExecutableForUnknownLabelAndHaveSuggestion() {
+        // given
+        String bukkitLabel = "unreg";
+        String[] bukkitArgs = {"testPlayer"};
+        CommandSender sender = mock(CommandSender.class);
+        CommandDescription command = mock(CommandDescription.class);
+        given(command.getLabels()).willReturn(Collections.singletonList("test_cmd"));
+        given(serviceMock.mapPartsToCommand(any(CommandSender.class), anyListOf(String.class))).willReturn(
+            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.01, UNKNOWN_LABEL));
+
+        // when
+        handler.processCommand(sender, bukkitLabel, bukkitArgs);
+
+        // then
+        verify(serviceMock).mapPartsToCommand(eq(sender), captor.capture());
+        assertThat(captor.getValue(), contains("unreg", "testPlayer"));
+
+        verify(command, never()).getExecutableCommand();
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender, times(3)).sendMessage(captor.capture());
+        assertThat(captor.getAllValues().get(0), containsString("Unknown command"));
+        assertThat(captor.getAllValues().get(1), containsString("Did you mean"));
+        assertThat(captor.getAllValues().get(1), containsString("/test_cmd"));
+        assertThat(captor.getAllValues().get(2), containsString("Use the command"));
+        assertThat(captor.getAllValues().get(2), containsString("to view help"));
+    }
+
+    @Test
+    public void shouldNotCallExecutableForUnknownLabelAndNotSuggestCommand() {
+        // given
+        String bukkitLabel = "unreg";
+        String[] bukkitArgs = {"testPlayer"};
+        CommandSender sender = mock(CommandSender.class);
+        CommandDescription command = mock(CommandDescription.class);
+        given(command.getLabels()).willReturn(Collections.singletonList("test_cmd"));
+        given(serviceMock.mapPartsToCommand(any(CommandSender.class), anyListOf(String.class))).willReturn(
+            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 1.0, UNKNOWN_LABEL));
+
+        // when
+        handler.processCommand(sender, bukkitLabel, bukkitArgs);
+
+        // then
+        verify(serviceMock).mapPartsToCommand(eq(sender), captor.capture());
+        assertThat(captor.getValue(), contains("unreg", "testPlayer"));
+
+        verify(command, never()).getExecutableCommand();
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender, times(2)).sendMessage(captor.capture());
+        assertThat(captor.getAllValues().get(0), containsString("Unknown command"));
+        assertThat(captor.getAllValues().get(1), containsString("Use the command"));
+        assertThat(captor.getAllValues().get(1), containsString("to view help"));
+    }
+
     @Test
     public void shouldStripWhitespace() {
         // given

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

@@ -254,4 +254,23 @@ public class CommandMapperTest {
         assertThat(result.getDifference(), equalTo(0.0));
     }
 
+    @Test
+    public void shouldRecognizeMissingPermissionForCommand() {
+        // given
+        List<String> parts = Arrays.asList("authme", "login", "test1");
+        CommandSender sender = mock(CommandSender.class);
+        given(permissionsManagerMock.hasPermission(eq(sender), any(CommandDescription.class))).willReturn(false);
+
+        // when
+        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
+
+        // then
+        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "authme", "login")));
+        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.NO_PERMISSION));
+        assertThat(result.getArguments(), contains("test1"));
+        assertThat(result.getDifference(), equalTo(0.0));
+        assertThat(result.getLabels(), equalTo(parts.subList(0, 2)));
+        assertThat(result.getArguments(), contains(parts.get(2)));
+    }
+
 }

src/test/java/fr/xephi/authme/command/executable/captcha/CaptchaCommandTest.java

@@ -11,7 +11,6 @@ import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 import org.junit.Before;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.mockito.Mockito;