Merge branch '427-register-with-pass-and-email' of https://github.com/AuthMe-Team/AuthMeReloaded

src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java

@@ -4,12 +4,13 @@ import fr.xephi.authme.TestHelper;
 import fr.xephi.authme.mail.SendMailSSL;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.Management;
+import fr.xephi.authme.process.register.executors.RegistrationExecutor;
+import fr.xephi.authme.process.register.executors.RegistrationExecutorProvider;
 import fr.xephi.authme.security.HashAlgorithm;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.settings.properties.EmailSettings;
+import fr.xephi.authme.settings.properties.RegistrationArgumentType;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.CommandSender;
@@ -25,9 +26,7 @@ import org.mockito.junit.MockitoJUnitRunner;
 import java.util.Arrays;
 import java.util.Collections;
 
-import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
 import static org.hamcrest.Matchers.containsString;
-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
@@ -44,7 +43,7 @@ public class RegisterCommandTest {
     private RegisterCommand command;
 
     @Mock
-    private CommonService commandService;
+    private CommonService commonService;
 
     @Mock
     private Management management;
@@ -55,6 +54,9 @@ public class RegisterCommandTest {
     @Mock
     private ValidationService validationService;
 
+    @Mock
+    private RegistrationExecutorProvider registrationExecutorProvider;
+
     @BeforeClass
     public static void setup() {
         TestHelper.setupLogger();
@@ -62,9 +64,8 @@ public class RegisterCommandTest {
 
     @Before
     public void linkMocksAndProvideSettingDefaults() {
-        given(commandService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.BCRYPT);
-        given(commandService.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(false);
-        given(commandService.getProperty(RestrictionSettings.ENABLE_PASSWORD_CONFIRMATION)).willReturn(false);
+        given(commonService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.BCRYPT);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD);
     }
 
     @Test
@@ -83,14 +84,16 @@ public class RegisterCommandTest {
     @Test
     public void shouldForwardToManagementForTwoFactor() {
         // given
-        given(commandService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.TWO_FACTOR);
+        given(commonService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.TWO_FACTOR);
         Player player = mock(Player.class);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+        given(registrationExecutorProvider.getTwoFactorRegisterExecutor(player)).willReturn(executor);
 
         // when
         command.executeCommand(player, Collections.emptyList());
 
         // then
-        verify(management).performRegister(player, "", "", true);
+        verify(management).performRegister(player, executor);
         verifyZeroInteractions(sendMailSsl);
     }
 
@@ -103,44 +106,42 @@ public class RegisterCommandTest {
         command.executeCommand(player, Collections.emptyList());
 
         // then
-        verify(commandService).send(player, MessageKey.USAGE_REGISTER);
+        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
         verifyZeroInteractions(management, sendMailSsl);
     }
 
     @Test
     public void shouldReturnErrorForMissingConfirmation() {
         // given
-        given(commandService.getProperty(RestrictionSettings.ENABLE_PASSWORD_CONFIRMATION)).willReturn(true);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION);
         Player player = mock(Player.class);
 
         // when
         command.executeCommand(player, Collections.singletonList("arrrr"));
 
         // then
-        verify(commandService).send(player, MessageKey.USAGE_REGISTER);
+        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
         verifyZeroInteractions(management, sendMailSsl);
     }
 
     @Test
     public void shouldReturnErrorForMissingEmailConfirmation() {
         // given
-        given(commandService.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
-        given(commandService.getProperty(RegistrationSettings.ENABLE_CONFIRM_EMAIL)).willReturn(true);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION);
         Player player = mock(Player.class);
 
         // when
         command.executeCommand(player, Collections.singletonList("test@example.org"));
 
         // then
-        verify(commandService).send(player, MessageKey.USAGE_REGISTER);
+        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
         verifyZeroInteractions(management, sendMailSsl);
     }
 
     @Test
     public void shouldThrowErrorForMissingEmailConfiguration() {
         // given
-        given(commandService.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
-        given(commandService.getProperty(RegistrationSettings.ENABLE_CONFIRM_EMAIL)).willReturn(false);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL);
         given(sendMailSsl.hasAllInformation()).willReturn(false);
         Player player = mock(Player.class);
 
@@ -148,7 +149,7 @@ public class RegisterCommandTest {
         command.executeCommand(player, Collections.singletonList("myMail@example.tld"));
 
         // then
-        verify(commandService).send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
+        verify(commonService).send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
         verify(sendMailSsl).hasAllInformation();
         verifyZeroInteractions(management);
     }
@@ -158,9 +159,7 @@ public class RegisterCommandTest {
         // given
         String playerMail = "player@example.org";
         given(validationService.validateEmail(playerMail)).willReturn(false);
-
-        given(commandService.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
-        given(commandService.getProperty(RegistrationSettings.ENABLE_CONFIRM_EMAIL)).willReturn(true);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION);
         given(sendMailSsl.hasAllInformation()).willReturn(true);
         Player player = mock(Player.class);
 
@@ -169,7 +168,7 @@ public class RegisterCommandTest {
 
         // then
         verify(validationService).validateEmail(playerMail);
-        verify(commandService).send(player, MessageKey.INVALID_EMAIL);
+        verify(commonService).send(player, MessageKey.INVALID_EMAIL);
         verifyZeroInteractions(management);
     }
 
@@ -178,9 +177,7 @@ public class RegisterCommandTest {
         // given
         String playerMail = "bobber@bobby.org";
         given(validationService.validateEmail(playerMail)).willReturn(true);
-
-        given(commandService.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
-        given(commandService.getProperty(RegistrationSettings.ENABLE_CONFIRM_EMAIL)).willReturn(true);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION);
         given(sendMailSsl.hasAllInformation()).willReturn(true);
         Player player = mock(Player.class);
 
@@ -188,7 +185,7 @@ public class RegisterCommandTest {
         command.executeCommand(player, Arrays.asList(playerMail, "invalid"));
 
         // then
-        verify(commandService).send(player, MessageKey.USAGE_REGISTER);
+        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
         verify(sendMailSsl).hasAllInformation();
         verifyZeroInteractions(management);
     }
@@ -198,13 +195,11 @@ public class RegisterCommandTest {
         // given
         String playerMail = "asfd@lakjgre.lds";
         given(validationService.validateEmail(playerMail)).willReturn(true);
-        int passLength = 7;
-        given(commandService.getProperty(EmailSettings.RECOVERY_PASSWORD_LENGTH)).willReturn(passLength);
-
-        given(commandService.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
-        given(commandService.getProperty(RegistrationSettings.ENABLE_CONFIRM_EMAIL)).willReturn(true);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION);
         given(sendMailSsl.hasAllInformation()).willReturn(true);
         Player player = mock(Player.class);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+        given(registrationExecutorProvider.getEmailRegisterExecutor(player, playerMail)).willReturn(executor);
 
         // when
         command.executeCommand(player, Arrays.asList(playerMail, playerMail));
@@ -212,20 +207,20 @@ public class RegisterCommandTest {
         // then
         verify(validationService).validateEmail(playerMail);
         verify(sendMailSsl).hasAllInformation();
-        verify(management).performRegister(eq(player), argThat(stringWithLength(passLength)), eq(playerMail), eq(true));
+        verify(management).performRegister(player, executor);
     }
 
     @Test
     public void shouldRejectInvalidPasswordConfirmation() {
         // given
-        given(commandService.getProperty(RestrictionSettings.ENABLE_PASSWORD_CONFIRMATION)).willReturn(true);
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION);
         Player player = mock(Player.class);
 
         // when
         command.executeCommand(player, Arrays.asList("myPass", "mypass"));
 
         // then
-        verify(commandService).send(player, MessageKey.PASSWORD_MATCH_ERROR);
+        verify(commonService).send(player, MessageKey.PASSWORD_MATCH_ERROR);
         verifyZeroInteractions(management, sendMailSsl);
     }
 
@@ -233,11 +228,65 @@ public class RegisterCommandTest {
     public void shouldPerformPasswordValidation() {
         // given
         Player player = mock(Player.class);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+        given(registrationExecutorProvider.getPasswordRegisterExecutor(player, "myPass")).willReturn(executor);
 
         // when
         command.executeCommand(player, Collections.singletonList("myPass"));
 
         // then
-        verify(management).performRegister(player, "myPass", "", true);
+        verify(management).performRegister(player, executor);
+    }
+
+    @Test
+    public void shouldPerformMailValidationForPasswordWithEmail() {
+        // given
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE))
+            .willReturn(RegistrationArgumentType.PASSWORD_WITH_EMAIL);
+        String email = "email@example.org";
+        given(validationService.validateEmail(email)).willReturn(true);
+        Player player = mock(Player.class);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+        given(registrationExecutorProvider.getPasswordRegisterExecutor(player, "myPass", email)).willReturn(executor);
+
+        // when
+        command.executeCommand(player, Arrays.asList("myPass", email));
+
+        // then
+        verify(validationService).validateEmail(email);
+        verify(management).performRegister(player, executor);
+    }
+
+    @Test
+    public void shouldStopForInvalidEmail() {
+        // given
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE))
+            .willReturn(RegistrationArgumentType.PASSWORD_WITH_EMAIL);
+        String email = "email@example.org";
+        given(validationService.validateEmail(email)).willReturn(false);
+        Player player = mock(Player.class);
+
+        // when
+        command.executeCommand(player, Arrays.asList("myPass", email));
+
+        // then
+        verify(validationService).validateEmail(email);
+        verify(commonService).send(player, MessageKey.INVALID_EMAIL);
+        verifyZeroInteractions(management);
+    }
+
+    @Test
+    public void shouldFailForInsufficientArguments() {
+        // given
+        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE))
+            .willReturn(RegistrationArgumentType.PASSWORD_WITH_EMAIL);
+        Player player = mock(Player.class);
+
+        // when
+        command.executeCommand(player, Collections.singletonList("myPass"));
+
+        // then
+        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
+        verifyZeroInteractions(management);
     }
 }

src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java

@@ -8,6 +8,7 @@ import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.ValidationService;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RegistrationArgumentType;
 import org.bukkit.entity.Player;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -172,7 +173,7 @@ public class AsyncAddEmailTest {
         given(player.getName()).willReturn("user");
         given(playerCache.isAuthenticated("user")).willReturn(false);
         given(dataSource.isAuthAvailable("user")).willReturn(false);
-        given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
+        given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL);
 
         // when
         asyncAddEmail.addEmail(player, "test@mail.com");
@@ -188,7 +189,7 @@ public class AsyncAddEmailTest {
         given(player.getName()).willReturn("user");
         given(playerCache.isAuthenticated("user")).willReturn(false);
         given(dataSource.isAuthAvailable("user")).willReturn(false);
-        given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(false);
+        given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION);
 
         // when
         asyncAddEmail.addEmail(player, "test@mail.com");

src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java

@@ -7,6 +7,7 @@ import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.service.CommonService;
 import fr.xephi.authme.service.ValidationService;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RegistrationArgumentType;
 import org.bukkit.entity.Player;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -184,7 +185,7 @@ public class AsyncChangeEmailTest {
         given(player.getName()).willReturn("Bobby");
         given(playerCache.isAuthenticated("bobby")).willReturn(false);
         given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
-        given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
+        given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION);
 
         // when
         process.changeEmail(player, "old@mail.tld", "new@mail.tld");
@@ -201,7 +202,7 @@ public class AsyncChangeEmailTest {
         given(player.getName()).willReturn("Bobby");
         given(playerCache.isAuthenticated("bobby")).willReturn(false);
         given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
-        given(service.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(false);
+        given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD);
 
         // when
         process.changeEmail(player, "old@mail.tld", "new@mail.tld");

src/test/java/fr/xephi/authme/process/register/AsyncRegisterTest.java

@@ -0,0 +1,121 @@
+package fr.xephi.authme.process.register;
+
+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.permission.PermissionsManager;
+import fr.xephi.authme.process.register.executors.RegistrationExecutor;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RestrictionSettings;
+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.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;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+/**
+ * Test for {@link AsyncRegister}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class AsyncRegisterTest {
+
+    @InjectMocks
+    private AsyncRegister asyncRegister;
+
+    @Mock
+    private PlayerCache playerCache;
+    @Mock
+    private PermissionsManager permissionsManager;
+    @Mock
+    private CommonService commonService;
+    @Mock
+    private DataSource dataSource;
+
+    @Test
+    public void shouldDetectAlreadyLoggedInPlayer() {
+        // given
+        String name = "robert";
+        Player player = mockPlayerWithName(name);
+        given(playerCache.isAuthenticated(name)).willReturn(true);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+
+        // when
+        asyncRegister.register(player, executor);
+
+        // then
+        verify(commonService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
+        verifyZeroInteractions(dataSource, executor);
+    }
+
+    @Test
+    public void shouldStopForDisabledRegistration() {
+        // given
+        String name = "albert";
+        Player player = mockPlayerWithName(name);
+        given(playerCache.isAuthenticated(name)).willReturn(false);
+        given(commonService.getProperty(RegistrationSettings.IS_ENABLED)).willReturn(false);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+
+        // when
+        asyncRegister.register(player, executor);
+
+        // then
+        verify(commonService).send(player, MessageKey.REGISTRATION_DISABLED);
+        verifyZeroInteractions(dataSource, executor);
+    }
+
+    @Test
+    public void shouldStopForAlreadyRegisteredName() {
+        // given
+        String name = "dilbert";
+        Player player = mockPlayerWithName(name);
+        given(playerCache.isAuthenticated(name)).willReturn(false);
+        given(commonService.getProperty(RegistrationSettings.IS_ENABLED)).willReturn(true);
+        given(dataSource.isAuthAvailable(name)).willReturn(true);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+
+        // when
+        asyncRegister.register(player, executor);
+
+        // then
+        verify(commonService).send(player, MessageKey.NAME_ALREADY_REGISTERED);
+        verify(dataSource, only()).isAuthAvailable(name);
+        verifyZeroInteractions(executor);
+    }
+
+    @Test
+    public void shouldStopForFailedExecutorCheck() {
+        // given
+        String name = "edbert";
+        Player player = mockPlayerWithName(name);
+        TestHelper.mockPlayerIp(player, "33.44.55.66");
+        given(playerCache.isAuthenticated(name)).willReturn(false);
+        given(commonService.getProperty(RegistrationSettings.IS_ENABLED)).willReturn(true);
+        given(commonService.getProperty(RestrictionSettings.MAX_REGISTRATION_PER_IP)).willReturn(0);
+        given(dataSource.isAuthAvailable(name)).willReturn(false);
+        RegistrationExecutor executor = mock(RegistrationExecutor.class);
+        given(executor.isRegistrationAdmitted()).willReturn(false);
+
+        // when
+        asyncRegister.register(player, executor);
+
+        // then
+        verify(dataSource, only()).isAuthAvailable(name);
+        verify(executor, only()).isRegistrationAdmitted();
+    }
+
+    private static Player mockPlayerWithName(String name) {
+        Player player = mock(Player.class);
+        given(player.getName()).willReturn(name);
+        return player;
+    }
+}

src/test/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorProviderTest.java

@@ -0,0 +1,173 @@
+package fr.xephi.authme.process.register.executors;
+
+import fr.xephi.authme.ReflectionTestUtils;
+import fr.xephi.authme.TestHelper;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.mail.SendMailSSL;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.permission.PlayerStatePermission;
+import fr.xephi.authme.process.SyncProcessManager;
+import fr.xephi.authme.security.PasswordSecurity;
+import fr.xephi.authme.security.crypts.HashedPassword;
+import fr.xephi.authme.service.CommonService;
+import fr.xephi.authme.settings.properties.EmailSettings;
+import org.bukkit.Location;
+import org.bukkit.World;
+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.junit.MockitoJUnitRunner;
+
+import static fr.xephi.authme.AuthMeMatchers.hasAuthBasicData;
+import static fr.xephi.authme.AuthMeMatchers.hasAuthLocation;
+import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+/**
+ * Test for {@link EmailRegisterExecutorProvider}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class EmailRegisterExecutorProviderTest {
+
+    @InjectMocks
+    private EmailRegisterExecutorProvider emailRegisterExecutorProvider;
+
+    @Mock
+    private PermissionsManager permissionsManager;
+    @Mock
+    private DataSource dataSource;
+    @Mock
+    private CommonService commonService;
+    @Mock
+    private SendMailSSL sendMailSsl;
+    @Mock
+    private SyncProcessManager syncProcessManager;
+    @Mock
+    private PasswordSecurity passwordSecurity;
+
+    @Test
+    public void shouldNotPassEmailValidation() {
+        // given
+        given(commonService.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(3);
+        String email = "test@example.com";
+        given(dataSource.countAuthsByEmail(email)).willReturn(4);
+        Player player = mock(Player.class);
+        RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, email);
+
+        // when
+        boolean result = executor.isRegistrationAdmitted();
+
+        // then
+        assertThat(result, equalTo(false));
+        verify(dataSource).countAuthsByEmail(email);
+        verify(permissionsManager).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
+        verify(commonService).send(player, MessageKey.MAX_REGISTER_EXCEEDED, "3", "4", "@");
+    }
+
+    @Test
+    public void shouldPassVerificationForPlayerWithPermission() {
+        // given
+        given(commonService.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(3);
+        Player player = mock(Player.class);
+        given(permissionsManager.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(true);
+        RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
+
+        // when
+        boolean result = executor.isRegistrationAdmitted();
+
+        // then
+        assertThat(result, equalTo(true));
+        verify(permissionsManager).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
+    }
+
+    @Test
+    public void shouldPassVerificationForPreviouslyUnregisteredIp() {
+        // given
+        given(commonService.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(1);
+        String email = "test@example.com";
+        given(dataSource.countAuthsByEmail(email)).willReturn(0);
+        Player player = mock(Player.class);
+        RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
+
+        // when
+        boolean result = executor.isRegistrationAdmitted();
+
+        // then
+        assertThat(result, equalTo(true));
+        verify(permissionsManager).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
+        verify(dataSource).countAuthsByEmail(email);
+    }
+
+    @Test
+    public void shouldCreatePlayerAuth() {
+        // given
+        given(commonService.getProperty(EmailSettings.RECOVERY_PASSWORD_LENGTH)).willReturn(12);
+        given(passwordSecurity.computeHash(anyString(), anyString())).willAnswer(
+            invocation -> new HashedPassword(invocation.getArgument(0)));
+        Player player = mock(Player.class);
+        TestHelper.mockPlayerIp(player, "123.45.67.89");
+        given(player.getName()).willReturn("Veronica");
+        World world = mock(World.class);
+        given(world.getName()).willReturn("someWorld");
+        given(player.getLocation()).willReturn(new Location(world, 48, 96, 144));
+        RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
+
+        // when
+        PlayerAuth auth = executor.buildPlayerAuth();
+
+        // then
+        assertThat(auth, hasAuthBasicData("veronica", "Veronica", "test@example.com", "123.45.67.89"));
+        assertThat(auth, hasAuthLocation(48, 96, 144, "someWorld"));
+        assertThat(auth.getPassword().getHash(), stringWithLength(12));
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldPerformActionAfterDataSourceSave() {
+        // given
+        given(sendMailSsl.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
+        Player player = mock(Player.class);
+        given(player.getName()).willReturn("Laleh");
+        RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
+        String password = "A892C#@";
+        ReflectionTestUtils.setField((Class) executor.getClass(), executor, "password", password);
+
+        // when
+        executor.executePostPersistAction();
+
+        // then
+        verify(sendMailSsl).sendPasswordMail("Laleh", "test@example.com", password);
+        verify(syncProcessManager).processSyncEmailRegister(player);
+    }
+
+    @Test
+    @SuppressWarnings("unchecked")
+    public void shouldHandleEmailSendingFailure() {
+        // given
+        given(sendMailSsl.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(false);
+        Player player = mock(Player.class);
+        given(player.getName()).willReturn("Laleh");
+        RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
+        String password = "A892C#@";
+        ReflectionTestUtils.setField((Class) executor.getClass(), executor, "password", password);
+
+        // when
+        executor.executePostPersistAction();
+
+        // then
+        verify(sendMailSsl).sendPasswordMail("Laleh", "test@example.com", password);
+        verify(commonService).send(player, MessageKey.EMAIL_SEND_FAILURE);
+        verifyZeroInteractions(syncProcessManager);
+    }
+
+}

src/test/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutorProviderTest.java

@@ -0,0 +1,152 @@
+package fr.xephi.authme.process.register.executors;
+
+import fr.xephi.authme.TestHelper;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.message.MessageKey;
+import fr.xephi.authme.process.SyncProcessManager;
+import fr.xephi.authme.process.login.AsynchronousLogin;
+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 fr.xephi.authme.settings.properties.PluginSettings;
+import fr.xephi.authme.settings.properties.RegistrationSettings;
+import org.bukkit.Location;
+import org.bukkit.World;
+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.junit.MockitoJUnitRunner;
+
+import static fr.xephi.authme.AuthMeMatchers.equalToHash;
+import static fr.xephi.authme.AuthMeMatchers.hasAuthBasicData;
+import static fr.xephi.authme.AuthMeMatchers.hasAuthLocation;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+/**
+ * Test for {@link PasswordRegisterExecutorProvider}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PasswordRegisterExecutorProviderTest {
+
+    @InjectMocks
+    private PasswordRegisterExecutorProvider passwordRegisterExecutorProvider;
+
+    @Mock
+    private ValidationService validationService;
+    @Mock
+    private CommonService commonService;
+    @Mock
+    private PasswordSecurity passwordSecurity;
+    @Mock
+    private BukkitService bukkitService;
+    @Mock
+    private SyncProcessManager syncProcessManager;
+    @Mock
+    private AsynchronousLogin asynchronousLogin;
+
+    @Test
+    public void shouldCheckPasswordValidity() {
+        // given
+        String password = "myPass";
+        String name = "player040";
+        given(validationService.validatePassword(password, name)).willReturn(new ValidationResult());
+        Player player = mockPlayerWithName(name);
+        RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, password, null);
+
+        // when
+        boolean result = executor.isRegistrationAdmitted();
+
+        // then
+        assertThat(result, equalTo(true));
+        verify(validationService).validatePassword(password, name);
+    }
+
+    @Test
+    public void shouldDetectInvalidPasswordAndInformPlayer() {
+        // given
+        String password = "myPass";
+        String name = "player040";
+        given(validationService.validatePassword(password, name)).willReturn(
+            new ValidationResult(MessageKey.PASSWORD_CHARACTERS_ERROR, "[a-z]"));
+        Player player = mockPlayerWithName(name);
+        RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, password, null);
+
+        // when
+        boolean result = executor.isRegistrationAdmitted();
+
+        // then
+        assertThat(result, equalTo(false));
+        verify(validationService).validatePassword(password, name);
+        verify(commonService).send(player, MessageKey.PASSWORD_CHARACTERS_ERROR, "[a-z]");
+    }
+
+    @Test
+    public void shouldCreatePlayerAuth() {
+        // given
+        given(passwordSecurity.computeHash(anyString(), anyString())).willAnswer(
+            invocation -> new HashedPassword(invocation.getArgument(0)));
+        Player player = mockPlayerWithName("S1m0N");
+        TestHelper.mockPlayerIp(player, "123.45.67.89");
+        World world = mock(World.class);
+        given(world.getName()).willReturn("someWorld");
+        given(player.getLocation()).willReturn(new Location(world, 48, 96, 144));
+        RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, "pass", "mail@example.org");
+
+        // when
+        PlayerAuth auth = executor.buildPlayerAuth();
+
+        // then
+        assertThat(auth, hasAuthBasicData("s1m0n", "S1m0N", "mail@example.org", "123.45.67.89"));
+        assertThat(auth, hasAuthLocation(48, 96, 144, "someWorld"));
+        assertThat(auth.getPassword(), equalToHash("pass"));
+    }
+
+    @Test
+    public void shouldLogPlayerIn() {
+        // given
+        given(commonService.getProperty(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER)).willReturn(false);
+        given(commonService.getProperty(PluginSettings.USE_ASYNC_TASKS)).willReturn(false);
+        Player player = mock(Player.class);
+        RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, "pass", "mail@example.org");
+
+        // when
+        executor.executePostPersistAction();
+
+        // then
+        TestHelper.runSyncDelayedTaskWithDelay(bukkitService);
+        verify(asynchronousLogin).forceLogin(player);
+        verify(syncProcessManager).processSyncPasswordRegister(player);
+    }
+
+    @Test
+    public void shouldNotLogPlayerIn() {
+        // given
+        given(commonService.getProperty(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER)).willReturn(true);
+        Player player = mock(Player.class);
+        RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, "pass", "mail@example.org");
+
+        // when
+        executor.executePostPersistAction();
+
+        // then
+        verifyZeroInteractions(bukkitService, asynchronousLogin);
+        verify(syncProcessManager).processSyncPasswordRegister(player);
+    }
+
+    private static Player mockPlayerWithName(String name) {
+        Player player = mock(Player.class);
+        given(player.getName()).willReturn(name);
+        return player;
+    }
+}

src/test/java/fr/xephi/authme/process/register/executors/PlayerAuthBuilderHelperTest.java

@@ -0,0 +1,49 @@
+package fr.xephi.authme.process.register.executors;
+
+import fr.xephi.authme.TestHelper;
+import fr.xephi.authme.data.auth.PlayerAuth;
+import fr.xephi.authme.security.crypts.HashedPassword;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.junit.Test;
+
+import static fr.xephi.authme.AuthMeMatchers.hasAuthBasicData;
+import static fr.xephi.authme.AuthMeMatchers.hasAuthLocation;
+import static org.junit.Assert.assertThat;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Test for {@link PlayerAuthBuilderHelper}.
+ */
+public class PlayerAuthBuilderHelperTest {
+
+    @Test
+    public void shouldConstructPlayerAuth() {
+        // given
+        Player player = mock(Player.class);
+        given(player.getName()).willReturn("Noah");
+        String ip = "192.168.34.47";
+        TestHelper.mockPlayerIp(player, ip);
+        World world = mock(World.class);
+        given(world.getName()).willReturn("worldName");
+        Location location = new Location(world, 123, 80, -99);
+        given(player.getLocation()).willReturn(location);
+        HashedPassword hashedPassword = new HashedPassword("myHash0001");
+        String email = "test@example.org";
+
+        // when
+        PlayerAuth auth = PlayerAuthBuilderHelper.createPlayerAuth(player, hashedPassword, email);
+
+        // then
+        assertThat(auth, hasAuthBasicData("noah", "Noah", email, ip));
+        assertThat(auth, hasAuthLocation(123, 80, -99, "worldName"));
+    }
+
+    @Test
+    public void shouldHaveHiddenConstructor() {
+        TestHelper.validateHasOnlyPrivateEmptyConstructor(PlayerAuthBuilderHelper.class);
+    }
+
+}

src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java

@@ -6,6 +6,7 @@ import com.google.common.io.Files;
 import fr.xephi.authme.TestHelper;
 import fr.xephi.authme.output.LogLevel;
 import fr.xephi.authme.settings.properties.AuthMeSettingsRetriever;
+import fr.xephi.authme.settings.properties.RegistrationArgumentType;
 import org.junit.BeforeClass;
 import org.junit.Rule;
 import org.junit.Test;
@@ -18,6 +19,7 @@ import java.nio.charset.StandardCharsets;
 import static fr.xephi.authme.TestHelper.getJarFile;
 import static fr.xephi.authme.settings.properties.PluginSettings.LOG_LEVEL;
 import static fr.xephi.authme.settings.properties.RegistrationSettings.DELAY_JOIN_MESSAGE;
+import static fr.xephi.authme.settings.properties.RegistrationSettings.REGISTRATION_TYPE;
 import static fr.xephi.authme.settings.properties.RestrictionSettings.ALLOWED_NICKNAME_CHARACTERS;
 import static fr.xephi.authme.settings.properties.RestrictionSettings.FORCE_SPAWN_LOCATION_AFTER_LOGIN;
 import static fr.xephi.authme.settings.properties.RestrictionSettings.FORCE_SPAWN_ON_WORLDS;
@@ -59,6 +61,7 @@ public class SettingsMigrationServiceTest {
         assertThat(settings.getProperty(FORCE_SPAWN_LOCATION_AFTER_LOGIN), equalTo(true));
         assertThat(settings.getProperty(FORCE_SPAWN_ON_WORLDS), contains("survival", "survival_nether", "creative"));
         assertThat(settings.getProperty(LOG_LEVEL), equalTo(LogLevel.INFO));
+        assertThat(settings.getProperty(REGISTRATION_TYPE), equalTo(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION));
 
         // Check migration of old setting to email.html
         assertThat(Files.readLines(new File(dataFolder, "email.html"), StandardCharsets.UTF_8),

src/test/java/fr/xephi/authme/task/LimboPlayerTaskManagerTest.java

@@ -9,6 +9,7 @@ import fr.xephi.authme.message.Messages;
 import fr.xephi.authme.service.BukkitService;
 import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.properties.RegistrationSettings;
+import fr.xephi.authme.settings.properties.RegistrationArgumentType;
 import fr.xephi.authme.settings.properties.RestrictionSettings;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitTask;
@@ -67,7 +68,7 @@ public class LimboPlayerTaskManagerTest {
         given(messages.retrieve(key)).willReturn(new String[]{"Please register!"});
         int interval = 12;
         given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(interval);
-        given(settings.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
+        given(settings.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION);
 
         // when
         limboPlayerTaskManager.registerMessageTask(name, false);
@@ -123,7 +124,7 @@ public class LimboPlayerTaskManagerTest {
             .willReturn(new String[]{"Please register", "Use /register"});
 
         given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(8);
-        given(settings.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(true);
+        given(settings.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL);
 
         // when
         limboPlayerTaskManager.registerMessageTask(name, false);

src/test/resources/fr/xephi/authme/settings/config-old.yml

@@ -218,11 +218,11 @@ settings:
         # See restrictions for exceptions
         force: true
         # Does we replace password registration by an Email registration method ?
-        enableEmailRegistrationSystem: false
+        enableEmailRegistrationSystem: true
         # Enable double check of email when you register
         # when it's true, registration require that kind of command:
         # /register <email> <confirmEmail>
-        doubleEmailCheck: false
+        doubleEmailCheck: true
         # Do we force kicking player after a successful registration ?
         # Do not use with login feature below
         forceKickAfterRegister: false