#930 Register captcha: avoid circular dependency by handling limbo message in captcha command

- Set limbo message in captcha command (as is done for login captcha)
- Add clarifying comments to captcha command
- Remove classes handling circular dependencies

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

@@ -6,11 +6,8 @@ import ch.jalu.injector.InjectorBuilder;
 import com.google.common.io.Files;
 import fr.xephi.authme.api.v3.AuthMeApi;
 import fr.xephi.authme.command.CommandHandler;
-import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
-import fr.xephi.authme.data.limbo.LimboService;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.initialization.circulardependency.CircularDependencyInitializer;
 import fr.xephi.authme.listener.BlockListener;
 import fr.xephi.authme.permission.PermissionsManager;
 import fr.xephi.authme.process.Management;
@@ -42,7 +39,6 @@ import java.util.logging.Logger;
 import static fr.xephi.authme.settings.properties.AuthMeSettingsRetriever.buildConfigurationData;
 import static org.hamcrest.Matchers.not;
 import static org.hamcrest.Matchers.nullValue;
-import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.Assert.assertThat;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
@@ -112,7 +108,6 @@ public class AuthMeInitializationTest {
         // when
         authMe.instantiateServices(injector);
         authMe.registerEventListeners(injector);
-        injector.newInstance(CircularDependencyInitializer.class).initializeCircularDependencies();
 
         // then
         // Take a few samples and ensure that they are not null
@@ -126,17 +121,5 @@ public class AuthMeInitializationTest {
         assertThat(injector.getIfAvailable(PermissionsManager.class), not(nullValue()));
         assertThat(injector.getIfAvailable(ProcessSyncPlayerLogin.class), not(nullValue()));
         assertThat(injector.getIfAvailable(PurgeService.class), not(nullValue()));
-
-        assertCircularDependencyWasSet(injector);
-    }
-
-    private void assertCircularDependencyWasSet(Injector injector) {
-        RegistrationCaptchaManager registrationCaptchaManager = injector.getIfAvailable(RegistrationCaptchaManager.class);
-        LimboService limboServiceOnCaptchaManager = ReflectionTestUtils.getFieldValue(
-            RegistrationCaptchaManager.class, registrationCaptchaManager, "limboService");
-        LimboService limboServiceFromInjector = injector.getIfAvailable(LimboService.class);
-
-        assertThat(limboServiceOnCaptchaManager, not(nullValue()));
-        assertThat(limboServiceOnCaptchaManager, sameInstance(limboServiceFromInjector));
     }
 }

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

@@ -4,6 +4,7 @@ import fr.xephi.authme.data.auth.PlayerCache;
 import fr.xephi.authme.data.captcha.LoginCaptchaManager;
 import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
 import fr.xephi.authme.data.limbo.LimboService;
+import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.service.CommonService;
 import org.bukkit.entity.Player;
@@ -45,6 +46,9 @@ public class CaptchaCommandTest {
     @Mock
     private LimboService limboService;
 
+    @Mock
+    private DataSource dataSource;
+
     @Test
     public void shouldDetectIfPlayerIsLoggedIn() {
         // given
@@ -66,7 +70,8 @@ public class CaptchaCommandTest {
         Player player = mockPlayerWithName(name);
         given(playerCache.isAuthenticated(name)).willReturn(false);
         given(loginCaptchaManager.isCaptchaRequired(name)).willReturn(false);
-        given(registrationCaptchaManager.isCaptchaRequired(name)).willReturn(false);
+        given(registrationCaptchaManager.isCaptchaRequired(name)).willReturn(true);
+        given(dataSource.isAuthAvailable(name)).willReturn(true);
 
         // when
         command.executeCommand(player, Collections.singletonList("1234"));
@@ -74,7 +79,6 @@ public class CaptchaCommandTest {
         // then
         verify(commonService).send(player, MessageKey.USAGE_LOGIN);
         verify(loginCaptchaManager).isCaptchaRequired(name);
-        verify(registrationCaptchaManager).isCaptchaRequired(name);
         verifyNoMoreInteractions(loginCaptchaManager, registrationCaptchaManager);
     }
 
@@ -164,6 +168,21 @@ public class CaptchaCommandTest {
         verify(commonService).send(player, MessageKey.CAPTCHA_WRONG_ERROR, "new code");
     }
 
+    @Test
+    public void shouldShowRegisterUsageWhenRegistrationCaptchaIsSolved() {
+        // given
+        String name = "alice";
+        Player player = mockPlayerWithName(name);
+        given(registrationCaptchaManager.isCaptchaRequired(name)).willReturn(false);
+
+        // when
+        command.executeCommand(player, Collections.singletonList("test"));
+
+        // then
+        verify(registrationCaptchaManager, only()).isCaptchaRequired(name);
+        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
+    }
+
     private static Player mockPlayerWithName(String name) {
         Player player = mock(Player.class);
         given(player.getName()).willReturn(name);

src/test/java/fr/xephi/authme/data/captcha/RegistrationCaptchaManagerTest.java

@@ -1,28 +1,23 @@
 package fr.xephi.authme.data.captcha;
 
 import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.data.limbo.LimboService;
 import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import fr.xephi.authme.util.expiring.ExpiringMap;
 import org.bukkit.entity.Player;
 import org.junit.Test;
-import org.mockito.Mockito;
 
 import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
 import static org.hamcrest.Matchers.equalTo;
 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 RegistrationCaptchaManager}.
  */
 public class RegistrationCaptchaManagerTest {
 
-    private LimboService limboService = Mockito.mock(LimboService.class);
-
     @Test
     public void shouldBeDisabled() {
         // given
@@ -50,7 +45,6 @@ public class RegistrationCaptchaManagerTest {
 
         String captcha = "abc3";
         RegistrationCaptchaManager captchaManager = new RegistrationCaptchaManager(settings);
-        captchaManager.setLimboService(limboService);
         getCodeMap(captchaManager).put("test", captcha);
 
         Player player = mock(Player.class);
@@ -63,7 +57,6 @@ public class RegistrationCaptchaManagerTest {
         assertThat(isSuccessful, equalTo(true));
         assertThat(getCodeMap(captchaManager).isEmpty(), equalTo(true));
         assertThat(captchaManager.isCaptchaRequired("test"), equalTo(false));
-        verify(limboService).resetMessageTask(player, false);
     }
 
     @Test
@@ -74,7 +67,6 @@ public class RegistrationCaptchaManagerTest {
         int captchaLength = 9;
         given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(captchaLength);
         RegistrationCaptchaManager captchaManager = new RegistrationCaptchaManager(settings);
-        captchaManager.setLimboService(limboService);
 
         // when
         String captcha1 = captchaManager.getCaptchaCodeOrGenerateNew("toast");
@@ -90,7 +82,6 @@ public class RegistrationCaptchaManagerTest {
 
         // when (2) / then (2)
         assertThat(captchaManager.checkCode(player, captcha1), equalTo(true));
-        verify(limboService).resetMessageTask(player, false);
     }
 
     @SuppressWarnings("unchecked")