From 0b4d7273f672a69eed6349d4f09f1aeb62475abc Mon Sep 17 00:00:00 2001 From: ljacqu Date: Sat, 31 Dec 2016 15:34:40 +0100 Subject: [PATCH] #427 Define registration type with two options - one configuring the 2nd argument - Split sole setting to two: one defining the registration type, and one defining what the register command should take as second argument - Contains ugly code that will be fixed with a later issue --- docs/config.md | 16 ++- .../executable/register/RegisterCommand.java | 107 +++++++++++++----- .../authme/process/email/AsyncAddEmail.java | 13 ++- .../process/email/AsyncChangeEmail.java | 13 ++- .../register/RegisterSecondaryArgument.java | 20 ++++ .../process/register/RegistrationType.java | 19 ++++ .../RegistrationExecutorProvider.java | 4 - .../settings/SettingsMigrationService.java | 22 ++-- .../properties/RegistrationSettings.java | 20 +++- .../authme/task/LimboPlayerTaskManager.java | 20 ++-- src/main/java/fr/xephi/authme/util/Utils.java | 31 +++++ .../register/RegisterCommandTest.java | 49 ++++---- .../process/email/AsyncAddEmailTest.java | 9 +- .../process/email/AsyncChangeEmailTest.java | 9 +- .../settings/SettingsConsistencyTest.java | 2 +- .../SettingsMigrationServiceTest.java | 7 +- .../task/LimboPlayerTaskManagerTest.java | 9 +- 17 files changed, 264 insertions(+), 106 deletions(-) create mode 100644 src/main/java/fr/xephi/authme/process/register/RegisterSecondaryArgument.java create mode 100644 src/main/java/fr/xephi/authme/process/register/RegistrationType.java diff --git a/docs/config.md b/docs/config.md index 54a87418..c9119623 100644 --- a/docs/config.md +++ b/docs/config.md @@ -1,5 +1,5 @@ - + ## AuthMe Configuration The first time you run AuthMe it will create a config.yml file in the plugins/AuthMe folder, @@ -271,9 +271,15 @@ settings: # Only registered and logged in players can play. # See restrictions for exceptions force: true - # Type of registration: PASSWORD, PASSWORD_WITH_CONFIRMATION, EMAIL - # EMAIL_WITH_CONFIRMATION, PASSWORD_WITH_EMAIL - type: 'PASSWORD_WITH_CONFIRMATION' + # Type of registration: PASSWORD or EMAIL + # Password = account is registered with a password supplied by the user; + # Email = password is generated and sent to the email provided by the user. + type: 'PASSWORD' + # Second argument the /register command should take: NONE = no 2nd argument + # CONFIRMATION = must repeat first argument (pass or email) + # EMAIL_OPTIONAL = for password register: 2nd argument can be empty or have email address + # EMAIL_MANDATORY = for password register: 2nd argument MUST be an email address + secondArg: 'CONFIRMATION' # Do we force kick a player after a successful registration? # Do not use with login feature below forceKickAfterRegister: false @@ -447,4 +453,4 @@ To change settings on a running server, save your changes to config.yml and use --- -This page was automatically generated on the [AuthMe/AuthMeReloaded repository](https://github.com/AuthMe/AuthMeReloaded/tree/master/docs/) on Thu Dec 15 22:27:25 CET 2016 +This page was automatically generated on the [AuthMe/AuthMeReloaded repository](https://github.com/AuthMe/AuthMeReloaded/tree/master/docs/) on Sat Dec 31 15:11:17 CET 2016 diff --git a/src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java b/src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java index 243e4b12..301baf65 100644 --- a/src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java +++ b/src/main/java/fr/xephi/authme/command/executable/register/RegisterCommand.java @@ -5,23 +5,25 @@ import fr.xephi.authme.command.PlayerCommand; import fr.xephi.authme.mail.SendMailSSL; import fr.xephi.authme.message.MessageKey; import fr.xephi.authme.process.Management; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; 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.RegistrationArgumentType.Execution; +import fr.xephi.authme.settings.properties.RegistrationSettings; import fr.xephi.authme.settings.properties.SecuritySettings; import org.bukkit.entity.Player; import javax.inject.Inject; import java.util.List; -import static fr.xephi.authme.settings.properties.RegistrationArgumentType.EMAIL_WITH_CONFIRMATION; -import static fr.xephi.authme.settings.properties.RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION; -import static fr.xephi.authme.settings.properties.RegistrationArgumentType.PASSWORD_WITH_EMAIL; -import static fr.xephi.authme.settings.properties.RegistrationSettings.REGISTRATION_TYPE; +import static fr.xephi.authme.process.register.RegisterSecondaryArgument.CONFIRMATION; +import static fr.xephi.authme.process.register.RegisterSecondaryArgument.EMAIL_MANDATORY; +import static fr.xephi.authme.process.register.RegisterSecondaryArgument.EMAIL_OPTIONAL; +import static fr.xephi.authme.process.register.RegisterSecondaryArgument.NONE; +import static fr.xephi.authme.settings.properties.RegistrationSettings.REGISTER_SECOND_ARGUMENT; /** * Command for /register. @@ -50,19 +52,18 @@ public class RegisterCommand extends PlayerCommand { management.performRegister(player, registrationExecutorProvider.getTwoFactorRegisterExecutor(player)); return; - } - - // Ensure that there is 1 argument, or 2 if confirmation is required - RegistrationArgumentType registerType = commonService.getProperty(REGISTRATION_TYPE); - if (registerType.getRequiredNumberOfArgs() > arguments.size()) { + } else if (arguments.size() < 1) { commonService.send(player, MessageKey.USAGE_REGISTER); return; } - if (registerType.getExecution() == Execution.EMAIL) { + RegistrationType registrationType = commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE); + if (registrationType == RegistrationType.PASSWORD) { + handlePasswordRegistration(player, arguments); + } else if (registrationType == RegistrationType.EMAIL) { handleEmailRegistration(player, arguments); } else { - handlePasswordRegistration(player, arguments); + throw new IllegalStateException("Unknown registration type '" + registrationType + "'"); } } @@ -72,23 +73,51 @@ public class RegisterCommand extends PlayerCommand { } private void handlePasswordRegistration(Player player, List arguments) { - RegistrationArgumentType registrationType = commonService.getProperty(REGISTRATION_TYPE); - if (registrationType == PASSWORD_WITH_CONFIRMATION && !arguments.get(0).equals(arguments.get(1))) { - commonService.send(player, MessageKey.PASSWORD_MATCH_ERROR); - } else if (registrationType == PASSWORD_WITH_EMAIL && arguments.size() > 1) { - handlePasswordWithEmailRegistration(player, arguments); - } else { - management.performRegister(player, registrationExecutorProvider - .getPasswordRegisterExecutor(player, arguments.get(0))); + if (isSecondArgValidForPasswordRegistration(player, arguments)) { + final String password = arguments.get(0); + final String email = getEmailIfAvailable(arguments); + + management.performRegister( + player, registrationExecutorProvider.getPasswordRegisterExecutor(player, password, email)); } } - private void handlePasswordWithEmailRegistration(Player player, List arguments) { - if (validationService.validateEmail(arguments.get(1))) { - management.performRegister(player, registrationExecutorProvider - .getPasswordRegisterExecutor(player, arguments.get(0), arguments.get(1))); + private String getEmailIfAvailable(List arguments) { + if (arguments.size() >= 2) { + RegisterSecondaryArgument secondArgType = commonService.getProperty(REGISTER_SECOND_ARGUMENT); + if (secondArgType == EMAIL_MANDATORY || secondArgType == EMAIL_OPTIONAL) { + return arguments.get(1); + } + } + return null; + } + + private boolean isSecondArgValidForPasswordRegistration(Player player, List arguments) { + RegisterSecondaryArgument secondArgType = commonService.getProperty(REGISTER_SECOND_ARGUMENT); + // cases where args.size < 2 + if (secondArgType == NONE || secondArgType == EMAIL_OPTIONAL && arguments.size() < 2) { + return true; + } else if (arguments.size() < 2) { + commonService.send(player, MessageKey.USAGE_REGISTER); + return false; + } + + if (secondArgType == CONFIRMATION) { + if (arguments.get(0).equals(arguments.get(1))) { + return true; + } else { + commonService.send(player, MessageKey.PASSWORD_MATCH_ERROR); + return false; + } + } else if (secondArgType == EMAIL_MANDATORY || secondArgType == EMAIL_OPTIONAL) { + if (validationService.validateEmail(arguments.get(1))) { + return true; + } else { + commonService.send(player, MessageKey.INVALID_EMAIL); + return false; + } } else { - commonService.send(player, MessageKey.INVALID_EMAIL); + throw new IllegalStateException("Unknown secondary argument type '" + secondArgType + "'"); } } @@ -103,10 +132,30 @@ public class RegisterCommand extends PlayerCommand { final String email = arguments.get(0); if (!validationService.validateEmail(email)) { commonService.send(player, MessageKey.INVALID_EMAIL); - } else if (commonService.getProperty(REGISTRATION_TYPE) == EMAIL_WITH_CONFIRMATION && !email.equals(arguments.get(1))) { - commonService.send(player, MessageKey.USAGE_REGISTER); - } else { + } else if (isSecondArgValidForEmailRegistration(player, arguments)) { management.performRegister(player, registrationExecutorProvider.getEmailRegisterExecutor(player, email)); } } + + private boolean isSecondArgValidForEmailRegistration(Player player, List arguments) { + RegisterSecondaryArgument secondArgType = commonService.getProperty(REGISTER_SECOND_ARGUMENT); + // cases where args.size < 2 + if (secondArgType == NONE || secondArgType == EMAIL_OPTIONAL && arguments.size() < 2) { + return true; + } else if (arguments.size() < 2) { + commonService.send(player, MessageKey.USAGE_REGISTER); + return false; + } + + if (secondArgType == EMAIL_OPTIONAL || secondArgType == EMAIL_MANDATORY || secondArgType == CONFIRMATION) { + if (arguments.get(0).equals(arguments.get(1))) { + return true; + } else { + commonService.send(player, MessageKey.USAGE_REGISTER); + return false; + } + } else { + throw new IllegalStateException("Unknown secondary argument type '" + secondArgType + "'"); + } + } } diff --git a/src/main/java/fr/xephi/authme/process/email/AsyncAddEmail.java b/src/main/java/fr/xephi/authme/process/email/AsyncAddEmail.java index 24546f7a..44bc4d82 100644 --- a/src/main/java/fr/xephi/authme/process/email/AsyncAddEmail.java +++ b/src/main/java/fr/xephi/authme/process/email/AsyncAddEmail.java @@ -1,9 +1,5 @@ package fr.xephi.authme.process.email; -import javax.inject.Inject; - -import org.bukkit.entity.Player; - import fr.xephi.authme.ConsoleLogger; import fr.xephi.authme.data.auth.PlayerAuth; import fr.xephi.authme.data.auth.PlayerCache; @@ -13,6 +9,10 @@ import fr.xephi.authme.process.AsynchronousProcess; import fr.xephi.authme.service.CommonService; import fr.xephi.authme.service.ValidationService; import fr.xephi.authme.settings.properties.RegistrationSettings; +import fr.xephi.authme.util.Utils; +import org.bukkit.entity.Player; + +import javax.inject.Inject; /** * Async task to add an email to an account. @@ -65,7 +65,10 @@ public class AsyncAddEmail implements AsynchronousProcess { if (dataSource.isAuthAvailable(player.getName())) { service.send(player, MessageKey.LOGIN_MESSAGE); } else { - service.send(player, service.getProperty(RegistrationSettings.REGISTRATION_TYPE).getMessageKey()); + MessageKey registerMessage = Utils.getRegisterMessage( + service.getProperty(RegistrationSettings.REGISTRATION_TYPE), + service.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)); + service.send(player, registerMessage); } } diff --git a/src/main/java/fr/xephi/authme/process/email/AsyncChangeEmail.java b/src/main/java/fr/xephi/authme/process/email/AsyncChangeEmail.java index 956f5baf..3968bd41 100644 --- a/src/main/java/fr/xephi/authme/process/email/AsyncChangeEmail.java +++ b/src/main/java/fr/xephi/authme/process/email/AsyncChangeEmail.java @@ -1,9 +1,5 @@ package fr.xephi.authme.process.email; -import javax.inject.Inject; - -import org.bukkit.entity.Player; - import fr.xephi.authme.data.auth.PlayerAuth; import fr.xephi.authme.data.auth.PlayerCache; import fr.xephi.authme.datasource.DataSource; @@ -12,6 +8,10 @@ import fr.xephi.authme.process.AsynchronousProcess; import fr.xephi.authme.service.CommonService; import fr.xephi.authme.service.ValidationService; import fr.xephi.authme.settings.properties.RegistrationSettings; +import fr.xephi.authme.util.Utils; +import org.bukkit.entity.Player; + +import javax.inject.Inject; /** * Async task for changing the email. @@ -68,7 +68,10 @@ public class AsyncChangeEmail implements AsynchronousProcess { if (dataSource.isAuthAvailable(player.getName())) { service.send(player, MessageKey.LOGIN_MESSAGE); } else { - service.send(player, service.getProperty(RegistrationSettings.REGISTRATION_TYPE).getMessageKey()); + MessageKey registerMessage = Utils.getRegisterMessage( + service.getProperty(RegistrationSettings.REGISTRATION_TYPE), + service.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)); + service.send(player, registerMessage); } } } diff --git a/src/main/java/fr/xephi/authme/process/register/RegisterSecondaryArgument.java b/src/main/java/fr/xephi/authme/process/register/RegisterSecondaryArgument.java new file mode 100644 index 00000000..4ac4f2d5 --- /dev/null +++ b/src/main/java/fr/xephi/authme/process/register/RegisterSecondaryArgument.java @@ -0,0 +1,20 @@ +package fr.xephi.authme.process.register; + +/** + * Type of the second argument of the {@code /register} command. + */ +public enum RegisterSecondaryArgument { + + /** No second argument. */ + NONE, + + /** Confirmation of the first argument. */ + CONFIRMATION, + + /** For password registration, mandatory secondary argument is email. */ + EMAIL_MANDATORY, + + /** For password registration, optional secondary argument is email. */ + EMAIL_OPTIONAL + +} diff --git a/src/main/java/fr/xephi/authme/process/register/RegistrationType.java b/src/main/java/fr/xephi/authme/process/register/RegistrationType.java new file mode 100644 index 00000000..7b03b1c2 --- /dev/null +++ b/src/main/java/fr/xephi/authme/process/register/RegistrationType.java @@ -0,0 +1,19 @@ +package fr.xephi.authme.process.register; + +/** + * Registration type. + */ +public enum RegistrationType { + + /** + * Password registration: account is registered with a password supplied by the player. + */ + PASSWORD, + + /** + * Email registration: account is registered with an email supplied by the player. A password + * is generated and sent to the email address. + */ + EMAIL + +} diff --git a/src/main/java/fr/xephi/authme/process/register/executors/RegistrationExecutorProvider.java b/src/main/java/fr/xephi/authme/process/register/executors/RegistrationExecutorProvider.java index 04adce31..286a5163 100644 --- a/src/main/java/fr/xephi/authme/process/register/executors/RegistrationExecutorProvider.java +++ b/src/main/java/fr/xephi/authme/process/register/executors/RegistrationExecutorProvider.java @@ -18,10 +18,6 @@ public class RegistrationExecutorProvider { RegistrationExecutorProvider() { } - public RegistrationExecutor getPasswordRegisterExecutor(Player player, String password) { - return getPasswordRegisterExecutor(player, password, null); - } - public RegistrationExecutor getPasswordRegisterExecutor(Player player, String password, String email) { return passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, password, email); } diff --git a/src/main/java/fr/xephi/authme/settings/SettingsMigrationService.java b/src/main/java/fr/xephi/authme/settings/SettingsMigrationService.java index cc79440e..96a65f75 100644 --- a/src/main/java/fr/xephi/authme/settings/SettingsMigrationService.java +++ b/src/main/java/fr/xephi/authme/settings/SettingsMigrationService.java @@ -8,8 +8,9 @@ import com.google.common.base.Objects; import fr.xephi.authme.ConsoleLogger; import fr.xephi.authme.initialization.DataFolder; import fr.xephi.authme.output.LogLevel; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; import fr.xephi.authme.settings.properties.PluginSettings; -import fr.xephi.authme.settings.properties.RegistrationArgumentType; import fr.xephi.authme.settings.properties.RegistrationSettings; import fr.xephi.authme.settings.properties.SecuritySettings; @@ -232,25 +233,20 @@ public class SettingsMigrationService extends PlainMigrationService { } boolean useEmail = newProperty("settings.registration.enableEmailRegistrationSystem", false).getValue(resource); + RegistrationType registrationType = useEmail ? RegistrationType.EMAIL : RegistrationType.PASSWORD; + String useConfirmationPath = useEmail ? "settings.registration.doubleEmailCheck" : "settings.restrictions.enablePasswordConfirmation"; boolean hasConfirmation = newProperty(useConfirmationPath, false).getValue(resource); - - RegistrationArgumentType registerType; - if (useEmail) { - registerType = hasConfirmation - ? RegistrationArgumentType.EMAIL_WITH_CONFIRMATION - : RegistrationArgumentType.EMAIL; - } else { - registerType = hasConfirmation - ? RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION - : RegistrationArgumentType.PASSWORD; - } + RegisterSecondaryArgument secondaryArgument = hasConfirmation + ? RegisterSecondaryArgument.CONFIRMATION + : RegisterSecondaryArgument.NONE; ConsoleLogger.warning("Merging old registration settings into '" + RegistrationSettings.REGISTRATION_TYPE.getPath() + "'"); - resource.setValue(RegistrationSettings.REGISTRATION_TYPE.getPath(), registerType); + resource.setValue(RegistrationSettings.REGISTRATION_TYPE.getPath(), registrationType); + resource.setValue(RegistrationSettings.REGISTER_SECOND_ARGUMENT.getPath(), secondaryArgument); return true; } diff --git a/src/main/java/fr/xephi/authme/settings/properties/RegistrationSettings.java b/src/main/java/fr/xephi/authme/settings/properties/RegistrationSettings.java index 5ab4d21a..932c1be3 100644 --- a/src/main/java/fr/xephi/authme/settings/properties/RegistrationSettings.java +++ b/src/main/java/fr/xephi/authme/settings/properties/RegistrationSettings.java @@ -3,6 +3,8 @@ package fr.xephi.authme.settings.properties; import ch.jalu.configme.Comment; import ch.jalu.configme.SettingsHolder; import ch.jalu.configme.properties.Property; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; import static ch.jalu.configme.properties.PropertyInitializer.newProperty; @@ -25,11 +27,21 @@ public class RegistrationSettings implements SettingsHolder { newProperty("settings.registration.force", true); @Comment({ - "Type of registration: PASSWORD, PASSWORD_WITH_CONFIRMATION, EMAIL", - "EMAIL_WITH_CONFIRMATION, PASSWORD_WITH_EMAIL" + "Type of registration: PASSWORD or EMAIL", + "Password = account is registered with a password supplied by the user;", + "Email = password is generated and sent to the email provided by the user." }) - public static final Property REGISTRATION_TYPE = - newProperty(RegistrationArgumentType.class, "settings.registration.type", RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION); + public static final Property REGISTRATION_TYPE = + newProperty(RegistrationType.class, "settings.registration.type", RegistrationType.PASSWORD); + + @Comment({ + "Second argument the /register command should take: NONE = no 2nd argument", + "CONFIRMATION = must repeat first argument (pass or email)", + "EMAIL_OPTIONAL = for password register: 2nd argument can be empty or have email address", + "EMAIL_MANDATORY = for password register: 2nd argument MUST be an email address" + }) + public static final Property REGISTER_SECOND_ARGUMENT = + newProperty(RegisterSecondaryArgument.class, "settings.registration.secondArg", RegisterSecondaryArgument.CONFIRMATION); @Comment({ "Do we force kick a player after a successful registration?", diff --git a/src/main/java/fr/xephi/authme/task/LimboPlayerTaskManager.java b/src/main/java/fr/xephi/authme/task/LimboPlayerTaskManager.java index e4b280e7..3ab83132 100644 --- a/src/main/java/fr/xephi/authme/task/LimboPlayerTaskManager.java +++ b/src/main/java/fr/xephi/authme/task/LimboPlayerTaskManager.java @@ -1,13 +1,5 @@ package fr.xephi.authme.task; -import static fr.xephi.authme.service.BukkitService.TICKS_PER_SECOND; - -import javax.inject.Inject; - -import org.bukkit.entity.Player; -import org.bukkit.scheduler.BukkitRunnable; -import org.bukkit.scheduler.BukkitTask; - import fr.xephi.authme.ConsoleLogger; import fr.xephi.authme.data.auth.PlayerCache; import fr.xephi.authme.data.limbo.LimboCache; @@ -18,6 +10,14 @@ 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.RestrictionSettings; +import fr.xephi.authme.util.Utils; +import org.bukkit.entity.Player; +import org.bukkit.scheduler.BukkitRunnable; +import org.bukkit.scheduler.BukkitTask; + +import javax.inject.Inject; + +import static fr.xephi.authme.service.BukkitService.TICKS_PER_SECOND; /** * Registers tasks associated with a PlayerData. @@ -96,7 +96,9 @@ public class LimboPlayerTaskManager { if (isRegistered) { return MessageKey.LOGIN_MESSAGE; } else { - return settings.getProperty(RegistrationSettings.REGISTRATION_TYPE).getMessageKey(); + return Utils.getRegisterMessage( + settings.getProperty(RegistrationSettings.REGISTRATION_TYPE), + settings.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)); } } diff --git a/src/main/java/fr/xephi/authme/util/Utils.java b/src/main/java/fr/xephi/authme/util/Utils.java index 39419689..914d2744 100644 --- a/src/main/java/fr/xephi/authme/util/Utils.java +++ b/src/main/java/fr/xephi/authme/util/Utils.java @@ -1,6 +1,10 @@ package fr.xephi.authme.util; import fr.xephi.authme.ConsoleLogger; +import fr.xephi.authme.message.MessageKey; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; + import java.util.regex.Pattern; /** @@ -57,4 +61,31 @@ public final class Utils { public static int getCoreCount() { return Runtime.getRuntime().availableProcessors(); } + + /** + * Returns the proper message key for the given registration types. + * + * @param registrationType the registration type + * @param secondaryArgType secondary argument type for the register command + * @return the message key + */ + // TODO #1037: Remove this method + public static MessageKey getRegisterMessage(RegistrationType registrationType, + RegisterSecondaryArgument secondaryArgType) { + if (registrationType == RegistrationType.PASSWORD) { + if (secondaryArgType == RegisterSecondaryArgument.CONFIRMATION) { + return MessageKey.REGISTER_MESSAGE; + } else if (secondaryArgType == RegisterSecondaryArgument.NONE) { + return MessageKey.REGISTER_NO_REPEAT_MESSAGE; + } else { /* EMAIL_MANDATORY || EMAIL_OPTIONAL */ + return MessageKey.REGISTER_PASSWORD_EMAIL_MESSAGE; + } + } else { /* registrationType == EMAIL */ + if (secondaryArgType == RegisterSecondaryArgument.NONE) { + return MessageKey.REGISTER_EMAIL_NO_REPEAT_MESSAGE; + } else { /* CONFIRMATION || EMAIL_MANDATORY || EMAIL_OPTIONAL */ + return MessageKey.REGISTER_EMAIL_MESSAGE; + } + } + } } diff --git a/src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java index 7b111cf9..76d1352d 100644 --- a/src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java +++ b/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.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; 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.RegistrationArgumentType; import fr.xephi.authme.settings.properties.RegistrationSettings; import fr.xephi.authme.settings.properties.SecuritySettings; import org.bukkit.command.BlockCommandSender; @@ -67,7 +68,8 @@ public class RegisterCommandTest { @Before public void linkMocksAndProvideSettingDefaults() { given(commonService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.BCRYPT); - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.NONE); } @Test @@ -115,7 +117,8 @@ public class RegisterCommandTest { @Test public void shouldReturnErrorForMissingConfirmation() { // given - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION); Player player = mock(Player.class); // when @@ -129,7 +132,10 @@ public class RegisterCommandTest { @Test public void shouldReturnErrorForMissingEmailConfirmation() { // given - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION); + given(sendMailSsl.hasAllInformation()).willReturn(true); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.EMAIL_MANDATORY); + given(validationService.validateEmail(anyString())).willReturn(true); Player player = mock(Player.class); // when @@ -137,13 +143,13 @@ public class RegisterCommandTest { // then verify(commonService).send(player, MessageKey.USAGE_REGISTER); - verifyZeroInteractions(management, sendMailSsl); + verifyZeroInteractions(management); } @Test public void shouldThrowErrorForMissingEmailConfiguration() { // given - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); given(sendMailSsl.hasAllInformation()).willReturn(false); Player player = mock(Player.class); @@ -161,7 +167,7 @@ public class RegisterCommandTest { // given String playerMail = "player@example.org"; given(validationService.validateEmail(playerMail)).willReturn(false); - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); given(sendMailSsl.hasAllInformation()).willReturn(true); Player player = mock(Player.class); @@ -179,7 +185,8 @@ public class RegisterCommandTest { // given String playerMail = "bobber@bobby.org"; given(validationService.validateEmail(playerMail)).willReturn(true); - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION); given(sendMailSsl.hasAllInformation()).willReturn(true); Player player = mock(Player.class); @@ -197,7 +204,8 @@ public class RegisterCommandTest { // given String playerMail = "asfd@lakjgre.lds"; given(validationService.validateEmail(playerMail)).willReturn(true); - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION); given(sendMailSsl.hasAllInformation()).willReturn(true); Player player = mock(Player.class); RegistrationExecutor executor = mock(RegistrationExecutor.class); @@ -215,7 +223,8 @@ public class RegisterCommandTest { @Test public void shouldRejectInvalidPasswordConfirmation() { // given - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION); Player player = mock(Player.class); // when @@ -227,11 +236,11 @@ public class RegisterCommandTest { } @Test - public void shouldPerformPasswordValidation() { + public void shouldPerformPasswordRegistration() { // given Player player = mock(Player.class); RegistrationExecutor executor = mock(RegistrationExecutor.class); - given(registrationExecutorProvider.getPasswordRegisterExecutor(player, "myPass")).willReturn(executor); + given(registrationExecutorProvider.getPasswordRegisterExecutor(player, "myPass", null)).willReturn(executor); // when command.executeCommand(player, Collections.singletonList("myPass")); @@ -243,8 +252,8 @@ public class RegisterCommandTest { @Test public void shouldPerformMailValidationForPasswordWithEmail() { // given - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)) - .willReturn(RegistrationArgumentType.PASSWORD_WITH_EMAIL); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.EMAIL_MANDATORY); String email = "email@example.org"; given(validationService.validateEmail(email)).willReturn(true); Player player = mock(Player.class); @@ -262,8 +271,8 @@ public class RegisterCommandTest { @Test public void shouldStopForInvalidEmail() { // given - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)) - .willReturn(RegistrationArgumentType.PASSWORD_WITH_EMAIL); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.EMAIL_OPTIONAL); String email = "email@example.org"; given(validationService.validateEmail(email)).willReturn(false); Player player = mock(Player.class); @@ -280,17 +289,17 @@ public class RegisterCommandTest { @Test public void shouldPerformNormalPasswordRegisterForOneArgument() { // given - given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)) - .willReturn(RegistrationArgumentType.PASSWORD_WITH_EMAIL); + given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.EMAIL_OPTIONAL); Player player = mock(Player.class); RegistrationExecutor executor = mock(RegistrationExecutor.class); - given(registrationExecutorProvider.getPasswordRegisterExecutor(eq(player), anyString())).willReturn(executor); + given(registrationExecutorProvider.getPasswordRegisterExecutor(eq(player), anyString(), eq(null))).willReturn(executor); // when command.executeCommand(player, Collections.singletonList("myPass")); // then - verify(registrationExecutorProvider).getPasswordRegisterExecutor(player, "myPass"); + verify(registrationExecutorProvider).getPasswordRegisterExecutor(player, "myPass", null); verify(management).performRegister(player, executor); } } diff --git a/src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java b/src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java index 433e5f10..29c95240 100644 --- a/src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java +++ b/src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java @@ -5,10 +5,11 @@ import fr.xephi.authme.data.auth.PlayerAuth; import fr.xephi.authme.data.auth.PlayerCache; import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.message.MessageKey; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; 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; @@ -173,7 +174,8 @@ public class AsyncAddEmailTest { given(player.getName()).willReturn("user"); given(playerCache.isAuthenticated("user")).willReturn(false); given(dataSource.isAuthAvailable("user")).willReturn(false); - given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL); + given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); + given(service.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.NONE); // when asyncAddEmail.addEmail(player, "test@mail.com"); @@ -189,7 +191,8 @@ public class AsyncAddEmailTest { given(player.getName()).willReturn("user"); given(playerCache.isAuthenticated("user")).willReturn(false); given(dataSource.isAuthAvailable("user")).willReturn(false); - given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD_WITH_CONFIRMATION); + given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(service.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION); // when asyncAddEmail.addEmail(player, "test@mail.com"); diff --git a/src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java b/src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java index aab07642..77461f56 100644 --- a/src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java +++ b/src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java @@ -4,10 +4,11 @@ import fr.xephi.authme.data.auth.PlayerAuth; import fr.xephi.authme.data.auth.PlayerCache; import fr.xephi.authme.datasource.DataSource; import fr.xephi.authme.message.MessageKey; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; 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; @@ -185,7 +186,8 @@ public class AsyncChangeEmailTest { given(player.getName()).willReturn("Bobby"); given(playerCache.isAuthenticated("bobby")).willReturn(false); given(dataSource.isAuthAvailable("Bobby")).willReturn(false); - given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION); + given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); + given(service.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION); // when process.changeEmail(player, "old@mail.tld", "new@mail.tld"); @@ -202,7 +204,8 @@ public class AsyncChangeEmailTest { given(player.getName()).willReturn("Bobby"); given(playerCache.isAuthenticated("bobby")).willReturn(false); given(dataSource.isAuthAvailable("Bobby")).willReturn(false); - given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.PASSWORD); + given(service.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD); + given(service.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.NONE); // when process.changeEmail(player, "old@mail.tld", "new@mail.tld"); diff --git a/src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java b/src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java index 0df17990..88724a84 100644 --- a/src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java +++ b/src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java @@ -37,7 +37,7 @@ public class SettingsConsistencyTest { // when / then for (Property property : properties) { if (configurationData.getCommentsForSection(property.getPath()).length == 0) { - fail("No comment defined for '" + property + "'"); + fail("No comment defined for " + property); } } } diff --git a/src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java b/src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java index 852f5c3b..67893666 100644 --- a/src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java +++ b/src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java @@ -5,8 +5,9 @@ import ch.jalu.configme.resource.YamlFileResource; import com.google.common.io.Files; import fr.xephi.authme.TestHelper; import fr.xephi.authme.output.LogLevel; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; 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; @@ -19,6 +20,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.REGISTER_SECOND_ARGUMENT; 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; @@ -61,7 +63,8 @@ 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)); + assertThat(settings.getProperty(REGISTRATION_TYPE), equalTo(RegistrationType.EMAIL)); + assertThat(settings.getProperty(REGISTER_SECOND_ARGUMENT), equalTo(RegisterSecondaryArgument.CONFIRMATION)); // Check migration of old setting to email.html assertThat(Files.readLines(new File(dataFolder, "email.html"), StandardCharsets.UTF_8), diff --git a/src/test/java/fr/xephi/authme/task/LimboPlayerTaskManagerTest.java b/src/test/java/fr/xephi/authme/task/LimboPlayerTaskManagerTest.java index 132adef9..d1713878 100644 --- a/src/test/java/fr/xephi/authme/task/LimboPlayerTaskManagerTest.java +++ b/src/test/java/fr/xephi/authme/task/LimboPlayerTaskManagerTest.java @@ -6,10 +6,11 @@ import fr.xephi.authme.data.limbo.LimboCache; import fr.xephi.authme.data.limbo.LimboPlayer; import fr.xephi.authme.message.MessageKey; import fr.xephi.authme.message.Messages; +import fr.xephi.authme.process.register.RegisterSecondaryArgument; +import fr.xephi.authme.process.register.RegistrationType; 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; @@ -68,7 +69,8 @@ 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.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL_WITH_CONFIRMATION); + given(settings.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); + given(settings.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION); // when limboPlayerTaskManager.registerMessageTask(name, false); @@ -124,7 +126,8 @@ public class LimboPlayerTaskManagerTest { .willReturn(new String[]{"Please register", "Use /register"}); given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(8); - given(settings.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationArgumentType.EMAIL); + given(settings.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL); + given(settings.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.NONE); // when limboPlayerTaskManager.registerMessageTask(name, false);