Refactorings - prepare to remove FoundCommandResult

- Reduce tight coupling by passing list of available commands as param to CommandHandler
- Split command processing method into several smaller ones
- Remove unfinished logic for unlimited command arguments (reason: was not implemented and not used, probably needs another way to handle it once the need for it arises)
- Create test for CommandHandler

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

@@ -0,0 +1,115 @@
+package fr.xephi.authme.command;
+
+import fr.xephi.authme.permission.PlayerPermission;
+import fr.xephi.authme.util.WrapperMock;
+import org.bukkit.command.CommandSender;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.stringContainsInOrder;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link CommandHandler}.
+ */
+public class CommandHandlerTest {
+
+    private static List<CommandDescription> commands;
+    private static CommandHandler handler;
+
+    @BeforeClass
+    public static void setUpCommandHandler() {
+        WrapperMock.createInstance();
+
+        CommandDescription authMeBase = createCommand(null, null, singletonList("authme"));
+        createCommand(PlayerPermission.LOGIN, authMeBase, singletonList("login"), newArgument("password", false));
+        createCommand(PlayerPermission.LOGIN, authMeBase, asList("register", "reg"),
+            newArgument("password", false), newArgument("confirmation", false));
+
+        CommandDescription testBase = createCommand(null, null, singletonList("test"), newArgument("test", true));
+        commands = asList(authMeBase, testBase);
+        handler = new CommandHandler(commands);
+    }
+
+    @Test
+    public void shouldForwardCommandToExecutable() {
+        // given
+        CommandSender sender = Mockito.mock(CommandSender.class);
+        given(sender.isOp()).willReturn(true);
+        String bukkitLabel = "authme";
+        String[] args = {"login", "password"};
+
+        // when
+        handler.processCommand(sender, bukkitLabel, args);
+
+        // then
+        final CommandDescription loginCmd = commands.get(0).getChildren().get(0);
+        verify(sender, never()).sendMessage(anyString());
+        verify(loginCmd.getExecutableCommand()).executeCommand(
+            eq(sender), any(CommandParts.class), any(CommandParts.class));
+    }
+
+    @Test
+    @Ignore // TODO ljacqu Fix test --> command classes too tightly coupled at the moment
+    public void shouldRejectCommandWithTooManyArguments() {
+        // given
+        CommandSender sender = Mockito.mock(CommandSender.class);
+        given(sender.isOp()).willReturn(true);
+        String bukkitLabel = "authme";
+        String[] args = {"login", "password", "__unneededArgument__"};
+
+        // when
+        boolean result = handler.processCommand(sender, bukkitLabel, args);
+
+        // then
+        assertThat(result, equalTo(true));
+        final CommandDescription loginCmd = commands.get(0).getChildren().get(0);
+        assertSenderGotMessageContaining("help", sender);
+        verify(loginCmd.getExecutableCommand()).executeCommand(
+            eq(sender), any(CommandParts.class), any(CommandParts.class));
+    }
+
+    private static CommandDescription createCommand(PlayerPermission permission, CommandDescription parent,
+                                                    List<String> labels, CommandArgumentDescription... arguments) {
+        CommandDescription.CommandBuilder command = CommandDescription.builder()
+            .labels(labels)
+            .parent(parent)
+            .permissions(CommandPermissions.DefaultPermission.OP_ONLY, permission)
+            .description("Test")
+            .detailedDescription("Test command")
+            .executableCommand(mock(ExecutableCommand.class));
+
+        if (arguments != null && arguments.length > 0) {
+            for (CommandArgumentDescription argument : arguments) {
+                command.withArgument(argument.getLabel(), "Test description", argument.isOptional());
+            }
+        }
+
+        return command.build();
+    }
+
+    private static CommandArgumentDescription newArgument(String label, boolean isOptional) {
+        return new CommandArgumentDescription(label, "Test description", isOptional);
+    }
+
+    private void assertSenderGotMessageContaining(String text, CommandSender sender) {
+        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
+        verify(sender).sendMessage(captor.capture());
+        assertThat(captor.getValue(), stringContainsInOrder(text));
+    }
+}

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

@@ -27,8 +27,7 @@ public class HelpSyntaxHelperTest {
             .build();
 
         // when
-        String result = HelpSyntaxHelper.getCommandSyntax(
-                description, new CommandParts(), "", false);
+        String result = HelpSyntaxHelper.getCommandSyntax(description, new CommandParts(), "", false);
 
         // then
         assertThat(result, equalTo(WHITE + "/authme register" + ITALIC + " [name]"));
@@ -42,8 +41,7 @@ public class HelpSyntaxHelperTest {
             .build();
 
         // when
-        String result = HelpSyntaxHelper.getCommandSyntax(
-                description, new CommandParts(), null, false);
+        String result = HelpSyntaxHelper.getCommandSyntax(description, new CommandParts(), null, false);
 
         // then
         assertThat(result, equalTo(WHITE + "/authme register" + ITALIC + " <test>"));
@@ -58,8 +56,7 @@ public class HelpSyntaxHelperTest {
             .build();
 
         // when
-        String result = HelpSyntaxHelper.getCommandSyntax(
-                description, new CommandParts(), "", false);
+        String result = HelpSyntaxHelper.getCommandSyntax(description, new CommandParts(), "", false);
 
         // then
         assertThat(result, equalTo(WHITE + "/authme register" + ITALIC + " [name]" + ITALIC + " <test>"));
@@ -74,8 +71,7 @@ public class HelpSyntaxHelperTest {
             .build();
 
         // when
-        String result = HelpSyntaxHelper.getCommandSyntax(
-                description, new CommandParts(), "", true);
+        String result = HelpSyntaxHelper.getCommandSyntax(description, new CommandParts(), "", true);
 
         // then
         assertThat(result, equalTo(WHITE + "/authme "
@@ -89,8 +85,7 @@ public class HelpSyntaxHelperTest {
         CommandDescription description = getDescriptionBuilder().build();
 
         // when
-        String result = HelpSyntaxHelper.getCommandSyntax(
-                description, new CommandParts(), null, true);
+        String result = HelpSyntaxHelper.getCommandSyntax(description, new CommandParts(), null, true);
 
         // then
         assertThat(result, equalTo(WHITE + "/authme " + YELLOW + BOLD + "register" + YELLOW));
@@ -104,32 +99,12 @@ public class HelpSyntaxHelperTest {
             .build();
 
         // when
-        String result = HelpSyntaxHelper.getCommandSyntax(
-                description, new CommandParts(), "alt", false);
+        String result = HelpSyntaxHelper.getCommandSyntax(description, new CommandParts(), "alt", false);
 
         // then
         assertThat(result, equalTo(WHITE + "/authme alt" + ITALIC + " [name]"));
     }
 
-    @Test
-    public void shouldHighlightCommandWithAltLabelAndUnlimitedArguments() {
-        // given
-        CommandDescription description = getDescriptionBuilder()
-            .withArgument("name", "", true)
-            .withArgument("test", "", false)
-            .noArgumentMaximum(true)
-            .build();
-
-        // when
-        String result = HelpSyntaxHelper.getCommandSyntax(
-                description, new CommandParts(), "test", true);
-
-        // then
-        assertThat(result, equalTo(WHITE + "/authme "
-                + YELLOW + BOLD + "test"
-                + YELLOW + ITALIC + " [name]" + ITALIC + " <test>" + ITALIC + " ..."));
-    }
-
 
     private static CommandDescription.CommandBuilder getDescriptionBuilder() {
         CommandDescription base = CommandDescription.builder()