#601 Integrate plugin manager

- Encapsulate captcha functionality into a class instead of two public fields on the AuthMe main class(!)
   - Let CaptchaManager worry about whether it is enabled or not -> no need to check on the outside
- Implement full reloading support to enable/disable captchas + parameters
- Add unit tests

src/test/java/fr/xephi/authme/cache/CaptchaManagerTest.java

@@ -1,10 +1,14 @@
 package fr.xephi.authme.cache;
 
+import fr.xephi.authme.ReflectionTestUtils;
 import fr.xephi.authme.settings.NewSetting;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import org.junit.Test;
 
+import java.util.Map;
+
 import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.nullValue;
 import static org.junit.Assert.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
@@ -39,7 +43,7 @@ public class CaptchaManagerTest {
         String player = "Miner";
         NewSetting settings = mockSettings(1, 4);
         CaptchaManager manager = new CaptchaManager(settings);
-        String captchaCode = manager.getCaptchaCode(player);
+        String captchaCode = manager.getCaptchaCodeOrGenerateNew(player);
 
         // when
         boolean badResult = manager.checkCode(player, "wrong_code");
@@ -53,11 +57,105 @@ public class CaptchaManagerTest {
         assertThat(manager.checkCode(player, "bogus"), equalTo(true));
     }
 
+    /**
+     * Tests {@link CaptchaManager#getCaptchaCode} and {@link CaptchaManager#getCaptchaCodeOrGenerateNew}.
+     * The former method should never change the code (and so return {@code null} for no code) while the latter should
+     * generate a new code if no code is yet present. If a code is saved, it should never generate a new one.
+     */
+    @Test
+    public void shouldHaveSameCodeAfterGeneration() {
+        // given
+        String player = "Tester";
+        NewSetting settings = mockSettings(1, 5);
+        CaptchaManager manager = new CaptchaManager(settings);
+
+        // when
+        String code1 = manager.getCaptchaCode(player);
+        String code2 = manager.getCaptchaCodeOrGenerateNew(player);
+        String code3 = manager.getCaptchaCode(player);
+        String code4 = manager.getCaptchaCodeOrGenerateNew(player);
+        String code5 = manager.getCaptchaCode(player);
+
+        // then
+        assertThat(code1, nullValue());
+        assertThat(code2.length(), equalTo(5));
+        assertThat(code3, equalTo(code2));
+        assertThat(code4, equalTo(code2));
+        assertThat(code5, equalTo(code2));
+    }
+
+    @Test
+    public void shouldIncreaseAndResetCount() {
+        // given
+        String player = "plaYer";
+        NewSetting settings = mockSettings(2, 3);
+        CaptchaManager manager = new CaptchaManager(settings);
+
+        // when
+        manager.increaseCount(player);
+        manager.increaseCount(player);
+
+        // then
+        assertThat(manager.isCaptchaRequired(player), equalTo(true));
+        assertHasCount(manager, player, 2);
+
+        // when 2
+        manager.resetCounts(player);
+
+        // then 2
+        assertThat(manager.isCaptchaRequired(player), equalTo(false));
+        assertHasCount(manager, player, null);
+    }
+
+    @Test
+    public void shouldNotIncreaseCountForDisabledCaptcha() {
+        // given
+        String player = "someone_";
+        NewSetting settings = mockSettings(1, 3);
+        given(settings.getProperty(SecuritySettings.USE_CAPTCHA)).willReturn(false);
+        CaptchaManager manager = new CaptchaManager(settings);
+
+        // when
+        manager.increaseCount(player);
+
+        // then
+        assertThat(manager.isCaptchaRequired(player), equalTo(false));
+        assertHasCount(manager, player, null);
+    }
+
+    @Test
+    public void shouldNotCheckCountIfCaptchaIsDisabled() {
+        // given
+        String player = "Robert001";
+        NewSetting settings = mockSettings(1, 5);
+        CaptchaManager manager = new CaptchaManager(settings);
+        given(settings.getProperty(SecuritySettings.USE_CAPTCHA)).willReturn(false);
+
+        // when
+        manager.increaseCount(player);
+        // assumptions
+        assertThat(manager.isCaptchaRequired(player), equalTo(true));
+        assertHasCount(manager, player, 1);
+        // end assumptions
+        manager.loadSettings(settings);
+        boolean result = manager.isCaptchaRequired(player);
+
+        // then
+        assertThat(result, equalTo(false));
+    }
 
     private static NewSetting mockSettings(int maxTries, int captchaLength) {
         NewSetting settings = mock(NewSetting.class);
+        given(settings.getProperty(SecuritySettings.USE_CAPTCHA)).willReturn(true);
         given(settings.getProperty(SecuritySettings.MAX_LOGIN_TRIES_BEFORE_CAPTCHA)).willReturn(maxTries);
         given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(captchaLength);
         return settings;
     }
+
+    private static void assertHasCount(CaptchaManager manager, String player, Integer count) {
+        @SuppressWarnings("unchecked")
+        Map<String, Integer> playerCounts = (Map<String, Integer>) ReflectionTestUtils
+            .getFieldValue(CaptchaManager.class, manager, "playerCounts");
+        assertThat(playerCounts.get(player.toLowerCase()), equalTo(count));
+    }
 }

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

@@ -0,0 +1,121 @@
+package fr.xephi.authme.command.executable.captcha;
+
+import fr.xephi.authme.cache.CaptchaManager;
+import fr.xephi.authme.cache.auth.PlayerCache;
+import fr.xephi.authme.command.CommandService;
+import fr.xephi.authme.output.MessageKey;
+import org.bukkit.entity.Player;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.util.Collections;
+
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+
+/**
+ * Test for {@link CaptchaCommand}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class CaptchaCommandTest {
+
+    @InjectMocks
+    private CaptchaCommand command;
+
+    @Mock
+    private CaptchaManager captchaManager;
+
+    @Mock
+    private PlayerCache playerCache;
+
+    @Mock
+    private CommandService commandService;
+
+    @Test
+    public void shouldDetectIfPlayerIsLoggedIn() {
+        // given
+        String name = "creeper011";
+        Player player = mockPlayerWithName(name);
+        given(playerCache.isAuthenticated(name)).willReturn(true);
+
+        // when
+        command.executeCommand(player, Collections.singletonList("123"), commandService);
+
+        // then
+        verify(commandService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
+    }
+
+    @Test
+    public void shouldShowLoginUsageIfCaptchaIsNotRequired() {
+        // given
+        String name = "bobby";
+        Player player = mockPlayerWithName(name);
+        given(playerCache.isAuthenticated(name)).willReturn(false);
+        given(captchaManager.isCaptchaRequired(name)).willReturn(false);
+
+        // when
+        command.executeCommand(player, Collections.singletonList("1234"), commandService);
+
+        // then
+        verify(commandService).send(player, MessageKey.USAGE_LOGIN);
+        verify(captchaManager).isCaptchaRequired(name);
+        verifyNoMoreInteractions(captchaManager);
+    }
+
+    @Test
+    public void shouldHandleCorrectCaptchaInput() {
+        // given
+        String name = "smith";
+        Player player = mockPlayerWithName(name);
+        given(playerCache.isAuthenticated(name)).willReturn(false);
+        given(captchaManager.isCaptchaRequired(name)).willReturn(true);
+        String captchaCode = "3991";
+        given(captchaManager.checkCode(name, captchaCode)).willReturn(true);
+
+        // when
+        command.executeCommand(player, Collections.singletonList(captchaCode), commandService);
+
+        // then
+        verify(captchaManager).isCaptchaRequired(name);
+        verify(captchaManager).checkCode(name, captchaCode);
+        verifyNoMoreInteractions(captchaManager);
+        verify(commandService).send(player, MessageKey.CAPTCHA_SUCCESS);
+        verify(commandService).send(player, MessageKey.LOGIN_MESSAGE);
+        verifyNoMoreInteractions(commandService);
+    }
+
+    @Test
+    public void shouldHandleWrongCaptchaInput() {
+        // given
+        String name = "smith";
+        Player player = mockPlayerWithName(name);
+        given(playerCache.isAuthenticated(name)).willReturn(false);
+        given(captchaManager.isCaptchaRequired(name)).willReturn(true);
+        String captchaCode = "2468";
+        given(captchaManager.checkCode(name, captchaCode)).willReturn(false);
+        String newCode = "1337";
+        given(captchaManager.generateCode(name)).willReturn(newCode);
+
+        // when
+        command.executeCommand(player, Collections.singletonList(captchaCode), commandService);
+
+        // then
+        verify(captchaManager).isCaptchaRequired(name);
+        verify(captchaManager).checkCode(name, captchaCode);
+        verify(captchaManager).generateCode(name);
+        verifyNoMoreInteractions(captchaManager);
+        verify(commandService).send(player, MessageKey.CAPTCHA_WRONG_ERROR, newCode);
+        verifyNoMoreInteractions(commandService);
+    }
+
+    private static Player mockPlayerWithName(String name) {
+        Player player = mock(Player.class);
+        given(player.getName()).willReturn(name);
+        return player;
+    }
+}