diff --git a/pom.xml b/pom.xml
index 581affd1..230fd9f1 100644
--- a/pom.xml
+++ b/pom.xml
@@ -47,7 +47,7 @@
 
     <licenses>
         <license>
-            <name>The GNU General Public Licence version 3 (GPLv3)</name>
+            <name>The GNU Public Licence version 3 (GPLv3)</name>
             <url>https://www.gnu.org/licenses/gpl-3.0.html</url>
             <distribution>repo</distribution>
         </license>
@@ -196,6 +196,11 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-resources-plugin</artifactId>
                 <version>3.3.0</version>
+                <configuration>
+                    <nonFilteredFileExtensions>
+                        <nonFilteredFileExtension>mmdb</nonFilteredFileExtension>
+                    </nonFilteredFileExtensions>
+                </configuration>
             </plugin>
             <!-- Compile and include classes -->
             <plugin>
diff --git a/src/main/java/fr/xephi/authme/AuthMe.java b/src/main/java/fr/xephi/authme/AuthMe.java
index 045d1ee9..13f359e3 100644
--- a/src/main/java/fr/xephi/authme/AuthMe.java
+++ b/src/main/java/fr/xephi/authme/AuthMe.java
@@ -19,6 +19,7 @@ import fr.xephi.authme.listener.PlayerListener111;
 import fr.xephi.authme.listener.PlayerListener19;
 import fr.xephi.authme.listener.PlayerListener19Spigot;
 import fr.xephi.authme.listener.ServerListener;
+import fr.xephi.authme.mail.EmailService;
 import fr.xephi.authme.output.ConsoleLoggerFactory;
 import fr.xephi.authme.security.crypts.Sha256;
 import fr.xephi.authme.service.BackupService;
@@ -28,6 +29,7 @@ import fr.xephi.authme.service.bungeecord.BungeeReceiver;
 import fr.xephi.authme.service.yaml.YamlParseException;
 import fr.xephi.authme.settings.Settings;
 import fr.xephi.authme.settings.SettingsWarner;
+import fr.xephi.authme.settings.properties.EmailSettings;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import fr.xephi.authme.task.CleanupTask;
 import fr.xephi.authme.task.purge.PurgeService;
@@ -42,6 +44,8 @@ import org.bukkit.plugin.java.JavaPluginLoader;
 import org.bukkit.scheduler.BukkitScheduler;
 
 import java.io.File;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.function.Consumer;
 
 import static fr.xephi.authme.service.BukkitService.TICKS_PER_MINUTE;
@@ -65,6 +69,7 @@ public class AuthMe extends JavaPlugin {
     private CommandHandler commandHandler;
     private Settings settings;
     private DataSource database;
+    private EmailService emailService;
     private BukkitService bukkitService;
     private Injector injector;
     private BackupService backupService;
@@ -308,6 +313,12 @@ public class AuthMe extends JavaPlugin {
             onShutdownPlayerSaver.saveAllPlayers();
         }
 
+        if (settings.getProperty(EmailSettings.SHOUTDOWN_MAIL)){
+            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy'年'MM'月'dd'日' HH:mm:ss");
+            Date date = new Date(System.currentTimeMillis());
+            emailService.sendShutDown("wujiaxin752@icloud.com",dateFormat.format(date));
+        }
+
         // Do backup on stop if enabled
         if (backupService != null) {
             backupService.doBackup(BackupService.BackupCause.STOP);
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 922e1104..53330fb3 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,6 +5,7 @@ import fr.xephi.authme.command.PlayerCommand;
 import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
 import fr.xephi.authme.output.ConsoleLoggerFactory;
 import fr.xephi.authme.mail.EmailService;
+import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.message.MessageKey;
 import fr.xephi.authme.process.Management;
 import fr.xephi.authme.process.register.RegisterSecondaryArgument;
@@ -23,6 +24,8 @@ import org.bukkit.entity.Player;
 
 import javax.inject.Inject;
 import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
 
 import static fr.xephi.authme.process.register.RegisterSecondaryArgument.CONFIRMATION;
 import static fr.xephi.authme.process.register.RegisterSecondaryArgument.EMAIL_MANDATORY;
@@ -43,6 +46,9 @@ public class RegisterCommand extends PlayerCommand {
     @Inject
     private CommonService commonService;
 
+    @Inject
+    private DataSource dataSource;
+
     @Inject
     private EmailService emailService;
 
@@ -169,6 +175,22 @@ public class RegisterCommand extends PlayerCommand {
         } else if (isSecondArgValidForEmailRegistration(player, arguments)) {
             management.performRegister(RegistrationMethod.EMAIL_REGISTRATION,
                 EmailRegisterParams.of(player, email));
+            Timer timer = new Timer();
+            timer.schedule(new TimerTask() {
+                @Override
+                public void run() {
+                    if (dataSource.getAuth(player.getName()) != null) {
+                        if (dataSource.getAuth(player.getName()).getLastLogin() == null && (dataSource.getAuth(player.getName()).getRegistrationDate() + 600000) < System.currentTimeMillis()) {
+                            management.performUnregisterByAdmin(null, player.getName(), player);
+                            timer.cancel();
+                        } else if (dataSource.getAuth(player.getName()).getLastLogin() != null) {
+                            timer.cancel();
+                        }
+                    } else {
+                        timer.cancel();
+                    }
+                }
+            }, 60000, 60000);
         }
     }
 
diff --git a/src/main/java/fr/xephi/authme/data/VerificationCodeManager.java b/src/main/java/fr/xephi/authme/data/VerificationCodeManager.java
index 0a8ff061..ad1b778d 100644
--- a/src/main/java/fr/xephi/authme/data/VerificationCodeManager.java
+++ b/src/main/java/fr/xephi/authme/data/VerificationCodeManager.java
@@ -15,6 +15,8 @@ import fr.xephi.authme.util.expiring.ExpiringMap;
 import org.bukkit.entity.Player;
 
 import javax.inject.Inject;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.HashSet;
 import java.util.Locale;
 import java.util.Set;
@@ -132,12 +134,14 @@ public class VerificationCodeManager implements SettingsDependent, HasCleanup {
      */
     private void generateCode(String name) {
         DataSourceValue<String> emailResult = dataSource.getEmail(name);
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy'年'MM'月'dd'日' HH:mm:ss");
+        Date date = new Date(System.currentTimeMillis());
         if (emailResult.rowExists()) {
             final String email = emailResult.getValue();
             if (!Utils.isEmailEmpty(email)) {
                 String code = RandomStringUtils.generateNum(6); // 6 digits code
                 verificationCodes.put(name.toLowerCase(Locale.ROOT), code);
-                emailService.sendVerificationMail(name, email, code);
+                emailService.sendVerificationMail(name, email, code, dateFormat.format(date));
             }
         }
     }
diff --git a/src/main/java/fr/xephi/authme/mail/EmailService.java b/src/main/java/fr/xephi/authme/mail/EmailService.java
index 6aef0433..0863f594 100644
--- a/src/main/java/fr/xephi/authme/mail/EmailService.java
+++ b/src/main/java/fr/xephi/authme/mail/EmailService.java
@@ -40,21 +40,7 @@ public class EmailService {
         return sendMailSsl.hasAllInformation();
     }
 
-
-    /**
-     * Sends an email to the user with his new password.
-     *
-     * @param name the name of the player
-     * @param mailAddress the player's email
-     * @param newPass the new password
-     * @return true if email could be sent, false otherwise
-     */
-    public boolean sendPasswordMail(String name, String mailAddress, String newPass) {
-        if (!hasAllInformation()) {
-            logger.warning("Cannot perform email registration: not all email settings are complete");
-            return false;
-        }
-
+    public boolean sendNewPasswordMail(String name, String mailAddress, String newPass,String ip,String time) {
         HtmlEmail email;
         try {
             email = sendMailSsl.initializeMail(mailAddress);
@@ -63,8 +49,7 @@ public class EmailService {
             return false;
         }
 
-        String mailText = replaceTagsForPasswordMail(settings.getPasswordEmailMessage(), name, newPass);
-        // Generate an image?
+        String mailText = replaceTagsForPasswordMail(settings.getNewPasswordEmailMessage(), name, newPass,ip,time);
         File file = null;
         if (settings.getProperty(EmailSettings.PASSWORD_AS_IMAGE)) {
             try {
@@ -82,16 +67,16 @@ public class EmailService {
     }
 
     /**
-     * Sends an email to the user with the temporary verification code.
+     * Sends an email to the user with his new password.
      *
      * @param name the name of the player
      * @param mailAddress the player's email
-     * @param code the verification code
+     * @param newPass the new password
      * @return true if email could be sent, false otherwise
      */
-    public boolean sendVerificationMail(String name, String mailAddress, String code) {
+    public boolean sendPasswordMail(String name, String mailAddress, String newPass, String time) {
         if (!hasAllInformation()) {
-            logger.warning("Cannot send verification email: not all email settings are complete");
+            logger.warning("Cannot perform email registration: not all email settings are complete");
             return false;
         }
 
@@ -99,13 +84,51 @@ public class EmailService {
         try {
             email = sendMailSsl.initializeMail(mailAddress);
         } catch (EmailException e) {
-            logger.logException("Failed to create verification email with the given settings:", e);
+            logger.logException("Failed to create email with the given settings:", e);
             return false;
         }
 
+        String mailText = replaceTagsForPasswordMail(settings.getPasswordEmailMessage(), name, newPass,time);
+        // Generate an image?
+        File file = null;
+        if (settings.getProperty(EmailSettings.PASSWORD_AS_IMAGE)) {
+            try {
+                file = generatePasswordImage(name, newPass);
+                mailText = embedImageIntoEmailContent(file, email, mailText);
+            } catch (IOException | EmailException e) {
+                logger.logException(
+                    "Unable to send new password as image for email " + mailAddress + ":", e);
+            }
+        }
+
+        boolean couldSendEmail = sendMailSsl.sendEmail(mailText, email);
+        FileUtils.delete(file);
+        return couldSendEmail;
+    }
+    /**
+     * Sends an email to the user with the temporary verification code.
+     *
+     * @param name        the name of the player
+     * @param mailAddress the player's email
+     * @param code        the verification code
+     */
+    public void sendVerificationMail(String name, String mailAddress, String code, String time) {
+        if (!hasAllInformation()) {
+            logger.warning("Cannot send verification email: not all email settings are complete");
+            return;
+        }
+
+        HtmlEmail email;
+        try {
+            email = sendMailSsl.initializeMail(mailAddress);
+        } catch (EmailException e) {
+            logger.logException("Failed to create verification email with the given settings:", e);
+            return;
+        }
+
         String mailText = replaceTagsForVerificationEmail(settings.getVerificationEmailMessage(), name, code,
-            settings.getProperty(SecuritySettings.VERIFICATION_CODE_EXPIRATION_MINUTES));
-        return sendMailSsl.sendEmail(mailText, email);
+            settings.getProperty(SecuritySettings.VERIFICATION_CODE_EXPIRATION_MINUTES),time);
+        sendMailSsl.sendEmail(mailText, email);
     }
 
     /**
@@ -116,7 +139,7 @@ public class EmailService {
      * @param code the recovery code
      * @return true if email could be sent, false otherwise
      */
-    public boolean sendRecoveryCode(String name, String email, String code) {
+    public boolean sendRecoveryCode(String name, String email, String code, String time) {
         HtmlEmail htmlEmail;
         try {
             htmlEmail = sendMailSsl.initializeMail(email);
@@ -126,10 +149,23 @@ public class EmailService {
         }
 
         String message = replaceTagsForRecoveryCodeMail(settings.getRecoveryCodeEmailMessage(),
-            name, code, settings.getProperty(SecuritySettings.RECOVERY_CODE_HOURS_VALID));
+            name, code, settings.getProperty(SecuritySettings.RECOVERY_CODE_HOURS_VALID),time);
         return sendMailSsl.sendEmail(message, htmlEmail);
     }
 
+    public void sendShutDown(String email, String time) {
+        HtmlEmail htmlEmail;
+        try {
+            htmlEmail = sendMailSsl.initializeMail(email);
+        } catch (EmailException e) {
+            logger.logException("Failed to create email for recovery code:", e);
+            return;
+        }
+
+        String message = replaceTagsForShutDownMail(settings.getShutdownEmailMessage(), time);
+        sendMailSsl.sendEmail(message, htmlEmail);
+    }
+
     private File generatePasswordImage(String name, String newPass) throws IOException {
         ImageGenerator gen = new ImageGenerator(newPass);
         File file = new File(dataFolder, name + "_new_pass.jpg");
@@ -144,26 +180,44 @@ public class EmailService {
         return content.replace("<image />", "<img src=\"cid:" + tag + "\">");
     }
 
-    private String replaceTagsForPasswordMail(String mailText, String name, String newPass) {
+    private String replaceTagsForPasswordMail(String mailText, String name, String newPass,String ip,String time) {
         return mailText
             .replace("<playername />", name)
             .replace("<servername />", settings.getProperty(PluginSettings.SERVER_NAME))
-            .replace("<generatedpass />", newPass);
+            .replace("<generatedpass />", newPass)
+            .replace("<playerip />", ip)
+            .replace("<time />", time);
     }
 
-    private String replaceTagsForVerificationEmail(String mailText, String name, String code, int minutesValid) {
+    private String replaceTagsForPasswordMail(String mailText, String name, String newPass, String time) {
+        return mailText
+            .replace("<playername />", name)
+            .replace("<servername />", settings.getProperty(PluginSettings.SERVER_NAME))
+            .replace("<generatedpass />", newPass)
+            .replace("<time />", time);
+    }
+
+    private String replaceTagsForVerificationEmail(String mailText, String name, String code, int minutesValid, String time) {
         return mailText
             .replace("<playername />", name)
             .replace("<servername />", settings.getProperty(PluginSettings.SERVER_NAME))
             .replace("<generatedcode />", code)
-            .replace("<minutesvalid />", String.valueOf(minutesValid));
+            .replace("<minutesvalid />", String.valueOf(minutesValid))
+            .replace("<time />", time);
     }
 
-    private String replaceTagsForRecoveryCodeMail(String mailText, String name, String code, int hoursValid) {
+    private String replaceTagsForRecoveryCodeMail(String mailText, String name, String code, int hoursValid, String time) {
         return mailText
             .replace("<playername />", name)
             .replace("<servername />", settings.getProperty(PluginSettings.SERVER_NAME))
             .replace("<recoverycode />", code)
-            .replace("<hoursvalid />", String.valueOf(hoursValid));
+            .replace("<hoursvalid />", String.valueOf(hoursValid))
+            .replace("<time />", time);
     }
+    private String replaceTagsForShutDownMail(String mailText, String time) {
+        return mailText
+            .replace("<servername />", settings.getProperty(PluginSettings.SERVER_NAME))
+            .replace("<time />", time);
+    }
+
 }
diff --git a/src/main/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutor.java b/src/main/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutor.java
index c344447c..9cc9ce1d 100644
--- a/src/main/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutor.java
+++ b/src/main/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutor.java
@@ -9,11 +9,15 @@ 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 fr.xephi.authme.util.PlayerUtils;
 import fr.xephi.authme.util.RandomStringUtils;
 import org.bukkit.entity.Player;
 
 import javax.inject.Inject;
 
+import java.text.SimpleDateFormat;
+import java.util.Date;
+
 import static fr.xephi.authme.permission.PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS;
 import static fr.xephi.authme.process.register.executors.PlayerAuthBuilderHelper.createPlayerAuth;
 import static fr.xephi.authme.settings.properties.EmailSettings.RECOVERY_PASSWORD_LENGTH;
@@ -64,8 +68,10 @@ class EmailRegisterExecutor implements RegistrationExecutor<EmailRegisterParams>
     @Override
     public void executePostPersistAction(EmailRegisterParams params) {
         Player player = params.getPlayer();
-        boolean couldSendMail = emailService.sendPasswordMail(
-            player.getName(), params.getEmail(), params.getPassword());
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy'年'MM'月'dd'日' HH:mm:ss");
+        Date date = new Date(System.currentTimeMillis());
+        boolean couldSendMail = emailService.sendNewPasswordMail(
+            player.getName(), params.getEmail(), params.getPassword(), PlayerUtils.getPlayerIp(player), dateFormat.format(date));
         if (couldSendMail) {
             syncProcessManager.processSyncEmailRegister(player);
         } else {
diff --git a/src/main/java/fr/xephi/authme/service/PasswordRecoveryService.java b/src/main/java/fr/xephi/authme/service/PasswordRecoveryService.java
index 78c5ee62..6fa589f2 100644
--- a/src/main/java/fr/xephi/authme/service/PasswordRecoveryService.java
+++ b/src/main/java/fr/xephi/authme/service/PasswordRecoveryService.java
@@ -20,6 +20,8 @@ import org.bukkit.entity.Player;
 
 import javax.annotation.PostConstruct;
 import javax.inject.Inject;
+import java.text.SimpleDateFormat;
+import java.util.Date;
 import java.util.Locale;
 import java.util.concurrent.TimeUnit;
 
@@ -72,9 +74,10 @@ public class PasswordRecoveryService implements Reloadable, HasCleanup {
         if (!checkEmailCooldown(player)) {
             return;
         }
-
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy'年'MM'月'dd'日' HH:mm:ss");
+        Date date = new Date(System.currentTimeMillis());
         String recoveryCode = recoveryCodeService.generateCode(player.getName());
-        boolean couldSendMail = emailService.sendRecoveryCode(player.getName(), email, recoveryCode);
+        boolean couldSendMail = emailService.sendRecoveryCode(player.getName(), email, recoveryCode, dateFormat.format(date));
         if (couldSendMail) {
             commonService.send(player, MessageKey.RECOVERY_CODE_SENT);
             emailCooldown.add(player.getName().toLowerCase(Locale.ROOT));
@@ -94,6 +97,8 @@ public class PasswordRecoveryService implements Reloadable, HasCleanup {
         if (!checkEmailCooldown(player)) {
             return;
         }
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy'年'MM'月'dd'日' HH:mm:ss");
+        Date date = new Date(System.currentTimeMillis());
 
         String name = player.getName();
         String thePass = RandomStringUtils.generate(commonService.getProperty(RECOVERY_PASSWORD_LENGTH));
@@ -102,7 +107,7 @@ public class PasswordRecoveryService implements Reloadable, HasCleanup {
         logger.info("Generating new password for '" + name + "'");
 
         dataSource.updatePassword(name, hashNew);
-        boolean couldSendMail = emailService.sendPasswordMail(name, email, thePass);
+        boolean couldSendMail = emailService.sendPasswordMail(name, email, thePass, dateFormat.format(date));
         if (couldSendMail) {
             commonService.send(player, MessageKey.RECOVERY_EMAIL_SENT_MESSAGE);
             emailCooldown.add(player.getName().toLowerCase(Locale.ROOT));
diff --git a/src/main/java/fr/xephi/authme/service/ValidationService.java b/src/main/java/fr/xephi/authme/service/ValidationService.java
index 2b4e72f8..3925a111 100644
--- a/src/main/java/fr/xephi/authme/service/ValidationService.java
+++ b/src/main/java/fr/xephi/authme/service/ValidationService.java
@@ -17,7 +17,6 @@ import fr.xephi.authme.settings.properties.ProtectionSettings;
 import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import fr.xephi.authme.util.PlayerUtils;
-import fr.xephi.authme.util.StringUtils;
 import fr.xephi.authme.util.Utils;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -50,6 +49,7 @@ public class ValidationService implements Reloadable {
     private GeoIpService geoIpService;
 
     private Pattern passwordRegex;
+    private Pattern emailRegex;
     private Multimap<String, String> restrictedNames;
 
     ValidationService() {
@@ -62,6 +62,7 @@ public class ValidationService implements Reloadable {
         restrictedNames = settings.getProperty(RestrictionSettings.ENABLE_RESTRICTED_USERS)
             ? loadNameRestrictions(settings.getProperty(RestrictionSettings.RESTRICTED_USERS))
             : HashMultimap.create();
+        emailRegex = Utils.safePatternCompile(settings.getProperty(RestrictionSettings.ALLOWED_EMAIL_REGEX));
     }
 
     /**
@@ -93,12 +94,7 @@ public class ValidationService implements Reloadable {
      * @return true if the email is valid, false otherwise
      */
     public boolean validateEmail(String email) {
-        if (Utils.isEmailEmpty(email) || !StringUtils.isInsideString('@', email)) {
-            return false;
-        }
-        final String emailDomain = email.split("@")[1];
-        return validateWhitelistAndBlacklist(
-            emailDomain, EmailSettings.DOMAIN_WHITELIST, EmailSettings.DOMAIN_BLACKLIST);
+        return emailRegex.matcher(email).matches();
     }
 
     /**
diff --git a/src/main/java/fr/xephi/authme/settings/Settings.java b/src/main/java/fr/xephi/authme/settings/Settings.java
index ab33a7e8..ad0afa6f 100644
--- a/src/main/java/fr/xephi/authme/settings/Settings.java
+++ b/src/main/java/fr/xephi/authme/settings/Settings.java
@@ -24,6 +24,9 @@ public class Settings extends SettingsManagerImpl {
     private String passwordEmailMessage;
     private String verificationEmailMessage;
     private String recoveryCodeEmailMessage;
+    private String shutdownEmailMessage;
+    private String newPasswordEmailMessage;
+
 
     /**
      * Constructor.
@@ -67,10 +70,19 @@ public class Settings extends SettingsManagerImpl {
         return recoveryCodeEmailMessage;
     }
 
+    public String getShutdownEmailMessage() {return shutdownEmailMessage;}
+
+    public String getNewPasswordEmailMessage() {
+        return newPasswordEmailMessage;
+    }
+
     private void loadSettingsFromFiles() {
+        newPasswordEmailMessage = readFile("new_email.html");
         passwordEmailMessage = readFile("email.html");
         verificationEmailMessage = readFile("verification_code_email.html");
         recoveryCodeEmailMessage = readFile("recovery_code_email.html");
+        shutdownEmailMessage = readFile("shutdown.html");
+        String country = readFile("GeoLite2-Country.mmdb");
     }
 
     @Override
diff --git a/src/main/java/fr/xephi/authme/settings/properties/EmailSettings.java b/src/main/java/fr/xephi/authme/settings/properties/EmailSettings.java
index f7522b94..fe41a011 100644
--- a/src/main/java/fr/xephi/authme/settings/properties/EmailSettings.java
+++ b/src/main/java/fr/xephi/authme/settings/properties/EmailSettings.java
@@ -74,6 +74,9 @@ public final class EmailSettings implements SettingsHolder {
     @Comment("The OAuth2 token")
     public static final Property<String> OAUTH2_TOKEN =
         newProperty("Email.emailOauth2Token", "");
+    @Comment("Email notifications when the server shuts down")
+    public static final Property<Boolean> SHOUTDOWN_MAIL =
+        newProperty("Email.shutDownEmail", true);
 
     private EmailSettings() {
     }
diff --git a/src/main/java/fr/xephi/authme/settings/properties/RestrictionSettings.java b/src/main/java/fr/xephi/authme/settings/properties/RestrictionSettings.java
index 8794ba44..16dbaa3d 100644
--- a/src/main/java/fr/xephi/authme/settings/properties/RestrictionSettings.java
+++ b/src/main/java/fr/xephi/authme/settings/properties/RestrictionSettings.java
@@ -165,6 +165,11 @@ public final class RestrictionSettings implements SettingsHolder {
     public static final Property<String> ALLOWED_PASSWORD_REGEX =
         newProperty("settings.restrictions.allowedPasswordCharacters", "[!-~]*");
 
+    @Comment("Regex syntax for allowed chars in email.")
+    public static final Property<String> ALLOWED_EMAIL_REGEX =
+        newProperty("settings.restrictions.allowedEmailCharacters", "^[A-Za-z0-9]{4,15}@(qq|163|icloud).com$");
+
+
     @Comment("Force survival gamemode when player joins?")
     public static final Property<Boolean> FORCE_SURVIVAL_MODE =
         newProperty("settings.GameMode.ForceSurvivalMode", false);
diff --git a/src/main/resources/GeoLite2-Country.mmdb b/src/main/resources/GeoLite2-Country.mmdb
new file mode 100644
index 00000000..3ab66a4e
Binary files /dev/null and b/src/main/resources/GeoLite2-Country.mmdb differ
diff --git a/src/main/resources/email.html b/src/main/resources/email.html
index a2a7ed06..085e63bf 100644
--- a/src/main/resources/email.html
+++ b/src/main/resources/email.html
@@ -1,18 +1,120 @@
-<h1>
-Dear <playername />,
-</h1>
-
-<p>
-This is your new AuthMe password for the server <servername />:
-</p>
-<p>
-<generatedpass />
-</p>
-<image />
-<p>
-Do not forget to change password after login!<br />
-/changepassword <generatedpass /> newPassword'
-</p>
-<p>
-See you on <servername />!
-</p>
\ No newline at end of file
+<div class="mail">
+    <style>
+        .mail td{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            font-size: 16px;
+            color: #718096;
+        }
+        .mail th, div, p, a, h1, h2, h3, h4, h5, h6{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            color: #3d4852;
+        }
+        .mail .mail-content {
+            max-width: 100vw;
+            padding: 32px;
+            box-shadow: 0 15px 28px rgba(0, 0, 0, 0.25), 0 10px 10px rgba(0, 0, 0, 0.25);
+        }
+        .mail div{
+            background-color: #ffffff;color: #718096;height: 100%;line-height: 1.4;width: 100%;
+        }
+        .mail .x_wrapper{
+            background-color: #edf2f7; 
+            width:100%;
+        }
+        .mail .x_content{
+            width: 100%;
+        }
+        .mail .x_inner-body{
+            background-color: #ffffff;border-color: #e8e5ef;border-radius: 2px;border-width: 1px;margin: 0 auto;padding:0;width: 570px;
+        }
+        .mail .x_content-cell{
+            margin: 0 auto;padding: 0;width: 570px;line-height: 1.5em;
+            color: #b0adc5;font-size: 12px;
+        }
+        .mail .x_content-cell td{
+            max-width: 100vw;padding: 32px;
+        }
+    </style>
+    <div>
+        <table class="x_wrapper">
+            <tbody>
+            <tr>
+                <td>
+                    <table class="x_content">
+                        <tbody>
+                        <tr>
+                            <td style="padding: 25px 0;">
+                                <h1 style="font-size: 20px;">密码重置邮件</h1>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_inner-body">
+                                    <tbody>
+                                    <tr>
+                                        <td class="mail-content">
+                                       <h1 style="font-size: 18px;margin-bottom: 25px;">Minecraft · <servername /><br/><playername /></h1>
+                                            <hr>
+                                            <table style="width: 100%;">
+                                                <tbody>
+                                                <tr>
+                                                    <td>
+                                                        您正在申请的新密码为
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="font-weight: bold;">
+                                                        <br/><generatedpass /></td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <br/>请妥善保存,在新地址上进行登录时,需提供该密码.
+                                                        <br/>若非必要,请勿更换密码,否则将对您的账户安全构成威胁.
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="text-align:right;">
+                                                        <br/>
+                                                        <br/>祝您游玩愉快~!
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <small>
+                                                            <br/><time />
+                                                            <br/>请勿回复
+                                                        </small>
+                                                    </td>
+                                                </tr>
+                                                </tbody>
+                                            </table>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_content-cell">
+                                    <tbody>
+                                    <tr>
+                                        <td>
+                                            <p style="color:#b0adc5;">© 2023 IrisCraft. All rights reserved.</p>
+                                            <a href="https://www.mcbbs.net/thread-1263385-1-1.html" target="_blank" style="text-decoration: none; font-size: 16px">iriscraft.work</a>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        </tbody>
+                    </table>
+                </td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
diff --git a/src/main/resources/messages/help_zhcn.yml b/src/main/resources/messages/help_zhcn.yml
index 36fc06e4..c08add09 100644
--- a/src/main/resources/messages/help_zhcn.yml
+++ b/src/main/resources/messages/help_zhcn.yml
@@ -1,8 +1,5 @@
-# AuthmeReloaded帮助文件汉化
-# Translated By CH1
-# -------------------------------------------------------
 common:
-    header: '==========[ AuthMeReloaded ]=========='
+    header: '======================================'
     optional: '可选'
     hasPermission: '您拥有权限去使用这个指令'
     noPermission: '您没有权限使用这个指令'
diff --git a/src/main/resources/messages/messages_zhcn.yml b/src/main/resources/messages/messages_zhcn.yml
index 4292484d..9d53e32e 100644
--- a/src/main/resources/messages/messages_zhcn.yml
+++ b/src/main/resources/messages/messages_zhcn.yml
@@ -5,132 +5,140 @@
 
 # Registration
 registration:
-    disabled: '&8[&6玩家系统&8] &c目前服务器暂时禁止注册，请到服务器论坛以得到更多资讯'
-    name_taken: '&8[&6玩家系统&8] &c此用户已经在此服务器注册过'
-    register_request: '&8[&6玩家系统&8] &c请输入“/register <密码> <再输入一次以确定密码>”以注册'
-    command_usage: '&8[&6玩家系统&8] &c正确用法：“/register <密码> <再输入一次以确定密码>”'
-    reg_only: '&8[&6玩家系统&8] &f只允许注册过的玩家进服！请到 https://example.cn 注册'
-    success: '&8[&6玩家系统&8] &c已成功注册！'
-    kicked_admin_registered: '有一位管理员刚刚为您完成了注册，请重新登录'
+    disabled: '&c注册已被禁止'
+    name_taken: '&c此用户已经在此服务器注册过'
+    register_request: '&7请输入“/register <邮箱>”以注册'
+    command_usage: '&c正确用法:“/register <邮箱>”'
+    reg_only: '&c只允许注册过的玩家进服!'
+    success: '&a*** 已成功注册 ***'
 
 # Password errors on registration
 password:
-    match_error: '&8[&6玩家系统&8] &f密码不相同'
-    name_in_password: '&8[&6玩家系统&8] &f你不能使用你的名字作为密码。 '
-    unsafe_password: '&8[&6玩家系统&8] &f你不能使用安全性过低的密码。 '
-    forbidden_characters: '&4您的密码包含了非法字符。可使用的字符: %valid_chars'
-    wrong_length: '&8[&6玩家系统&8] &c你的密码不符合要求'
+    match_error: '&c密码不相同'
+    name_in_password: '&c您不能使用您的名字作为密码。 '
+    unsafe_password: '&c您不能使用安全性过低的密码。 '
+    forbidden_characters: '&4您的密码包含了非法字符.可使用的字符: %valid_chars'
+    wrong_length: '&4您的密码没有达到要求!'
 
 # Login
 login:
-    command_usage: '&8[&6玩家系统&8] &c正确用法：“/login <密码>”'
-    wrong_password: '&8[&6玩家系统&8] &c错误的密码'
-    success: '&8[&6玩家系统&8] &c已成功登录！'
-    login_request: '&8[&6玩家系统&8] &c请输入“/login <密码>”以登录'
-    timeout_error: '&8[&6玩家系统&8] &f登录超时'
+    command_usage: '&c正确用法:“/login <密码>”'
+    wrong_password: '&c*** 密码错误 ***'
+    success: '&a*** 已成功登录 ***'
+    login_request: '&c请输入“/login <密码>”以登录'
+    timeout_error: '给您登录的时间已经过了'
 
 # Errors
 error:
-    denied_command: '&c您需要先通过验证才能使用该命令！'
-    denied_chat: '&c您需要先通过验证才能聊天！'
-    unregistered_user: '&8[&6玩家系统&8] &c此用户名还未注册过'
-    not_logged_in: '&8[&6玩家系统&8] &c你还未登录！'
-    no_permission: '&8[&6玩家系统&8] &c没有权限'
-    unexpected_error: '&8[&6玩家系统&8] &f发现错误，请联系管理员'
-    max_registration: '&8[&6玩家系统&8] &f你不允许再为你的IP在服务器注册更多用户了！'
-    logged_in: '&8[&6玩家系统&8] &c你已经登陆过了！'
-    kick_for_vip: '&8[&6玩家系统&8] &cA VIP玩家加入了已满的服务器!'
-    kick_unresolved_hostname: '&8[&6玩家系统&8] &c发生了一个错误: 无法解析玩家的Hostname'
-    tempban_max_logins: '&c由于您登录失败次数过多，已被暂时禁止登录。'
+    denied_command: '&7您需要先通过验证才能使用该命令!'
+    denied_chat: '&7您需要先通过验证才能聊天!'
+    unregistered_user: '&c此用户名还未注册过'
+    not_logged_in: '&c您还未登录!'
+    no_permission: '&c没有权限'
+    unexpected_error: '&4发现错误,请联系管理员'
+    max_registration: '&c该地址已无法注册,请联系管理员进行注册.'
+    logged_in: '&c您已经登陆过了!'
+    kick_for_vip: '&c一个VIP玩家加入了已满的服务器!'
+    kick_unresolved_hostname: '&c发生了一个错误: 无法解析玩家的主机名'
+    tempban_max_logins: '&c由于您登录失败次数过多,已被暂时禁止登录。'
 
 # AntiBot
 antibot:
-    kick_antibot: '&8[&6玩家系统&8] &f验证程序已启用 !请稍等几分钟后再次进入服务器'
-    auto_enabled: '&8[&6玩家系统&8] &f验证程序由于大量异常连接而启用'
-    auto_disabled: '&8[&6玩家系统&8] &f验证程序由于异常连接减少而在 %m 分钟后停止'
+    kick_antibot: '连接异常,请稍后加入'
+    auto_enabled: '&c由于发生大量异常连接,本服将禁止连接.'
+    auto_disabled: '&a异常连接减少,本服将在 &a%m &a分钟后自动开放连接.'
 
 # Unregister
 unregister:
-    success: '&8[&6玩家系统&8] &c成功删除此用户！'
-    command_usage: '&8[&6玩家系统&8] &c正确用法：“/unregister <密码>”'
+    success: '&a*** 已成功注销 ***'
+    command_usage: '&c正确用法:“/unregister <密码>”'
 
 # Other messages
 misc:
-    account_not_activated: '&8[&6玩家系统&8] &f你的帐号还未激活，请查看你的邮箱！'
-    password_changed: '&8[&6玩家系统&8] &c密码已成功修改！'
-    logout: '&8[&6玩家系统&8] &c已成功登出！'
-    reload: '&8[&6玩家系统&8] &f配置以及数据已经重新加载完毕'
-    usage_change_password: '&8[&6玩家系统&8] &f正确用法：“/changepassword 旧密码 新密码”'
-    accounts_owned_self: '您拥有 %count 个账户：'
-    accounts_owned_other: '玩家 %name 拥有 %count 个账户：'
+    account_not_activated: |-
+      &a一封包含密码的邮件已发送至您的收件箱.
+      &a请在十分钟内完成激活,否则将注销此账户.
+    not_activated: '&c账户未激活,请注册激活后再次尝试.'
+    password_changed: '&a*** 密码已修改 ***'
+    logout: '&a*** 已成功登出 ***'
+    reload: '&a配置以及数据已经重新加载完毕'
+    usage_change_password: '&a正确用法:“/changepassword 旧密码 新密码”'
+    accounts_owned_self: '您拥有 %count 个账户:'
+    accounts_owned_other: '玩家 %name 拥有 %count 个账户:'
 
 # Session messages
 session:
-    valid_session: '&8[&6玩家系统&8] &c欢迎回来，已帮你自动登录到此服务器'
-    invalid_session: '&8[&6玩家系统&8] &f登录数据异常，请等待登录结束'
+    valid_session: ''
+    invalid_session: '&c*** 请重新登录 ***'
 
 # Error messages when joining
 on_join_validation:
-    same_ip_online: '已有一个同IP玩家在游戏中了！'
-    same_nick_online: '&8[&6玩家系统&8] &f同样的用户名现在在线且已经登录了！'
-    name_length: '&8[&6玩家系统&8] &c你的用户名太短或者太长了'
-    characters_in_name: '&8[&6玩家系统&8] &c你的用户名包含非法字母，用户名里允许的字母: %valid_chars'
-    kick_full_server: '&8[&6玩家系统&8] &c抱歉，服务器已满!'
-    country_banned: '这个服务器禁止该国家登陆'
-    not_owner_error: '&8[&6玩家系统&8] &4警告！ &c你并不是此帐户的拥有者，请立即登出！ '
-    invalid_name_case: '&8[&6玩家系统&8] &c你应该使用「%valid」而并非「%invalid」登入游戏。 '
-    quick_command: '&8[&6玩家系统&8] &c您发送命令的速度太快了，请重新加入服务器再等待一会后再使用命令'
+    same_ip_online: '已有一个同IP玩家在游戏中了!'
+    same_nick_online: '&a同样的用户名现在在线且已经登录了!'
+    name_length: '&c您的用户名太短或者太长了'
+    characters_in_name: '&c您的用户名不符合标准.'
+    kick_full_server: '&c抱歉,服务器已满!'
+    country_banned: |-
+      &6[&b&lAccount Security System&6]
+      &c为保证您的游玩体验,请使用中国境内网络连接.
+      &cTo ensure your play experience,please use the Internet connection within China.
+    not_owner_error: |-
+      &6[&b&lAccount Security System&6]
+      &c请勿尝试登陆系统账户,系统账户受安全系统保护.
+      &c如果您并不知情,请更换您的用户名重新加入该服务器.
+    invalid_name_case: '&c您应该使用 %valid 登录服务器,当前名字: %invalid .'
+    quick_command: '&c您发送命令的速度太快了,请重新加入服务器等待一会后再使用命令'
 
 # Email
 email:
-    add_email_request: '&8[&6玩家系统&8] &c请输入“/email add <你的邮箱> <再输入一次以确认>”以添加您的邮箱到此帐号'
-    usage_email_add: '&8[&6玩家系统&8] &f用法: /email add <邮箱> <确认邮箱地址> '
-    usage_email_change: '&8[&6玩家系统&8] &f用法: /email change <旧邮箱> <新邮箱> '
-    new_email_invalid: '&8[&6玩家系统&8] &f新邮箱无效!'
-    old_email_invalid: '&8[&6玩家系统&8] &f旧邮箱无效!'
-    invalid: '&8[&6玩家系统&8] &f无效的邮箱'
-    added: '&8[&6玩家系统&8] &f邮箱已添加 !'
-    add_not_allowed: '&8[&6玩家系统&8] &c服务器不允许添加邮箱地址'
-    request_confirmation: '&8[&6玩家系统&8] &f确认你的邮箱 !'
-    changed: '&8[&6玩家系统&8] &f邮箱已修改 !'
-    change_not_allowed: '&8[&6玩家系统&8] &c服务器不允许修改邮箱地址'
-    email_show: '&8[&6玩家系统&8] &2您当前的电子邮件地址为： &f%email'
-    no_email_for_account: '&8[&6玩家系统&8] &2您当前并没有任何邮箱与该账号绑定'
-    already_used: '&8[&6玩家系统&8] &4邮箱已被使用'
-    incomplete_settings: '&8[&6玩家系统&8] 错误：必要设置未设定完成，请联系管理员'
-    send_failure: '&8[&6玩家系统&8] 邮件发送失败，请联系管理员'
-    change_password_expired: '&8[&6玩家系统&8] 您不能使用此命令更改密码'
-    email_cooldown_error: '&8[&6玩家系统&8] &c邮件已在几分钟前发送，您需要等待 %time 后才能再次请求发送'
+    add_email_request: ''
+    usage_email_add: '&a用法: /email add <邮箱> <确认邮箱> '
+    usage_email_change: '&a用法: /email change <旧邮箱> <新邮箱> '
+    new_email_invalid: '&c新邮箱无效!'
+    old_email_invalid: '&c旧邮箱无效!'
+    invalid: '&c无效的邮箱'
+    added: '&a*** 邮箱已添加 ***'
+    add_not_allowed: '&c服务器不允许添加电子邮箱'
+    request_confirmation: '&c确认您的邮箱'
+    changed: '&a*** 邮箱已修改 ***'
+    change_not_allowed: '&c服务器不允许修改邮箱地址'
+    email_show: '&a该账户使用的电子邮箱为: &a%email'
+    no_email_for_account: '&c当前并没有任何邮箱与该账号绑定'
+    already_used: '&c邮箱已被使用'
+    incomplete_settings: '&c错误: 必要设置未设定完成,请联系管理员'
+    send_failure: '&c邮件已被作废,请检查您的邮箱是否正常工作.'
+    change_password_expired: '&c您不能使用此命令更改密码'
+    email_cooldown_error: '&c您需要等待 %time 后才能再次请求发送'
 
 # Password recovery by email
 recovery:
-    forgot_password_hint: '&8[&6玩家系统&8] &c忘了你的密码？请输入：“/email recovery <你的邮箱>”'
-    command_usage: '&8[&6玩家系统&8] &f用法: /email recovery <邮箱>'
-    email_sent: '&8[&6玩家系统&8] &f找回密码邮件已发送 !'
+    forgot_password_hint: '&c忘了您的密码？请输入:“/email recovery <您的邮箱>”'
+    command_usage: '&a用法: /email recovery <邮箱>'
+    email_sent: '&a找回密码邮件已发送!'
     code:
-        code_sent: '一个用于重置您的密码的验证码已发到您的邮箱'
-        incorrect: '验证码不正确！ 使用 /email recovery [邮箱] 以生成新的验证码'
-        tries_exceeded: '您已经达到输入验证码次数的最大允许次数。请使用 "/email recovery [邮箱]" 来生成一个新的'
-        correct: '验证码正确！'
-        change_password: '请使用 /email setpassword <新密码> 立即设置新的密码'
+        code_sent: '&a*** 已发送验证邮件 ***'
+        incorrect: '&a验证码不正确! 使用 /email recovery [邮箱] 以生成新的验证码'
+        tries_exceeded: '&a您已经达到输入验证码次数的最大允许次数.'
+        correct: '&a*** 验证通过 ***'
+        change_password: '&c请使用 /email setpassword <新密码> 立即设置新的密码'
 
 # Captcha
 captcha:
-    usage_captcha: '&8[&6玩家系统&8] &c正确用法：/captcha %captcha_code'
-    wrong_captcha: '&8[&6玩家系统&8] &c错误的验证码，请输入：“/captcha %captcha_code”'
-    valid_captcha: '&8[&6玩家系统&8] &c你的验证码是有效的！'
-    captcha_for_registration: '注册前您需要先提供验证码，请使用指令：/captcha %captcha_code'
-    register_captcha_valid: '&2有效的验证码！您现在可以使用 /register 注册啦！'
+    usage_captcha: '&7请输入 /captcha %captcha_code 来验证操作.'
+    wrong_captcha: '&c错误的验证码.'
+    valid_captcha: '&a*** 验证通过 ***'
+    captcha_for_registration: '&7请输入 /captcha %captcha_code 来验证操作.'
+    register_captcha_valid: '&a验证通过, 现在可以使用 /register 注册啦!'
 
 # Verification code
 verification:
-    code_required: '&3这个命令非常敏感，需要电子邮件验证！请检查您的收件箱，并遵循邮件的指导。'
-    command_usage: '&c使用方法： /verification <验证码>'
-    incorrect_code: '&c验证码错误， 请在聊天框输入 "/verification <验证码>"，使用您在电子邮件中收到的验证码。'
-    success: '&2您的身份已经得到验证！您现在可以在当前会话中执行所有命令！'
-    already_verified: '&2您已经可以在当前会话中执行任何敏感命令！'
-    code_expired: '&3您的验证码已失效！执行另一个敏感命令以获得新的验证码！'
-    email_needed: '&3为了验证您的身份，您需要将一个电子邮件地址与您的帐户绑定！！'
+    code_required: '&a*** 已发送验证邮件 ***'
+    command_usage: '&c使用方法:/verification <验证码>'
+    incorrect_code: '&c错误的验证码.'
+    success: '&a*** 验证通过 ***'
+    already_verified: '&a您已经通过验证'
+    code_expired: '&c验证码已失效'
+    email_needed: '&c邮箱未绑定'
 
 # Time units
 time:
@@ -138,20 +146,20 @@ time:
     seconds: '秒'
     minute: '分'
     minutes: '分'
-    hour: '小时'
-    hours: '小时'
+    hour: '时'
+    hours: '时'
     day: '天'
     days: '天'
 
 # Two-factor authentication
 two_factor:
-    code_created: '&8[&6玩家系统&8] &a你的代码是 %code，你可以使用 %url 来进行扫描'
-    confirmation_required: '&8[&6玩家系统&8] &3请输入 &a/2fa confirm <验证码> &3来确认双重认证'
-    code_required: '&8[&6玩家系统&8] &c请输入 &a/2fa code <验证码> &c来提交双重认证验证码'
-    already_enabled: '&8[&6玩家系统&8] &a双重认证已在您的账号上启用'
-    enable_error_no_code: '&8[&6玩家系统&8] &c双重认证密钥不存在或已过期，请输入 &a/2fa add &c来添加'
-    enable_success: '&8[&6玩家系统&8] &a已成功启用双重认证'
-    enable_error_wrong_code: '&8[&6玩家系统&8] &c双重认证代码错误或者已经过期，请重新执行 &a/2fa add'
-    not_enabled_error: '&8[&6玩家系统&8] &c双重认证码未在您的账号上启用，请使用 &a/2fa add &c来启用'
-    removed_success: '&8[&6玩家系统&8] &c双重认证码已从您的账号上删除'
-    invalid_code: '&8[&6玩家系统&8] &c无效的验证码'
+    code_created: '&7您正在激活双重验证, 请打开 &a%url &7扫描二维码'
+    confirmation_required: '&7请输入“/totp confirm <验证码>”来确认激活双重验证'
+    code_required: '&c请输入“/totp code <验证码>”来提交验证码'
+    already_enabled: '&a双重验证已启用'
+    enable_error_no_code: '&c验证码丢失'
+    enable_success: '&a已成功启用双重验证'
+    enable_error_wrong_code: '&c验证码错误或者已经过期,请重新执行“/totp add”'
+    not_enabled_error: '&c双重验证未在您的账号上启用,请使用“/totp add”来启用'
+    removed_success: '&c双重验证已从您的账号上禁用'
+    invalid_code: '&c无效的验证码'
diff --git a/src/main/resources/new_email.html b/src/main/resources/new_email.html
new file mode 100644
index 00000000..60ed405a
--- /dev/null
+++ b/src/main/resources/new_email.html
@@ -0,0 +1,126 @@
+<div class="mail">
+    <style>
+        .mail td{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            font-size: 16px;
+            color: #718096;
+        }
+        .mail th, div, p, a, h1, h2, h3, h4, h5, h6{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            color: #3d4852;
+        }
+        .mail .mail-content {
+            max-width: 100vw;
+            padding: 32px;
+            box-shadow: 0 15px 28px rgba(0, 0, 0, 0.25), 0 10px 10px rgba(0, 0, 0, 0.25);
+        }
+        .mail div{
+            background-color: #ffffff;color: #718096;height: 100%;line-height: 1.4;width: 100%;
+        }
+        .mail .x_wrapper{
+            background-color: #edf2f7; 
+            width:100%;
+        }
+        .mail .x_content{
+            width: 100%;
+        }
+        .mail .x_inner-body{
+            background-color: #ffffff;border-color: #e8e5ef;border-radius: 2px;border-width: 1px;margin: 0 auto;padding:0;width: 570px;
+        }
+        .mail .x_content-cell{
+            margin: 0 auto;padding: 0;width: 570px;line-height: 1.5em;
+            color: #b0adc5;font-size: 12px;
+        }
+        .mail .x_content-cell td{
+            max-width: 100vw;padding: 32px;
+        }
+    </style>
+    <div>
+        <table class="x_wrapper">
+            <tbody>
+            <tr>
+                <td>
+                    <table class="x_content">
+                        <tbody>
+                        <tr>
+                            <td style="padding: 25px 0;">
+                                <h1 style="font-size: 20px;">账户激活邮件</h1>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_inner-body">
+                                    <tbody>
+                                    <tr>
+                                        <td class="mail-content">
+                                            <h1 style="font-size: 18px;margin-bottom: 25px;">Minecraft · <servername /><br/><playername /></h1>
+                                            <hr>
+                                            <table style="width: 100%;">
+                                                <tbody>
+                                                <tr>
+                                                    <td>
+                                                        您的账户初始密码为
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="font-weight: bold;">
+                                                        <br/><generatedpass /></td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <br/>已将地址(<playerip />)进行记录.
+                                                        <br/>
+                                                        <br/>请妥善保存,在新地址上进行登录时,需提供该密码.
+                                                        <br/>若非必要,请勿更换密码,否则将对您的账户安全构成威胁.
+                                                        <br/>账户所绑定的邮箱地址已被永久存储,需要更换请联系管理员.
+                                                        <br/>
+                                                        <br/>更换密码: /changepassword <generatedpass /> [新密码]
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="text-align:right;">
+                                                        <br/>
+                                                        <br/>账户将在激活后生效
+                                                        <br/>欢迎您的加入~!
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <small>
+                                                            <br/><time />
+                                                            <br/>请勿回复
+                                                        </small>
+                                                    </td>
+                                                </tr>
+                                                </tbody>
+                                            </table>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_content-cell">
+                                    <tbody>
+                                    <tr>
+                                        <td>
+                                            <p style="color:#b0adc5;">© 2023 IrisCraft. All rights reserved.</p>
+                                            <a href="https://www.mcbbs.net/thread-1263385-1-1.html" target="_blank" style="text-decoration: none; font-size: 16px">iriscraft.work</a>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        </tbody>
+                    </table>
+                </td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
diff --git a/src/main/resources/recovery_code_email.html b/src/main/resources/recovery_code_email.html
index fc7327a1..87a060d1 100644
--- a/src/main/resources/recovery_code_email.html
+++ b/src/main/resources/recovery_code_email.html
@@ -1,9 +1,119 @@
-<h1>Dear <playername />,</h1>
-
-<p>
-    You have requested to reset your password on <servername />. To reset it,
-    please use the recovery code <recoverycode />: /email code <recoverycode />.
-</p>
-<p>
-    The code expires in <hoursvalid /> hours.
-</p>
+<div class="mail">
+    <style>
+        .mail td{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            font-size: 16px;
+            color: #718096;
+        }
+        .mail th, div, p, a, h1, h2, h3, h4, h5, h6{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            color: #3d4852;
+        }
+        .mail .mail-content {
+            max-width: 100vw;
+            padding: 32px;
+            box-shadow: 0 15px 28px rgba(0, 0, 0, 0.25), 0 10px 10px rgba(0, 0, 0, 0.25);
+        }
+        .mail div{
+            background-color: #ffffff;color: #718096;height: 100%;line-height: 1.4;width: 100%;
+        }
+        .mail .x_wrapper{
+            background-color: #edf2f7; 
+            width:100%;
+        }
+        .mail .x_content{
+            width: 100%;
+        }
+        .mail .x_inner-body{
+            background-color: #ffffff;border-color: #e8e5ef;border-radius: 2px;border-width: 1px;margin: 0 auto;padding:0;width: 570px;
+        }
+        .mail .x_content-cell{
+            margin: 0 auto;padding: 0;width: 570px;line-height: 1.5em;
+            color: #b0adc5;font-size: 12px;
+        }
+        .mail .x_content-cell td{
+            max-width: 100vw;padding: 32px;
+        }
+    </style>
+    <div>
+        <table class="x_wrapper">
+            <tbody>
+            <tr>
+                <td>
+                    <table class="x_content">
+                        <tbody>
+                        <tr>
+                            <td style="padding: 25px 0;">
+                                <h1 style="font-size: 20px;">代码验证邮件</h1>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_inner-body">
+                                    <tbody>
+                                    <tr>
+                                        <td class="mail-content">
+                                            <h1 style="font-size: 18px;margin-bottom: 25px;">Minecraft · <servername /><br/><playername /></h1>
+                                            <hr>
+                                            <table style="width: 100%;">
+                                                <tbody>
+                                                <tr>
+                                                    <td>
+                                                        您正在申请的验证码为
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="font-weight: bold;">
+                                                        <br/><recoverycode /></td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <br/>使用指令: /email code <recoverycode /> 来完成验证过程.
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="text-align:right;">
+                                                        <br/>
+                                                        <br/>验证码将在<hoursvalid />小时后失效
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <small>
+                                                            <br/><time />
+                                                            <br/>请勿回复
+                                                        </small>
+                                                    </td>
+                                                </tr>
+                                                </tbody>
+                                            </table>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_content-cell">
+                                    <tbody>
+                                    <tr>
+                                        <td>
+                                            <p style="color:#b0adc5;">© 2023 IrisCraft. All rights reserved.</p>
+                                            <a href="https://www.mcbbs.net/thread-1263385-1-1.html" target="_blank" style="text-decoration: none; font-size: 16px">iriscraft.work</a>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        </tbody>
+                    </table>
+                </td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
diff --git a/src/main/resources/shutdown.html b/src/main/resources/shutdown.html
new file mode 100644
index 00000000..94d9573e
--- /dev/null
+++ b/src/main/resources/shutdown.html
@@ -0,0 +1,117 @@
+<div class="mail">
+    <style>
+        .mail td{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            font-size: 16px;
+            color: #718096;
+        }
+        .mail th, div, p, a, h1, h2, h3, h4, h5, h6{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            color: #3d4852;
+        }
+        .mail .mail-content {
+            max-width: 100vw;
+            padding: 32px;
+            box-shadow: 0 15px 28px rgba(0, 0, 0, 0.25), 0 10px 10px rgba(0, 0, 0, 0.25);
+        }
+        .mail div{
+            background-color: #ffffff;color: #718096;height: 100%;line-height: 1.4;width: 100%;
+        }
+        .mail .x_wrapper{
+            background-color: #edf2f7; 
+            width:100%;
+        }
+        .mail .x_content{
+            width: 100%;
+        }
+        .mail .x_inner-body{
+            background-color: #ffffff;border-color: #e8e5ef;border-radius: 2px;border-width: 1px;margin: 0 auto;padding:0;width: 570px;
+        }
+        .mail .x_content-cell{
+            margin: 0 auto;padding: 0;width: 570px;line-height: 1.5em;
+            color: #b0adc5;font-size: 12px;
+        }
+        .mail .x_content-cell td{
+            max-width: 100vw;padding: 32px;
+        }
+    </style>
+    <div>
+        <table class="x_wrapper">
+            <tbody>
+            <tr>
+                <td>
+                    <table class="x_content">
+                        <tbody>
+                        <tr>
+                            <td style="padding: 25px 0;">
+                                <h1 style="font-size: 20px;">服务器关闭通知</h1>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_inner-body">
+                                    <tbody>
+                                    <tr>
+                                        <td class="mail-content">
+                                            <h1 style="font-size: 18px;margin-bottom: 25px;">Minecraft · <servername /></h1>
+                                            <hr>
+                                            <table style="width: 100%;">
+                                                <tbody>
+                                                <tr>
+                                                    <td style="font-weight: bold;color: #da1515;">
+                                                        <br/>紧急通知</td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <br/>服务器当前已被关闭
+                                                        <br/>
+                                                        <br/>请及时检查服务器运行状态.
+                                                        <br/>
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="text-align:right;">
+                                                        <br/>
+                                                        <br/>IrisCraft Team
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <small>
+                                                            <br/><time />
+                                                            <br/>请勿回复
+                                                        </small>
+                                                    </td>
+                                                </tr>
+                                                </tbody>
+                                            </table>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_content-cell">
+                                    <tbody>
+                                    <tr>
+                                        <td>
+                                            <p style="color:#b0adc5;">© 2023 IrisCraft. All rights reserved.</p>
+                                            <a href="https://www.mcbbs.net/thread-1263385-1-1.html" target="_blank" style="text-decoration: none; font-size: 16px">iriscraft.work</a>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        </tbody>
+                    </table>
+                </td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
diff --git a/src/main/resources/verification_code_email.html b/src/main/resources/verification_code_email.html
index c12ae946..f9a988d5 100644
--- a/src/main/resources/verification_code_email.html
+++ b/src/main/resources/verification_code_email.html
@@ -1,20 +1,119 @@
-<h1>
-    Dear <playername />,
-</h1>
-
-<p>
-    This is your temporary verification code for the server <servername />:
-</p>
-<p>
-    <generatedcode />
-</p>
-
-<p>
-    This code will be valid for the next <minutesvalid /> mins!<br />
-    Use the command
-    /verification <generatedcode />
-    to complete the verification process.
-</p>
-<p>
-    See you on <servername />!
-</p>
+<div class="mail">
+    <style>
+        .mail td{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            font-size: 16px;
+            color: #718096;
+        }
+        .mail th, div, p, a, h1, h2, h3, h4, h5, h6{
+            font-family: "Segoe UI", sans-serif;
+            text-align: center;
+            color: #3d4852;
+        }
+        .mail .mail-content {
+            max-width: 100vw;
+            padding: 32px;
+            box-shadow: 0 15px 28px rgba(0, 0, 0, 0.25), 0 10px 10px rgba(0, 0, 0, 0.25);
+        }
+        .mail div{
+            background-color: #ffffff;color: #718096;height: 100%;line-height: 1.4;width: 100%;
+        }
+        .mail .x_wrapper{
+            background-color: #edf2f7; 
+            width:100%;
+        }
+        .mail .x_content{
+            width: 100%;
+        }
+        .mail .x_inner-body{
+            background-color: #ffffff;border-color: #e8e5ef;border-radius: 2px;border-width: 1px;margin: 0 auto;padding:0;width: 570px;
+        }
+        .mail .x_content-cell{
+            margin: 0 auto;padding: 0;width: 570px;line-height: 1.5em;
+            color: #b0adc5;font-size: 12px;
+        }
+        .mail .x_content-cell td{
+            max-width: 100vw;padding: 32px;
+        }
+    </style>
+    <div>
+        <table class="x_wrapper">
+            <tbody>
+            <tr>
+                <td>
+                    <table class="x_content">
+                        <tbody>
+                        <tr>
+                            <td style="padding: 25px 0;">
+                                <h1 style="font-size: 20px;">代码验证邮件</h1>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_inner-body">
+                                    <tbody>
+                                    <tr>
+                                        <td class="mail-content">
+                                            <h1 style="font-size: 18px;margin-bottom: 25px;">Minecraft · <servername /><br/><playername /></h1>
+                                            <hr>
+                                            <table style="width: 100%;">
+                                                <tbody>
+                                                <tr>
+                                                    <td>
+                                                        您正在申请的验证码为
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="font-weight: bold;">
+                                                        <br/><generatedcode /></td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <br/>使用指令: /verification <generatedcode /> 来完成验证过程.
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td style="text-align:right;">
+                                                        <br/>
+                                                        <br/>验证码将在30分钟后失效
+                                                    </td>
+                                                </tr>
+                                                <tr>
+                                                    <td>
+                                                        <small>
+                                                            <br/><time />
+                                                            <br/>请勿回复
+                                                        </small>
+                                                    </td>
+                                                </tr>
+                                                </tbody>
+                                            </table>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <table class="x_content-cell">
+                                    <tbody>
+                                    <tr>
+                                        <td>
+                                            <p style="color:#b0adc5;">© 2023 IrisCraft. All rights reserved.</p>
+                                            <a href="https://www.mcbbs.net/thread-1263385-1-1.html" target="_blank" style="text-decoration: none; font-size: 16px">iriscraft.work</a>
+                                        </td>
+                                    </tr>
+                                    </tbody>
+                                </table>
+                            </td>
+                        </tr>
+                        </tbody>
+                    </table>
+                </td>
+            </tr>
+            </tbody>
+        </table>
+    </div>
+</div>
diff --git a/src/test/java/fr/xephi/authme/AuthMeInitializationTest.java b/src/test/java/fr/xephi/authme/AuthMeInitializationTest.java
deleted file mode 100644
index 290312bb..00000000
--- a/src/test/java/fr/xephi/authme/AuthMeInitializationTest.java
+++ /dev/null
@@ -1,145 +0,0 @@
-package fr.xephi.authme;
-
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.PropertyResource;
-import ch.jalu.injector.Injector;
-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.datasource.DataSource;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.listener.BlockListener;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.process.login.ProcessSyncPlayerLogin;
-import fr.xephi.authme.security.PasswordSecurity;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.bungeecord.BungeeReceiver;
-import fr.xephi.authme.service.bungeecord.BungeeSender;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.task.purge.PurgeService;
-import org.bukkit.Bukkit;
-import org.bukkit.Server;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.java.JavaPluginLoader;
-import org.bukkit.scheduler.BukkitScheduler;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Collections;
-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.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Integration test verifying that all services can be initialized in {@link AuthMe}
- * with the {@link Injector}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AuthMeInitializationTest {
-
-    @Mock
-    private Server server;
-
-    @Mock
-    private PluginManager pluginManager;
-
-    private AuthMe authMe;
-    private File dataFolder;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @Before
-    public void initAuthMe() throws IOException {
-        dataFolder = temporaryFolder.newFolder();
-        File settingsFile = new File(dataFolder, "config.yml");
-        given(server.getLogger()).willReturn(Logger.getAnonymousLogger());
-        JavaPluginLoader pluginLoader = new JavaPluginLoader(server);
-        Files.copy(TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "config.test.yml"), settingsFile);
-
-        // Mock / wire various Bukkit components
-        ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
-        given(server.getPluginManager()).willReturn(pluginManager);
-
-        // PluginDescriptionFile is final: need to create a sample one
-        PluginDescriptionFile descriptionFile = new PluginDescriptionFile(
-            "AuthMe", "N/A", AuthMe.class.getCanonicalName());
-
-        // Initialize AuthMe
-        authMe = new AuthMe(pluginLoader, descriptionFile, dataFolder, null);
-    }
-
-    @Test
-    public void shouldInitializeAllServices() {
-        // given
-        PropertyReader reader = mock(PropertyReader.class);
-        PropertyResource resource = mock(PropertyResource.class);
-        given(resource.createReader()).willReturn(reader);
-        Settings settings = new Settings(dataFolder, resource, null, buildConfigurationData());
-
-        TestHelper.setupLogger();
-
-        Injector injector = new InjectorBuilder()
-            .addDefaultHandlers("fr.xephi.authme")
-            .create();
-        injector.provide(DataFolder.class, dataFolder);
-        injector.register(Server.class, server);
-        injector.register(PluginManager.class, pluginManager);
-
-        injector.register(AuthMe.class, authMe);
-        injector.register(Settings.class, settings);
-        injector.register(DataSource.class, mock(DataSource.class));
-        injector.register(BukkitService.class, mock(BukkitService.class));
-
-        // when
-        authMe.instantiateServices(injector);
-        authMe.registerEventListeners(injector);
-
-        // then
-        // Take a few samples and ensure that they are not null
-        assertThat(injector.getIfAvailable(AuthMeApi.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(BlockListener.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(BungeeReceiver.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(BungeeSender.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(CommandHandler.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(Management.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(PasswordSecurity.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(PermissionsManager.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(ProcessSyncPlayerLogin.class), not(nullValue()));
-        assertThat(injector.getIfAvailable(PurgeService.class), not(nullValue()));
-    }
-
-    @Test
-    public void shouldHandlePrematureShutdownGracefully() {
-        // given
-        BukkitScheduler scheduler = mock(BukkitScheduler.class);
-        given(server.getScheduler()).willReturn(scheduler);
-
-        // Make sure ConsoleLogger has no logger reference since that may happen on unexpected stops
-        ReflectionTestUtils.setField(ConsoleLogger.class, null, "logger", null);
-
-        // when
-        authMe.onDisable();
-
-        // then - no exceptions
-        verify(scheduler).getActiveWorkers(); // via TaskCloser
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/AuthMeMatchers.java b/src/test/java/fr/xephi/authme/AuthMeMatchers.java
deleted file mode 100644
index 86fe4cb9..00000000
--- a/src/test/java/fr/xephi/authme/AuthMeMatchers.java
+++ /dev/null
@@ -1,136 +0,0 @@
-package fr.xephi.authme;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-
-import java.util.Objects;
-
-/**
- * Custom matchers for AuthMe entities.
- */
-// Justification: Javadoc would be huge because of the many parameters
-@SuppressWarnings("checkstyle:MissingJavadocMethod")
-public final class AuthMeMatchers {
-
-    private AuthMeMatchers() {
-    }
-
-    public static Matcher<? super HashedPassword> equalToHash(String hash) {
-        return equalToHash(new HashedPassword(hash));
-    }
-
-    public static Matcher<? super HashedPassword> equalToHash(String hash, String salt) {
-        return equalToHash(new HashedPassword(hash, salt));
-    }
-
-    public static Matcher<? super HashedPassword> equalToHash(HashedPassword hash) {
-        return new TypeSafeMatcher<HashedPassword>() {
-            @Override
-            public boolean matchesSafely(HashedPassword item) {
-                return Objects.equals(hash.getHash(), item.getHash())
-                    && Objects.equals(hash.getSalt(), item.getSalt());
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                String representation = "'" + hash.getHash() + "'";
-                if (hash.getSalt() != null) {
-                    representation += ", '" + hash.getSalt() + "'";
-                }
-                description.appendValue("HashedPassword(" + representation + ")");
-            }
-        };
-    }
-
-    public static Matcher<PlayerAuth> hasAuthBasicData(String name, String realName,
-                                                       String email, String lastIp) {
-        return new TypeSafeMatcher<PlayerAuth>() {
-            @Override
-            public boolean matchesSafely(PlayerAuth item) {
-                return Objects.equals(name, item.getNickname())
-                    && Objects.equals(realName, item.getRealName())
-                    && Objects.equals(email, item.getEmail())
-                    && Objects.equals(lastIp, item.getLastIp());
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendValue(String.format("PlayerAuth with name %s, realname %s, email %s, lastIp %s",
-                    name, realName, email, lastIp));
-            }
-
-            @Override
-            public void describeMismatchSafely(PlayerAuth item, Description description) {
-                description.appendValue(String.format("PlayerAuth with name %s, realname %s, email %s, lastIp %s",
-                    item.getNickname(), item.getRealName(), item.getEmail(), item.getLastIp()));
-            }
-        };
-    }
-
-    public static Matcher<? super PlayerAuth> hasRegistrationInfo(String registrationIp, long registrationDate) {
-        return new TypeSafeMatcher<PlayerAuth>() {
-            @Override
-            public boolean matchesSafely(PlayerAuth item) {
-                return Objects.equals(registrationIp, item.getRegistrationIp())
-                    && Objects.equals(registrationDate, item.getRegistrationDate());
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendValue(String.format("PlayerAuth with reg. IP %s and reg date %d",
-                    registrationIp, registrationDate));
-            }
-
-            @Override
-            public void describeMismatchSafely(PlayerAuth item, Description description) {
-                description.appendValue(String.format("PlayerAuth with reg. IP %s and reg date %d",
-                    item.getRegistrationIp(), item.getRegistrationDate()));
-            }
-        };
-    }
-
-    public static Matcher<? super PlayerAuth> hasAuthLocation(PlayerAuth auth) {
-        return hasAuthLocation(auth.getQuitLocX(), auth.getQuitLocY(), auth.getQuitLocZ(), auth.getWorld(),
-            auth.getYaw(), auth.getPitch());
-    }
-
-    public static Matcher<? super PlayerAuth> hasAuthLocation(double x, double y, double z,
-                                                              String world, float yaw, float pitch) {
-        return new TypeSafeMatcher<PlayerAuth>() {
-            @Override
-            public boolean matchesSafely(PlayerAuth item) {
-                return Objects.equals(x, item.getQuitLocX())
-                    && Objects.equals(y, item.getQuitLocY())
-                    && Objects.equals(z, item.getQuitLocZ())
-                    && Objects.equals(world, item.getWorld())
-                    && Objects.equals(yaw, item.getYaw())
-                    && Objects.equals(pitch, item.getPitch());
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendValue(
-                    String.format("PlayerAuth with quit location (x: %f, y: %f, z: %f, world: %s, yaw: %f, pitch: %f)",
-                        x, y, z, world, yaw, pitch));
-            }
-        };
-    }
-
-    public static Matcher<String> stringWithLength(int length) {
-        return new TypeSafeMatcher<String>() {
-            @Override
-            protected boolean matchesSafely(String item) {
-                return item != null && item.length() == length;
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendText("String with length " + length);
-            }
-        };
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/ClassCollector.java b/src/test/java/fr/xephi/authme/ClassCollector.java
deleted file mode 100644
index 23c065e8..00000000
--- a/src/test/java/fr/xephi/authme/ClassCollector.java
+++ /dev/null
@@ -1,165 +0,0 @@
-package fr.xephi.authme;
-
-import java.io.File;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Function;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-
-/**
- * Collects available classes by walking through a source directory.
- * <p>
- * This is a naive, zero dependency collector that walks through a file directory
- * and loads classes from the class loader based on the .java files it encounters.
- * This is a very slow approach and should be avoided for production code.
- * <p>
- * For more performant approaches, see e.g. <a href="https://github.com/ronmamo/reflections">org.reflections</a>.
- */
-public class ClassCollector {
-
-    private final String root;
-    private final String nonCodePath;
-
-    /**
-     * Constructor. The arguments make up the path from which the collector will start scanning.
-     *
-     * @param nonCodePath beginning of the starting path that are not Java packages, e.g. {@code src/main/java/}
-     * @param packagePath folders following {@code nonCodePath} that are packages, e.g. {@code com/project/app}
-     */
-    public ClassCollector(String nonCodePath, String packagePath) {
-        if (!nonCodePath.endsWith("/") && !nonCodePath.endsWith("\\")) {
-            nonCodePath = nonCodePath.concat(File.separator);
-        }
-        this.root = nonCodePath + packagePath;
-        this.nonCodePath = nonCodePath;
-    }
-
-    /**
-     * Collects all classes from the parent folder and below.
-     *
-     * @return all classes
-     */
-    public List<Class<?>> collectClasses() {
-        return collectClasses(x -> true);
-    }
-
-    /**
-     * Collects all classes from the parent folder and below which are of type {@link T}.
-     *
-     * @param parent the parent which classes need to extend (or be equal to) in order to be collected
-     * @param <T> the parent type
-     * @return list of matching classes
-     */
-    @SuppressWarnings({ "unchecked", "rawtypes" })
-    public <T> List<Class<? extends T>> collectClasses(Class<T> parent) {
-        List<Class<?>> classes = collectClasses(parent::isAssignableFrom);
-        return new ArrayList<>((List) classes);
-    }
-
-    /**
-     * Collects all classes from the parent folder and below which match the given predicate.
-     *
-     * @param filter the predicate classes need to satisfy in order to be collected
-     * @return list of matching classes
-     */
-    public List<Class<?>> collectClasses(Predicate<Class<?>> filter) {
-        File rootFolder = new File(root);
-        List<Class<?>> collection = new ArrayList<>();
-        gatherClassesFromFile(rootFolder, filter, collection);
-        return collection;
-    }
-
-    /**
-     * Constructs an instance of all classes which are of the provided type {@code clazz}.
-     * This method assumes that every class has an accessible no-args constructor for creation.
-     *
-     * @param parent the parent which classes need to extend (or be equal to) in order to be instantiated
-     * @param <T> the parent type
-     * @return collection of created objects
-     */
-    public <T> List<T> getInstancesOfType(Class<T> parent) {
-        return getInstancesOfType(parent, (clz) -> {
-           try {
-               return canInstantiate(clz) ? clz.newInstance() : null;
-           } catch (InstantiationException | IllegalAccessException e) {
-               throw new IllegalStateException(e);
-           }
-        });
-    }
-
-    /**
-     * Constructs an instance of all classes which are of the provided type {@code clazz}
-     * with the provided {@code instantiator}.
-     *
-     * @param parent the parent which classes need to extend (or be equal to) in order to be instantiated
-     * @param instantiator function which returns an object of the given class, or null to skip the class
-     * @param <T> the parent type
-     * @return collection of created objects
-     */
-    public <T> List<T> getInstancesOfType(Class<T> parent, Function<Class<? extends T>, T> instantiator) {
-        return collectClasses(parent)
-            .stream()
-            .map(instantiator)
-            .filter(o -> o != null)
-            .collect(Collectors.toList());
-    }
-
-    /**
-     * Returns whether the given class can be instantiated, i.e. if it is not abstract, an interface, etc.
-     *
-     * @param clazz the class to process
-     * @return true if the class can be instantiated, false otherwise
-     */
-    public static boolean canInstantiate(Class<?> clazz) {
-        return clazz != null && !clazz.isEnum() && !clazz.isInterface()
-            && !clazz.isArray() && !Modifier.isAbstract(clazz.getModifiers());
-    }
-
-    /**
-     * Recursively collects the classes based on the files in the directory and in its child directories.
-     *
-     * @param folder the folder to scan
-     * @param filter the class predicate
-     * @param collection collection to add classes to
-     */
-    private void gatherClassesFromFile(File folder, Predicate<Class<?>> filter, List<Class<?>> collection) {
-        File[] files = folder.listFiles();
-        if (files == null) {
-            throw new IllegalStateException("Could not read files from '" + folder + "'");
-        }
-        for (File file : files) {
-            if (file.isDirectory()) {
-                gatherClassesFromFile(file, filter, collection);
-            } else if (file.isFile()) {
-                Class<?> clazz = loadTaskClassFromFile(file);
-                if (clazz != null && filter.test(clazz)) {
-                    collection.add(clazz);
-                }
-            }
-        }
-    }
-
-    /**
-     * Loads a class from the class loader based on the given file.
-     *
-     * @param file the file whose corresponding Java class should be retrieved
-     * @return the corresponding class, or null if not applicable
-     */
-    private Class<?> loadTaskClassFromFile(File file) {
-        if (!file.getName().endsWith(".java")) {
-            return null;
-        }
-
-        String filePath = file.getPath();
-        String className = filePath
-            .substring(nonCodePath.length(), filePath.length() - 5)
-            .replace(File.separator, ".");
-        try {
-            return Class.forName(className);
-        } catch (ClassNotFoundException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/ClassesConsistencyTest.java b/src/test/java/fr/xephi/authme/ClassesConsistencyTest.java
deleted file mode 100644
index f02b5dc9..00000000
--- a/src/test/java/fr/xephi/authme/ClassesConsistencyTest.java
+++ /dev/null
@@ -1,173 +0,0 @@
-package fr.xephi.authme;
-
-import ch.jalu.configme.properties.Property;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import fr.xephi.authme.data.captcha.CaptchaCodeStorage;
-import fr.xephi.authme.datasource.AbstractSqlDataSource;
-import fr.xephi.authme.datasource.Columns;
-import fr.xephi.authme.datasource.columnshandler.DataSourceColumn;
-import fr.xephi.authme.datasource.columnshandler.PlayerAuthColumn;
-import fr.xephi.authme.datasource.mysqlextensions.MySqlExtension;
-import fr.xephi.authme.initialization.HasCleanup;
-import fr.xephi.authme.process.register.executors.RegistrationMethod;
-import fr.xephi.authme.security.crypts.Whirlpool;
-import fr.xephi.authme.util.expiring.ExpiringMap;
-import fr.xephi.authme.util.expiring.ExpiringSet;
-import fr.xephi.authme.util.expiring.TimedCounter;
-import org.junit.Test;
-
-import java.io.File;
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.nio.charset.Charset;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Contains consistency tests across all AuthMe classes.
- */
-public class ClassesConsistencyTest {
-
-    /** Contains all production classes. */
-    private static final List<Class<?>> ALL_CLASSES =
-        new ClassCollector(TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT).collectClasses();
-
-    /** Expiring structure types. */
-    private static final Set<Class<?>> EXPIRING_STRUCTURES = ImmutableSet.of(
-        ExpiringSet.class, ExpiringMap.class, TimedCounter.class, CaptchaCodeStorage.class);
-
-    /** Immutable types, which are allowed to be used in non-private constants. */
-    private static final Set<Class<?>> IMMUTABLE_TYPES = ImmutableSet.of(
-        /* JDK */
-        int.class, long.class, float.class, String.class, File.class, Enum.class, collectionsUnmodifiableList(),
-        Charset.class,
-        /* AuthMe */
-        Property.class, RegistrationMethod.class, DataSourceColumn.class, PlayerAuthColumn.class,
-        /* Guava */
-        ImmutableMap.class, ImmutableList.class);
-
-    /** Classes excluded from the field visibility test. */
-    private static final Set<Class<?>> CLASSES_EXCLUDED_FROM_VISIBILITY_TEST = ImmutableSet.of(
-        Whirlpool.class, // not our implementation, so we don't touch it
-        MySqlExtension.class, // has immutable protected fields used by all children
-        AbstractSqlDataSource.class, // protected members for inheritance
-        Columns.class // uses non-static String constants, which is safe
-    );
-
-    /**
-     * Checks that there aren't two classes with the same name; this is confusing and should be avoided.
-     */
-    @Test
-    public void shouldNotHaveSameName() {
-        // given
-        Set<String> names = new HashSet<>();
-
-        // when / then
-        for (Class<?> clazz : ALL_CLASSES) {
-            if (!names.add(clazz.getSimpleName())) {
-                fail("Class with name '" + clazz.getSimpleName() + "' already encountered!");
-            }
-        }
-    }
-
-    /**
-     * Checks that fields of classes are either private or static final fields of an immutable type.
-     */
-    @Test
-    public void shouldHaveNonPrivateConstantsOnly() {
-        // given / when
-        Set<String> invalidFields = ALL_CLASSES.stream()
-            .filter(clz -> !CLASSES_EXCLUDED_FROM_VISIBILITY_TEST.contains(clz))
-            .map(Class::getDeclaredFields)
-            .flatMap(Arrays::stream)
-            .filter(f -> !f.getName().contains("$"))
-            .filter(f -> hasIllegalFieldVisibility(f))
-            .map(f -> formatField(f))
-            .collect(Collectors.toSet());
-
-        // then
-        if (!invalidFields.isEmpty()) {
-            fail("Found " + invalidFields.size() + " fields with non-private, mutable fields:\n- "
-                + String.join("\n- ", invalidFields));
-        }
-    }
-
-    private static boolean hasIllegalFieldVisibility(Field field) {
-        final int modifiers = field.getModifiers();
-        if (Modifier.isPrivate(modifiers)) {
-            return false;
-        } else if (!Modifier.isStatic(modifiers) || !Modifier.isFinal(modifiers)) {
-            return true;
-        }
-
-        // Field is non-private, static and final
-        Class<?> valueType;
-        if (Collection.class.isAssignableFrom(field.getType()) || Map.class.isAssignableFrom(field.getType())) {
-            // For collections/maps, need to check the actual type to ensure it's an unmodifiable implementation
-            Object value = ReflectionTestUtils.getFieldValue(field, null);
-            valueType = value.getClass();
-        } else {
-             valueType = field.getType();
-        }
-
-        // Field is static, final, and not private -> check that it is immutable type
-        return IMMUTABLE_TYPES.stream()
-            .noneMatch(immutableType -> immutableType.isAssignableFrom(valueType));
-    }
-
-    /**
-     * Prints out the field with its modifiers.
-     *
-     * @param field the field to format
-     * @return description of the field
-     */
-    private static String formatField(Field field) {
-        String modifiersText = Modifier.toString(field.getModifiers());
-        return String.format("[%s] %s %s %s", field.getDeclaringClass().getSimpleName(), modifiersText.trim(),
-            field.getType().getSimpleName(), field.getName());
-    }
-
-    /**
-     * Checks that classes with expiring collections (such as {@link ExpiringMap}) implement the {@link HasCleanup}
-     * interface to regularly clean up expired data.
-     */
-    @Test
-    public void shouldImplementHasCleanup() {
-        // given / when / then
-        for (Class<?> clazz : ALL_CLASSES) {
-            if (hasExpiringCollectionAsField(clazz) && !EXPIRING_STRUCTURES.contains(clazz)) {
-                assertThat("Class '" + clazz.getSimpleName() + "' has expiring collections, should implement HasCleanup",
-                    HasCleanup.class.isAssignableFrom(clazz), equalTo(true));
-            }
-        }
-    }
-
-    private static boolean hasExpiringCollectionAsField(Class<?> clazz) {
-        for (Field field : clazz.getDeclaredFields()) {
-            if (EXPIRING_STRUCTURES.stream().anyMatch(t -> t.isAssignableFrom(field.getType()))) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * @return the concrete class of the unmodifiable list as returned by {@link Collections#unmodifiableList(List)}.
-     */
-    private static Class<?> collectionsUnmodifiableList() {
-        return Collections.unmodifiableList(new ArrayList<>()).getClass();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/CodeClimateConfigTest.java b/src/test/java/fr/xephi/authme/CodeClimateConfigTest.java
deleted file mode 100644
index e645922e..00000000
--- a/src/test/java/fr/xephi/authme/CodeClimateConfigTest.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package fr.xephi.authme;
-
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.junit.Test;
-
-import java.io.File;
-import java.util.List;
-
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Consistency test for the CodeClimate configuration file.
- */
-public class CodeClimateConfigTest {
-
-    private static final String CONFIG_FILE = ".codeclimate.yml";
-
-    @Test
-    public void shouldHaveExistingClassesInExclusions() {
-        // given / when
-        FileConfiguration configuration = YamlConfiguration.loadConfiguration(new File(CONFIG_FILE));
-        List<String> excludePaths = configuration.getStringList("exclude_patterns");
-
-        // then
-        assertThat(excludePaths, not(empty()));
-        removeTestsExclusionOrThrow(excludePaths);
-        for (String path : excludePaths) {
-            if (!new File(path).exists()) {
-                fail("Path '" + path + "' does not exist!");
-            }
-        }
-    }
-
-    private static void removeTestsExclusionOrThrow(List<String> excludePaths) {
-        boolean wasRemoved = excludePaths.removeIf("src/test/java/**/*Test.java"::equals);
-        assertThat("Expected an exclusion for test classes",
-            wasRemoved, equalTo(true));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/ConsoleLoggerTest.java b/src/test/java/fr/xephi/authme/ConsoleLoggerTest.java
deleted file mode 100644
index 3f334e47..00000000
--- a/src/test/java/fr/xephi/authme/ConsoleLoggerTest.java
+++ /dev/null
@@ -1,227 +0,0 @@
-package fr.xephi.authme;
-
-import fr.xephi.authme.output.LogLevel;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.util.List;
-import java.util.logging.Logger;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link ConsoleLogger}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ConsoleLoggerTest {
-
-    private ConsoleLogger consoleLogger;
-
-    @Mock
-    private Logger logger;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    private File logFile;
-
-    @Before
-    public void setMockLogger() throws IOException {
-        File folder = temporaryFolder.newFolder();
-        File logFile = new File(folder, "authme.log");
-        if (!logFile.createNewFile()) {
-            throw new IOException("Could not create file '" + logFile.getPath() + "'");
-        }
-        ConsoleLogger.initialize(logger, logFile);
-        this.logFile = logFile;
-        this.consoleLogger = new ConsoleLogger("test");
-    }
-
-    @After
-    public void closeFileHandlers() {
-        ConsoleLogger.closeFileWriter();
-    }
-
-    /**
-     * Resets the ConsoleLogger back to its defaults after running all tests. Especially important
-     * is that we no longer enable logging to a file as the log file we've supplied will no longer
-     * be around after this test class has finished.
-     */
-    @AfterClass
-    public static void resetConsoleToDefault() {
-        ConsoleLogger.initializeSharedSettings(newSettings(false, LogLevel.INFO));
-    }
-
-    @Test
-    public void shouldLogToFile() throws IOException {
-        // given
-        Settings settings = newSettings(true, LogLevel.FINE);
-        ConsoleLogger.initializeSharedSettings(settings);
-        consoleLogger.initializeSettings(settings);
-
-        // when
-        consoleLogger.fine("Logging a FINE message");
-        consoleLogger.debug("Logging a DEBUG message");
-        consoleLogger.info("This is an INFO message");
-
-        // then
-        verify(logger, times(2)).info(anyString());
-        verifyNoMoreInteractions(logger);
-        List<String> loggedLines = Files.readAllLines(logFile.toPath(), StandardCharsets.UTF_8);
-        assertThat(loggedLines, hasSize(2));
-        assertThat(loggedLines.get(0), containsString("[FINE] Logging a FINE message"));
-        assertThat(loggedLines.get(1), containsString("[INFO] This is an INFO message"));
-    }
-
-    @Test
-    public void shouldNotLogToFile() {
-        // given
-        Settings settings = newSettings(false, LogLevel.DEBUG);
-        ConsoleLogger.initializeSharedSettings(settings);
-        consoleLogger.initializeSettings(settings);
-
-        // when
-        consoleLogger.debug("Created test");
-        consoleLogger.warning("Encountered a warning");
-
-        // then
-        verify(logger).info("[DEBUG] Created test");
-        verify(logger).warning("Encountered a warning");
-        verifyNoMoreInteractions(logger);
-        assertThat(logFile.length(), equalTo(0L));
-    }
-
-    @Test
-    public void shouldLogStackTraceToFile() throws IOException {
-        // given
-        Settings settings = newSettings(true, LogLevel.INFO);
-        ConsoleLogger.initializeSharedSettings(settings);
-        Exception e = new IllegalStateException("Test exception message");
-
-        // when
-        consoleLogger.info("Info text");
-        consoleLogger.debug("Debug message");
-        consoleLogger.fine("Fine-level message");
-        consoleLogger.logException("Exception occurred:", e);
-
-        // then
-        verify(logger).info("Info text");
-        verify(logger).warning("Exception occurred: [IllegalStateException]: Test exception message");
-        verifyNoMoreInteractions(logger);
-        List<String> loggedLines = Files.readAllLines(logFile.toPath(), StandardCharsets.UTF_8);
-        assertThat(loggedLines.size(), greaterThan(3));
-        assertThat(loggedLines.get(0), containsString("[INFO] Info text"));
-        assertThat(loggedLines.get(1),
-            containsString("[WARN] Exception occurred: [IllegalStateException]: Test exception message"));
-        // Check that we have this class' full name somewhere in the file -> stacktrace of Exception e
-        assertThat(String.join("", loggedLines), containsString(getClass().getCanonicalName()));
-    }
-
-    @Test
-    public void shouldSupportVariousDebugMethods() throws IOException {
-        // given
-        Settings settings = newSettings(true, LogLevel.DEBUG);
-        ConsoleLogger.initializeSharedSettings(settings);
-        consoleLogger.initializeSettings(settings);
-
-        // when
-        consoleLogger.debug("Got {0} entries", 17);
-        consoleLogger.debug("Player `{0}` is in world `{1}`", "Bobby", new WorldDummy("world"));
-        consoleLogger.debug("{0} quick {1} jump over {2} lazy {3} (reason: {4})", 5, "foxes", 3, "dogs", null);
-        consoleLogger.debug(() -> "Too little too late");
-
-        // then
-        verify(logger).info("[DEBUG] Got 17 entries");
-        verify(logger).info("[DEBUG] Player `Bobby` is in world `w[world]`");
-        verify(logger).info("[DEBUG] 5 quick foxes jump over 3 lazy dogs (reason: null)");
-        verify(logger).info("[DEBUG] Too little too late");
-        verifyNoMoreInteractions(logger);
-
-        List<String> loggedLines = Files.readAllLines(logFile.toPath(), StandardCharsets.UTF_8);
-        assertThat(loggedLines, contains(
-            containsString("[DEBUG] Got 17 entries"),
-            containsString("[DEBUG] Player `Bobby` is in world `w[world]`"),
-            containsString("[DEBUG] 5 quick foxes jump over 3 lazy dogs (reason: null)"),
-            containsString("[DEBUG] Too little too late")));
-    }
-
-    @Test
-    public void shouldCloseFileWriterDespiteExceptionOnFlush() throws IOException {
-        // given
-        FileWriter fileWriter = mock(FileWriter.class);
-        doThrow(new IOException("Error during flush")).when(fileWriter).flush();
-        ReflectionTestUtils.setField(ConsoleLogger.class, null, "fileWriter", fileWriter);
-
-        // when
-        ConsoleLogger.closeFileWriter();
-
-        // then
-        verify(fileWriter).flush();
-        verify(fileWriter).close();
-        assertThat(ReflectionTestUtils.getFieldValue(ConsoleLogger.class, null, "fileWriter"), nullValue());
-    }
-
-    @Test
-    public void shouldHandleExceptionOnFileWriterClose() throws IOException {
-        // given
-        FileWriter fileWriter = mock(FileWriter.class);
-        doThrow(new IOException("Cannot close")).when(fileWriter).close();
-        ReflectionTestUtils.setField(ConsoleLogger.class, null, "fileWriter", fileWriter);
-
-        // when
-        ConsoleLogger.closeFileWriter();
-
-        // then
-        verify(fileWriter).flush();
-        verify(fileWriter).close();
-        assertThat(ReflectionTestUtils.getFieldValue(ConsoleLogger.class, null, "fileWriter"), nullValue());
-    }
-
-    private static Settings newSettings(boolean logToFile, LogLevel logLevel) {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(SecuritySettings.USE_LOGGING)).willReturn(logToFile);
-        given(settings.getProperty(PluginSettings.LOG_LEVEL)).willReturn(logLevel);
-        return settings;
-    }
-
-    private static final class WorldDummy {
-        private final String name;
-
-        WorldDummy(String name) {
-            this.name = name;
-        }
-
-        @Override
-        public String toString() {
-            return "w[" + name + "]";
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/IsEqualByReflectionMatcher.java b/src/test/java/fr/xephi/authme/IsEqualByReflectionMatcher.java
deleted file mode 100644
index 2acf5ee7..00000000
--- a/src/test/java/fr/xephi/authme/IsEqualByReflectionMatcher.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package fr.xephi.authme;
-
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-
-import static org.junit.Assert.fail;
-
-/**
- * Matcher which checks with reflection that all fields have the same value.
- * This matcher considers all non-static fields until the Object parent.
- */
-public final class IsEqualByReflectionMatcher<T> extends TypeSafeMatcher<T> {
-
-    private final T expected;
-
-    private IsEqualByReflectionMatcher(T expected) {
-        this.expected = expected;
-    }
-
-    /**
-     * Creates a matcher that checks if all fields are the same as on the {@code expected} object.
-     *
-     * @param expected the object to match
-     * @param <T> the object's type
-     * @return the matcher for the expected object
-     */
-    public static <T> Matcher<T> hasEqualValuesOnAllFields(T expected) {
-        return new IsEqualByReflectionMatcher<>(expected);
-    }
-
-    @Override
-    protected boolean matchesSafely(T item) {
-        return assertAreFieldsEqual(item);
-    }
-
-    @Override
-    public void describeTo(Description description) {
-        description.appendText("parameters " + expected);
-    }
-
-    /**
-     * Checks that all fields of the given {@code item} are equal to the {@link #expected} object. Both objects must
-     * be exactly of the same type.
-     *
-     * @param item the object to check
-     * @return true if all fields are equal, false otherwise
-     */
-    private boolean assertAreFieldsEqual(T item) {
-        if (expected.getClass() != item.getClass()) {
-            fail("Classes don't match, got " + expected.getClass().getSimpleName()
-                + " and " + item.getClass().getSimpleName());
-            return false;
-        }
-
-        List<Field> fieldsToCheck = getAllFields(expected);
-        for (Field field : fieldsToCheck) {
-            Object lhsValue = ReflectionTestUtils.getFieldValue(field, expected);
-            Object rhsValue = ReflectionTestUtils.getFieldValue(field, item);
-            if (!Objects.equals(lhsValue, rhsValue)) {
-                fail("Field '" + field.getName() + "' does not have same value: '"
-                    + lhsValue + "' vs. '" + rhsValue + "'");
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private static List<Field> getAllFields(Object object) {
-        List<Field> fields = new ArrayList<>();
-        Class<?> currentClass = object.getClass();
-        while (currentClass != null) {
-            for (Field f : currentClass.getDeclaredFields()) {
-                if (!Modifier.isStatic(f.getModifiers()) && !f.isSynthetic()) {
-                    fields.add(f);
-                }
-            }
-            if (currentClass == Object.class) {
-                break;
-            }
-            currentClass = currentClass.getSuperclass();
-        }
-        return fields;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/ReflectionTestUtils.java b/src/test/java/fr/xephi/authme/ReflectionTestUtils.java
deleted file mode 100644
index 69a1e1d9..00000000
--- a/src/test/java/fr/xephi/authme/ReflectionTestUtils.java
+++ /dev/null
@@ -1,153 +0,0 @@
-package fr.xephi.authme;
-
-import ch.jalu.injector.handlers.postconstruct.PostConstructMethodInvoker;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-import static java.lang.String.format;
-
-/**
- * Offers reflection functionality to set up tests. Use only when absolutely necessary.
- */
-public final class ReflectionTestUtils {
-
-    private ReflectionTestUtils() {
-        // Util class
-    }
-
-    /**
-     * Sets the field of a given object to a new value with reflection.
-     *
-     * @param clazz the class declaring the field
-     * @param instance the instance to modify (pass null for static fields)
-     * @param fieldName the field name
-     * @param value the value to set the field to
-     * @param <T> the instance type
-     */
-    public static <T> void setField(Class<? super T> clazz, T instance, String fieldName, Object value) {
-        try {
-            Field field = getField(clazz, fieldName);
-            field.set(instance, value);
-        } catch (IllegalAccessException e) {
-            throw new IllegalStateException(
-                format("Could not set value to field '%s' for instance '%s' of class '%s'",
-                    fieldName, instance, clazz.getName()), e);
-        }
-    }
-
-    /**
-     * Sets the field on the given instance to the new value.
-     *
-     * @param instance the instance to modify
-     * @param fieldName the field name
-     * @param value the value to set the field to
-     */
-    @SuppressWarnings("unchecked")
-    public static void setField(Object instance, String fieldName, Object value) {
-        setField((Class) instance.getClass(), instance, fieldName, value);
-    }
-
-    private static <T> Field getField(Class<T> clazz, String fieldName) {
-        try {
-            Field field = clazz.getDeclaredField(fieldName);
-            field.setAccessible(true);
-            return field;
-        } catch (NoSuchFieldException e) {
-            throw new IllegalStateException(format("Could not get field '%s' from class '%s'",
-                fieldName, clazz.getName()), e);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T, V> V getFieldValue(Class<T> clazz, T instance, String fieldName) {
-        Field field = getField(clazz, fieldName);
-        return getFieldValue(field, instance);
-    }
-
-    /**
-     * Returns the value of the field on the given instance. Wraps exceptions into a runtime exception.
-     *
-     * @param field the field to read
-     * @param instance the instance to get the value from, null if field is static
-     * @param <V> type of the field
-     * @return value of the field
-     */
-    @SuppressWarnings("unchecked")
-    public static <V> V getFieldValue(Field field, Object instance) {
-        field.setAccessible(true);
-        try {
-            return (V) field.get(instance);
-        } catch (IllegalAccessException e) {
-            throw new IllegalStateException("Could not get value of field '" + field.getName() + "'", e);
-        }
-    }
-
-    /**
-     * Returns the method on the given class with the supplied parameter types.
-     *
-     * @param clazz the class to retrieve a method from
-     * @param methodName the name of the method
-     * @param parameterTypes the parameter types the method to retrieve has
-     * @return the method of the class, set to be accessible
-     */
-    public static Method getMethod(Class<?> clazz, String methodName, Class<?>... parameterTypes) {
-        try {
-            Method method = clazz.getDeclaredMethod(methodName, parameterTypes);
-            method.setAccessible(true);
-            return method;
-        } catch (NoSuchMethodException e) {
-            throw new IllegalStateException("Could not retrieve method '" + methodName + "' from class '"
-                + clazz.getName() + "'");
-        }
-    }
-
-    /**
-     * Invokes the given method on the provided instance with the given parameters.
-     *
-     * @param method the method to invoke
-     * @param instance the instance to invoke the method on (null for static methods)
-     * @param parameters the parameters to pass to the method
-     * @param <V> return value of the method
-     * @return method return value
-     */
-    @SuppressWarnings("unchecked")
-    public static <V> V invokeMethod(Method method, Object instance, Object... parameters) {
-        method.setAccessible(true);
-        try {
-            return (V) method.invoke(instance, parameters);
-        } catch (InvocationTargetException | IllegalAccessException e) {
-            throw new IllegalStateException("Could not invoke method '" + method + "'", e);
-        }
-    }
-
-    /**
-     * Runs all methods annotated with {@link javax.annotation.PostConstruct} on the given instance
-     * (including such methods on superclasses).
-     *
-     * @param instance the instance to process
-     */
-    public static void invokePostConstructMethods(Object instance) {
-        // Use the implementation of the injector to invoke all @PostConstruct methods the same way
-        new PostConstructMethodInvoker().postProcess(instance, null, null);
-    }
-
-    /**
-     * Creates a new instance of the given class, using a no-args constructor (which may be hidden).
-     *
-     * @param clazz the class to instantiate
-     * @param <T> the class' type
-     * @return the created instance
-     */
-    public static <T> T newInstance(Class<T> clazz) {
-        try {
-            Constructor<T> constructor = clazz.getDeclaredConstructor();
-            constructor.setAccessible(true);
-            return constructor.newInstance();
-        } catch (ReflectiveOperationException e) {
-            throw new IllegalStateException("Could not invoke no-args constructor of class " + clazz, e);
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/TestHelper.java b/src/test/java/fr/xephi/authme/TestHelper.java
deleted file mode 100644
index ad50c511..00000000
--- a/src/test/java/fr/xephi/authme/TestHelper.java
+++ /dev/null
@@ -1,121 +0,0 @@
-package fr.xephi.authme;
-
-import ch.jalu.configme.properties.Property;
-import fr.xephi.authme.settings.Settings;
-import org.bukkit.entity.Player;
-import org.mockito.Mockito;
-
-import java.io.File;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.net.URL;
-import java.net.UnknownHostException;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.util.logging.Logger;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-
-/**
- * AuthMe test utilities.
- */
-public final class TestHelper {
-
-    public static final String SOURCES_FOLDER = "src/main/java/";
-    public static final String TEST_SOURCES_FOLDER = "src/test/java/";
-    public static final String TEST_RESOURCES_FOLDER = "src/test/resources/";
-    public static final String PROJECT_ROOT = "/fr/xephi/authme/";
-
-    private TestHelper() {
-    }
-
-    /**
-     * Return a {@link File} to a file in the JAR's resources (main or test).
-     *
-     * @param path The absolute path to the file
-     * @return The project file
-     */
-    public static File getJarFile(String path) {
-        URI uri = getUriOrThrow(path);
-        return new File(uri.getPath());
-    }
-
-    /**
-     * Return a {@link Path} to a file in the JAR's resources (main or test).
-     *
-     * @param path The absolute path to the file
-     * @return The Path object to the file
-     */
-    public static Path getJarPath(String path) {
-        String sqlFilePath = getUriOrThrow(path).getPath();
-        // Windows prepends the path with a '/' or '\', which Paths cannot handle
-        String appropriatePath = System.getProperty("os.name").contains("indow")
-            ? sqlFilePath.substring(1)
-            : sqlFilePath;
-        return Paths.get(appropriatePath);
-    }
-
-    private static URI getUriOrThrow(String path) {
-        URL url = TestHelper.class.getResource(path);
-        if (url == null) {
-            throw new IllegalStateException("File '" + path + "' could not be loaded");
-        }
-        try {
-            return new URI(url.toString());
-        } catch (URISyntaxException e) {
-            throw new IllegalStateException("File '" + path + "' cannot be converted to a URI");
-        }
-    }
-
-    /**
-     * Assign the necessary fields on ConsoleLogger with mocks.
-     *
-     * @return The logger mock used
-     */
-    public static Logger setupLogger() {
-        Logger logger = Mockito.mock(Logger.class);
-        ConsoleLogger.initialize(logger, null);
-        return logger;
-    }
-
-    /**
-     * Set ConsoleLogger to use a new real logger.
-     *
-     * @return The real logger used by ConsoleLogger
-     */
-    public static Logger setRealLogger() {
-        Logger logger = Logger.getAnonymousLogger();
-        ConsoleLogger.initialize(logger, null);
-        return logger;
-    }
-
-    /**
-     * Configures the player mock to return the given IP address.
-     *
-     * @param player the player mock
-     * @param ip the ip address it should return
-     */
-    public static void mockIpAddressToPlayer(Player player, String ip) {
-        try {
-            InetAddress inetAddress = InetAddress.getByName(ip);
-            InetSocketAddress inetSocketAddress = new InetSocketAddress(inetAddress, 8093);
-            given(player.getAddress()).willReturn(inetSocketAddress);
-        } catch (UnknownHostException e) {
-            throw new IllegalStateException("Invalid IP address: " + ip, e);
-        }
-    }
-
-    /**
-     * Configures the Settings mock to return the property's default value for any given property.
-     *
-     * @param settings the settings mock
-     */
-    @SuppressWarnings("unchecked")
-    public static void returnDefaultsForAllProperties(Settings settings) {
-        given(settings.getProperty(any(Property.class)))
-            .willAnswer(invocation -> ((Property<?>) invocation.getArgument(0)).getDefaultValue());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/api/v3/AuthMeApiTest.java b/src/test/java/fr/xephi/authme/api/v3/AuthMeApiTest.java
deleted file mode 100644
index b52f7908..00000000
--- a/src/test/java/fr/xephi/authme/api/v3/AuthMeApiTest.java
+++ /dev/null
@@ -1,558 +0,0 @@
-package fr.xephi.authme.api.v3;
-
-import fr.xephi.authme.AuthMe;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.process.register.executors.ApiPasswordRegisterParams;
-import fr.xephi.authme.process.register.executors.RegistrationMethod;
-import fr.xephi.authme.security.PasswordSecurity;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.service.GeoIpService;
-import fr.xephi.authme.service.ValidationService;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.time.Instant;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.IsEqualByReflectionMatcher.hasEqualValuesOnAllFields;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.hamcrest.Matchers.sameInstance;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-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.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link AuthMeApi}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AuthMeApiTest {
-
-    @InjectMocks
-    private AuthMeApi api;
-
-    @Mock
-    private ValidationService validationService;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private Management management;
-    @Mock
-    private PasswordSecurity passwordSecurity;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private AuthMe authMe;
-    @Mock
-    private GeoIpService geoIpService;
-
-    @Test
-    public void shouldReturnInstanceOrNull() {
-        AuthMeApi result = AuthMeApi.getInstance();
-        assertThat(result, sameInstance(api));
-
-        ReflectionTestUtils.setField(AuthMeApi.class, null, "singleton", null);
-        assertThat(AuthMeApi.getInstance(), nullValue());
-    }
-
-    @Test
-    public void shouldReturnIfPlayerIsAuthenticated() {
-        // given
-        String name = "Bobby";
-        Player player = mockPlayerWithName(name);
-        given(playerCache.isAuthenticated(name)).willReturn(true);
-
-        // when
-        boolean result = api.isAuthenticated(player);
-
-        // then
-        verify(playerCache).isAuthenticated(name);
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldReturnIfPlayerIsNpc() {
-        // given
-        Player player = mock(Player.class);
-        given(player.hasMetadata("NPC")).willReturn(true);
-
-        // when
-        boolean result = api.isNpc(player);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(player).hasMetadata("NPC");
-    }
-
-    @Test
-    public void shouldReturnIfPlayerIsUnrestricted() {
-        // given
-        String name = "Tester";
-        Player player = mockPlayerWithName(name);
-        given(validationService.isUnrestricted(name)).willReturn(true);
-
-        // when
-        boolean result = api.isUnrestricted(player);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldGetLastLocation() {
-        // given
-        String name = "Gary";
-        Player player = mockPlayerWithName(name);
-        PlayerAuth auth = PlayerAuth.builder().name(name)
-            .locWorld("world")
-            .locX(12.4)
-            .locY(24.6)
-            .locZ(-438.2)
-            .locYaw(3.41f)
-            .locPitch(0.29f)
-            .build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-        Server server = mock(Server.class);
-        ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
-        World world = mock(World.class);
-        given(server.getWorld(auth.getWorld())).willReturn(world);
-
-        // when
-        Location result = api.getLastLocation(player);
-
-        // then
-        assertThat(result, not(nullValue()));
-        assertThat(result.getX(), equalTo(auth.getQuitLocX()));
-        assertThat(result.getY(), equalTo(auth.getQuitLocY()));
-        assertThat(result.getZ(), equalTo(auth.getQuitLocZ()));
-        assertThat(result.getWorld(), equalTo(world));
-        assertThat(result.getYaw(), equalTo(auth.getYaw()));
-        assertThat(result.getPitch(), equalTo(auth.getPitch()));
-    }
-
-    @Test
-    public void shouldGetLastIp() {
-        // given
-        String name = "Gabriel";
-        Player player = mockPlayerWithName(name);
-        PlayerAuth auth = PlayerAuth.builder().name(name)
-            .lastIp("93.23.44.55")
-            .build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-
-        // when
-        String result = api.getLastIp(player.getName());
-
-        // then
-        assertThat(result, not(nullValue()));
-        assertThat(result, equalTo("93.23.44.55"));
-    }
-
-    @Test
-    public void shouldReturnNullAsLastIpForUnknownUser() {
-        // given
-        String name = "Harrison";
-        given(playerCache.getAuth(name)).willReturn(null);
-        given(dataSource.getAuth(name)).willReturn(null);
-
-        // when
-        String result = api.getLastIp(name);
-
-        // then
-        assertThat(result, nullValue());
-        verify(playerCache).getAuth(name);
-        verify(dataSource).getAuth(name);
-    }
-
-    @Test
-    public void shouldGetLastLogin() {
-        // given
-        String name = "David";
-        PlayerAuth auth = PlayerAuth.builder().name(name)
-            .lastLogin(1501597979L)
-            .build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-
-        // when
-        Date result = api.getLastLogin(name);
-
-        // then
-        assertThat(result, not(nullValue()));
-        assertThat(result, equalTo(new Date(1501597979L)));
-    }
-
-    @Test
-    public void shouldHandleNullLastLogin() {
-        // given
-        String name = "John";
-        PlayerAuth auth = PlayerAuth.builder().name(name)
-            .lastLogin(null)
-            .build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        Date result = api.getLastLogin(name);
-
-        // then
-        assertThat(result, nullValue());
-        verify(dataSource).getAuth(name);
-    }
-
-    @Test
-    public void shouldGetLastLoginTime() {
-        // given
-        String name = "David";
-        PlayerAuth auth = PlayerAuth.builder().name(name)
-            .lastLogin(1501597979L)
-            .build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-
-        // when
-        Instant result = api.getLastLoginTime(name);
-
-        // then
-        assertThat(result, not(nullValue()));
-        assertThat(result, equalTo(Instant.ofEpochMilli(1501597979L)));
-    }
-
-    @Test
-    public void testGetLastLoginMillis() {
-        AuthMeApi result = AuthMeApi.getInstance();
-        assertThat(result.getLastLoginTime("notAPlayer"), nullValue());
-    }
-
-    @Test
-    public void shouldHandleNullLastLoginTime() {
-        // given
-        String name = "John";
-        PlayerAuth auth = PlayerAuth.builder().name(name)
-            .lastLogin(null)
-            .build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        Instant result = api.getLastLoginTime(name);
-
-        // then
-        assertThat(result, nullValue());
-        verify(dataSource).getAuth(name);
-    }
-
-    @Test
-    public void shouldReturnNullForUnavailablePlayer() {
-        // given
-        String name = "Numan";
-        Player player = mockPlayerWithName(name);
-        given(playerCache.getAuth(name)).willReturn(null);
-
-        // when
-        Location result = api.getLastLocation(player);
-
-        // then
-        assertThat(result, nullValue());
-    }
-
-    @Test
-    public void shouldCheckForRegisteredName() {
-        // given
-        String name = "toaster";
-        given(dataSource.isAuthAvailable(name)).willReturn(true);
-
-        // when
-        boolean result = api.isRegistered(name);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldCheckPassword() {
-        // given
-        String playerName = "Robert";
-        String password = "someSecretPhrase2983";
-        given(passwordSecurity.comparePassword(password, playerName)).willReturn(true);
-
-        // when
-        boolean result = api.checkPassword(playerName, password);
-
-        // then
-        verify(passwordSecurity).comparePassword(password, playerName);
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldReturnAuthNames() {
-        // given
-        String[] names = {"bobby", "peter", "elisabeth", "craig"};
-        List<PlayerAuth> auths = Arrays.stream(names)
-            .map(name -> PlayerAuth.builder().name(name).build())
-            .collect(Collectors.toList());
-        given(dataSource.getAllAuths()).willReturn(auths);
-
-        // when
-        List<String> result = api.getRegisteredNames();
-
-        // then
-        assertThat(result, contains(names));
-    }
-
-    @Test
-    public void shouldReturnAuthRealNames() {
-        // given
-        String[] names = {"Bobby", "peter", "Elisabeth", "CRAIG"};
-        List<PlayerAuth> auths = Arrays.stream(names)
-            .map(name -> PlayerAuth.builder().name(name).realName(name).build())
-            .collect(Collectors.toList());
-        given(dataSource.getAllAuths()).willReturn(auths);
-
-        // when
-        List<String> result = api.getRegisteredRealNames();
-
-        // then
-        assertThat(result, contains(names));
-    }
-
-    @Test
-    public void shouldUnregisterPlayer() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Donald";
-        given(player.getName()).willReturn(name);
-
-        // when
-        api.forceUnregister(player);
-
-        // then
-        verify(management).performUnregisterByAdmin(null, name, player);
-    }
-
-    @Test
-    public void shouldUnregisterPlayerByName() {
-        // given
-        Server server = mock(Server.class);
-        ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
-        String name = "tristan";
-        Player player = mock(Player.class);
-        given(server.getPlayer(name)).willReturn(player);
-
-        // when
-        api.forceUnregister(name);
-
-        // then
-        verify(management).performUnregisterByAdmin(null, name, player);
-    }
-
-    @Test
-    public void shouldChangePassword() {
-        // given
-        String name = "Bobby12";
-        String password = "resetPw!";
-
-        // when
-        api.changePassword(name, password);
-
-        // then
-        verify(management).performPasswordChangeAsAdmin(null, name, password);
-    }
-
-    @Test
-    public void shouldReturnAuthMeInstance() {
-        // given / when
-        AuthMe result = api.getPlugin();
-
-        // then
-        assertThat(result, equalTo(authMe));
-    }
-
-    @Test
-    public void shouldReturnVersion() {
-        // given / when
-        String result = api.getPluginVersion();
-
-        // then
-        assertThat(result, equalTo(AuthMe.getPluginVersion()));
-    }
-
-    @Test
-    public void shouldForceLogin() {
-        // given
-        Player player = mock(Player.class);
-
-        // when
-        api.forceLogin(player);
-
-        // then
-        verify(management).forceLogin(player);
-    }
-
-    @Test
-    public void shouldForceLogout() {
-        // given
-        Player player = mock(Player.class);
-
-        // when
-        api.forceLogout(player);
-
-        // then
-        verify(management).performLogout(player);
-    }
-
-    @Test
-    public void shouldForceRegister() {
-        // given
-        Player player = mock(Player.class);
-        String pass = "test235";
-
-        // when
-        api.forceRegister(player, pass);
-
-        // then
-        verify(management).performRegister(eq(RegistrationMethod.API_REGISTRATION),
-            argThat(hasEqualValuesOnAllFields(ApiPasswordRegisterParams.of(player, pass, true))));
-    }
-
-    @Test
-    public void shouldForceRegisterAndNotAutoLogin() {
-        // given
-        Player player = mock(Player.class);
-        String pass = "test235";
-
-        // when
-        api.forceRegister(player, pass, false);
-
-        // then
-        verify(management).performRegister(eq(RegistrationMethod.API_REGISTRATION),
-            argThat(hasEqualValuesOnAllFields(ApiPasswordRegisterParams.of(player, pass, false))));
-    }
-
-    @Test
-    public void shouldRegisterPlayer() {
-        // given
-        String name = "Marco";
-        String password = "myP4ss";
-        HashedPassword hashedPassword = new HashedPassword("0395872SLKDFJOWEIUTEJSD");
-        given(passwordSecurity.computeHash(password, name.toLowerCase(Locale.ROOT))).willReturn(hashedPassword);
-        given(dataSource.saveAuth(any(PlayerAuth.class))).willReturn(true);
-
-        // when
-        boolean result = api.registerPlayer(name, password);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(passwordSecurity).computeHash(password, name.toLowerCase(Locale.ROOT));
-        ArgumentCaptor<PlayerAuth> authCaptor = ArgumentCaptor.forClass(PlayerAuth.class);
-        verify(dataSource).saveAuth(authCaptor.capture());
-        assertThat(authCaptor.getValue().getNickname(), equalTo(name.toLowerCase(Locale.ROOT)));
-        assertThat(authCaptor.getValue().getRealName(), equalTo(name));
-        assertThat(authCaptor.getValue().getPassword(), equalTo(hashedPassword));
-    }
-
-    @Test
-    public void shouldNotRegisterAlreadyRegisteredPlayer() {
-        // given
-        String name = "jonah";
-        given(dataSource.isAuthAvailable(name)).willReturn(true);
-
-        // when
-        boolean result = api.registerPlayer(name, "pass");
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(dataSource, only()).isAuthAvailable(name);
-        verifyNoInteractions(management, passwordSecurity);
-    }
-
-    @Test
-    public void shouldGetNamesByIp() {
-        // given
-        String ip = "123.123.123.123";
-        List<String> names = Arrays.asList("Morgan", "Batista", "QUINN");
-        given(dataSource.getAllAuthsByIp(ip)).willReturn(names);
-
-        // when
-        List<String> result = api.getNamesByIp(ip);
-
-        // then
-        assertThat(result, equalTo(names));
-        verify(dataSource).getAllAuthsByIp(ip);
-    }
-
-    @Test
-    public void shouldReturnGeoIpInfo() {
-        // given
-        String ip = "127.127.12.1";
-        given(geoIpService.getCountryCode(ip)).willReturn("XA");
-        given(geoIpService.getCountryName(ip)).willReturn("Syldavia");
-
-        // when
-        String countryCode = api.getCountryCode(ip);
-        String countryName = api.getCountryName(ip);
-
-        // then
-        assertThat(countryCode, equalTo("XA"));
-        assertThat(countryName, equalTo("Syldavia"));
-    }
-
-    @Test
-    public void shouldReturnAuthMePlayerInfo() {
-        // given
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("bobb")
-            .realName("Bobb")
-            .registrationDate(1433166082000L)
-            .build();
-        given(dataSource.getAuth("bobb")).willReturn(auth);
-
-        // when
-        Optional<AuthMePlayer> result = api.getPlayerInfo("bobb");
-
-        // then
-        AuthMePlayer playerInfo = result.get();
-        assertThat(playerInfo.getName(), equalTo("Bobb"));
-        assertThat(playerInfo.getRegistrationDate(), equalTo(Instant.ofEpochMilli(1433166082000L)));
-    }
-
-    @Test
-    public void shouldReturnNullForNonExistentAuth() {
-        // given / when
-        Optional<AuthMePlayer> result = api.getPlayerInfo("doesNotExist");
-
-        // then
-        assertThat(result.isPresent(), equalTo(false));
-        verify(playerCache).getAuth("doesNotExist");
-        verify(dataSource).getAuth("doesNotExist");
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/api/v3/AuthMePlayerImplTest.java b/src/test/java/fr/xephi/authme/api/v3/AuthMePlayerImplTest.java
deleted file mode 100644
index aa8b50c9..00000000
--- a/src/test/java/fr/xephi/authme/api/v3/AuthMePlayerImplTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package fr.xephi.authme.api.v3;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-import org.junit.Test;
-
-import java.time.Instant;
-import java.util.Optional;
-import java.util.UUID;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
-
-/**
- * Test for {@link AuthMePlayerImpl}.
- */
-public class AuthMePlayerImplTest {
-
-    @Test
-    public void shouldMapNullWithoutError() {
-        // given / when / then
-        assertThat(AuthMePlayerImpl.fromPlayerAuth(null), emptyOptional());
-    }
-
-    @Test
-    public void shouldMapFromPlayerAuth() {
-        // given
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("victor")
-            .realName("Victor")
-            .email("vic@example.com")
-            .registrationDate(1480075661000L)
-            .registrationIp("124.125.126.127")
-            .lastLogin(1542675632000L)
-            .lastIp("62.63.64.65")
-            .uuid(UUID.fromString("deadbeef-2417-4653-9026-feedbabeface"))
-            .build();
-
-        // when
-        Optional<AuthMePlayer> result = AuthMePlayerImpl.fromPlayerAuth(auth);
-
-        // then
-        AuthMePlayer playerInfo = result.get();
-        assertThat(playerInfo.getName(), equalTo("Victor"));
-        assertThat(playerInfo.getUuid().get(), equalTo(auth.getUuid()));
-        assertThat(playerInfo.getEmail().get(), equalTo(auth.getEmail()));
-        assertThat(playerInfo.getRegistrationDate(), equalTo(Instant.ofEpochMilli(auth.getRegistrationDate())));
-        assertThat(playerInfo.getRegistrationIpAddress().get(), equalTo(auth.getRegistrationIp()));
-        assertThat(playerInfo.getLastLoginDate().get(), equalTo(Instant.ofEpochMilli(auth.getLastLogin())));
-        assertThat(playerInfo.getLastLoginIpAddress().get(), equalTo(auth.getLastIp()));
-    }
-
-    @Test
-    public void shouldHandleNullAndDefaultValues() {
-        // given
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("victor")
-            .realName("Victor")
-            .email("your@email.com") // DB default
-            .registrationDate(1480075661000L)
-            .lastLogin(0L) // DB default
-            .lastIp("127.0.0.1") // DB default
-            .build();
-
-        // when
-        Optional<AuthMePlayer> result = AuthMePlayerImpl.fromPlayerAuth(auth);
-
-        // then
-        AuthMePlayer playerInfo = result.get();
-        assertThat(playerInfo.getName(), equalTo("Victor"));
-        assertThat(playerInfo.getUuid(), emptyOptional());
-        assertThat(playerInfo.getEmail(), emptyOptional());
-        assertThat(playerInfo.getRegistrationDate(), equalTo(Instant.ofEpochMilli(auth.getRegistrationDate())));
-        assertThat(playerInfo.getRegistrationIpAddress(), emptyOptional());
-        assertThat(playerInfo.getLastLoginDate(), emptyOptional());
-        assertThat(playerInfo.getLastLoginIpAddress(), emptyOptional());
-    }
-
-    private static <T> Matcher<Optional<T>> emptyOptional() {
-        return new TypeSafeMatcher<Optional<T>>() {
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendText("an empty optional");
-            }
-
-            @Override
-            protected boolean matchesSafely(Optional<T> item) {
-                return !item.isPresent();
-            }
-        };
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/CommandConsistencyTest.java b/src/test/java/fr/xephi/authme/command/CommandConsistencyTest.java
deleted file mode 100644
index d2033d1b..00000000
--- a/src/test/java/fr/xephi/authme/command/CommandConsistencyTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package fr.xephi.authme.command;
-
-import org.bukkit.configuration.MemorySection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-
-import static fr.xephi.authme.TestHelper.getJarFile;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Checks that the commands declared in plugin.yml correspond
- * to the ones built by the {@link CommandInitializer}.
- */
-public class CommandConsistencyTest {
-
-    @Test
-    public void shouldHaveEqualDefinitions() {
-        // given
-        Collection<List<String>> initializedCommands = initializeCommands();
-        Map<String, List<String>> pluginFileLabels = getLabelsFromPluginFile();
-
-        // when / then
-        assertThat("number of base commands are equal in plugin.yml and CommandInitializer",
-            initializedCommands.size(), equalTo(pluginFileLabels.size()));
-        for (List<String> commandLabels : initializedCommands) {
-            List<String> pluginYmlLabels = pluginFileLabels.get(commandLabels.get(0));
-            // NB: the first label in CommandDescription needs to correspond to the key in plugin.yml
-            assertThat("plugin.yml contains definition for command '" + commandLabels.get(0) + "'",
-                pluginYmlLabels, not(nullValue()));
-            assertThat("plugin.yml and CommandDescription have same alternative labels for /" + commandLabels.get(0),
-                pluginYmlLabels, containsInAnyOrder(commandLabels.subList(1, commandLabels.size()).toArray()));
-        }
-    }
-
-    /**
-     * Gets the command definitions from CommandInitializer and returns the
-     * labels of all base commands.
-     *
-     * @return collection of all base command labels
-     */
-    private static Collection<List<String>> initializeCommands() {
-        CommandInitializer initializer = new CommandInitializer();
-        Collection<List<String>> commandLabels = new ArrayList<>();
-        for (CommandDescription baseCommand : initializer.getCommands()) {
-            commandLabels.add(baseCommand.getLabels());
-        }
-        return commandLabels;
-    }
-
-    /**
-     * Reads plugin.yml and returns the defined commands by main label and aliases.
-     *
-     * @return collection of all labels and their aliases
-     */
-    @SuppressWarnings("unchecked")
-    private static Map<String, List<String>> getLabelsFromPluginFile() {
-        FileConfiguration pluginFile = YamlConfiguration.loadConfiguration(getJarFile("/plugin.yml"));
-        MemorySection commandList = (MemorySection) pluginFile.get("commands");
-        Map<String, Object> commandDefinitions = commandList.getValues(false);
-
-        Map<String, List<String>> commandLabels = new HashMap<>();
-        for (Map.Entry<String, Object> commandDefinition : commandDefinitions.entrySet()) {
-            MemorySection definition = (MemorySection) commandDefinition.getValue();
-            List<String> alternativeLabels = definition.get("aliases") == null
-                ? Collections.EMPTY_LIST
-                : (List<String>) definition.get("aliases");
-            commandLabels.put(commandDefinition.getKey(), alternativeLabels);
-        }
-        return commandLabels;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/CommandHandlerTest.java b/src/test/java/fr/xephi/authme/command/CommandHandlerTest.java
deleted file mode 100644
index d80d8f8a..00000000
--- a/src/test/java/fr/xephi/authme/command/CommandHandlerTest.java
+++ /dev/null
@@ -1,302 +0,0 @@
-package fr.xephi.authme.command;
-
-import ch.jalu.injector.Injector;
-import ch.jalu.injector.factory.Factory;
-import com.google.common.collect.Sets;
-import fr.xephi.authme.command.TestCommandsUtil.TestLoginCommand;
-import fr.xephi.authme.command.TestCommandsUtil.TestRegisterCommand;
-import fr.xephi.authme.command.TestCommandsUtil.TestUnregisterCommand;
-import fr.xephi.authme.command.help.HelpProvider;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.permission.PermissionsManager;
-import org.bukkit.command.CommandSender;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-
-import static fr.xephi.authme.command.FoundResultStatus.INCORRECT_ARGUMENTS;
-import static fr.xephi.authme.command.FoundResultStatus.MISSING_BASE_COMMAND;
-import static fr.xephi.authme.command.FoundResultStatus.NO_PERMISSION;
-import static fr.xephi.authme.command.FoundResultStatus.SUCCESS;
-import static fr.xephi.authme.command.FoundResultStatus.UNKNOWN_LABEL;
-import static java.util.Arrays.asList;
-import static org.hamcrest.Matchers.containsString;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link CommandHandler}.
- */
-// Justification: It's more readable to use asList() everywhere in the test when we often generated two lists where one
-// often consists of only one element, e.g. myMethod(asList("authme"), asList("my", "args"), ...)
-@SuppressWarnings("ArraysAsListWithZeroOrOneArgument")
-@RunWith(MockitoJUnitRunner.class)
-public class CommandHandlerTest {
-
-    private CommandHandler handler;
-
-    @Mock
-    private Factory<ExecutableCommand> commandFactory;
-    @Mock
-    private CommandMapper commandMapper;
-    @Mock
-    private PermissionsManager permissionsManager;
-    @Mock
-    private Messages messages;
-    @Mock
-    private HelpProvider helpProvider;
-
-    private Map<Class<? extends ExecutableCommand>, ExecutableCommand> mockedCommands = new HashMap<>();
-
-    @Before
-    @SuppressWarnings("unchecked")
-    public void initializeCommandMapper() {
-        given(commandMapper.getCommandClasses()).willReturn(Sets.newHashSet(
-            ExecutableCommand.class, TestLoginCommand.class, TestRegisterCommand.class, TestUnregisterCommand.class));
-        setInjectorToMockExecutableCommandClasses();
-
-        handler = new CommandHandler(commandFactory, commandMapper, permissionsManager, messages, helpProvider);
-    }
-
-    /**
-     * Makes the injector return a mock when {@link Injector#newInstance(Class)} is invoked
-     * with (a child of) ExecutableCommand.class. The mocks the injector creates are stored in {@link #mockedCommands}.
-     * <p>
-     * The {@link CommandMapper} is mocked in {@link #initializeCommandMapper()} to return certain test classes.
-     */
-    @SuppressWarnings("unchecked")
-    private void setInjectorToMockExecutableCommandClasses() {
-        given(commandFactory.newInstance(any(Class.class))).willAnswer(new Answer<Object>() {
-            @Override
-            public Object answer(InvocationOnMock invocation) throws Throwable {
-                Class<?> clazz = invocation.getArgument(0);
-                if (ExecutableCommand.class.isAssignableFrom(clazz)) {
-                    Class<? extends ExecutableCommand> commandClass = (Class<? extends ExecutableCommand>) clazz;
-                    ExecutableCommand mock = mock(commandClass);
-                    mockedCommands.put(commandClass, mock);
-                    return mock;
-                }
-                throw new IllegalStateException("Unexpected class '" + clazz.getName()
-                    + "': Not a child of ExecutableCommand");
-            }
-        });
-    }
-
-
-    @Test
-    public void shouldCallMappedCommandWithArgs() {
-        // given
-        String bukkitLabel = "Authme";
-        String[] bukkitArgs = {"Login", "myPass"};
-
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        doReturn(TestLoginCommand.class).when(command).getExecutableCommand();
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList()))
-            .willReturn(new FoundCommandResult(command, asList("Authme", "Login"), asList("myPass"), 0.0, SUCCESS));
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        ExecutableCommand executableCommand = mockedCommands.get(TestLoginCommand.class);
-        verify(commandMapper).mapPartsToCommand(sender, asList("Authme", "Login", "myPass"));
-        verify(executableCommand).executeCommand(sender, asList("myPass"));
-        // Ensure that no error message was issued to the command sender
-        verify(sender, never()).sendMessage(anyString());
-    }
-
-    @Test
-    public void shouldNotCallExecutableCommandIfNoPermission() {
-        // given
-        String bukkitLabel = "unreg";
-        String[] bukkitArgs = {"testPlayer"};
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList()))
-            .willReturn(new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, NO_PERMISSION));
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, asList("unreg", "testPlayer"));
-        verify(command, never()).getExecutableCommand();
-        verify(messages).send(sender, MessageKey.NO_PERMISSION);
-    }
-
-    @Test
-    public void shouldNotCallExecutableForWrongArguments() {
-        // given
-        String bukkitLabel = "unreg";
-        String[] bukkitArgs = {"testPlayer"};
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        given(command.getExecutableCommand()).willReturn((Class) TestUnregisterCommand.class);
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList())).willReturn(
-            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, INCORRECT_ARGUMENTS));
-        given(permissionsManager.hasPermission(sender, command.getPermission())).willReturn(true);
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, asList("unreg", "testPlayer"));
-        verify(sender, atLeastOnce()).sendMessage(argThat(containsString("Incorrect command arguments")));
-    }
-
-    @Test
-    public void shouldUseCustomMessageUponArgumentMismatch() {
-        // given
-        String bukkitLabel = "unreg";
-        String[] bukkitArgs = {"testPlayer"};
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        given(command.getExecutableCommand()).willReturn((Class) TestUnregisterCommand.class);
-        given(mockedCommands.get(TestUnregisterCommand.class).getArgumentsMismatchMessage())
-            .willReturn(MessageKey.USAGE_RECOVER_EMAIL);
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList())).willReturn(
-            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, INCORRECT_ARGUMENTS));
-        given(permissionsManager.hasPermission(sender, command.getPermission())).willReturn(true);
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, asList("unreg", "testPlayer"));
-        verify(messages).send(sender, MessageKey.USAGE_RECOVER_EMAIL);
-        verify(sender, never()).sendMessage(anyString());
-    }
-
-    @Test
-    public void shouldNotCallExecutableForWrongArgumentsAndPermissionDenied() {
-        // given
-        String bukkitLabel = "unreg";
-        String[] bukkitArgs = {"testPlayer"};
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList())).willReturn(
-            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, INCORRECT_ARGUMENTS));
-        given(permissionsManager.hasPermission(sender, command.getPermission())).willReturn(false);
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, asList("unreg", "testPlayer"));
-        verify(command, never()).getExecutableCommand();
-        verify(messages).send(sender, MessageKey.NO_PERMISSION);
-    }
-
-    @Test
-    public void shouldNotCallExecutableForFailedParsing() {
-        // given
-        String bukkitLabel = "unreg";
-        String[] bukkitArgs = {"testPlayer"};
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList())).willReturn(
-            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.0, MISSING_BASE_COMMAND));
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, asList("unreg", "testPlayer"));
-        verify(command, never()).getExecutableCommand();
-        verify(sender).sendMessage(argThat(containsString("Failed to parse")));
-    }
-
-    @Test
-    public void shouldNotCallExecutableForUnknownLabelAndHaveSuggestion() {
-        // given
-        String bukkitLabel = "unreg";
-        String[] bukkitArgs = {"testPlayer"};
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        given(command.getLabels()).willReturn(Collections.singletonList("test_cmd"));
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList())).willReturn(
-            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 0.01, UNKNOWN_LABEL));
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, asList("unreg", "testPlayer"));
-        verify(command, never()).getExecutableCommand();
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(3)).sendMessage(captor.capture());
-        assertThat(captor.getAllValues().get(0), containsString("Unknown command"));
-        assertThat(captor.getAllValues().get(1), containsString("Did you mean"));
-        assertThat(captor.getAllValues().get(1), containsString("/test_cmd"));
-        assertThat(captor.getAllValues().get(2), containsString("Use the command"));
-        assertThat(captor.getAllValues().get(2), containsString("to view help"));
-    }
-
-    @Test
-    public void shouldNotCallExecutableForUnknownLabelAndNotSuggestCommand() {
-        // given
-        String bukkitLabel = "unreg";
-        String[] bukkitArgs = {"testPlayer"};
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription command = mock(CommandDescription.class);
-        given(commandMapper.mapPartsToCommand(any(CommandSender.class), anyList())).willReturn(
-            new FoundCommandResult(command, asList("unreg"), asList("testPlayer"), 1.0, UNKNOWN_LABEL));
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, asList("unreg", "testPlayer"));
-        verify(command, never()).getExecutableCommand();
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(2)).sendMessage(captor.capture());
-        assertThat(captor.getAllValues().get(0), containsString("Unknown command"));
-        assertThat(captor.getAllValues().get(1), containsString("Use the command"));
-        assertThat(captor.getAllValues().get(1), containsString("to view help"));
-    }
-
-    @Test
-    public void shouldStripWhitespace() {
-        // given
-        String bukkitLabel = "AuthMe";
-        String[] bukkitArgs = {" ", "", "REGISTER", "  ", "testArg", " "};
-        CommandSender sender = mock(CommandSender.class);
-
-        CommandDescription command = mock(CommandDescription.class);
-        doReturn(TestRegisterCommand.class).when(command).getExecutableCommand();
-        given(commandMapper.mapPartsToCommand(eq(sender), anyList()))
-            .willReturn(new FoundCommandResult(command, asList("AuthMe", "REGISTER"), asList("testArg"), 0.0, SUCCESS));
-
-        // when
-        handler.processCommand(sender, bukkitLabel, bukkitArgs);
-
-        // then
-        ExecutableCommand executableCommand = mockedCommands.get(TestRegisterCommand.class);
-        verify(commandMapper).mapPartsToCommand(sender, asList("AuthMe", "REGISTER", "testArg"));
-        verify(executableCommand).executeCommand(sender, asList("testArg"));
-        verify(sender, never()).sendMessage(anyString());
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/CommandInitializerTest.java b/src/test/java/fr/xephi/authme/command/CommandInitializerTest.java
deleted file mode 100644
index 5cac2462..00000000
--- a/src/test/java/fr/xephi/authme/command/CommandInitializerTest.java
+++ /dev/null
@@ -1,283 +0,0 @@
-package fr.xephi.authme.command;
-
-import fr.xephi.authme.util.StringUtils;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-import java.util.function.BiConsumer;
-import java.util.regex.Pattern;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link CommandInitializer} to guarantee the integrity of the defined commands.
- */
-public class CommandInitializerTest {
-
-    /**
-     * Defines the maximum allowed depths for nesting CommandDescription instances.
-     * Note that the depth starts at 0 (e.g. /authme), so a depth of 2 is something like /authme hello world
-     */
-    private static int MAX_ALLOWED_DEPTH = 1;
-
-    private static Collection<CommandDescription> commands;
-
-    @BeforeClass
-    public static void initializeCommandCollection() {
-        CommandInitializer commandInitializer = new CommandInitializer();
-        commands = commandInitializer.getCommands();
-    }
-
-    @Test
-    public void shouldInitializeCommands() {
-        // given/when/then
-        // It obviously doesn't make sense to test much of the concrete data
-        // that is being initialized; we just want to guarantee with this test
-        // that data is indeed being initialized and we take a few "probes"
-        assertThat(commands, hasSize(10));
-        assertThat(commandsIncludeLabel(commands, "authme"), equalTo(true));
-        assertThat(commandsIncludeLabel(commands, "register"), equalTo(true));
-        assertThat(commandsIncludeLabel(commands, "help"), equalTo(false));
-    }
-
-    @Test
-    public void shouldNotBeNestedExcessively() {
-        // given
-        BiConsumer<CommandDescription, Integer> descriptionTester =
-            (command, depth) -> assertThat(depth <= MAX_ALLOWED_DEPTH, equalTo(true));
-
-        // when/then
-        walkThroughCommands(commands, descriptionTester);
-    }
-
-    /** Ensure that all children of a command stored the parent. */
-    @Test
-    public void shouldHaveConnectionBetweenParentAndChild() {
-        // given
-        BiConsumer<CommandDescription, Integer> connectionTester = new BiConsumer<CommandDescription, Integer>() {
-            @Override
-            public void accept(CommandDescription command, Integer depth) {
-                if (!command.getChildren().isEmpty()) {
-                    for (CommandDescription child : command.getChildren()) {
-                        assertThat(command.equals(child.getParent()), equalTo(true));
-                    }
-                }
-                // Checking that the parent has the current command as child is redundant as this is how we can traverse
-                // the "command tree" in the first place - if we're here, it's that the parent definitely has the
-                // command as child.
-            }
-        };
-
-        // when/then
-        walkThroughCommands(commands, connectionTester);
-    }
-
-    @Test
-    public void shouldUseProperLowerCaseLabels() {
-        // given
-        final Pattern invalidPattern = Pattern.compile("\\s");
-        BiConsumer<CommandDescription, Integer> labelFormatTester = new BiConsumer<CommandDescription, Integer>() {
-            @Override
-            public void accept(CommandDescription command, Integer depth) {
-                for (String label : command.getLabels()) {
-                    if (!label.equals(label.toLowerCase(Locale.ROOT))) {
-                        fail("Label '" + label + "' should be lowercase");
-                    } else if (invalidPattern.matcher(label).matches()) {
-                        fail("Label '" + label + "' has whitespace");
-                    }
-                }
-            }
-        };
-
-        // when/then
-        walkThroughCommands(commands, labelFormatTester);
-    }
-
-    @Test
-    public void shouldNotDefineSameLabelTwice() {
-        // given
-        final Set<String> commandMappings = new HashSet<>();
-        BiConsumer<CommandDescription, Integer> uniqueMappingTester = new BiConsumer<CommandDescription, Integer>() {
-            @Override
-            public void accept(CommandDescription command, Integer depth) {
-                int initialSize = commandMappings.size();
-                List<String> newMappings = getAbsoluteLabels(command);
-                commandMappings.addAll(newMappings);
-                // Set only contains unique entries, so we just check after adding all new mappings that the size
-                // of the Set corresponds to our expectation
-                assertThat("All bindings are unique for command with bindings '" + newMappings + "'",
-                    commandMappings.size() == initialSize + newMappings.size(), equalTo(true));
-            }
-        };
-
-        // when/then
-        walkThroughCommands(commands, uniqueMappingTester);
-    }
-
-    /**
-     * The description should provide a very short description of the command and shouldn't end in a ".", whereas the
-     * detailed description should be longer and end with a period.
-     */
-    @Test
-    public void shouldHaveProperDescription() {
-        // given
-        BiConsumer<CommandDescription, Integer> descriptionTester = new BiConsumer<CommandDescription, Integer>() {
-            @Override
-            public void accept(CommandDescription command, Integer depth) {
-                String forCommandText = " for command with labels '" + command.getLabels() + "'";
-
-                assertThat("has description" + forCommandText,
-                    StringUtils.isBlank(command.getDescription()), equalTo(false));
-                assertThat("short description doesn't end in '.'" + forCommandText,
-                    command.getDescription().endsWith("."), equalTo(false));
-                assertThat("has detailed description" + forCommandText,
-                    StringUtils.isBlank(command.getDetailedDescription()), equalTo(false));
-                assertThat("detailed description ends in '.'" + forCommandText,
-                    command.getDetailedDescription().endsWith("."), equalTo(true));
-            }
-        };
-
-        // when/then
-        walkThroughCommands(commands, descriptionTester);
-    }
-
-    @Test
-    public void shouldHaveOptionalArgumentsAfterMandatoryOnes() {
-        // given
-        BiConsumer<CommandDescription, Integer> argumentOrderTester = new BiConsumer<CommandDescription, Integer>() {
-            @Override
-            public void accept(CommandDescription command, Integer depth) {
-                boolean encounteredOptionalArg = false;
-                for (CommandArgumentDescription argument : command.getArguments()) {
-                    if (argument.isOptional()) {
-                        encounteredOptionalArg = true;
-                    } else if (encounteredOptionalArg) {
-                        fail("Mandatory arguments should come before optional ones for command with labels '"
-                            + command.getLabels() + "'");
-                    }
-                }
-            }
-        };
-
-        // when/then
-        walkThroughCommands(commands, argumentOrderTester);
-    }
-
-    /**
-     * Ensure that a command with children (i.e. a base command) doesn't define any arguments. This might otherwise
-     * clash with the label of the child.
-     */
-    @Test
-    public void shouldNotHaveArgumentsIfCommandHasChildren() {
-        // given
-        BiConsumer<CommandDescription, Integer> noArgumentForParentChecker = new BiConsumer<CommandDescription, Integer>() {
-            @Override
-            public void accept(CommandDescription command, Integer depth) {
-                // Fail if the command has children and has arguments at the same time
-                // Exception: If the parent only has one child defining the help label, it is acceptable
-                if (!command.getChildren().isEmpty() && !command.getArguments().isEmpty()
-                        && (command.getChildren().size() != 1 || !command.getChildren().get(0).hasLabel("help"))) {
-                    fail("Parent command (labels='" + command.getLabels() + "') should not have any arguments");
-                }
-            }
-        };
-
-        // when/then
-        walkThroughCommands(commands, noArgumentForParentChecker);
-    }
-
-    /**
-     * Tests that multiple CommandDescription instances pointing to the same ExecutableCommand use the same
-     * count of arguments.
-     */
-    @Test
-    public void shouldPointToSameExecutableCommandWithConsistentArgumentCount() {
-        // given
-        final Map<Class<? extends ExecutableCommand>, Integer> mandatoryArguments = new HashMap<>();
-        final Map<Class<? extends ExecutableCommand>, Integer> totalArguments = new HashMap<>();
-
-        BiConsumer<CommandDescription, Integer> argChecker = new BiConsumer<CommandDescription, Integer>() {
-            @Override
-            public void accept(CommandDescription command, Integer depth) {
-                testCollectionForCommand(command, CommandUtils.getMinNumberOfArguments(command), mandatoryArguments);
-                testCollectionForCommand(command, CommandUtils.getMaxNumberOfArguments(command), totalArguments);
-            }
-
-            private void testCollectionForCommand(CommandDescription command, int argCount,
-                                                  Map<Class<? extends ExecutableCommand>, Integer> collection) {
-                final Class<? extends ExecutableCommand> clazz = command.getExecutableCommand();
-                Integer existingCount = collection.get(clazz);
-                if (existingCount == null) {
-                    collection.put(clazz, argCount);
-                } else {
-                    String commandDescription = "Command with label '" + command.getLabels().get(0) + "' and parent '"
-                        + (command.getParent() == null ? "null" : command.getLabels().get(0)) + "' ";
-                    assertThat(commandDescription + "should point to " + clazz + " with arguments consistent to others",
-                        argCount, equalTo(existingCount));
-                }
-            }
-        };
-
-        // when / then
-        walkThroughCommands(commands, argChecker);
-    }
-
-
-    // ------------
-    // Helper methods
-    // ------------
-    private static void walkThroughCommands(Collection<CommandDescription> commands,
-                                            BiConsumer<CommandDescription, Integer> consumer) {
-        walkThroughCommands(commands, consumer, 0);
-    }
-
-    private static void walkThroughCommands(Collection<CommandDescription> commands,
-                                            BiConsumer<CommandDescription, Integer> consumer, int depth) {
-        for (CommandDescription command : commands) {
-            consumer.accept(command, depth);
-            if (!command.getChildren().isEmpty()) {
-                walkThroughCommands(command.getChildren(), consumer, depth + 1);
-            }
-        }
-    }
-
-    private static boolean commandsIncludeLabel(Iterable<CommandDescription> commands, String label) {
-        for (CommandDescription command : commands) {
-            if (command.getLabels().contains(label)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Get the absolute binding that a command defines. Note: Assumes that only the passed command can have
-     * multiple labels; only considering the first label for all of the command's parents.
-     *
-     * @param command The command to process
-     *
-     * @return List of all bindings that lead to the command
-     */
-    private static List<String> getAbsoluteLabels(CommandDescription command) {
-        CommandDescription parent = command.getParent();
-        String parentPath = (parent == null) ? "" : parent.getLabels().get(0) + " ";
-
-        List<String> bindings = new ArrayList<>(command.getLabels().size());
-        for (String label : command.getLabels()) {
-            bindings.add(parentPath + label);
-        }
-        return bindings;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/CommandMapperTest.java b/src/test/java/fr/xephi/authme/command/CommandMapperTest.java
deleted file mode 100644
index 3a23cdc8..00000000
--- a/src/test/java/fr/xephi/authme/command/CommandMapperTest.java
+++ /dev/null
@@ -1,319 +0,0 @@
-package fr.xephi.authme.command;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.command.TestCommandsUtil.TestLoginCommand;
-import fr.xephi.authme.command.TestCommandsUtil.TestRegisterCommand;
-import fr.xephi.authme.command.TestCommandsUtil.TestUnregisterCommand;
-import fr.xephi.authme.command.executable.HelpCommand;
-import fr.xephi.authme.permission.PermissionNode;
-import fr.xephi.authme.permission.PermissionsManager;
-import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.util.List;
-import java.util.Set;
-
-import static fr.xephi.authme.command.TestCommandsUtil.getCommandWithLabel;
-import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.ArgumentMatchers.isNull;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link CommandMapper}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class CommandMapperTest {
-
-    private static List<CommandDescription> commands;
-
-    @InjectDelayed
-    private CommandMapper mapper;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Mock
-    private CommandInitializer commandInitializer;
-
-    @BeforeClass
-    public static void setUpCommandHandler() {
-        commands = TestCommandsUtil.generateCommands();
-    }
-
-    @BeforeInjecting
-    public void setUpMocks() {
-        given(commandInitializer.getCommands()).willReturn(commands);
-    }
-
-    // -----------
-    // mapPartsToCommand() tests
-    // -----------
-    @Test
-    public void shouldMapPartsToLoginChildCommand() {
-        // given
-        List<String> parts = asList("authme", "login", "test1");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "authme", "login")));
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.SUCCESS));
-        assertThat(result.getArguments(), contains("test1"));
-        assertThat(result.getDifference(), equalTo(0.0));
-        assertThat(result.getLabels(), equalTo(parts.subList(0, 2)));
-        assertThat(result.getArguments(), contains(parts.get(2)));
-    }
-
-    @Test
-    public void shouldMapPartsToCommandWithNoCaseSensitivity() {
-        // given
-        List<String> parts = asList("Authme", "REG", "arg1", "arg2");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "authme", "register")));
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.SUCCESS));
-        assertThat(result.getLabels(), equalTo(parts.subList(0, 2)));
-        assertThat(result.getArguments(), contains("arg1", "arg2"));
-        assertThat(result.getDifference(), equalTo(0.0));
-    }
-
-    @Test
-    public void shouldRejectCommandWithTooManyArguments() {
-        // given
-        List<String> parts = asList("authme", "register", "pass123", "pass123", "pass123");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "authme", "register")));
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.INCORRECT_ARGUMENTS));
-        assertThat(result.getDifference(), equalTo(0.0));
-        assertThat(result.getLabels(), equalTo(parts.subList(0, 2)));
-        assertThat(result.getArguments(), equalTo(parts.subList(2, 5)));
-    }
-
-    @Test
-    public void shouldRejectCommandWithTooFewArguments() {
-        // given
-        List<String> parts = asList("authme", "Reg");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "authme", "register")));
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.INCORRECT_ARGUMENTS));
-        assertThat(result.getDifference(), equalTo(0.0));
-        assertThat(result.getLabels(), equalTo(parts));
-        assertThat(result.getArguments(), empty());
-    }
-
-    @Test
-    public void shouldSuggestCommandWithSimilarLabel() {
-        // given
-        List<String> parts = asList("authme", "reh", "pass123", "pass123");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "authme", "register")));
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.UNKNOWN_LABEL));
-        assertThat(result.getDifference() < 0.75, equalTo(true));
-        assertThat(result.getLabels(), equalTo(parts.subList(0, 2)));
-        assertThat(result.getArguments(), contains("pass123", "pass123"));
-    }
-
-    /** In contrast to the previous test, we test a command request with a very apart label. */
-    @Test
-    public void shouldSuggestMostSimilarCommand() {
-        // given
-        List<String> parts = asList("authme", "asdfawetawty4asdca");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getCommandDescription(), not(nullValue()));
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.UNKNOWN_LABEL));
-        assertThat(result.getDifference() > 0.75, equalTo(true));
-        assertThat(result.getLabels(), equalTo(parts));
-        assertThat(result.getArguments(), empty());
-    }
-
-    @Test
-    public void shouldHandleBaseWithWrongArguments() {
-        // given
-        List<String> parts = singletonList("unregister");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.INCORRECT_ARGUMENTS));
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "unregister")));
-        assertThat(result.getDifference(), equalTo(0.0));
-        assertThat(result.getArguments(), empty());
-        assertThat(result.getLabels(), equalTo(parts));
-    }
-
-    @Test
-    public void shouldHandleUnknownBase() {
-        // given
-        List<String> parts = asList("bogus", "label1", "arg1");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.MISSING_BASE_COMMAND));
-        assertThat(result.getCommandDescription(), nullValue());
-    }
-
-    @Test
-    public void shouldHandleNullInput() {
-        // given / when
-        FoundCommandResult result = mapper.mapPartsToCommand(mock(CommandSender.class), null);
-
-        // then
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.MISSING_BASE_COMMAND));
-        assertThat(result.getCommandDescription(), nullValue());
-    }
-
-    @Test
-    public void shouldMapToBaseWithProperArguments() {
-        // given
-        List<String> parts = asList("Unreg", "player1");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.SUCCESS));
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "unregister")));
-        assertThat(result.getDifference(), equalTo(0.0));
-        assertThat(result.getArguments(), contains("player1"));
-        assertThat(result.getLabels(), contains("Unreg"));
-    }
-
-    @Test
-    public void shouldReturnChildlessBaseCommandWithArgCountError() {
-        // given
-        List<String> parts = asList("unregistER", "player1", "wrongArg");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.INCORRECT_ARGUMENTS));
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "unregister")));
-        assertThat(result.getDifference(), equalTo(0.0));
-        assertThat(result.getArguments(), contains("player1", "wrongArg"));
-        assertThat(result.getLabels(), contains("unregistER"));
-    }
-
-    @Test
-    public void shouldPassCommandPathAsArgumentsToHelpCommand() {
-        // given
-        List<String> parts = asList("email", "helptest", "arg1");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), isNull())).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.SUCCESS));
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "email", "helptest")));
-        assertThat(result.getLabels(), contains("email", "helptest"));
-        assertThat(result.getArguments(), contains("email", "arg1"));
-        assertThat(result.getDifference(), equalTo(0.0));
-    }
-
-    @Test
-    public void shouldRecognizeMissingPermissionForCommand() {
-        // given
-        List<String> parts = asList("authme", "login", "test1");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(false);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "authme", "login")));
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.NO_PERMISSION));
-        assertThat(result.getArguments(), contains("test1"));
-        assertThat(result.getDifference(), equalTo(0.0));
-        assertThat(result.getLabels(), equalTo(parts.subList(0, 2)));
-        assertThat(result.getArguments(), contains(parts.get(2)));
-    }
-
-    @Test
-    public void shouldSupportAuthMePrefix() {
-        // given
-        List<String> parts = asList("authme:unregister", "Betty");
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(true);
-
-        // when
-        FoundCommandResult result = mapper.mapPartsToCommand(sender, parts);
-
-        // then
-        assertThat(result.getResultStatus(), equalTo(FoundResultStatus.SUCCESS));
-        assertThat(result.getCommandDescription(), equalTo(getCommandWithLabel(commands, "unregister")));
-    }
-
-    @SuppressWarnings("unchecked")
-    @Test
-    public void shouldReturnExecutableCommandClasses() {
-        // given / when
-        Set<Class<? extends ExecutableCommand>> commandClasses = mapper.getCommandClasses();
-
-        // then
-        assertThat(commandClasses, containsInAnyOrder(ExecutableCommand.class, HelpCommand.class,
-            TestLoginCommand.class, TestRegisterCommand.class, TestUnregisterCommand.class));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/CommandUtilsTest.java b/src/test/java/fr/xephi/authme/command/CommandUtilsTest.java
deleted file mode 100644
index be17f6cf..00000000
--- a/src/test/java/fr/xephi/authme/command/CommandUtilsTest.java
+++ /dev/null
@@ -1,138 +0,0 @@
-package fr.xephi.authme.command;
-
-import org.bukkit.ChatColor;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link CommandUtils}.
- */
-public class CommandUtilsTest {
-
-    private static Collection<CommandDescription> commands;
-
-    @BeforeClass
-    public static void setUpTestCommands() {
-        commands = Collections.unmodifiableCollection(TestCommandsUtil.generateCommands());
-    }
-
-    @Test
-    public void shouldReturnCommandPath() {
-        // given
-        CommandDescription base = CommandDescription.builder()
-            .labels("authme", "auth")
-            .description("Base")
-            .detailedDescription("Test base command.")
-            .executableCommand(ExecutableCommand.class)
-            .register();
-        CommandDescription command = CommandDescription.builder()
-            .parent(base)
-            .labels("help", "h", "?")
-            .description("Child")
-            .detailedDescription("Test child command.")
-            .executableCommand(ExecutableCommand.class)
-            .register();
-
-        // when
-        String commandPath = CommandUtils.constructCommandPath(command);
-
-        // then
-        assertThat(commandPath, equalTo("/authme help"));
-    }
-
-    @Test
-    public void shouldComputeMinAndMaxOnEmptyCommand() {
-        // given
-        CommandDescription command = getBuilderForArgsTest().register();
-
-        // when / then
-        checkArgumentCount(command, 0, 0);
-    }
-
-    @Test
-    public void shouldComputeMinAndMaxOnCommandWithMandatoryArgs() {
-        // given
-        CommandDescription command = getBuilderForArgsTest()
-            .withArgument("Test", "Arg description", false)
-            .withArgument("Test22", "Arg description 2", false)
-            .register();
-
-        // when / then
-        checkArgumentCount(command, 2, 2);
-    }
-
-    @Test
-    public void shouldComputeMinAndMaxOnCommandIncludingOptionalArgs() {
-        // given
-        CommandDescription command = getBuilderForArgsTest()
-            .withArgument("arg1", "Arg description", false)
-            .withArgument("arg2", "Arg description 2", true)
-            .withArgument("arg3", "Arg description 3", true)
-            .register();
-
-        // when / then
-        checkArgumentCount(command, 1, 3);
-    }
-
-    @Test
-    public void shouldFormatSimpleArgument() {
-        // given
-        CommandDescription command = TestCommandsUtil.getCommandWithLabel(commands, "authme");
-        List<String> labels = Collections.singletonList("authme");
-
-        // when
-        String result = CommandUtils.buildSyntax(command, labels);
-
-        // then
-        assertThat(result, equalTo(ChatColor.WHITE + "/authme" + ChatColor.YELLOW));
-    }
-
-    @Test
-    public void shouldFormatCommandWithMultipleArguments() {
-        // given
-        CommandDescription command = TestCommandsUtil.getCommandWithLabel(commands, "authme", "register");
-        List<String> labels = Arrays.asList("authme", "reg");
-
-        // when
-        String result = CommandUtils.buildSyntax(command, labels);
-
-        // then
-        assertThat(result, equalTo(ChatColor.WHITE + "/authme" + ChatColor.YELLOW + " reg <password> <confirmation>"));
-    }
-
-
-    @Test
-    public void shouldFormatCommandWithOptionalArgument() {
-        // given
-        CommandDescription command = TestCommandsUtil.getCommandWithLabel(commands, "email");
-        List<String> labels = Collections.singletonList("email");
-
-        // when
-        String result = CommandUtils.buildSyntax(command, labels);
-
-        // then
-        assertThat(result, equalTo(ChatColor.WHITE + "/email" + ChatColor.YELLOW + " [player]"));
-    }
-
-
-    private static void checkArgumentCount(CommandDescription command, int expectedMin, int expectedMax) {
-        assertThat(CommandUtils.getMinNumberOfArguments(command), equalTo(expectedMin));
-        assertThat(CommandUtils.getMaxNumberOfArguments(command), equalTo(expectedMax));
-    }
-
-    private static CommandDescription.CommandBuilder getBuilderForArgsTest() {
-        return CommandDescription.builder()
-            .labels("authme", "auth")
-            .description("Base")
-            .detailedDescription("Test base command.")
-            .executableCommand(ExecutableCommand.class);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/PlayerCommandTest.java b/src/test/java/fr/xephi/authme/command/PlayerCommandTest.java
deleted file mode 100644
index 4f0c9997..00000000
--- a/src/test/java/fr/xephi/authme/command/PlayerCommandTest.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package fr.xephi.authme.command;
-
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PlayerCommand}.
- */
-public class PlayerCommandTest {
-
-    @Test
-    public void shouldRejectNonPlayerSender() {
-        // given
-        CommandSender sender = mock(BlockCommandSender.class);
-        PlayerCommandImpl command = new PlayerCommandImpl();
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("only for players")));
-    }
-
-    @Test
-    public void shouldCallRunCommandForPlayer() {
-        // given
-        Player player = mock(Player.class);
-        List<String> arguments = Arrays.asList("arg1", "testarg2");
-        PlayerCommandImpl command = new PlayerCommandImpl();
-
-        // when
-        command.executeCommand(player, arguments);
-
-        // then
-        verify(player, times(1)).sendMessage("testarg2");
-    }
-
-    @Test
-    public void shouldRejectNonPlayerAndSendAlternative() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerCommandWithAlt command = new PlayerCommandWithAlt();
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender, times(1)).sendMessage(argThat(containsString("use /authme test <command> instead")));
-    }
-
-
-    private static class PlayerCommandImpl extends PlayerCommand {
-        @Override
-        public void runCommand(Player player, List<String> arguments) {
-            player.sendMessage(arguments.get(1));
-        }
-    }
-
-    private static class PlayerCommandWithAlt extends PlayerCommand {
-        @Override
-        public void runCommand(Player player, List<String> arguments) {
-            throw new IllegalStateException("Should not be called");
-        }
-        @Override
-        public String getAlternativeCommand() {
-            return "/authme test <command>";
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/TestCommandsUtil.java b/src/test/java/fr/xephi/authme/command/TestCommandsUtil.java
deleted file mode 100644
index c7a2d1d3..00000000
--- a/src/test/java/fr/xephi/authme/command/TestCommandsUtil.java
+++ /dev/null
@@ -1,133 +0,0 @@
-package fr.xephi.authme.command;
-
-import com.google.common.collect.ImmutableList;
-import fr.xephi.authme.command.executable.HelpCommand;
-import fr.xephi.authme.permission.AdminPermission;
-import fr.xephi.authme.permission.PermissionNode;
-import fr.xephi.authme.permission.PlayerPermission;
-import org.bukkit.command.CommandSender;
-
-import java.util.Collection;
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
-
-/**
- * Util class for generating and retrieving test commands.
- */
-public final class TestCommandsUtil {
-
-    private TestCommandsUtil() {
-    }
-
-    /**
-     * Generate the collection of test commands.
-     *
-     * @return The generated commands
-     */
-    public static List<CommandDescription> generateCommands() {
-        // Register /authme
-        CommandDescription authMeBase = createCommand(null, null, singletonList("authme"), ExecutableCommand.class);
-        // Register /authme login <password>
-        createCommand(PlayerPermission.LOGIN, authMeBase, singletonList("login"),
-            TestLoginCommand.class, newArgument("password", false));
-        // Register /authme register <password> <confirmation>, aliases: /authme reg, /authme r
-        createCommand(PlayerPermission.LOGIN, authMeBase, asList("register", "reg", "r"), TestRegisterCommand.class,
-            newArgument("password", false), newArgument("confirmation", false));
-
-        // Register /email [player]
-        CommandDescription emailBase = createCommand(null, null, singletonList("email"), ExecutableCommand.class,
-            newArgument("player", true));
-        // Register /email helptest -- use only to test for help command arguments special case
-        CommandDescription.builder().parent(emailBase).labels("helptest").executableCommand(HelpCommand.class)
-            .description("test").detailedDescription("Test.").withArgument("Query", "", false).register();
-
-        // Register /unregister <player>, alias: /unreg
-        CommandDescription unregisterBase = createCommand(AdminPermission.UNREGISTER, null,
-            asList("unregister", "unreg"), TestUnregisterCommand.class, newArgument("player", false));
-
-        return ImmutableList.of(authMeBase, emailBase, unregisterBase);
-    }
-
-    /**
-     * Retrieve the command with the given label from the collection of commands.
-     * Example: <code>getCommandWithLabel(commands, "authme", "reg")</code> to find the command description
-     * which defines the command /authme reg.
-     *
-     * @param commands The commands to search in
-     * @param parentLabel The parent label to search for
-     * @param childLabel The child label to find
-     * @return The matched command, or throws an exception if no command could be found
-     */
-    public static CommandDescription getCommandWithLabel(Collection<CommandDescription> commands, String parentLabel,
-                                                         String childLabel) {
-        CommandDescription parent = getCommandWithLabel(commands, parentLabel);
-        return getCommandWithLabel(parent.getChildren(), childLabel);
-    }
-
-    /**
-     * Retrieve the command with the given label from the collection of commands.
-     *
-     * @param commands The commands to search in
-     * @param label The label to search for
-     * @return The matched command, or throws an exception if no command could be found
-     */
-    public static CommandDescription getCommandWithLabel(Collection<CommandDescription> commands, String label) {
-        for (CommandDescription child : commands) {
-            if (child.hasLabel(label)) {
-                return child;
-            }
-        }
-        throw new IllegalStateException("Could not find command with label '" + label + "'");
-    }
-
-    /* Shortcut command to initialize a new test command. */
-    private static CommandDescription createCommand(PermissionNode permission, CommandDescription parent,
-                                                    List<String> labels,
-                                                    Class<? extends ExecutableCommand> commandClass,
-                                                    CommandArgumentDescription... arguments) {
-        CommandDescription.CommandBuilder command = CommandDescription.builder()
-            .labels(labels)
-            .parent(parent)
-            .permission(permission)
-            .description(labels.get(0) + " cmd")
-            .detailedDescription("'" + labels.get(0) + "' test command")
-            .executableCommand(commandClass);
-
-        if (arguments != null && arguments.length > 0) {
-            for (CommandArgumentDescription argument : arguments) {
-                command.withArgument(argument.getName(), argument.getDescription(), argument.isOptional());
-            }
-        }
-
-        return command.register();
-    }
-
-    /* Shortcut command to initialize a new argument description. */
-    private static CommandArgumentDescription newArgument(String label, boolean isOptional) {
-        return new CommandArgumentDescription(label, "'" + label + "' argument description", isOptional);
-    }
-
-    public static class TestLoginCommand implements ExecutableCommand {
-        @Override
-        public void executeCommand(CommandSender sender, List<String> arguments) {
-            // noop
-        }
-    }
-
-    public static class TestRegisterCommand implements ExecutableCommand {
-        @Override
-        public void executeCommand(CommandSender sender, List<String> arguments) {
-            // noop
-        }
-    }
-
-    public static class TestUnregisterCommand implements ExecutableCommand {
-        @Override
-        public void executeCommand(CommandSender sender, List<String> arguments) {
-            // noop
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/HelpCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/HelpCommandTest.java
deleted file mode 100644
index 33e0508e..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/HelpCommandTest.java
+++ /dev/null
@@ -1,163 +0,0 @@
-package fr.xephi.authme.command.executable;
-
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.CommandMapper;
-import fr.xephi.authme.command.FoundCommandResult;
-import fr.xephi.authme.command.help.HelpProvider;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-import java.util.List;
-
-import static fr.xephi.authme.command.FoundResultStatus.INCORRECT_ARGUMENTS;
-import static fr.xephi.authme.command.FoundResultStatus.MISSING_BASE_COMMAND;
-import static fr.xephi.authme.command.FoundResultStatus.SUCCESS;
-import static fr.xephi.authme.command.FoundResultStatus.UNKNOWN_LABEL;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_ALTERNATIVES;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_CHILDREN;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_COMMAND;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_DESCRIPTION;
-import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
-import static org.hamcrest.Matchers.containsString;
-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.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link HelpCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class HelpCommandTest {
-
-    @InjectMocks
-    private HelpCommand command;
-
-    @Mock
-    private CommandMapper commandMapper;
-
-    @Mock
-    private HelpProvider helpProvider;
-
-    @Test
-    public void shouldHandleMissingBaseCommand() {
-        // given
-        List<String> arguments = asList("some", "command");
-        CommandSender sender = mock(CommandSender.class);
-        FoundCommandResult foundCommandResult = new FoundCommandResult(null, null, null, 0.0, MISSING_BASE_COMMAND);
-        given(commandMapper.mapPartsToCommand(sender, arguments)).willReturn(foundCommandResult);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Could not get base command")));
-        verifyNoInteractions(helpProvider);
-    }
-
-    @Test
-    public void shouldHandleWrongCommandWithSuggestion() {
-        // given
-        List<String> arguments = asList("authme", "ragister", "test");
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription description = newCommandDescription("authme", "register");
-        FoundCommandResult foundCommandResult = new FoundCommandResult(description, asList("authme", "ragister"),
-            singletonList("test"), 0.1, UNKNOWN_LABEL);
-        given(commandMapper.mapPartsToCommand(sender, arguments)).willReturn(foundCommandResult);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender).sendMessage(captor.capture());
-        assertThat(removeColors(captor.getValue()), containsString("Assuming /authme register"));
-        verify(helpProvider).outputHelp(sender, foundCommandResult, HelpProvider.ALL_OPTIONS);
-    }
-
-    @Test
-    public void shouldHandleWrongCommandWithoutSuggestion() {
-        List<String> arguments = asList("authme", "ragister", "test");
-        CommandSender sender = mock(CommandSender.class);
-        FoundCommandResult foundCommandResult = new FoundCommandResult(null, asList("authme", "ragister"),
-            singletonList("test"), 0.4, UNKNOWN_LABEL);
-        given(commandMapper.mapPartsToCommand(sender, arguments)).willReturn(foundCommandResult);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender).sendMessage(captor.capture());
-        assertThat(removeColors(captor.getValue()), containsString("Unknown command"));
-        verifyNoInteractions(helpProvider);
-    }
-
-    @Test
-    public void shouldShowChildrenOfBaseCommand() {
-        List<String> arguments = singletonList("authme");
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription commandDescription = mock(CommandDescription.class);
-        given(commandDescription.getLabelCount()).willReturn(1);
-        FoundCommandResult foundCommandResult = new FoundCommandResult(commandDescription, singletonList("authme"),
-            Collections.emptyList(), 0.0, SUCCESS);
-        given(commandMapper.mapPartsToCommand(sender, arguments)).willReturn(foundCommandResult);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        verify(sender, never()).sendMessage(anyString());
-        verify(helpProvider).outputHelp(sender, foundCommandResult,
-            SHOW_DESCRIPTION | SHOW_COMMAND | SHOW_CHILDREN | SHOW_ALTERNATIVES);
-    }
-
-    @Test
-    public void shouldShowDetailedHelpForChildCommand() {
-        List<String> arguments = asList("authme", "getpos");
-        CommandSender sender = mock(CommandSender.class);
-        CommandDescription commandDescription = mock(CommandDescription.class);
-        given(commandDescription.getLabelCount()).willReturn(2);
-        FoundCommandResult foundCommandResult = new FoundCommandResult(commandDescription, asList("authme", "getpos"),
-            Collections.emptyList(), 0.0, INCORRECT_ARGUMENTS);
-        given(commandMapper.mapPartsToCommand(sender, arguments)).willReturn(foundCommandResult);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        verify(sender, never()).sendMessage(anyString());
-        verify(helpProvider).outputHelp(sender, foundCommandResult, HelpProvider.ALL_OPTIONS);
-    }
-
-    private static CommandDescription newCommandDescription(String... labels) {
-        CommandDescription parent = null;
-        // iterate through the labels backwards so we can set the parent
-        for (String label : labels) {
-            CommandDescription description = mock(CommandDescription.class);
-            given(description.getParent()).willReturn(parent);
-            given(description.getLabels()).willReturn(singletonList(label));
-            parent = description;
-        }
-        return parent;
-    }
-
-    private static String removeColors(String str) {
-        for (ChatColor color : ChatColor.values()) {
-            str = str.replace(color.toString(), "");
-        }
-        return str;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/AccountsCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/AccountsCommandTest.java
deleted file mode 100644
index 2fcb0e56..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/AccountsCommandTest.java
+++ /dev/null
@@ -1,178 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToRunTaskAsynchronously;
-import static org.hamcrest.Matchers.containsString;
-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.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link AccountsCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AccountsCommandTest {
-
-    @InjectMocks
-    private AccountsCommand command;
-    @Mock
-    private CommonService service;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private BukkitService bukkitService;
-
-    @Test
-    public void shouldGetAccountsOfCurrentUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-        List<String> arguments = Collections.emptyList();
-        given(dataSource.getAuth("tester")).willReturn(authWithIp("123.45.67.89"));
-        given(dataSource.getAllAuthsByIp("123.45.67.89")).willReturn(Arrays.asList("Toaster", "Pester"));
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        String[] messages = getMessagesSentToSender(sender, 2);
-        assertThat(messages[0], containsString("2 accounts"));
-        assertThat(messages[1], containsString("Toaster, Pester"));
-    }
-
-    @Test
-    public void shouldReturnUnknownUserForNullAuth() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        List<String> arguments = Collections.singletonList("SomeUser");
-        given(dataSource.getAuth("someuser")).willReturn(null);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        verify(service).send(sender, MessageKey.UNKNOWN_USER);
-        verify(sender, never()).sendMessage(anyString());
-    }
-
-    @Test
-    public void shouldReturnUnregisteredMessageForEmptyAuthList() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        List<String> arguments = Collections.singletonList("SomeUser");
-        PlayerAuth auth = authWithIp("144.56.77.88");
-        given(dataSource.getAuth("someuser")).willReturn(auth);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        verify(service).send(sender, MessageKey.UNKNOWN_USER);
-        verify(sender, never()).sendMessage(anyString());
-    }
-
-    @Test
-    public void shouldReturnSingleAccountMessage() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        List<String> arguments = Collections.singletonList("SomeUser");
-        given(dataSource.getAuth("someuser")).willReturn(authWithIp("56.78.90.123"));
-        given(dataSource.getAllAuthsByIp("56.78.90.123")).willReturn(Collections.singletonList("SomeUser"));
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        String[] messages = getMessagesSentToSender(sender, 1);
-        assertThat(messages[0], containsString("single account"));
-    }
-
-    // -----
-    // Query by IP
-    // -----
-    @Test
-    public void shouldReturnIpUnknown() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        List<String> arguments = Collections.singletonList("123.45.67.89");
-        given(dataSource.getAllAuthsByIp("123.45.67.89")).willReturn(Collections.emptyList());
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        String[] messages = getMessagesSentToSender(sender, 1);
-        assertThat(messages[0], containsString("IP does not exist"));
-    }
-
-    @Test
-    public void shouldReturnSingleAccountForIpQuery() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        List<String> arguments = Collections.singletonList("24.24.48.48");
-        given(dataSource.getAllAuthsByIp("24.24.48.48")).willReturn(Collections.singletonList("SomeUser"));
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        String[] messages = getMessagesSentToSender(sender, 1);
-        assertThat(messages[0], containsString("single account"));
-    }
-
-    @Test
-    public void shouldReturnAccountListForIpQuery() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        List<String> arguments = Collections.singletonList("98.76.41.122");
-        given(dataSource.getAllAuthsByIp("98.76.41.122")).willReturn(Arrays.asList("Tester", "Lester", "Taster"));
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        String[] messages = getMessagesSentToSender(sender, 2);
-        assertThat(messages[0], containsString("3 accounts"));
-        assertThat(messages[1], containsString("Tester, Lester, Taster"));
-    }
-
-    private static String[] getMessagesSentToSender(CommandSender sender, int expectedCount) {
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(expectedCount)).sendMessage(captor.capture());
-        return captor.getAllValues().toArray(new String[expectedCount]);
-    }
-
-    private static PlayerAuth authWithIp(String ip) {
-        return PlayerAuth.builder()
-            .name("Test")
-            .lastIp(ip)
-            .build();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/AuthMeCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/AuthMeCommandTest.java
deleted file mode 100644
index 84ce1a9c..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/AuthMeCommandTest.java
+++ /dev/null
@@ -1,36 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.command.ExecutableCommand;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.mockito.ArgumentCaptor;
-
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link AuthMeCommand}.
- */
-public class AuthMeCommandTest {
-
-    @Test
-    public void shouldDisplayInformation() {
-        // given
-        ExecutableCommand command = new AuthMeCommand();
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        ArgumentCaptor<String> messagesCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(3)).sendMessage(messagesCaptor.capture());
-        assertThat(messagesCaptor.getAllValues().get(1), containsString("/authme help"));
-        assertThat(messagesCaptor.getAllValues().get(2), containsString("/authme about"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/BackupCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/BackupCommandTest.java
deleted file mode 100644
index 2e1e0b5e..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/BackupCommandTest.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.service.BackupService;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link BackupCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class BackupCommandTest {
-
-    @InjectMocks
-    private BackupCommand command;
-
-    @Mock
-    private BackupService backupService;
-
-    @Test
-    public void shouldStartBackup() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(backupService).doBackup(BackupService.BackupCause.COMMAND, sender);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/ChangePasswordAdminCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/ChangePasswordAdminCommandTest.java
deleted file mode 100644
index 8e1a6081..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/ChangePasswordAdminCommandTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.service.ValidationService.ValidationResult;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link ChangePasswordAdminCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ChangePasswordAdminCommandTest {
-
-    @InjectMocks
-    private ChangePasswordAdminCommand command;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private ValidationService validationService;
-
-    @Mock
-    private Management management;
-
-    @Test
-    public void shouldForwardRequestToManagement() {
-        // given
-        String name = "theUser";
-        String pass = "newPassword";
-        given(validationService.validatePassword(pass, name)).willReturn(new ValidationResult());
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(name, pass));
-
-        // then
-        verify(validationService).validatePassword(pass, name);
-        verify(management).performPasswordChangeAsAdmin(sender, name, pass);
-    }
-
-    @Test
-    public void shouldSendErrorToCommandSender() {
-        // given
-        String name = "theUser";
-        String pass = "newPassword";
-        given(validationService.validatePassword(pass, name)).willReturn(
-            new ValidationResult(MessageKey.INVALID_PASSWORD_LENGTH, "7"));
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(name, pass));
-
-        // then
-        verify(validationService).validatePassword(pass, name);
-        verify(commonService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH, "7");
-        verifyNoInteractions(management);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/ConverterCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/ConverterCommandTest.java
deleted file mode 100644
index cad80f9f..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/ConverterCommandTest.java
+++ /dev/null
@@ -1,149 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import ch.jalu.injector.factory.Factory;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.converter.Converter;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.util.StringUtils;
-import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToRunTaskAsynchronously;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link ConverterCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ConverterCommandTest {
-
-    @InjectMocks
-    private ConverterCommand command;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private Factory<Converter> converterFactory;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldHandleUnknownConversionType() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("invalid"));
-
-        // then
-        String converters = String.join(", ", ConverterCommand.CONVERTERS.keySet());
-        verify(sender).sendMessage(argThat(containsString(converters)));
-        verifyNoInteractions(commonService, converterFactory, bukkitService);
-    }
-
-    @Test
-    public void shouldHandleCommandWithNoArgs() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        String converters = String.join(", ", ConverterCommand.CONVERTERS.keySet());
-        verify(sender).sendMessage(argThat(containsString(converters)));
-        verifyNoInteractions(commonService, converterFactory, bukkitService);
-    }
-
-    @Test
-    public void shouldHaveUniqueClassForEachConverter() {
-        // given
-        Set<Class<? extends Converter>> classes = new HashSet<>();
-
-        // when / then
-        for (Map.Entry<String, Class<? extends Converter>> entry : ConverterCommand.CONVERTERS.entrySet()) {
-            assertThat("Name is not null or empty",
-                StringUtils.isBlank(entry.getKey()), equalTo(false));
-
-            assertThat("Converter class is unique for each entry",
-                classes.add(entry.getValue()), equalTo(true));
-        }
-    }
-
-    @Test
-    public void shouldLaunchConverterForAllTypes() {
-        // given
-        String converterName = "rakamak";
-        Class<? extends Converter> converterClass = ConverterCommand.CONVERTERS.get(converterName);
-        Converter converter = createMockReturnedByInjector(converterClass);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(converterName));
-
-        // then
-        verify(converter).execute(sender);
-        verifyNoMoreInteractions(converter);
-        verify(converterFactory).newInstance(converterClass);
-        verifyNoMoreInteractions(converterFactory);
-    }
-
-    @Test
-    public void shouldCatchExceptionInConverterAndInformSender() {
-        // given
-        String converterName = "vauth";
-        Class<? extends Converter> converterClass = ConverterCommand.CONVERTERS.get(converterName);
-        Converter converter = createMockReturnedByInjector(converterClass);
-        doThrow(IllegalStateException.class).when(converter).execute(any(CommandSender.class));
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(converterName.toUpperCase(Locale.ROOT)));
-
-        // then
-        verify(converter).execute(sender);
-        verifyNoMoreInteractions(converter);
-        verify(converterFactory).newInstance(converterClass);
-        verifyNoMoreInteractions(converterFactory);
-        verify(commonService).send(sender, MessageKey.ERROR);
-    }
-
-    private <T extends Converter> T createMockReturnedByInjector(Class<T> clazz) {
-        T converter = mock(clazz);
-        given(converterFactory.newInstance(clazz)).willReturn(converter);
-        return converter;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/FirstSpawnCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/FirstSpawnCommandTest.java
deleted file mode 100644
index 4b1af2b9..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/FirstSpawnCommandTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.settings.SpawnLoader;
-import org.bukkit.Location;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link FirstSpawnCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class FirstSpawnCommandTest {
-
-    @InjectMocks
-    private FirstSpawnCommand command;
-
-    @Mock
-    private SpawnLoader spawnLoader;
-
-    @Test
-    public void shouldTeleportToFirstSpawn() {
-        // given
-        Location firstSpawn = mock(Location.class);
-        given(spawnLoader.getFirstSpawn()).willReturn(firstSpawn);
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(player).teleport(firstSpawn);
-        verify(spawnLoader, atLeastOnce()).getFirstSpawn();
-    }
-
-    @Test
-    public void shouldHandleMissingFirstSpawn() {
-        // given
-        given(spawnLoader.getFirstSpawn()).willReturn(null);
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(player).sendMessage(argThat(containsString("spawn has failed")));
-        verify(player, never()).teleport(any(Location.class));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/ForceLoginCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/ForceLoginCommandTest.java
deleted file mode 100644
index b07b8459..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/ForceLoginCommandTest.java
+++ /dev/null
@@ -1,133 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerPermission;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.BukkitService;
-import org.bukkit.command.CommandSender;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link ForceLoginCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ForceLoginCommandTest {
-
-    @InjectMocks
-    private ForceLoginCommand command;
-
-    @Mock
-    private Management management;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-    
-    @Mock
-    private BukkitService bukkitService;
-
-    @Test
-    public void shouldRejectOfflinePlayer() {
-        // given
-        String playerName = "Bobby";
-        Player player = mockPlayer(false);
-        given(bukkitService.getPlayerExact(playerName)).willReturn(player);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(playerName));
-
-        // then
-        verify(bukkitService).getPlayerExact(playerName);
-        verify(sender).sendMessage("Player needs to be online!");
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldRejectInexistentPlayer() {
-        // given
-        String playerName = "us3rname01";
-        given(bukkitService.getPlayerExact(playerName)).willReturn(null);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(playerName));
-
-        // then
-        verify(bukkitService).getPlayerExact(playerName);
-        verify(sender).sendMessage("Player needs to be online!");
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldRejectPlayerWithMissingPermission() {
-        // given
-        String playerName = "testTest";
-        Player player = mockPlayer(true);
-        given(bukkitService.getPlayerExact(playerName)).willReturn(player);
-        given(permissionsManager.hasPermission(player, PlayerPermission.CAN_LOGIN_BE_FORCED)).willReturn(false);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(playerName));
-
-        // then
-        verify(bukkitService).getPlayerExact(playerName);
-        verify(sender).sendMessage(argThat(containsString("You cannot force login the player")));
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldForceLoginPlayer() {
-        // given
-        String playerName = "tester23";
-        Player player = mockPlayer(true);
-        given(bukkitService.getPlayerExact(playerName)).willReturn(player);
-        given(permissionsManager.hasPermission(player, PlayerPermission.CAN_LOGIN_BE_FORCED)).willReturn(true);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(playerName));
-
-        // then
-        verify(bukkitService).getPlayerExact(playerName);
-        verify(management).forceLogin(player);
-    }
-
-    @Test
-    public void shouldForceLoginSenderSelf() {
-        // given
-        String senderName = "tester23";
-        Player player = mockPlayer(true);
-        given(bukkitService.getPlayerExact(senderName)).willReturn(player);
-        given(permissionsManager.hasPermission(player, PlayerPermission.CAN_LOGIN_BE_FORCED)).willReturn(true);
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn(senderName);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(bukkitService).getPlayerExact(senderName);
-        verify(management).forceLogin(player);
-    }
-
-    private static Player mockPlayer(boolean isOnline) {
-        Player player = mock(Player.class);
-        given(player.isOnline()).willReturn(isOnline);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/GetEmailCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/GetEmailCommandTest.java
deleted file mode 100644
index dc3fda40..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/GetEmailCommandTest.java
+++ /dev/null
@@ -1,65 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import ch.jalu.datasourcecolumns.data.DataSourceValueImpl;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link GetEmailCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class GetEmailCommandTest {
-
-    @InjectMocks
-    private GetEmailCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService service;
-
-    @Test
-    public void shouldReportUnknownUser() {
-        // given
-        String user = "myTestUser";
-        given(dataSource.getEmail(user)).willReturn(DataSourceValueImpl.unknownRow());
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(user));
-
-        // then
-        verify(service).send(sender, MessageKey.UNKNOWN_USER);
-    }
-
-    @Test
-    public void shouldReturnEmail() {
-        // given
-        String user = "userToView";
-        String email = "user.email@example.org";
-        given(dataSource.getEmail(user)).willReturn(DataSourceValueImpl.of(email));
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(user));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString(email)));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/GetIpCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/GetIpCommandTest.java
deleted file mode 100644
index 8fe65e90..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/GetIpCommandTest.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.service.BukkitService;
-import org.bukkit.command.CommandSender;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.both;
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.ArgumentMatchers.anyString;
-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.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link GetIpCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class GetIpCommandTest {
-
-    @InjectMocks
-    private GetIpCommand command;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private DataSource dataSource;
-
-
-    @Test
-    public void shouldGetIpOfPlayer() {
-        // given
-        given(bukkitService.getPlayerExact(anyString())).willReturn(null);
-        given(dataSource.getAuth(anyString())).willReturn(null);
-        CommandSender sender = mock(CommandSender.class);
-        String name = "Testt";
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(name));
-
-        // then
-        verify(bukkitService).getPlayerExact(name);
-        verify(dataSource).getAuth(name);
-        verify(sender, only()).sendMessage(argThat(containsString("not registered")));
-    }
-
-    @Test
-    public void shouldReturnIpAddressOfPlayer() {
-        // given
-        String playerName = "charlie";
-        String ip = "123.34.56.88";
-        Player player = mockPlayer(playerName, ip);
-        given(bukkitService.getPlayerExact(playerName)).willReturn(player);
-        PlayerAuth auth = PlayerAuth.builder().name("t").lastIp("44.33.22.11").registrationIp("77.11.44.88").build();
-        given(dataSource.getAuth(playerName)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(playerName));
-
-        // then
-        verify(bukkitService).getPlayerExact(playerName);
-        verify(dataSource).getAuth(playerName);
-        verify(sender).sendMessage(argThat(both(containsString(playerName)).and(containsString(ip))));
-        verify(sender).sendMessage(argThat(both(containsString("44.33.22.11")).and(containsString("77.11.44.88"))));
-    }
-
-    @Test
-    public void shouldHandleUnregisteredOnlinePlayer() {
-        // given
-        String playerName = "Test";
-        String ip = "44.111.22.33";
-        Player player = mockPlayer(playerName, ip);
-        given(bukkitService.getPlayerExact(playerName)).willReturn(player);
-        given(dataSource.getAuth(anyString())).willReturn(null);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(playerName));
-
-        // then
-        verify(bukkitService).getPlayerExact(playerName);
-        verify(dataSource).getAuth(playerName);
-        verify(sender).sendMessage(argThat(both(containsString(playerName)).and(containsString(ip))));
-        verify(sender).sendMessage(argThat(containsString("not registered")));
-    }
-
-    private static Player mockPlayer(String name, String ip) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/LastLoginCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/LastLoginCommandTest.java
deleted file mode 100644
index 9e35cd7c..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/LastLoginCommandTest.java
+++ /dev/null
@@ -1,135 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-import java.util.Date;
-
-import static org.hamcrest.Matchers.allOf;
-import static org.hamcrest.Matchers.containsString;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link LastLoginCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class LastLoginCommandTest {
-
-    private static final long HOUR_IN_MSEC = 3600 * 1000;
-    private static final long DAY_IN_MSEC = 24 * HOUR_IN_MSEC;
-
-    @InjectMocks
-    private LastLoginCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService service;
-
-
-    @Test
-    public void shouldRejectNonExistentUser() {
-        // given
-        String player = "tester";
-        given(dataSource.getAuth(player)).willReturn(null);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(player));
-
-        // then
-        verify(dataSource).getAuth(player);
-        verify(service).send(sender, MessageKey.UNKNOWN_USER);
-    }
-
-    @Test
-    public void shouldDisplayLastLoginOfUser() {
-        // given
-        String player = "SomePlayer";
-        long lastLogin = System.currentTimeMillis() -
-            (412 * DAY_IN_MSEC + 10 * HOUR_IN_MSEC - 9000);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getLastLogin()).willReturn(lastLogin);
-        given(auth.getLastIp()).willReturn("123.45.66.77");
-        given(dataSource.getAuth(player)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(player));
-
-        // then
-        verify(dataSource).getAuth(player);
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(3)).sendMessage(captor.capture());
-        String lastLoginString = new Date(lastLogin).toString();
-        assertThat(captor.getAllValues().get(0),
-            allOf(containsString(player), containsString(lastLoginString)));
-        assertThat(captor.getAllValues().get(1), containsString("412 days 9 hours"));
-        assertThat(captor.getAllValues().get(2), containsString("123.45.66.77"));
-    }
-
-    @Test
-    public void shouldDisplayLastLoginOfCommandSender() {
-        // given
-        String name = "CommandSender";
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn(name);
-
-        long lastLogin = System.currentTimeMillis()
-            - (412 * DAY_IN_MSEC + 10 * HOUR_IN_MSEC - 9000);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getLastLogin()).willReturn(lastLogin);
-        given(auth.getLastIp()).willReturn("123.45.66.77");
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(dataSource).getAuth(name);
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(3)).sendMessage(captor.capture());
-        String lastLoginString = new Date(lastLogin).toString();
-        assertThat(captor.getAllValues().get(0),
-            allOf(containsString(name), containsString(lastLoginString)));
-        assertThat(captor.getAllValues().get(1), containsString("412 days 9 hours"));
-        assertThat(captor.getAllValues().get(2), containsString("123.45.66.77"));
-    }
-
-    @Test
-    public void shouldHandleNullLastLoginDate() {
-        // given
-        String name = "player";
-        PlayerAuth auth = PlayerAuth.builder()
-            .name(name)
-            .lastIp("123.45.67.89")
-            .build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(name));
-
-        // then
-        verify(dataSource).getAuth(name);
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(2)).sendMessage(captor.capture());
-        assertThat(captor.getAllValues().get(0), allOf(containsString(name), containsString("never")));
-        assertThat(captor.getAllValues().get(1), containsString("123.45.67.89"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommandTest.java
deleted file mode 100644
index 7c675bc0..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommandTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.task.purge.PurgeService;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Locale;
-import java.util.Set;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static org.hamcrest.Matchers.arrayContainingInAnyOrder;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PurgeBannedPlayersCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PurgeBannedPlayersCommandTest {
-
-    @InjectMocks
-    private PurgeBannedPlayersCommand command;
-
-    @Mock
-    private PurgeService purgeService;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Test
-    public void shouldForwardRequestToService() {
-        // given
-        String[] names = {"bannedPlayer", "other_banned", "evilplayer", "Someone"};
-        OfflinePlayer[] players = offlinePlayersWithNames(names);
-        given(bukkitService.getBannedPlayers()).willReturn(newHashSet(players));
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(bukkitService).getBannedPlayers();
-        verify(purgeService).purgePlayers(eq(sender), eq(asLowerCaseSet(names)),
-            argThat(arrayContainingInAnyOrder(players)));
-    }
-
-    private static OfflinePlayer[] offlinePlayersWithNames(String... names) {
-        OfflinePlayer[] players = new OfflinePlayer[names.length];
-        for (int i = 0; i < names.length; ++i) {
-            OfflinePlayer player = mock(OfflinePlayer.class);
-            given(player.getName()).willReturn(names[i]);
-            players[i] = player;
-        }
-        return players;
-    }
-
-    private static Set<String> asLowerCaseSet(String... items) {
-        Set<String> result = new HashSet<>(items.length);
-        for (String item : items) {
-            result.add(item.toLowerCase(Locale.ROOT));
-        }
-        return result;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/PurgeCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/PurgeCommandTest.java
deleted file mode 100644
index 70e4f03a..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/PurgeCommandTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.task.purge.PurgeService;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Calendar;
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PurgeCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PurgeCommandTest {
-
-    @InjectMocks
-    private PurgeCommand command;
-
-    @Mock
-    private PurgeService purgeService;
-
-    @Test
-    public void shouldHandleInvalidNumber() {
-        // given
-        String interval = "invalid";
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(interval));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("The value you've entered is invalid")));
-        verifyNoInteractions(purgeService);
-    }
-
-    @Test
-    public void shouldRejectTooSmallInterval() {
-        // given
-        String interval = "29";
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(interval));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("You can only purge data older than 30 days")));
-        verifyNoInteractions(purgeService);
-    }
-
-    @Test
-    public void shouldForwardToService() {
-        // given
-        String interval = "45";
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(interval));
-
-        // then
-        ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
-        verify(purgeService).runPurge(eq(sender), captor.capture());
-
-        // Check the timestamp with a certain tolerance
-        int toleranceMillis = 100;
-        Calendar calendar = Calendar.getInstance();
-        calendar.add(Calendar.DATE, -Integer.valueOf(interval));
-        assertIsCloseTo(captor.getValue(), calendar.getTimeInMillis(), toleranceMillis);
-    }
-
-    private static void assertIsCloseTo(long value1, long value2, long tolerance) {
-        assertThat(Math.abs(value1 - value2), not(greaterThan(tolerance)));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/PurgeLastPositionCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/PurgeLastPositionCommandTest.java
deleted file mode 100644
index 57bb21e2..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/PurgeLastPositionCommandTest.java
+++ /dev/null
@@ -1,118 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.bungeecord.BungeeSender;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PurgeLastPositionCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PurgeLastPositionCommandTest {
-
-    @InjectMocks
-    private PurgeLastPositionCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService service;
-
-    @Mock
-    private BungeeSender bungeeSender;
-
-    @Test
-    public void shouldPurgeLastPosOfUser() {
-        // given
-        String player = "_Bobby";
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(dataSource.getAuth(player)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(player));
-
-        // then
-        verify(dataSource).getAuth(player);
-        verifyPositionWasReset(auth);
-        verify(sender).sendMessage(argThat(containsString("last position location is now reset")));
-    }
-
-    @Test
-    public void shouldPurgePositionOfCommandSender() {
-        // given
-        String player = "_Bobby";
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn(player);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(dataSource.getAuth(player)).willReturn(auth);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(dataSource).getAuth(player);
-        verifyPositionWasReset(auth);
-        verify(sender).sendMessage(argThat(containsString("position location is now reset")));
-    }
-
-    @Test
-    public void shouldHandleNonExistentUser() {
-        // given
-        String name = "invalidPlayer";
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(name));
-
-        // then
-        verify(dataSource).getAuth(name);
-        verify(service).send(sender, MessageKey.UNKNOWN_USER);
-    }
-
-    @Test
-    public void shouldResetAllLastPositions() {
-        // given
-        PlayerAuth auth1 = mock(PlayerAuth.class);
-        PlayerAuth auth2 = mock(PlayerAuth.class);
-        PlayerAuth auth3 = mock(PlayerAuth.class);
-        given(dataSource.getAllAuths()).willReturn(Arrays.asList(auth1, auth2, auth3));
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("*"));
-
-        // then
-        verify(dataSource).getAllAuths();
-        verifyPositionWasReset(auth1);
-        verifyPositionWasReset(auth2);
-        verifyPositionWasReset(auth3);
-        verify(sender).sendMessage(argThat(containsString("last position locations are now reset")));
-    }
-
-
-    private static void verifyPositionWasReset(PlayerAuth auth) {
-        verify(auth).setQuitLocX(0);
-        verify(auth).setQuitLocY(0);
-        verify(auth).setQuitLocZ(0);
-        verify(auth).setWorld("world");
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/PurgePlayerCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/PurgePlayerCommandTest.java
deleted file mode 100644
index cf48d2a3..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/PurgePlayerCommandTest.java
+++ /dev/null
@@ -1,94 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.task.purge.PurgeExecutor;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Locale;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToRunTaskAsynchronously;
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToRunTaskOptionallyAsync;
-import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PurgePlayerCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PurgePlayerCommandTest {
-
-    @InjectMocks
-    private PurgePlayerCommand command;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private PurgeExecutor purgeExecutor;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Test
-    public void shouldNotExecutePurgeForRegisteredPlayer() {
-        // given
-        String name = "Bobby";
-        given(dataSource.isAuthAvailable(name)).willReturn(true);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, singletonList(name));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("This player is still registered")));
-        verifyNoInteractions(purgeExecutor);
-    }
-
-    @Test
-    public void shouldExecutePurge() {
-        // given
-        String name = "Frank";
-        given(dataSource.isAuthAvailable(name)).willReturn(false);
-        OfflinePlayer player = mock(OfflinePlayer.class);
-        given(bukkitService.getOfflinePlayer(name)).willReturn(player);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, singletonList(name));
-
-        // then
-        verify(dataSource).isAuthAvailable(name);
-        verify(purgeExecutor).executePurge(singletonList(player), singletonList(name.toLowerCase(Locale.ROOT)));
-    }
-
-    @Test
-    public void shouldExecutePurgeOfRegisteredPlayer() {
-        // given
-        String name = "GhiJKlmn7";
-        OfflinePlayer player = mock(OfflinePlayer.class);
-        given(bukkitService.getOfflinePlayer(name)).willReturn(player);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, asList(name, "force"));
-
-        // then
-        verify(purgeExecutor).executePurge(singletonList(player), singletonList(name.toLowerCase(Locale.ROOT)));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/RecentPlayersCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/RecentPlayersCommandTest.java
deleted file mode 100644
index 30ee0e72..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/RecentPlayersCommandTest.java
+++ /dev/null
@@ -1,87 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Spy;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.time.ZoneId;
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalToIgnoringCase;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link RecentPlayersCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class RecentPlayersCommandTest {
-
-    @InjectMocks
-    @Spy
-    private RecentPlayersCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Test
-    public void shouldShowRecentPlayers() {
-        // given
-        PlayerAuth auth1 = PlayerAuth.builder()
-            .name("hannah").realName("Hannah").lastIp("11.11.11.11")
-            .lastLogin(1510387755000L) // 11/11/2017 @ 8:09am
-            .build();
-        PlayerAuth auth2 = PlayerAuth.builder()
-            .name("matt").realName("MATT").lastIp("22.11.22.33")
-            .lastLogin(1510269301000L) // 11/09/2017 @ 11:15pm
-            .build();
-        doReturn(ZoneId.of("UTC")).when(command).getZoneId();
-        given(dataSource.getRecentlyLoggedInPlayers()).willReturn(Arrays.asList(auth1, auth2));
-
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Recently logged in players")));
-        verify(sender).sendMessage(argThat(equalToIgnoringCase("- Hannah (08:09 AM, 11 Nov with IP 11.11.11.11)")));
-        verify(sender).sendMessage(argThat(equalToIgnoringCase("- MATT (11:15 PM, 09 Nov with IP 22.11.22.33)")));
-    }
-
-    @Test
-    public void shouldHandlePlayerWithNullLastLogin() {
-        // given
-        PlayerAuth auth1 = PlayerAuth.builder()
-            .name("xephren").realName("Xephren").lastIp("11.11.11.11")
-            .lastLogin(null)
-            .build();
-        PlayerAuth auth2 = PlayerAuth.builder()
-            .name("silvah777").realName("silvah777").lastIp("22.11.22.33")
-            .lastLogin(1510269301000L) // 11/09/2017 @ 11:15pm
-            .build();
-        doReturn(ZoneId.of("UTC")).when(command).getZoneId();
-        given(dataSource.getRecentlyLoggedInPlayers()).willReturn(Arrays.asList(auth1, auth2));
-
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Recently logged in players")));
-        verify(sender).sendMessage(argThat(equalToIgnoringCase("- Xephren (never with IP 11.11.11.11)")));
-        verify(sender).sendMessage(argThat(equalToIgnoringCase("- silvah777 (11:15 PM, 09 Nov with IP 22.11.22.33)")));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/RegisterAdminCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/RegisterAdminCommandTest.java
deleted file mode 100644
index 07808fa5..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/RegisterAdminCommandTest.java
+++ /dev/null
@@ -1,186 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-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 org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Locale;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToRunTaskOptionallyAsync;
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link RegisterAdminCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class RegisterAdminCommandTest {
-
-    @InjectMocks
-    private RegisterAdminCommand command;
-
-    @Mock
-    private PasswordSecurity passwordSecurity;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private CommonService commandService;
-
-    @Mock
-    private ValidationService validationService;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldRejectInvalidPassword() {
-        // given
-        String user = "tester";
-        String password = "myPassword";
-        given(validationService.validatePassword(password, user))
-            .willReturn(new ValidationResult(MessageKey.INVALID_PASSWORD_LENGTH));
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, password));
-
-        // then
-        verify(validationService).validatePassword(password, user);
-        verify(commandService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH, new String[0]);
-        verify(bukkitService, never()).runTaskAsynchronously(any(Runnable.class));
-    }
-
-    @Test
-    public void shouldRejectAlreadyRegisteredAccount() {
-        // given
-        String user = "my_name55";
-        String password = "@some-pass@";
-        given(validationService.validatePassword(password, user)).willReturn(new ValidationResult());
-        given(dataSource.isAuthAvailable(user)).willReturn(true);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, password));
-
-        // then
-        verify(validationService).validatePassword(password, user);
-        verify(commandService).send(sender, MessageKey.NAME_ALREADY_REGISTERED);
-        verify(dataSource, never()).saveAuth(any(PlayerAuth.class));
-    }
-
-    @Test
-    public void shouldHandleSavingError() {
-        // given
-        String user = "test-test";
-        String password = "afdjhfkt";
-        given(validationService.validatePassword(password, user)).willReturn(new ValidationResult());
-        given(dataSource.isAuthAvailable(user)).willReturn(false);
-        given(dataSource.saveAuth(any(PlayerAuth.class))).willReturn(false);
-        HashedPassword hashedPassword = new HashedPassword("235sdf4w5udsgf");
-        given(passwordSecurity.computeHash(password, user)).willReturn(hashedPassword);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, password));
-
-        // then
-        verify(validationService).validatePassword(password, user);
-        verify(commandService).send(sender, MessageKey.ERROR);
-        ArgumentCaptor<PlayerAuth> captor = ArgumentCaptor.forClass(PlayerAuth.class);
-        verify(dataSource).saveAuth(captor.capture());
-        assertAuthHasInfo(captor.getValue(), user, hashedPassword);
-    }
-
-    @Test
-    public void shouldRegisterOfflinePlayer() {
-        // given
-        String user = "someone";
-        String password = "Al1O3P49S5%";
-        given(validationService.validatePassword(password, user)).willReturn(new ValidationResult());
-        given(dataSource.isAuthAvailable(user)).willReturn(false);
-        given(dataSource.saveAuth(any(PlayerAuth.class))).willReturn(true);
-        HashedPassword hashedPassword = new HashedPassword("$aea2345EW235dfsa@#R%987048");
-        given(passwordSecurity.computeHash(password, user)).willReturn(hashedPassword);
-        given(bukkitService.getPlayerExact(user)).willReturn(null);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, password));
-
-        // then
-        verify(validationService).validatePassword(password, user);
-        verify(commandService).send(sender, MessageKey.REGISTER_SUCCESS);
-        ArgumentCaptor<PlayerAuth> captor = ArgumentCaptor.forClass(PlayerAuth.class);
-        verify(dataSource).saveAuth(captor.capture());
-        assertAuthHasInfo(captor.getValue(), user, hashedPassword);
-    }
-
-    @Test
-    public void shouldRegisterOnlinePlayer() {
-        // given
-        String user = "someone";
-        String password = "Al1O3P49S5%";
-        given(validationService.validatePassword(password, user)).willReturn(new ValidationResult());
-        given(dataSource.isAuthAvailable(user)).willReturn(false);
-        given(dataSource.saveAuth(any(PlayerAuth.class))).willReturn(true);
-        HashedPassword hashedPassword = new HashedPassword("$aea2345EW235dfsa@#R%987048");
-        given(passwordSecurity.computeHash(password, user)).willReturn(hashedPassword);
-        Player player = mock(Player.class);
-        given(bukkitService.getPlayerExact(user)).willReturn(player);
-        String kickForAdminRegister = "Admin registered you -- log in again";
-        given(commandService.retrieveSingleMessage(player, MessageKey.KICK_FOR_ADMIN_REGISTER)).willReturn(kickForAdminRegister);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, password));
-
-        // then
-        verify(validationService).validatePassword(password, user);
-        verify(commandService).send(sender, MessageKey.REGISTER_SUCCESS);
-        ArgumentCaptor<PlayerAuth> captor = ArgumentCaptor.forClass(PlayerAuth.class);
-        verify(dataSource).saveAuth(captor.capture());
-        assertAuthHasInfo(captor.getValue(), user, hashedPassword);
-        verify(player).kickPlayer(kickForAdminRegister);
-    }
-
-    private void assertAuthHasInfo(PlayerAuth auth, String name, HashedPassword hashedPassword) {
-        assertThat(auth.getRealName(), equalTo(name));
-        assertThat(auth.getNickname(), equalTo(name.toLowerCase(Locale.ROOT)));
-        assertThat(auth.getPassword(), equalTo(hashedPassword));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/ReloadCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/ReloadCommandTest.java
deleted file mode 100644
index 679b5e52..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/ReloadCommandTest.java
+++ /dev/null
@@ -1,148 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import ch.jalu.injector.factory.SingletonStore;
-import fr.xephi.authme.AuthMe;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.datasource.DataSourceType;
-import fr.xephi.authme.initialization.Reloadable;
-import fr.xephi.authme.initialization.SettingsDependent;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.output.LogLevel;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.SettingsWarner;
-import fr.xephi.authme.settings.properties.DatabaseSettings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.bukkit.command.CommandSender;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link ReloadCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ReloadCommandTest {
-
-    @InjectMocks
-    private ReloadCommand command;
-
-    @Mock
-    private AuthMe authMe;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService commandService;
-
-    @Mock
-    private SettingsWarner settingsWarner;
-
-    @Mock
-    private SingletonStore<Reloadable> reloadableStore;
-
-    @Mock
-    private SingletonStore<SettingsDependent> settingsDependentStore;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Before
-    public void setDefaultSettings() {
-        // Mock properties retrieved by ConsoleLogger
-        given(settings.getProperty(PluginSettings.LOG_LEVEL)).willReturn(LogLevel.INFO);
-        given(settings.getProperty(SecuritySettings.USE_LOGGING)).willReturn(false);
-    }
-
-    @Test
-    public void shouldReload() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(settings.getProperty(DatabaseSettings.BACKEND)).willReturn(DataSourceType.MYSQL);
-        given(dataSource.getType()).willReturn(DataSourceType.MYSQL);
-        List<Reloadable> reloadables = Arrays.asList(
-            mock(Reloadable.class), mock(Reloadable.class), mock(Reloadable.class));
-        List<SettingsDependent> dependents = Arrays.asList(
-            mock(SettingsDependent.class), mock(SettingsDependent.class));
-        given(reloadableStore.retrieveAllOfType()).willReturn(reloadables);
-        given(settingsDependentStore.retrieveAllOfType()).willReturn(dependents);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(settings).reload();
-        verifyReloadingCalls(reloadables, dependents);
-        verify(commandService).send(sender, MessageKey.CONFIG_RELOAD_SUCCESS);
-        verify(settingsWarner).logWarningsForMisconfigurations();
-    }
-
-    @Test
-    public void shouldHandleReloadError() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        doThrow(IllegalStateException.class).when(reloadableStore).retrieveAllOfType();
-        given(settings.getProperty(DatabaseSettings.BACKEND)).willReturn(DataSourceType.MYSQL);
-        given(dataSource.getType()).willReturn(DataSourceType.MYSQL);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(settings).reload();
-        verify(reloadableStore).retrieveAllOfType();
-        verify(sender).sendMessage(argThat(containsString("Error occurred")));
-        verify(authMe).stopOrUnload();
-    }
-
-    @Test
-    public void shouldIssueWarningForChangedDataSourceSetting() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(settings.getProperty(DatabaseSettings.BACKEND)).willReturn(DataSourceType.MYSQL);
-        given(dataSource.getType()).willReturn(DataSourceType.SQLITE);
-        given(reloadableStore.retrieveAllOfType()).willReturn(Collections.emptyList());
-        given(settingsDependentStore.retrieveAllOfType()).willReturn(Collections.emptyList());
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(settings).reload();
-        verify(reloadableStore).retrieveAllOfType();
-        verify(settingsDependentStore).retrieveAllOfType();
-        verify(sender).sendMessage(argThat(containsString("cannot change database type")));
-    }
-
-    private void verifyReloadingCalls(List<Reloadable> reloadables, List<SettingsDependent> dependents) {
-        for (Reloadable reloadable : reloadables) {
-            verify(reloadable).reload();
-        }
-        for (SettingsDependent dependent : dependents) {
-            verify(dependent).reload(settings);
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/SetEmailCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/SetEmailCommandTest.java
deleted file mode 100644
index 3b96070d..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/SetEmailCommandTest.java
+++ /dev/null
@@ -1,192 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-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.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.ValidationService;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToRunTaskOptionallyAsync;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link SetEmailCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class SetEmailCommandTest {
-
-    @InjectMocks
-    private SetEmailCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService commandService;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private BukkitService bukkitService;
-    
-    @Mock
-    private ValidationService validationService;
-
-    @Test
-    public void shouldRejectInvalidMail() {
-        // given
-        String user = "somebody";
-        String email = "some.test@example.org";
-        given(validationService.validateEmail(email)).willReturn(false);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, email));
-
-        // then
-        verify(validationService).validateEmail(email);
-        verify(commandService).send(sender, MessageKey.INVALID_EMAIL);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldHandleUnknownUser() {
-        // given
-        String user = "nonexistent";
-        String email = "mail@example.com";
-        given(validationService.validateEmail(email)).willReturn(true);
-        given(dataSource.getAuth(user)).willReturn(null);
-        CommandSender sender = mock(CommandSender.class);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, email));
-
-        // then
-        verify(validationService).validateEmail(email);
-        verify(dataSource).getAuth(user);
-        verify(commandService).send(sender, MessageKey.UNKNOWN_USER);
-        verifyNoMoreInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldHandleAlreadyTakenEmail() {
-        // given
-        String user = "someone";
-        String email = "mail@example.com";
-        given(validationService.validateEmail(email)).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(dataSource.getAuth(user)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-        given(validationService.isEmailFreeForRegistration(email, sender)).willReturn(false);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, email));
-
-        // then
-        verify(validationService).validateEmail(email);
-        verify(dataSource).getAuth(user);
-        verify(validationService).isEmailFreeForRegistration(email, sender);
-        verify(commandService).send(sender, MessageKey.EMAIL_ALREADY_USED_ERROR);
-        verifyNoMoreInteractions(dataSource);
-        verifyNoInteractions(auth);
-    }
-
-    @Test
-    public void shouldHandlePersistenceError() {
-        // given
-        String user = "Bobby";
-        String email = "new-addr@example.org";
-        given(validationService.validateEmail(email)).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(dataSource.getAuth(user)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-        given(validationService.isEmailFreeForRegistration(email, sender)).willReturn(true);
-        given(dataSource.updateEmail(auth)).willReturn(false);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, email));
-
-        // then
-        verify(validationService).validateEmail(email);
-        verify(dataSource).getAuth(user);
-        verify(validationService).isEmailFreeForRegistration(email, sender);
-        verify(commandService).send(sender, MessageKey.ERROR);
-        verify(dataSource).updateEmail(auth);
-        verifyNoMoreInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldUpdateEmail() {
-        // given
-        String user = "Bobby";
-        String email = "new-addr@example.org";
-        given(validationService.validateEmail(email)).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(dataSource.getAuth(user)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-        given(validationService.isEmailFreeForRegistration(email, sender)).willReturn(true);
-        given(dataSource.updateEmail(auth)).willReturn(true);
-        given(playerCache.getAuth(user)).willReturn(null);
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, email));
-
-        // then
-        verify(validationService).validateEmail(email);
-        verify(dataSource).getAuth(user);
-        verify(validationService).isEmailFreeForRegistration(email, sender);
-        verify(commandService).send(sender, MessageKey.EMAIL_CHANGED_SUCCESS);
-        verify(dataSource).updateEmail(auth);
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verifyNoMoreInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldUpdateEmailAndPlayerCache() {
-        // given
-        String user = "Bobby";
-        String email = "new-addr@example.org";
-        given(validationService.validateEmail(email)).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(dataSource.getAuth(user)).willReturn(auth);
-        CommandSender sender = mock(CommandSender.class);
-        given(validationService.isEmailFreeForRegistration(email, sender)).willReturn(true);
-        given(dataSource.updateEmail(auth)).willReturn(true);
-        given(playerCache.getAuth(user)).willReturn(mock(PlayerAuth.class));
-        setBukkitServiceToRunTaskOptionallyAsync(bukkitService);
-
-        // when
-        command.executeCommand(sender, Arrays.asList(user, email));
-
-        // then
-        verify(validationService).validateEmail(email);
-        verify(dataSource).getAuth(user);
-        verify(validationService).isEmailFreeForRegistration(email, sender);
-        verify(commandService).send(sender, MessageKey.EMAIL_CHANGED_SUCCESS);
-        verify(dataSource).updateEmail(auth);
-        verify(playerCache).updatePlayer(auth);
-        verifyNoMoreInteractions(dataSource);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/SetFirstSpawnCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/SetFirstSpawnCommandTest.java
deleted file mode 100644
index 67cb3d91..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/SetFirstSpawnCommandTest.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.settings.SpawnLoader;
-import org.bukkit.Location;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link SetFirstSpawnCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class SetFirstSpawnCommandTest {
-
-    @InjectMocks
-    private SetFirstSpawnCommand command;
-
-    @Mock
-    private SpawnLoader spawnLoader;
-
-
-    @Test
-    public void shouldSetFirstSpawn() {
-        // given
-        Player player = mock(Player.class);
-        Location location = mock(Location.class);
-        given(player.getLocation()).willReturn(location);
-        given(spawnLoader.setFirstSpawn(location)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(spawnLoader).setFirstSpawn(location);
-        verify(player).sendMessage(argThat(containsString("defined new first spawn")));
-    }
-
-    @Test
-    public void shouldHandleError() {
-        // given
-        Player player = mock(Player.class);
-        Location location = mock(Location.class);
-        given(player.getLocation()).willReturn(location);
-        given(spawnLoader.setFirstSpawn(location)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(spawnLoader).setFirstSpawn(location);
-        verify(player).sendMessage(argThat(containsString("has failed")));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/SetSpawnCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/SetSpawnCommandTest.java
deleted file mode 100644
index 17f77e31..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/SetSpawnCommandTest.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.settings.SpawnLoader;
-import org.bukkit.Location;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link SetSpawnCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class SetSpawnCommandTest {
-
-    @InjectMocks
-    private SetSpawnCommand command;
-
-    @Mock
-    private SpawnLoader spawnLoader;
-
-
-    @Test
-    public void shouldSetSpawn() {
-        // given
-        Player player = mock(Player.class);
-        Location location = mock(Location.class);
-        given(player.getLocation()).willReturn(location);
-        given(spawnLoader.setSpawn(location)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(spawnLoader).setSpawn(location);
-        verify(player).sendMessage(argThat(containsString("defined new spawn")));
-    }
-
-    @Test
-    public void shouldHandleError() {
-        // given
-        Player player = mock(Player.class);
-        Location location = mock(Location.class);
-        given(player.getLocation()).willReturn(location);
-        given(spawnLoader.setSpawn(location)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(spawnLoader).setSpawn(location);
-        verify(player).sendMessage(argThat(containsString("has failed")));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/SpawnCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/SpawnCommandTest.java
deleted file mode 100644
index b9566c98..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/SpawnCommandTest.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.settings.SpawnLoader;
-import org.bukkit.Location;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link SpawnCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class SpawnCommandTest {
-
-    @InjectMocks
-    private SpawnCommand command;
-
-    @Mock
-    private SpawnLoader spawnLoader;
-
-
-    @Test
-    public void shouldTeleportToSpawn() {
-        // given
-        Location spawn = mock(Location.class);
-        given(spawnLoader.getSpawn()).willReturn(spawn);
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(player).teleport(spawn);
-        verify(spawnLoader, atLeastOnce()).getSpawn();
-    }
-
-    @Test
-    public void shouldHandleMissingSpawn() {
-        // given
-        given(spawnLoader.getSpawn()).willReturn(null);
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(player).sendMessage(argThat(containsString("Spawn has failed")));
-        verify(player, never()).teleport(any(Location.class));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/SwitchAntiBotCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/SwitchAntiBotCommandTest.java
deleted file mode 100644
index f3c2e99c..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/SwitchAntiBotCommandTest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.command.CommandMapper;
-import fr.xephi.authme.command.FoundCommandResult;
-import fr.xephi.authme.command.help.HelpProvider;
-import fr.xephi.authme.service.AntiBotService;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static java.util.Arrays.asList;
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link SwitchAntiBotCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class SwitchAntiBotCommandTest {
-
-    @InjectMocks
-    private SwitchAntiBotCommand command;
-
-    @Mock
-    private AntiBotService antiBot;
-
-    @Mock
-    private CommandMapper commandMapper;
-
-    @Mock
-    private HelpProvider helpProvider;
-
-    @Test
-    public void shouldReturnAntiBotState() {
-        // given
-        given(antiBot.getAntiBotStatus()).willReturn(AntiBotService.AntiBotStatus.ACTIVE);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("status: ACTIVE")));
-    }
-
-    @Test
-    public void shouldActivateAntiBot() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("on"));
-
-        // then
-        verify(antiBot).overrideAntiBotStatus(true);
-        verify(sender).sendMessage(argThat(containsString("enabled")));
-    }
-
-    @Test
-    public void shouldDeactivateAntiBot() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("Off"));
-
-        // then
-        verify(antiBot).overrideAntiBotStatus(false);
-        verify(sender).sendMessage(argThat(containsString("disabled")));
-    }
-
-    @Test
-    public void shouldShowHelpForUnknownState() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        FoundCommandResult foundCommandResult = mock(FoundCommandResult.class);
-        given(commandMapper.mapPartsToCommand(sender, asList("authme", "antibot"))).willReturn(foundCommandResult);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("wrong"));
-
-        // then
-        verify(antiBot, never()).overrideAntiBotStatus(anyBoolean());
-        verify(sender).sendMessage(argThat(containsString("Invalid")));
-        verify(helpProvider).outputHelp(sender, foundCommandResult, HelpProvider.SHOW_ARGUMENTS);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/TotpDisableAdminCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/TotpDisableAdminCommandTest.java
deleted file mode 100644
index e6728d89..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/TotpDisableAdminCommandTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.service.BukkitService;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-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.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link TotpDisableAdminCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class TotpDisableAdminCommandTest {
-
-    @InjectMocks
-    private TotpDisableAdminCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private Messages messages;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldHandleUnknownUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(dataSource.getAuth("user")).willReturn(null);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("user"));
-
-        // then
-        verify(messages).send(sender, MessageKey.UNKNOWN_USER);
-        verify(dataSource, only()).getAuth("user");
-    }
-
-    @Test
-    public void shouldHandleUserWithNoTotpEnabled() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("billy")
-            .totpKey(null)
-            .build();
-        given(dataSource.getAuth("Billy")).willReturn(auth);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("Billy"));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("'Billy' does not have two-factor auth enabled")));
-        verify(dataSource, only()).getAuth("Billy");
-    }
-
-    @Test
-    public void shouldRemoveTotpFromUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("Bobby")
-            .totpKey("56484998")
-            .build();
-        given(dataSource.getAuth("Bobby")).willReturn(auth);
-        given(dataSource.removeTotpKey("Bobby")).willReturn(true);
-        Player player = mock(Player.class);
-        given(bukkitService.getPlayerExact("Bobby")).willReturn(player);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("Bobby"));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Disabled two-factor authentication successfully")));
-        verify(messages).send(player, MessageKey.TWO_FACTOR_REMOVED_SUCCESS);
-    }
-
-    @Test
-    public void shouldHandleErrorWhileRemovingTotp() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("Bobby")
-            .totpKey("321654")
-            .build();
-        given(dataSource.getAuth("Bobby")).willReturn(auth);
-        given(dataSource.removeTotpKey("Bobby")).willReturn(false);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("Bobby"));
-
-        // then
-        verify(messages).send(sender, MessageKey.ERROR);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/TotpViewStatusCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/TotpViewStatusCommandTest.java
deleted file mode 100644
index ba656030..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/TotpViewStatusCommandTest.java
+++ /dev/null
@@ -1,92 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-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.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link TotpViewStatusCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class TotpViewStatusCommandTest {
-
-    @InjectMocks
-    private TotpViewStatusCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private Messages messages;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldHandleUnknownUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(dataSource.getAuth("user")).willReturn(null);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("user"));
-
-        // then
-        verify(messages).send(sender, MessageKey.UNKNOWN_USER);
-        verify(dataSource, only()).getAuth("user");
-    }
-
-    @Test
-    public void shouldInformForUserWithoutTotp() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("billy")
-            .totpKey(null)
-            .build();
-        given(dataSource.getAuth("Billy")).willReturn(auth);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("Billy"));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("'Billy' does NOT have two-factor auth enabled")));
-    }
-
-    @Test
-    public void shouldInformForUserWithTotpEnabled() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("billy")
-            .totpKey("92841575")
-            .build();
-        given(dataSource.getAuth("Billy")).willReturn(auth);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("Billy"));
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("'Billy' has enabled two-factor authentication")));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/UnregisterAdminCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/UnregisterAdminCommandTest.java
deleted file mode 100644
index 4651b2be..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/UnregisterAdminCommandTest.java
+++ /dev/null
@@ -1,94 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.command.CommandSender;
-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 java.util.Collections;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link UnregisterAdminCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class UnregisterAdminCommandTest {
-
-    @InjectMocks
-    private UnregisterAdminCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService commandService;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private Management management;
-
-    @Test
-    public void shouldHandleUnknownPlayer() {
-        // given
-        String user = "bobby";
-        given(dataSource.isAuthAvailable(user)).willReturn(false);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(user));
-
-        // then
-        verify(dataSource, only()).isAuthAvailable(user);
-        verify(commandService).send(sender, MessageKey.UNKNOWN_USER);
-    }
-
-    @Test
-    public void shouldInvokeUnregisterProcess() {
-        // given
-        String user = "personaNonGrata";
-        given(dataSource.isAuthAvailable(user)).willReturn(true);
-        Player player = mock(Player.class);
-        given(bukkitService.getPlayerExact(user)).willReturn(player);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(user));
-
-        // then
-        verify(dataSource, only()).isAuthAvailable(user);
-        verify(bukkitService).getPlayerExact(user);
-        verify(management).performUnregisterByAdmin(sender, user, player);
-    }
-
-    @Test
-    public void shouldInvokeUnregisterProcessWithNullPlayer() {
-        // given
-        String user = "personaNonGrata";
-        given(dataSource.isAuthAvailable(user)).willReturn(true);
-        given(bukkitService.getPlayerExact(user)).willReturn(null);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(user));
-
-        // then
-        verify(dataSource, only()).isAuthAvailable(user);
-        verify(bukkitService).getPlayerExact(user);
-        verify(management).performUnregisterByAdmin(sender, user, null);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/UpdateHelpMessagesCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/UpdateHelpMessagesCommandTest.java
deleted file mode 100644
index 64113da4..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/UpdateHelpMessagesCommandTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package fr.xephi.authme.command.executable.authme;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.command.help.HelpMessagesService;
-import fr.xephi.authme.service.HelpTranslationGenerator;
-import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.io.File;
-import java.io.IOException;
-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.verifyNoInteractions;
-
-/**
- * Test for {@link UpdateHelpMessagesCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class UpdateHelpMessagesCommandTest {
-
-    @InjectMocks
-    private UpdateHelpMessagesCommand command;
-
-    @Mock
-    private HelpTranslationGenerator helpTranslationGenerator;
-    @Mock
-    private HelpMessagesService helpMessagesService;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldUpdateHelpMessage() throws IOException {
-        // given
-        File updatedFile = new File("some/path/help_xx.yml");
-        given(helpTranslationGenerator.updateHelpFile()).willReturn(updatedFile);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(helpMessagesService).reloadMessagesFile();
-        verify(sender).sendMessage("Successfully updated the help file 'help_xx.yml'");
-    }
-
-    @Test
-    public void shouldCatchAndReportException() throws IOException {
-        // given
-        given(helpTranslationGenerator.updateHelpFile()).willThrow(new IOException("Couldn't do the thing"));
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage("Could not update help file: Couldn't do the thing");
-        verifyNoInteractions(helpMessagesService);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DataStatisticsTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/DataStatisticsTest.java
deleted file mode 100644
index fe50d837..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DataStatisticsTest.java
+++ /dev/null
@@ -1,121 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import ch.jalu.injector.factory.SingletonStore;
-import com.google.common.cache.LoadingCache;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.data.limbo.LimboPlayer;
-import fr.xephi.authme.data.limbo.LimboService;
-import fr.xephi.authme.datasource.CacheDataSource;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.initialization.HasCleanup;
-import fr.xephi.authme.initialization.Reloadable;
-import fr.xephi.authme.initialization.SettingsDependent;
-import fr.xephi.authme.output.ConsoleLoggerFactory;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
-
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.hasItem;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link DataStatistics}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class DataStatisticsTest {
-
-    @InjectMocks
-    private DataStatistics dataStatistics;
-
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private LimboService limboService;
-    @Mock
-    private SingletonStore<Object> singletonStore;
-
-    @Before
-    public void setUpLimboCacheMap() {
-        Map<String, LimboPlayer> limboMap = new HashMap<>();
-        limboMap.put("test", mock(LimboPlayer.class));
-        ReflectionTestUtils.setField(LimboService.class, limboService, "entries", limboMap);
-    }
-
-    @Test
-    public void shouldOutputStatistics() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(singletonStore.retrieveAllOfType()).willReturn(mockListOfSize(Object.class, 7));
-        given(singletonStore.retrieveAllOfType(Reloadable.class)).willReturn(mockListOfSize(Reloadable.class, 4));
-        given(singletonStore.retrieveAllOfType(SettingsDependent.class)).willReturn(mockListOfSize(SettingsDependent.class, 3));
-        given(singletonStore.retrieveAllOfType(HasCleanup.class)).willReturn(mockListOfSize(HasCleanup.class, 2));
-        given(dataSource.getAccountsRegistered()).willReturn(219);
-        given(playerCache.getLogged()).willReturn(12);
-
-        // Clear any loggers that might exist and trigger the generation of two loggers
-        Map loggers = ReflectionTestUtils.getFieldValue(ConsoleLoggerFactory.class, null, "consoleLoggers");
-        loggers.clear();
-        ConsoleLoggerFactory.get(String.class);
-        ConsoleLoggerFactory.get(Integer.class);
-
-        // when
-        dataStatistics.execute(sender, Collections.emptyList());
-
-        // then
-        ArgumentCaptor<String> stringCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, atLeastOnce()).sendMessage(stringCaptor.capture());
-        assertThat(stringCaptor.getAllValues(), containsInAnyOrder(
-            ChatColor.BLUE + "AuthMe statistics",
-            "Singleton Java classes: 7",
-            "(Reloadable: 4 / SettingsDependent: 3 / HasCleanup: 2)",
-            "LimboPlayers in memory: 1",
-            "Total players in DB: 219",
-            "PlayerCache size: 12 (= logged in players)",
-            "Total logger instances: 2"));
-    }
-
-    @Test
-    public void shouldOutputCachedDataSourceStatistics() {
-        // given
-        CacheDataSource cacheDataSource = mock(CacheDataSource.class);
-        LoadingCache<String, Optional<PlayerAuth>> cache = mock(LoadingCache.class);
-        given(cache.size()).willReturn(11L);
-        given(cacheDataSource.getCachedAuths()).willReturn(cache);
-        ReflectionTestUtils.setField(DataStatistics.class, dataStatistics, "dataSource", cacheDataSource);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        dataStatistics.execute(sender, Collections.emptyList());
-
-        // then
-        ArgumentCaptor<String> stringCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, atLeastOnce()).sendMessage(stringCaptor.capture());
-        assertThat(stringCaptor.getAllValues(), hasItem("Cached PlayerAuth objects: 11"));
-    }
-
-    private static <T> List<T> mockListOfSize(Class<T> mockClass, int size) {
-        T mock = mock(mockClass);
-        return Collections.nCopies(size, mock);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugCommandTest.java
deleted file mode 100644
index 82e39d41..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugCommandTest.java
+++ /dev/null
@@ -1,158 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import ch.jalu.injector.factory.Factory;
-import fr.xephi.authme.permission.DebugSectionPermissions;
-import fr.xephi.authme.permission.PermissionNode;
-import fr.xephi.authme.permission.PermissionsManager;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.Locale;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Collections.emptyList;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link DebugCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class DebugCommandTest {
-
-    /**
-     * Number we test against if we expect an action to have been performed for each debug section.
-     * This is a minimum number so tests don't fail each time a new debug section is added; however,
-     * it should be close to the total.
-     */
-    private static final int MIN_DEBUG_SECTIONS = 9;
-
-    @InjectMocks
-    private DebugCommand command;
-
-    @Mock
-    private Factory<DebugSection> debugSectionFactory;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Before
-    @SuppressWarnings("unchecked")
-    public void initFactory() {
-        given(debugSectionFactory.newInstance(any(Class.class))).willAnswer(
-            invocation -> {
-                Class<?> classArgument = invocation.getArgument(0);
-                checkArgument(DebugSection.class.isAssignableFrom(classArgument));
-                return spy(classArgument);
-            });
-    }
-
-    @Test
-    public void shouldListAllAvailableDebugSections() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(false);
-        given(permissionsManager.hasPermission(sender, DebugSectionPermissions.INPUT_VALIDATOR)).willReturn(true);
-        given(permissionsManager.hasPermission(sender, DebugSectionPermissions.DATA_STATISTICS)).willReturn(true);
-
-        // when
-        command.executeCommand(sender, emptyList());
-
-        // then
-        verify(debugSectionFactory, atLeast(MIN_DEBUG_SECTIONS)).newInstance(any(Class.class));
-        verify(permissionsManager, atLeast(MIN_DEBUG_SECTIONS)).hasPermission(eq(sender), any(DebugSectionPermissions.class));
-
-        ArgumentCaptor<String> strCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(4)).sendMessage(strCaptor.capture());
-        assertThat(strCaptor.getAllValues(), contains(
-            equalTo(ChatColor.BLUE + "AuthMe debug utils"),
-            equalTo("Sections available to you:"),
-            containsString("stats: Outputs general data statistics"),
-            containsString("valid: Checks if your config.yml allows a password / email")));
-    }
-
-    @Test
-    public void shouldNotListAnyDebugSection() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(false);
-
-        // when
-        command.executeCommand(sender, emptyList());
-
-        // then
-        verify(debugSectionFactory, atLeast(MIN_DEBUG_SECTIONS)).newInstance(any(Class.class));
-        verify(permissionsManager, atLeast(MIN_DEBUG_SECTIONS)).hasPermission(eq(sender), any(DebugSectionPermissions.class));
-
-        ArgumentCaptor<String> strCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, times(3)).sendMessage(strCaptor.capture());
-        assertThat(strCaptor.getAllValues(), contains(
-            equalTo(ChatColor.BLUE + "AuthMe debug utils"),
-            equalTo("Sections available to you:"),
-            containsString("You don't have permission to view any debug section")));
-    }
-
-    @Test
-    public void shouldRunSection() {
-        // given
-        DebugSection section = spy(InputValidator.class);
-        doNothing().when(section).execute(any(CommandSender.class), anyList());
-        // Mockito throws a runtime error if below we use the usual "given(factory.newInstance(...)).willReturn(...)"
-        doReturn(section).when(debugSectionFactory).newInstance(InputValidator.class);
-
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(sender, section.getRequiredPermission())).willReturn(true);
-        List<String> arguments = Arrays.asList(section.getName().toUpperCase(Locale.ROOT), "test", "toast");
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        verify(permissionsManager).hasPermission(sender, section.getRequiredPermission());
-        verify(section).execute(sender, Arrays.asList("test", "toast"));
-    }
-
-    @Test
-    public void shouldNotRunSectionForMissingPermission() {
-        // given
-        DebugSection section = spy(InputValidator.class);
-        // Mockito throws a runtime error if below we use the usual "given(factory.newInstance(...)).willReturn(...)"
-        doReturn(section).when(debugSectionFactory).newInstance(InputValidator.class);
-
-        CommandSender sender = mock(CommandSender.class);
-        given(permissionsManager.hasPermission(sender, section.getRequiredPermission())).willReturn(false);
-        List<String> arguments = Arrays.asList(section.getName().toUpperCase(Locale.ROOT), "test");
-
-        // when
-        command.executeCommand(sender, arguments);
-
-        // then
-        verify(permissionsManager).hasPermission(sender, section.getRequiredPermission());
-        verify(section, never()).execute(any(CommandSender.class), anyList());
-        verify(sender).sendMessage(argThat(containsString("You don't have permission")));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionConsistencyTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionConsistencyTest.java
deleted file mode 100644
index ea92f85e..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionConsistencyTest.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.lang.reflect.Modifier;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Consistency tests for {@link DebugSection} implementors.
- */
-public class DebugSectionConsistencyTest {
-
-    private static List<Class<?>> debugClasses;
-    private static List<DebugSection> debugSections;
-
-    @BeforeClass
-    public static void collectClasses() {
-        // TODO ljacqu 20171021: Improve ClassCollector (pass pkg by class, improve #getInstancesOfType's instantiation)
-        ClassCollector classCollector = new ClassCollector(
-            TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT + "command/executable/authme/debug");
-
-        debugClasses = classCollector.collectClasses();
-        debugSections = classCollector.getInstancesOfType(DebugSection.class, clz -> instantiate(clz));
-    }
-
-    @Test
-    public void shouldAllBePackagePrivate() {
-        for (Class<?> clazz : debugClasses) {
-            if (clazz != DebugCommand.class) {
-                assertThat(clazz + " should be package-private",
-                    Modifier.isPublic(clazz.getModifiers()), equalTo(false));
-            }
-        }
-    }
-
-    @Test
-    public void shouldHaveDifferentSubcommandName() throws IllegalAccessException, InstantiationException {
-        Set<String> names = new HashSet<>();
-        for (DebugSection debugSection : debugSections) {
-            if (!names.add(debugSection.getName())) {
-                fail("Encountered name '" + debugSection.getName() + "' a second time in " + debugSection.getClass());
-            }
-        }
-    }
-
-    @Test
-    public void shouldAllHaveDescription() {
-        for (DebugSection debugSection : debugSections) {
-            assertThat("Description of '" + debugSection.getClass() + "' may not be null",
-                debugSection.getDescription(), not(nullValue()));
-        }
-    }
-
-    private static DebugSection instantiate(Class<? extends DebugSection> clazz) {
-        try {
-            return ClassCollector.canInstantiate(clazz) ? clazz.newInstance() : null;
-        } catch (InstantiationException | IllegalAccessException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionUtilsTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionUtilsTest.java
deleted file mode 100644
index 1157663b..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionUtilsTest.java
+++ /dev/null
@@ -1,125 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.data.limbo.LimboPlayer;
-import fr.xephi.authme.data.limbo.LimboService;
-import fr.xephi.authme.datasource.CacheDataSource;
-import fr.xephi.authme.datasource.DataSource;
-import org.bukkit.Location;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.Function;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.hamcrest.Matchers.sameInstance;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link DebugSectionUtils}.
- */
-public class DebugSectionUtilsTest {
-
-    @Before
-    public void initMockLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldFormatLocation() {
-        // given / when
-        String result = DebugSectionUtils.formatLocation(0.0, 10.248592, -18934.2349023, "Main");
-
-        // then
-        assertThat(result, equalTo("(0, 10.25, -18934.23) in 'Main'"));
-    }
-
-    @Test
-    public void shouldHandleNullWorld() {
-        // given
-        Location location = new Location(null, 3.7777, 2.14156, 1);
-
-        // when
-        String result = DebugSectionUtils.formatLocation(location);
-
-        // then
-        assertThat(result, equalTo("(3.78, 2.14, 1) in 'null'"));
-    }
-
-    @Test
-    public void shouldHandleNullLocation() {
-        // given / when / then
-        assertThat(DebugSectionUtils.formatLocation(null), equalTo("null"));
-    }
-
-    @Test
-    public void shouldFetchMapInLimboService() {
-        // given
-        LimboService limboService = mock(LimboService.class);
-        Map<String, LimboPlayer> limboMap = new HashMap<>();
-        ReflectionTestUtils.setField(LimboService.class, limboService, "entries", limboMap);
-
-        // when
-        Map map = DebugSectionUtils.applyToLimboPlayersMap(limboService, Function.identity());
-
-        // then
-        assertThat(map, sameInstance(limboMap));
-    }
-
-    @Test
-    public void shouldHandleErrorGracefully() {
-        // given
-        LimboService limboService = mock(LimboService.class);
-        Map<String, LimboPlayer> limboMap = new HashMap<>();
-        ReflectionTestUtils.setField(LimboService.class, limboService, "entries", limboMap);
-
-        // when
-        Object result = DebugSectionUtils.applyToLimboPlayersMap(limboService, map -> {
-           throw new IllegalStateException();
-        });
-
-        // then
-        assertThat(result, nullValue());
-    }
-
-    @Test
-    public void shouldReturnSameDataSourceInstance() {
-        // given
-        DataSource dataSource = mock(DataSource.class);
-
-        // when
-        DataSource result = DebugSectionUtils.unwrapSourceFromCacheDataSource(dataSource);
-
-        // then
-        assertThat(result, equalTo(dataSource));
-    }
-
-    @Test
-    public void shouldUnwrapCacheDataSource() {
-        // given
-        DataSource source = mock(DataSource.class);
-        PlayerCache playerCache = mock(PlayerCache.class);
-        CacheDataSource cacheDataSource = new CacheDataSource(source, playerCache);
-
-        // when
-        DataSource result = DebugSectionUtils.unwrapSourceFromCacheDataSource(cacheDataSource);
-
-        // then
-        assertThat(result, equalTo(source));
-    }
-
-    @Test
-    public void shouldCastOrReturnNull() {
-        // given / when / then
-        assertThat(DebugSectionUtils.castToTypeOrNull("test", String.class), equalTo("test"));
-        assertThat(DebugSectionUtils.castToTypeOrNull("test", Integer.class), nullValue());
-        assertThat(DebugSectionUtils.castToTypeOrNull(5, String.class), nullValue());
-        assertThat(DebugSectionUtils.castToTypeOrNull(5, Integer.class), equalTo(5));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/HasPermissionCheckerTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/HasPermissionCheckerTest.java
deleted file mode 100644
index 4bd8eab1..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/HasPermissionCheckerTest.java
+++ /dev/null
@@ -1,96 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.permission.AdminPermission;
-import fr.xephi.authme.permission.PermissionNode;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.service.BukkitService;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static java.util.Arrays.asList;
-import static java.util.Collections.emptyList;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link HasPermissionChecker}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class HasPermissionCheckerTest {
-
-    @InjectMocks
-    private HasPermissionChecker hasPermissionChecker;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Test
-    public void shouldListAllPermissionNodeClasses() {
-        // given
-        List<Class<? extends PermissionNode>> permissionClasses =
-            new ClassCollector(TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT)
-                .collectClasses(PermissionNode.class).stream()
-                .filter(clz -> !clz.isInterface())
-                .collect(Collectors.toList());
-
-        // when / then
-        assertThat(HasPermissionChecker.PERMISSION_NODE_CLASSES, containsInAnyOrder(permissionClasses.toArray()));
-    }
-
-    @Test
-    public void shouldShowUsageInfo() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        hasPermissionChecker.execute(sender, emptyList());
-
-        // then
-        ArgumentCaptor<String> msgCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, atLeast(2)).sendMessage(msgCaptor.capture());
-        assertThat(
-            msgCaptor.getAllValues().stream().anyMatch(msg -> msg.contains("/authme debug perm bobby my.perm.node")),
-            equalTo(true));
-    }
-
-    @Test
-    public void shouldShowSuccessfulTestWithRegularPlayer() {
-        // given
-        String name = "Chuck";
-        Player player = mock(Player.class);
-        given(bukkitService.getPlayerExact(name)).willReturn(player);
-        PermissionNode permission = AdminPermission.CHANGE_EMAIL;
-        given(permissionsManager.hasPermission(player, permission)).willReturn(true);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        hasPermissionChecker.execute(sender, asList(name, permission.getNode()));
-
-        // then
-        verify(bukkitService).getPlayerExact(name);
-        verify(permissionsManager).hasPermission(player, permission);
-        verify(sender).sendMessage(argThat(containsString("Success: player '" + player.getName()
-            + "' has permission '" + permission.getNode() + "'")));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/MySqlDefaultChangerColumnsTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/MySqlDefaultChangerColumnsTest.java
deleted file mode 100644
index df891fe6..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/MySqlDefaultChangerColumnsTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Consistency test for {@link MySqlDefaultChanger.Columns} enum.
- */
-public class MySqlDefaultChangerColumnsTest {
-
-    @Test
-    public void shouldAllHaveDifferentNameProperty() {
-        // given
-        Set<String> properties = new HashSet<>();
-
-        // when / then
-        for (MySqlDefaultChanger.Columns col : MySqlDefaultChanger.Columns.values()) {
-            if (!properties.add(col.getColumnNameProperty().getPath())) {
-                fail("Column '" + col + "' has a column name property path that was already encountered: "
-                    + col.getColumnNameProperty().getPath());
-            }
-        }
-    }
-
-    @Test
-    public void shouldHaveMatchingNullableAndNotNullDefinition() {
-        for (MySqlDefaultChanger.Columns col : MySqlDefaultChanger.Columns.values()) {
-            verifyHasCorrespondingColumnDefinitions(col);
-        }
-    }
-
-    @Test
-    public void shouldHaveMatchingDefaultValueInNotNullDefinition() {
-        for (MySqlDefaultChanger.Columns col : MySqlDefaultChanger.Columns.values()) {
-            verifyHasSameDefaultValueInNotNullDefinition(col);
-        }
-    }
-
-    private void verifyHasCorrespondingColumnDefinitions(MySqlDefaultChanger.Columns column) {
-        // given / when
-        String nullable = column.getNullableDefinition();
-        String notNull = column.getNotNullDefinition();
-
-        // then
-        String expectedNotNull = nullable + " NOT NULL DEFAULT ";
-        assertThat(column.name(), notNull.startsWith(expectedNotNull), equalTo(true));
-        // Check that `notNull` length is bigger because we expect a value after DEFAULT
-        assertThat(column.name(), notNull.length() > expectedNotNull.length(), equalTo(true));
-    }
-
-    private void verifyHasSameDefaultValueInNotNullDefinition(MySqlDefaultChanger.Columns column) {
-        // given / when
-        String notNull = column.getNotNullDefinition();
-        Object defaultValue = column.getDefaultValue();
-
-        // then
-        String defaultValueAsString = String.valueOf(defaultValue);
-        if (!notNull.endsWith("DEFAULT " + defaultValueAsString)
-                && !notNull.endsWith("DEFAULT '" + defaultValueAsString + "'")) {
-            fail("Expected '" + column + "' not-null definition to contain DEFAULT " + defaultValueAsString);
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/MySqlDefaultChangerTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/MySqlDefaultChangerTest.java
deleted file mode 100644
index 516d1678..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/MySqlDefaultChangerTest.java
+++ /dev/null
@@ -1,98 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import com.zaxxer.hikari.HikariDataSource;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.CacheDataSource;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.datasource.MySQL;
-import fr.xephi.authme.datasource.SqlDataSourceTestUtil;
-import fr.xephi.authme.settings.Settings;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-
-import static org.hamcrest.Matchers.equalTo;
-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;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link MySqlDefaultChanger}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class MySqlDefaultChangerTest {
-
-    @Mock
-    private Settings settings;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldReturnMySqlConnection() throws SQLException {
-        // given
-        Settings settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-        HikariDataSource dataSource = mock(HikariDataSource.class);
-        Connection connection = mock(Connection.class);
-        given(dataSource.getConnection()).willReturn(connection);
-        MySQL mySQL = SqlDataSourceTestUtil.createMySql(settings, dataSource);
-        MySqlDefaultChanger defaultChanger = createDefaultChanger(mySQL);
-
-        // when
-        Connection result = defaultChanger.getConnection(mySQL);
-
-        // then
-        assertThat(result, equalTo(connection));
-        verify(dataSource).getConnection();
-    }
-
-    @Test
-    public void shouldSetMySqlFieldOnInitialization() {
-        // given
-        MySQL mySql = mock(MySQL.class);
-        MySqlDefaultChanger defaultChanger = createDefaultChanger(mySql);
-
-        // when
-        defaultChanger.setMySqlField();
-
-        // then
-        assertThat(ReflectionTestUtils.getFieldValue(MySqlDefaultChanger.class, defaultChanger, "mySql"),
-            sameInstance(mySql));
-    }
-
-    @Test
-    public void shouldLeaveMySqlFieldToNullOnInitialization() {
-        // given
-        DataSource dataSource = mock(DataSource.class);
-        PlayerCache playerCache = mock(PlayerCache.class);
-        CacheDataSource cacheDataSource = new CacheDataSource(dataSource, playerCache);
-        MySqlDefaultChanger defaultChanger = createDefaultChanger(cacheDataSource);
-
-        // when
-        defaultChanger.setMySqlField();
-
-        // then
-        assertThat(ReflectionTestUtils.getFieldValue(MySqlDefaultChanger.class, defaultChanger, "mySql"),
-            nullValue());
-    }
-
-    private MySqlDefaultChanger createDefaultChanger(DataSource dataSource) {
-        MySqlDefaultChanger defaultChanger = new MySqlDefaultChanger();
-        ReflectionTestUtils.setField(defaultChanger, "dataSource", dataSource);
-        ReflectionTestUtils.setField(defaultChanger, "settings", settings);
-        return defaultChanger;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/authme/debug/PlayerAuthViewerTest.java b/src/test/java/fr/xephi/authme/command/executable/authme/debug/PlayerAuthViewerTest.java
deleted file mode 100644
index 8f34bcbf..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/authme/debug/PlayerAuthViewerTest.java
+++ /dev/null
@@ -1,106 +0,0 @@
-package fr.xephi.authme.command.executable.authme.debug;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.hasItem;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PlayerAuthViewer}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PlayerAuthViewerTest {
-
-    @InjectMocks
-    private PlayerAuthViewer authViewer;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Test
-    public void shouldMakeExample() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        authViewer.execute(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Example: /authme debug db Bobby")));
-    }
-
-    @Test
-    public void shouldHandleMissingPlayer() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        authViewer.execute(sender, Collections.singletonList("bogus"));
-
-        // then
-        verify(dataSource).getAuth("bogus");
-        verify(sender).sendMessage(argThat(containsString("No record exists for 'bogus'")));
-    }
-
-    @Test
-    public void shouldDisplayAuthInfo() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerAuth auth = PlayerAuth.builder().name("george").realName("George")
-            .password("abcdefghijkl", "mnopqrst")
-            .lastIp("127.1.2.7").registrationDate(1111140000000L)
-            .totpKey("SECRET1321")
-            .build();
-        given(dataSource.getAuth("George")).willReturn(auth);
-
-        // when
-        authViewer.execute(sender, Collections.singletonList("George"));
-
-        // then
-        ArgumentCaptor<String> textCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, atLeastOnce()).sendMessage(textCaptor.capture());
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("Player george / George")));
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("Registration: 2005-03-18T")));
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("Hash / salt (partial): 'abcdef...' / 'mnop...'")));
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("TOTP code (partial): 'SEC...'")));
-    }
-
-    @Test
-    public void shouldHandleCornerCases() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        PlayerAuth auth = PlayerAuth.builder().name("tar")
-            .password("abcd", null)
-            .lastIp("127.1.2.7").registrationDate(0L)
-            .build();
-        given(dataSource.getAuth("Tar")).willReturn(auth);
-
-        // when
-        authViewer.execute(sender, Collections.singletonList("Tar"));
-
-        // then
-        ArgumentCaptor<String> textCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sender, atLeastOnce()).sendMessage(textCaptor.capture());
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("Player tar / Player")));
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("Registration: Not available (0)")));
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("Last login: Not available (null)")));
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("Hash / salt (partial): 'ab...' / ''")));
-        assertThat(textCaptor.getAllValues(), hasItem(containsString("TOTP code (partial): ''")));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/captcha/CaptchaCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/captcha/CaptchaCommandTest.java
deleted file mode 100644
index 9f47dfae..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/captcha/CaptchaCommandTest.java
+++ /dev/null
@@ -1,190 +0,0 @@
-package fr.xephi.authme.command.executable.captcha;
-
-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;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-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.verifyNoMoreInteractions;
-
-/**
- * Test for {@link CaptchaCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class CaptchaCommandTest {
-
-    @InjectMocks
-    private CaptchaCommand command;
-
-    @Mock
-    private LoginCaptchaManager loginCaptchaManager;
-
-    @Mock
-    private RegistrationCaptchaManager registrationCaptchaManager;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private LimboService limboService;
-
-    @Mock
-    private DataSource dataSource;
-
-    @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"));
-
-        // then
-        verify(commonService).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(loginCaptchaManager.isCaptchaRequired(name)).willReturn(false);
-        given(dataSource.isAuthAvailable(name)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.singletonList("1234"));
-
-        // then
-        verify(commonService).send(player, MessageKey.USAGE_LOGIN);
-        verify(loginCaptchaManager).isCaptchaRequired(name);
-        verifyNoMoreInteractions(loginCaptchaManager, registrationCaptchaManager);
-    }
-
-    @Test
-    public void shouldHandleCorrectCaptchaInput() {
-        // given
-        String name = "smith";
-        Player player = mockPlayerWithName(name);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        given(loginCaptchaManager.isCaptchaRequired(name)).willReturn(true);
-        String captchaCode = "3991";
-        given(loginCaptchaManager.checkCode(player, captchaCode)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(captchaCode));
-
-        // then
-        verify(loginCaptchaManager).isCaptchaRequired(name);
-        verify(loginCaptchaManager).checkCode(player, captchaCode);
-        verifyNoMoreInteractions(loginCaptchaManager);
-        verify(commonService).send(player, MessageKey.CAPTCHA_SUCCESS);
-        verify(commonService).send(player, MessageKey.LOGIN_MESSAGE);
-        verify(limboService).unmuteMessageTask(player);
-        verifyNoMoreInteractions(commonService);
-    }
-
-    @Test
-    public void shouldHandleWrongCaptchaInput() {
-        // given
-        String name = "smith";
-        Player player = mockPlayerWithName(name);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        given(loginCaptchaManager.isCaptchaRequired(name)).willReturn(true);
-        String captchaCode = "2468";
-        given(loginCaptchaManager.checkCode(player, captchaCode)).willReturn(false);
-        String newCode = "1337";
-        given(loginCaptchaManager.getCaptchaCodeOrGenerateNew(name)).willReturn(newCode);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(captchaCode));
-
-        // then
-        verify(loginCaptchaManager).isCaptchaRequired(name);
-        verify(loginCaptchaManager).checkCode(player, captchaCode);
-        verify(loginCaptchaManager).getCaptchaCodeOrGenerateNew(name);
-        verifyNoMoreInteractions(loginCaptchaManager);
-        verify(commonService).send(player, MessageKey.CAPTCHA_WRONG_ERROR, newCode);
-        verifyNoMoreInteractions(commonService);
-    }
-
-    @Test
-    public void shouldVerifyWithRegisterCaptchaManager() {
-        // given
-        String name = "john";
-        Player player = mockPlayerWithName(name);
-        given(loginCaptchaManager.isCaptchaRequired(name)).willReturn(false);
-        given(registrationCaptchaManager.isCaptchaRequired(name)).willReturn(true);
-        String captchaCode = "A89Y3";
-        given(registrationCaptchaManager.checkCode(player, captchaCode)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(captchaCode));
-
-        // then
-        verify(registrationCaptchaManager).checkCode(player, captchaCode);
-        verify(loginCaptchaManager, only()).isCaptchaRequired(name);
-        verify(commonService).send(player, MessageKey.REGISTER_CAPTCHA_SUCCESS);
-        verify(commonService).send(player, MessageKey.REGISTER_MESSAGE);
-    }
-
-    @Test
-    public void shouldHandleFailedRegisterCaptcha() {
-        // given
-        String name = "asfd";
-        Player player = mockPlayerWithName(name);
-        given(registrationCaptchaManager.isCaptchaRequired(name)).willReturn(true);
-        String captchaCode = "SFL3";
-        given(registrationCaptchaManager.checkCode(player, captchaCode)).willReturn(false);
-        given(registrationCaptchaManager.getCaptchaCodeOrGenerateNew(name)).willReturn("new code");
-
-        // when
-        command.executeCommand(player, Collections.singletonList(captchaCode));
-
-        // then
-        verify(registrationCaptchaManager).checkCode(player, captchaCode);
-        verify(registrationCaptchaManager).getCaptchaCodeOrGenerateNew(name);
-        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);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/changepassword/ChangePasswordCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/changepassword/ChangePasswordCommandTest.java
deleted file mode 100644
index 4c5488cb..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/changepassword/ChangePasswordCommandTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package fr.xephi.authme.command.executable.changepassword;
-
-import fr.xephi.authme.data.VerificationCodeManager;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.service.ValidationService.ValidationResult;
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-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 java.util.Arrays;
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.eq;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link ChangePasswordCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ChangePasswordCommandTest {
-
-    @InjectMocks
-    private ChangePasswordCommand command;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private VerificationCodeManager codeManager;
-
-    @Mock
-    private ValidationService validationService;
-
-    @Mock
-    private Management management;
-
-    @Test
-    public void shouldRejectNonPlayerSender() {
-        // given
-        CommandSender sender = mock(BlockCommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("use /authme password <playername> <password> instead")));
-    }
-
-    @Test
-    public void shouldRejectNotLoggedInPlayer() {
-        // given
-        CommandSender sender = initPlayerWithName("name", false);
-
-        // when
-        command.executeCommand(sender, Arrays.asList("pass", "pass"));
-
-        // then
-        verify(commonService).send(sender, MessageKey.NOT_LOGGED_IN);
-    }
-
-    @Test
-    public void shouldRejectInvalidPassword() {
-        // given
-        Player sender = initPlayerWithName("abc12", true);
-        String password = "newPW";
-        given(validationService.validatePassword(password, "abc12")).willReturn(new ValidationResult(MessageKey.INVALID_PASSWORD_LENGTH));
-        given(codeManager.isVerificationRequired(sender)).willReturn(false);
-
-        // when
-        command.executeCommand(sender, Arrays.asList("tester", password));
-
-        // then
-        verify(validationService).validatePassword(password, "abc12");
-        verify(commonService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH, new String[0]);
-        verify(codeManager).isVerificationRequired(sender);
-    }
-
-    @Test
-    public void shouldForwardTheDataForValidPassword() {
-        // given
-        String oldPass = "oldpass";
-        String newPass = "abc123";
-        Player player = initPlayerWithName("parker", true);
-        given(validationService.validatePassword("abc123", "parker")).willReturn(new ValidationResult());
-        given(codeManager.isVerificationRequired(player)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Arrays.asList(oldPass, newPass));
-
-        // then
-        verify(validationService).validatePassword(newPass, "parker");
-        verify(commonService, never()).send(eq(player), any(MessageKey.class));
-        verify(management).performPasswordChange(player, oldPass, newPass);
-        verify(codeManager).isVerificationRequired(player);
-    }
-
-    @Test
-    public void shouldDefineArgumentMismatchMessage() {
-        // given / when / then
-        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_CHANGE_PASSWORD));
-    }
-
-    private Player initPlayerWithName(String name, boolean loggedIn) {
-        Player player = mock(Player.class);
-        when(player.getName()).thenReturn(name);
-        when(playerCache.isAuthenticated(name)).thenReturn(loggedIn);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java
deleted file mode 100644
index c8a57562..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java
+++ /dev/null
@@ -1,83 +0,0 @@
-package fr.xephi.authme.command.executable.email;
-
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-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 java.util.Arrays;
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link AddEmailCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AddEmailCommandTest {
-
-    @InjectMocks
-    private AddEmailCommand command;
-
-    @Mock
-    private CommonService commandService;
-
-    @Mock
-    private Management management;
-
-    @Test
-    public void shouldRejectNonPlayerSender() {
-        // given
-        CommandSender sender = mock(BlockCommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldForwardData() {
-        // given
-        Player sender = mock(Player.class);
-        String email = "mail@example";
-
-        // when
-        command.executeCommand(sender, Arrays.asList(email, email));
-
-        // then
-        verify(management).performAddEmail(sender, email);
-    }
-
-    @Test
-    public void shouldFailForConfirmationMismatch() {
-        // given
-        Player sender = mock(Player.class);
-        String email = "asdfasdf@example.com";
-
-        // when
-        command.executeCommand(sender, Arrays.asList(email, "wrongConf"));
-
-        // then
-        verifyNoInteractions(management);
-        verify(commandService).send(sender, MessageKey.CONFIRM_EMAIL_MESSAGE);
-    }
-
-    @Test
-    public void shouldDefineArgumentMismatchMessage() {
-        // given / when / then
-        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_ADD_EMAIL));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/email/ChangeEmailCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/email/ChangeEmailCommandTest.java
deleted file mode 100644
index 3c99e17d..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/email/ChangeEmailCommandTest.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package fr.xephi.authme.command.executable.email;
-
-import fr.xephi.authme.data.VerificationCodeManager;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-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 java.util.Arrays;
-import java.util.Collections;
-
-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;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.when;
-
-/**
- * Test for {@link ChangeEmailCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ChangeEmailCommandTest {
-
-    @InjectMocks
-    private ChangeEmailCommand command;
-
-    @Mock
-    private Management management;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private VerificationCodeManager codeManager;
-
-
-    @Test
-    public void shouldRejectNonPlayerSender() {
-        // given
-        CommandSender sender = mock(BlockCommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldStopIfVerificationIsRequired() {
-        // given
-        String name = "Testeroni";
-        Player player = initPlayerWithName(name);
-        given(codeManager.isVerificationRequired(player)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Arrays.asList("mail@example.org", "otherMail@example.com"));
-
-        // then
-        verify(codeManager).codeExistOrGenerateNew(name);
-        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_REQUIRED);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldForwardData() {
-        // given
-        Player sender = initPlayerWithName("AmATest");
-        given(codeManager.isVerificationRequired(sender)).willReturn(false);
-
-        // when
-        command.executeCommand(sender, Arrays.asList("new.mail@example.org", "old_mail@example.org"));
-
-        // then
-        verify(management).performChangeEmail(sender, "new.mail@example.org", "old_mail@example.org");
-        verify(codeManager).isVerificationRequired(sender);
-    }
-
-    @Test
-    public void shouldDefineArgumentMismatchMessage() {
-        // given / when / then
-        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_CHANGE_EMAIL));
-    }
-
-    private Player initPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        when(player.getName()).thenReturn(name);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/email/EmailBaseCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/email/EmailBaseCommandTest.java
deleted file mode 100644
index 7ca0aff9..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/email/EmailBaseCommandTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package fr.xephi.authme.command.executable.email;
-
-import fr.xephi.authme.command.CommandMapper;
-import fr.xephi.authme.command.FoundCommandResult;
-import fr.xephi.authme.command.help.HelpProvider;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.mockito.ArgumentMatchers.anyList;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link EmailBaseCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class EmailBaseCommandTest {
-
-    @InjectMocks
-    private EmailBaseCommand command;
-
-    @Mock
-    private HelpProvider helpProvider;
-    @Mock
-    private CommandMapper commandMapper;
-
-    @Test
-    public void shouldDisplayHelp() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        FoundCommandResult result = mock(FoundCommandResult.class);
-        given(commandMapper.mapPartsToCommand(eq(sender), anyList())).willReturn(result);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(commandMapper).mapPartsToCommand(sender, Collections.singletonList("email"));
-        verify(helpProvider).outputHelp(sender, result, HelpProvider.SHOW_CHILDREN);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/email/EmailSetPasswordCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/email/EmailSetPasswordCommandTest.java
deleted file mode 100644
index a0338492..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/email/EmailSetPasswordCommandTest.java
+++ /dev/null
@@ -1,108 +0,0 @@
-package fr.xephi.authme.command.executable.email;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.security.PasswordSecurity;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.PasswordRecoveryService;
-import fr.xephi.authme.service.ValidationService;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.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.verifyNoInteractions;
-
-/**
- * Tests for {@link EmailSetPasswordCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class EmailSetPasswordCommandTest {
-
-    @InjectMocks
-    private EmailSetPasswordCommand command;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private PasswordRecoveryService recoveryService;
-
-    @Mock
-    private PasswordSecurity passwordSecurity;
-
-    @Mock
-    private ValidationService validationService;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldChangePassword() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Jerry";
-        given(player.getName()).willReturn(name);
-        given(recoveryService.canChangePassword(player)).willReturn(true);
-        HashedPassword hashedPassword = passwordSecurity.computeHash("abc123", name);
-        given(passwordSecurity.computeHash("abc123", name)).willReturn(hashedPassword);
-        given(validationService.validatePassword("abc123", name))
-            .willReturn(new ValidationService.ValidationResult());
-
-        // when
-        command.runCommand(player, Collections.singletonList("abc123"));
-
-        // then
-        verify(validationService).validatePassword("abc123", name);
-        verify(dataSource).updatePassword(name, hashedPassword);
-        verify(recoveryService).removeFromSuccessfulRecovery(player);
-        verify(commonService).send(player, MessageKey.PASSWORD_CHANGED_SUCCESS);
-    }
-
-    @Test
-    public void shouldRejectInvalidPassword() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Morgan";
-        given(player.getName()).willReturn(name);
-        String password = "newPW";
-        given(validationService.validatePassword(password, name))
-            .willReturn(new ValidationService.ValidationResult(MessageKey.INVALID_PASSWORD_LENGTH));
-        given(recoveryService.canChangePassword(player)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(password));
-
-        // then
-        verify(validationService).validatePassword(password, name);
-        verify(commonService).send(player, MessageKey.INVALID_PASSWORD_LENGTH, new String[0]);
-    }
-
-    @Test
-    public void shouldDoNothingCantChangePass() {
-        // given
-        Player player = mock(Player.class);
-
-        // when
-        command.runCommand(player, Collections.singletonList("abc123"));
-
-        // then
-        verifyNoInteractions(validationService, dataSource);
-        verify(commonService).send(player, MessageKey.CHANGE_PASSWORD_EXPIRED);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/email/ProcessCodeCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/email/ProcessCodeCommandTest.java
deleted file mode 100644
index b5790cc4..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/email/ProcessCodeCommandTest.java
+++ /dev/null
@@ -1,92 +0,0 @@
-package fr.xephi.authme.command.executable.email;
-
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.PasswordRecoveryService;
-import fr.xephi.authme.service.RecoveryCodeService;
-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 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;
-
-/**
- * Tests for {@link ProcessCodeCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ProcessCodeCommandTest {
-
-    @InjectMocks
-    private ProcessCodeCommand command;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private RecoveryCodeService codeService;
-
-    @Mock
-    private PasswordRecoveryService recoveryService;
-
-    @Test
-    public void shouldSendErrorForInvalidRecoveryCode() {
-        // given
-        String name = "Vultur3";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(codeService.hasTriesLeft(name)).willReturn(true);
-        given(codeService.isCodeValid(name, "bogus")).willReturn(false);
-        given(codeService.getTriesLeft(name)).willReturn(2);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("bogus"));
-
-        // then
-        verify(commonService).send(sender, MessageKey.INCORRECT_RECOVERY_CODE, "2");
-        verifyNoMoreInteractions(recoveryService);
-    }
-
-    @Test
-    public void shouldSendErrorForNoMoreTries() {
-        // given
-        String name = "BobbY";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(codeService.hasTriesLeft(name)).willReturn(false);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("bogus"));
-
-        // then
-        verify(commonService).send(sender, MessageKey.RECOVERY_TRIES_EXCEEDED);
-        verify(codeService).removeCode(name);
-        verifyNoMoreInteractions(recoveryService);
-    }
-
-    @Test
-    public void shouldProcessCorrectCode() {
-        // given
-        String name = "Dwight";
-        String code = "chickenDinner";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(codeService.hasTriesLeft(name)).willReturn(true);
-        given(codeService.isCodeValid(name, code)).willReturn(true);
-
-        // when
-        command.runCommand(sender, Collections.singletonList(code));
-
-        // then
-        verify(commonService).send(sender, MessageKey.RECOVERY_CODE_CORRECT);
-        verify(recoveryService).addSuccessfulRecovery(sender);
-        verify(codeService).removeCode(name);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/email/RecoverEmailCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/email/RecoverEmailCommandTest.java
deleted file mode 100644
index 06ce4ee5..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/email/RecoverEmailCommandTest.java
+++ /dev/null
@@ -1,227 +0,0 @@
-package fr.xephi.authme.command.executable.email;
-
-import ch.jalu.datasourcecolumns.data.DataSourceValueImpl;
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.mail.EmailService;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.security.PasswordSecurity;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.PasswordRecoveryService;
-import fr.xephi.authme.service.RecoveryCodeService;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.util.Collections;
-import java.util.Locale;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToRunTaskAsynchronously;
-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.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link RecoverEmailCommand}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class RecoverEmailCommandTest {
-
-    private static final String DEFAULT_EMAIL = "your@email.com";
-
-    @InjectDelayed
-    private RecoverEmailCommand command;
-
-    @Mock
-    private PasswordSecurity passwordSecurity;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private EmailService emailService;
-
-    @Mock
-    private PasswordRecoveryService recoveryService;
-    
-    @Mock
-    private RecoveryCodeService recoveryCodeService;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    public void initSettings() {
-        given(commonService.getProperty(SecuritySettings.EMAIL_RECOVERY_COOLDOWN_SECONDS)).willReturn(40);
-    }
-
-    @Test
-    public void shouldHandleMissingMailProperties() {
-        // given
-        given(emailService.hasAllInformation()).willReturn(false);
-        Player sender = mock(Player.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("some@email.tld"));
-
-        // then
-        verify(commonService).send(sender, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
-        verifyNoInteractions(dataSource, passwordSecurity);
-    }
-
-    @Test
-    public void shouldShowErrorForAuthenticatedUser() {
-        // given
-        String name = "Bobby";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(emailService.hasAllInformation()).willReturn(true);
-        given(playerCache.isAuthenticated(name)).willReturn(true);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("bobby@example.org"));
-
-        // then
-        verify(emailService).hasAllInformation();
-        verifyNoInteractions(dataSource);
-        verify(commonService).send(sender, MessageKey.ALREADY_LOGGED_IN_ERROR);
-    }
-
-    @Test
-    public void shouldShowRegisterMessageForUnregisteredPlayer() {
-        // given
-        String name = "Player123";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(emailService.hasAllInformation()).willReturn(true);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        given(dataSource.getEmail(name)).willReturn(DataSourceValueImpl.unknownRow());
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("someone@example.com"));
-
-        // then
-        verify(emailService).hasAllInformation();
-        verify(dataSource).getEmail(name);
-        verifyNoMoreInteractions(dataSource);
-        verify(commonService).send(sender, MessageKey.USAGE_REGISTER);
-    }
-
-    @Test
-    public void shouldHandleDefaultEmail() {
-        // given
-        String name = "Tract0r";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(emailService.hasAllInformation()).willReturn(true);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        given(dataSource.getEmail(name)).willReturn(DataSourceValueImpl.of(DEFAULT_EMAIL));
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(DEFAULT_EMAIL));
-
-        // then
-        verify(emailService).hasAllInformation();
-        verify(dataSource).getEmail(name);
-        verifyNoMoreInteractions(dataSource);
-        verify(commonService).send(sender, MessageKey.INVALID_EMAIL);
-    }
-
-    @Test
-    public void shouldHandleInvalidEmailInput() {
-        // given
-        String name = "Rapt0r";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(emailService.hasAllInformation()).willReturn(true);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        given(dataSource.getEmail(name)).willReturn(DataSourceValueImpl.of("raptor@example.org"));
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("wrong-email@example.com"));
-
-        // then
-        verify(emailService).hasAllInformation();
-        verify(dataSource).getEmail(name);
-        verifyNoMoreInteractions(dataSource);
-        verify(commonService).send(sender, MessageKey.INVALID_EMAIL);
-    }
-
-    @Test
-    public void shouldGenerateRecoveryCode() {
-        // given
-        String name = "Vultur3";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(emailService.hasAllInformation()).willReturn(true);
-        given(emailService.sendRecoveryCode(anyString(), anyString(), anyString())).willReturn(true);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        String email = "v@example.com";
-        given(dataSource.getEmail(name)).willReturn(DataSourceValueImpl.of(email));
-        String code = "a94f37";
-        given(recoveryCodeService.isRecoveryCodeNeeded()).willReturn(true);
-        given(recoveryCodeService.generateCode(name)).willReturn(code);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(email.toUpperCase(Locale.ROOT)));
-
-        // then
-        verify(emailService).hasAllInformation();
-        verify(dataSource).getEmail(name);
-        verify(recoveryService).createAndSendRecoveryCode(sender, email);
-    }
-
-    @Test
-    public void shouldGenerateNewPasswordWithoutRecoveryCode() {
-        // given
-        String name = "Vultur3";
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(name);
-        given(emailService.hasAllInformation()).willReturn(true);
-        given(emailService.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        String email = "vulture@example.com";
-        given(dataSource.getEmail(name)).willReturn(DataSourceValueImpl.of(email));
-        given(recoveryCodeService.isRecoveryCodeNeeded()).willReturn(false);
-        setBukkitServiceToRunTaskAsynchronously(bukkitService);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList(email));
-
-        // then
-        verify(emailService).hasAllInformation();
-        verify(dataSource).getEmail(name);
-        verify(recoveryService).generateAndSendNewPassword(sender, email);
-    }
-
-    @Test
-    public void shouldDefineArgumentMismatchMessage() {
-        // given / when / then
-        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_RECOVER_EMAIL));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/email/ShowEmailCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/email/ShowEmailCommandTest.java
deleted file mode 100644
index 36e106ed..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/email/ShowEmailCommandTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package fr.xephi.authme.command.executable.email;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-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 java.util.Collections;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link ShowEmailCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ShowEmailCommandTest {
-
-    private static final String CURRENT_EMAIL = "my.email@example.com";
-    private static final String USERNAME = "name";
-
-    @InjectMocks
-    private ShowEmailCommand command;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Test
-    public void shouldShowCurrentEmailMessage() {
-        // given
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(USERNAME);
-        given(playerCache.getAuth(USERNAME)).willReturn(newAuthWithEmail(CURRENT_EMAIL));
-        given(commonService.getProperty(SecuritySettings.USE_EMAIL_MASKING)).willReturn(false);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(commonService).send(sender, MessageKey.EMAIL_SHOW, CURRENT_EMAIL);
-    }
-
-    @Test
-    public void shouldShowHiddenEmailMessage() {
-        // given
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(USERNAME);
-        given(playerCache.getAuth(USERNAME)).willReturn(newAuthWithEmail(CURRENT_EMAIL));
-        given(commonService.getProperty(SecuritySettings.USE_EMAIL_MASKING)).willReturn(true);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(commonService).send(sender, MessageKey.EMAIL_SHOW, "my.***@***mple.com");
-    }
-
-    @Test
-    public void shouldReturnNoEmailMessage() {
-        // given
-        Player sender = mock(Player.class);
-        given(sender.getName()).willReturn(USERNAME);
-        given(playerCache.getAuth(USERNAME)).willReturn(newAuthWithNoEmail());
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(commonService).send(sender, MessageKey.SHOW_NO_EMAIL);
-    }
-
-    private static PlayerAuth newAuthWithEmail(String email) {
-        return PlayerAuth.builder()
-            .name(USERNAME)
-            .email(email)
-            .build();
-    }
-
-    private static PlayerAuth newAuthWithNoEmail() {
-        return PlayerAuth.builder()
-            .name(USERNAME)
-            .build();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/login/LoginCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/login/LoginCommandTest.java
deleted file mode 100644
index 7f6c6675..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/login/LoginCommandTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package fr.xephi.authme.command.executable.login;
-
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.Management;
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link LoginCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class LoginCommandTest {
-
-    @InjectMocks
-    private LoginCommand command;
-
-    @Mock
-    private Management management;
-
-
-    @Test
-    public void shouldStopIfSenderIsNotAPlayer() {
-        // given
-        CommandSender sender = mock(BlockCommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verifyNoInteractions(management);
-        verify(sender).sendMessage(argThat(containsString("/authme forcelogin <player>")));
-    }
-
-    @Test
-    public void shouldCallManagementForPlayerCaller() {
-        // given
-        Player sender = mock(Player.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("password"));
-
-        // then
-        verify(management).performLogin(sender, "password" );
-    }
-
-    @Test
-    public void shouldDefineArgumentMismatchMessage() {
-        // given / when / then
-        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_LOGIN));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/logout/LogoutCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/logout/LogoutCommandTest.java
deleted file mode 100644
index ba80d6eb..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/logout/LogoutCommandTest.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package fr.xephi.authme.command.executable.logout;
-
-import fr.xephi.authme.process.Management;
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-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 java.util.ArrayList;
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link LogoutCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class LogoutCommandTest {
-
-    @InjectMocks
-    private LogoutCommand command;
-
-    @Mock
-    private Management management;
-
-
-    @Test
-    public void shouldStopIfSenderIsNotAPlayer() {
-        // given
-        CommandSender sender = mock(BlockCommandSender.class);
-
-        // when
-        command.executeCommand(sender, new ArrayList<String>());
-
-        // then
-        verifyNoInteractions(management);
-        verify(sender).sendMessage(argThat(containsString("only for players")));
-    }
-
-    @Test
-    public void shouldCallManagementForPlayerCaller() {
-        // given
-        Player sender = mock(Player.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("password"));
-
-        // then
-        verify(management).performLogout(sender);
-    }
-
-}
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
deleted file mode 100644
index cd695b65..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java
+++ /dev/null
@@ -1,332 +0,0 @@
-package fr.xephi.authme.command.executable.register;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
-import fr.xephi.authme.mail.EmailService;
-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.EmailRegisterParams;
-import fr.xephi.authme.process.register.executors.PasswordRegisterParams;
-import fr.xephi.authme.process.register.executors.RegistrationMethod;
-import fr.xephi.authme.process.register.executors.TwoFactorRegisterParams;
-import fr.xephi.authme.security.HashAlgorithm;
-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.SecuritySettings;
-import org.bukkit.command.BlockCommandSender;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Collections;
-
-import static fr.xephi.authme.IsEqualByReflectionMatcher.hasEqualValuesOnAllFields;
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link RegisterCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class RegisterCommandTest {
-
-    @InjectMocks
-    private RegisterCommand command;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private Management management;
-
-    @Mock
-    private EmailService emailService;
-
-    @Mock
-    private ValidationService validationService;
-
-    @Mock
-    private RegistrationCaptchaManager registrationCaptchaManager;
-
-    @BeforeClass
-    public static void setup() {
-        TestHelper.setupLogger();
-    }
-
-    @Before
-    public void linkMocksAndProvideSettingDefaults() {
-        given(commonService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.BCRYPT);
-        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD);
-        given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.NONE);
-    }
-
-    @Test
-    public void shouldNotRunForNonPlayerSender() {
-        // given
-        CommandSender sender = mock(BlockCommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Player only!")));
-        verifyNoInteractions(management, emailService);
-    }
-
-    @Test
-    public void shouldForwardToManagementForTwoFactor() {
-        // given
-        given(commonService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.TWO_FACTOR);
-        Player player = mockPlayerWithName("test2");
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(registrationCaptchaManager).isCaptchaRequired("test2");
-        verify(management).performRegister(eq(RegistrationMethod.TWO_FACTOR_REGISTRATION),
-            argThat(hasEqualValuesOnAllFields(TwoFactorRegisterParams.of(player))));
-        verifyNoInteractions(emailService);
-    }
-
-    @Test
-    public void shouldReturnErrorForEmptyArguments() {
-        // given
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Collections.emptyList());
-
-        // then
-        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
-        verifyNoInteractions(management, emailService);
-    }
-
-    @Test
-    public void shouldReturnErrorForMissingConfirmation() {
-        // given
-        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
-        command.executeCommand(player, Collections.singletonList("arrrr"));
-
-        // then
-        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
-        verifyNoInteractions(management, emailService);
-    }
-
-    @Test
-    public void shouldReturnErrorForMissingEmailConfirmation() {
-        // given
-        given(emailService.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
-        command.executeCommand(player, Collections.singletonList("test@example.org"));
-
-        // then
-        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldThrowErrorForMissingEmailConfiguration() {
-        // given
-        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL);
-        given(emailService.hasAllInformation()).willReturn(false);
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Collections.singletonList("myMail@example.tld"));
-
-        // then
-        verify(commonService).send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
-        verify(emailService).hasAllInformation();
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldRejectInvalidEmail() {
-        // given
-        String playerMail = "player@example.org";
-        given(validationService.validateEmail(playerMail)).willReturn(false);
-        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL);
-        given(emailService.hasAllInformation()).willReturn(true);
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Arrays.asList(playerMail, playerMail));
-
-        // then
-        verify(validationService).validateEmail(playerMail);
-        verify(commonService).send(player, MessageKey.INVALID_EMAIL);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldRejectInvalidEmailConfirmation() {
-        // given
-        String playerMail = "bobber@bobby.org";
-        given(validationService.validateEmail(playerMail)).willReturn(true);
-        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL);
-        given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION);
-        given(emailService.hasAllInformation()).willReturn(true);
-        Player player = mock(Player.class);
-
-        // when
-        command.executeCommand(player, Arrays.asList(playerMail, "invalid"));
-
-        // then
-        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
-        verify(emailService).hasAllInformation();
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldPerformEmailRegistration() {
-        // given
-        String playerMail = "asfd@lakjgre.lds";
-        given(validationService.validateEmail(playerMail)).willReturn(true);
-        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL);
-        given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION);
-        given(emailService.hasAllInformation()).willReturn(true);
-        Player player = mockPlayerWithName("brett");
-
-        // when
-        command.executeCommand(player, Arrays.asList(playerMail, playerMail));
-
-        // then
-        verify(registrationCaptchaManager).isCaptchaRequired("brett");
-        verify(validationService).validateEmail(playerMail);
-        verify(emailService).hasAllInformation();
-        verify(management).performRegister(eq(RegistrationMethod.EMAIL_REGISTRATION),
-            argThat(hasEqualValuesOnAllFields(EmailRegisterParams.of(player, playerMail))));
-    }
-
-    @Test
-    public void shouldRejectInvalidPasswordConfirmation() {
-        // given
-        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
-        command.executeCommand(player, Arrays.asList("myPass", "mypass"));
-
-        // then
-        verify(commonService).send(player, MessageKey.PASSWORD_MATCH_ERROR);
-        verifyNoInteractions(management, emailService);
-    }
-
-    @Test
-    public void shouldPerformPasswordRegistration() {
-        // given
-        Player player = mockPlayerWithName("newPlayer");
-
-        // when
-        command.executeCommand(player, Collections.singletonList("myPass"));
-
-        // then
-        verify(registrationCaptchaManager).isCaptchaRequired("newPlayer");
-        verify(management).performRegister(eq(RegistrationMethod.PASSWORD_REGISTRATION),
-            argThat(hasEqualValuesOnAllFields(PasswordRegisterParams.of(player, "myPass", null))));
-    }
-
-    @Test
-    public void shouldPerformMailValidationForPasswordWithEmail() {
-        // given
-        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);
-
-        // when
-        command.executeCommand(player, Arrays.asList("myPass", email));
-
-        // then
-        verify(validationService).validateEmail(email);
-        verify(management).performRegister(eq(RegistrationMethod.PASSWORD_REGISTRATION),
-            argThat(hasEqualValuesOnAllFields(PasswordRegisterParams.of(player, "myPass", email))));
-    }
-
-    @Test
-    public void shouldStopForInvalidEmail() {
-        // given
-        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 = mockPlayerWithName("Waaa");
-
-        // when
-        command.executeCommand(player, Arrays.asList("myPass", email));
-
-        // then
-        verify(registrationCaptchaManager).isCaptchaRequired("Waaa");
-        verify(validationService).validateEmail(email);
-        verify(commonService).send(player, MessageKey.INVALID_EMAIL);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldPerformNormalPasswordRegisterForOneArgument() {
-        // given
-        given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD);
-        given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.EMAIL_OPTIONAL);
-        Player player = mockPlayerWithName("Doa");
-
-        // when
-        command.executeCommand(player, Collections.singletonList("myPass"));
-
-        // then
-        verify(registrationCaptchaManager).isCaptchaRequired("Doa");
-        verify(management).performRegister(eq(RegistrationMethod.PASSWORD_REGISTRATION),
-            argThat(hasEqualValuesOnAllFields(PasswordRegisterParams.of(player, "myPass", null))));
-    }
-
-    @Test
-    public void shouldRequestCaptcha() {
-        // given
-        given(registrationCaptchaManager.isCaptchaRequired(anyString())).willReturn(true);
-        String name = "Brian";
-        Player player = mockPlayerWithName(name);
-        String captcha = "AB923C";
-        given(registrationCaptchaManager.getCaptchaCodeOrGenerateNew(name)).willReturn(captcha);
-
-        // when
-        command.executeCommand(player, Arrays.asList("myPass", "myPass"));
-
-        // then
-        verify(registrationCaptchaManager).isCaptchaRequired(name);
-        verify(commonService).send(player, MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, captcha);
-        verifyNoInteractions(management, validationService);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/totp/AddTotpCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/totp/AddTotpCommandTest.java
deleted file mode 100644
index 598200c5..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/totp/AddTotpCommandTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-package fr.xephi.authme.command.executable.totp;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.security.totp.GenerateTotpService;
-import fr.xephi.authme.security.totp.TotpAuthenticator.TotpGenerationResult;
-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 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.verifyNoInteractions;
-
-/**
- * Test for {@link AddTotpCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AddTotpCommandTest {
-
-    @InjectMocks
-    private AddTotpCommand addTotpCommand;
-
-    @Mock
-    private GenerateTotpService generateTotpService;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private Messages messages;
-
-    @Test
-    public void shouldHandleNonLoggedInUser() {
-        // given
-        Player player = mockPlayerWithName("bob");
-        given(playerCache.getAuth("bob")).willReturn(null);
-
-        // when
-        addTotpCommand.runCommand(player, Collections.emptyList());
-
-        // then
-        verify(messages).send(player, MessageKey.NOT_LOGGED_IN);
-        verifyNoInteractions(generateTotpService);
-    }
-
-    @Test
-    public void shouldNotAddCodeForAlreadyExistingTotp() {
-        // given
-        Player player = mockPlayerWithName("arend");
-        PlayerAuth auth = PlayerAuth.builder().name("arend")
-            .totpKey("TOTP2345").build();
-        given(playerCache.getAuth("arend")).willReturn(auth);
-
-        // when
-        addTotpCommand.runCommand(player, Collections.emptyList());
-
-        // then
-        verify(messages).send(player, MessageKey.TWO_FACTOR_ALREADY_ENABLED);
-        verifyNoInteractions(generateTotpService);
-    }
-
-    @Test
-    public void shouldGenerateTotpCode() {
-        // given
-        Player player = mockPlayerWithName("charles");
-        PlayerAuth auth = PlayerAuth.builder().name("charles").build();
-        given(playerCache.getAuth("charles")).willReturn(auth);
-
-        TotpGenerationResult generationResult = new TotpGenerationResult(
-            "777Key214", "http://example.org/qr-code/link");
-        given(generateTotpService.generateTotpKey(player)).willReturn(generationResult);
-
-        // when
-        addTotpCommand.runCommand(player, Collections.emptyList());
-
-        // then
-        verify(messages).send(player, MessageKey.TWO_FACTOR_CREATE, generationResult.getTotpKey(), generationResult.getAuthenticatorQrCodeUrl());
-        verify(messages).send(player, MessageKey.TWO_FACTOR_CREATE_CONFIRMATION_REQUIRED);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/totp/ConfirmTotpCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/totp/ConfirmTotpCommandTest.java
deleted file mode 100644
index 4c305364..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/totp/ConfirmTotpCommandTest.java
+++ /dev/null
@@ -1,158 +0,0 @@
-package fr.xephi.authme.command.executable.totp;
-
-import fr.xephi.authme.TestHelper;
-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.message.Messages;
-import fr.xephi.authme.security.totp.GenerateTotpService;
-import fr.xephi.authme.security.totp.TotpAuthenticator.TotpGenerationResult;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link ConfirmTotpCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ConfirmTotpCommandTest {
-
-    @InjectMocks
-    private ConfirmTotpCommand command;
-
-    @Mock
-    private GenerateTotpService generateTotpService;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private Messages messages;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldAddTotpCodeToUserAfterSuccessfulConfirmation() {
-        // given
-        Player player = mock(Player.class);
-        String playerName = "George";
-        given(player.getName()).willReturn(playerName);
-        PlayerAuth auth = PlayerAuth.builder().name(playerName).build();
-        given(playerCache.getAuth(playerName)).willReturn(auth);
-        String generatedTotpKey = "totp-key";
-        given(generateTotpService.getGeneratedTotpKey(player)).willReturn(new TotpGenerationResult(generatedTotpKey, "url-not-relevant"));
-        String totpCode = "954321";
-        given(generateTotpService.isTotpCodeCorrectForGeneratedTotpKey(player, totpCode)).willReturn(true);
-        given(dataSource.setTotpKey(anyString(), anyString())).willReturn(true);
-
-        // when
-        command.runCommand(player, Collections.singletonList(totpCode));
-
-        // then
-        verify(generateTotpService).isTotpCodeCorrectForGeneratedTotpKey(player, totpCode);
-        verify(generateTotpService).removeGenerateTotpKey(player);
-        verify(dataSource).setTotpKey(playerName, generatedTotpKey);
-        verify(playerCache).updatePlayer(auth);
-        verify(messages).send(player, MessageKey.TWO_FACTOR_ENABLE_SUCCESS);
-        assertThat(auth.getTotpKey(), equalTo(generatedTotpKey));
-    }
-
-    @Test
-    public void shouldHandleWrongTotpCode() {
-        // given
-        Player player = mock(Player.class);
-        String playerName = "George";
-        given(player.getName()).willReturn(playerName);
-        PlayerAuth auth = PlayerAuth.builder().name(playerName).build();
-        given(playerCache.getAuth(playerName)).willReturn(auth);
-        given(generateTotpService.getGeneratedTotpKey(player)).willReturn(new TotpGenerationResult("totp-key", "url-not-relevant"));
-        String totpCode = "754321";
-        given(generateTotpService.isTotpCodeCorrectForGeneratedTotpKey(player, totpCode)).willReturn(false);
-
-        // when
-        command.runCommand(player, Collections.singletonList(totpCode));
-
-        // then
-        verify(generateTotpService).isTotpCodeCorrectForGeneratedTotpKey(player, totpCode);
-        verify(generateTotpService, never()).removeGenerateTotpKey(any(Player.class));
-        verify(playerCache, only()).getAuth(playerName);
-        verify(messages).send(player, MessageKey.TWO_FACTOR_ENABLE_ERROR_WRONG_CODE);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldHandleMissingTotpKey() {
-        // given
-        Player player = mock(Player.class);
-        String playerName = "George";
-        given(player.getName()).willReturn(playerName);
-        PlayerAuth auth = PlayerAuth.builder().name(playerName).build();
-        given(playerCache.getAuth(playerName)).willReturn(auth);
-        given(generateTotpService.getGeneratedTotpKey(player)).willReturn(null);
-
-        // when
-        command.runCommand(player, Collections.singletonList("871634"));
-
-        // then
-        verify(generateTotpService, only()).getGeneratedTotpKey(player);
-        verify(playerCache, only()).getAuth(playerName);
-        verify(messages).send(player, MessageKey.TWO_FACTOR_ENABLE_ERROR_NO_CODE);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldStopForAlreadyExistingTotpKeyOnAccount() {
-        // given
-        Player player = mock(Player.class);
-        String playerName = "George";
-        given(player.getName()).willReturn(playerName);
-        PlayerAuth auth = PlayerAuth.builder().name(playerName).totpKey("A987234").build();
-        given(playerCache.getAuth(playerName)).willReturn(auth);
-
-        // when
-        command.runCommand(player, Collections.singletonList("871634"));
-
-        // then
-        verify(playerCache, only()).getAuth(playerName);
-        verifyNoInteractions(generateTotpService, dataSource);
-        verify(messages).send(player, MessageKey.TWO_FACTOR_ALREADY_ENABLED);
-    }
-
-    @Test
-    public void shouldHandleMissingAuthAccount() {
-        // given
-        Player player = mock(Player.class);
-        String playerName = "George";
-        given(player.getName()).willReturn(playerName);
-        given(playerCache.getAuth(playerName)).willReturn(null);
-
-        // when
-        command.runCommand(player, Collections.singletonList("984685"));
-
-        // then
-        verify(playerCache, only()).getAuth(playerName);
-        verifyNoInteractions(generateTotpService, dataSource);
-        verify(messages).send(player, MessageKey.NOT_LOGGED_IN);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/totp/RemoveTotpCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/totp/RemoveTotpCommandTest.java
deleted file mode 100644
index 26c7e871..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/totp/RemoveTotpCommandTest.java
+++ /dev/null
@@ -1,149 +0,0 @@
-package fr.xephi.authme.command.executable.totp;
-
-import fr.xephi.authme.TestHelper;
-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.message.Messages;
-import fr.xephi.authme.security.totp.TotpAuthenticator;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import static java.util.Collections.singletonList;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-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.verifyNoInteractions;
-
-/**
- * Test for {@link RemoveTotpCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class RemoveTotpCommandTest {
-
-    @InjectMocks
-    private RemoveTotpCommand command;
-
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private TotpAuthenticator totpAuthenticator;
-    @Mock
-    private Messages messages;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldRemoveTotpKey() {
-        // given
-        String name = "aws";
-        PlayerAuth auth = PlayerAuth.builder().name(name).totpKey("some-totp-key").build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-        String inputCode = "93847";
-        given(totpAuthenticator.checkCode(auth, inputCode)).willReturn(true);
-        given(dataSource.removeTotpKey(name)).willReturn(true);
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-
-        // when
-        command.runCommand(player, singletonList(inputCode));
-
-        // then
-        verify(dataSource).removeTotpKey(name);
-        verify(messages, only()).send(player, MessageKey.TWO_FACTOR_REMOVED_SUCCESS);
-        verify(playerCache).updatePlayer(auth);
-        assertThat(auth.getTotpKey(), nullValue());
-    }
-
-    @Test
-    public void shouldHandleDatabaseError() {
-        // given
-        String name = "aws";
-        PlayerAuth auth = PlayerAuth.builder().name(name).totpKey("some-totp-key").build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-        String inputCode = "93847";
-        given(totpAuthenticator.checkCode(auth, inputCode)).willReturn(true);
-        given(dataSource.removeTotpKey(name)).willReturn(false);
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-
-        // when
-        command.runCommand(player, singletonList(inputCode));
-
-        // then
-        verify(dataSource).removeTotpKey(name);
-        verify(messages, only()).send(player, MessageKey.ERROR);
-        verify(playerCache, only()).getAuth(name);
-    }
-
-    @Test
-    public void shouldHandleInvalidCode() {
-        // given
-        String name = "cesar";
-        PlayerAuth auth = PlayerAuth.builder().name(name).totpKey("some-totp-key").build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-        String inputCode = "93847";
-        given(totpAuthenticator.checkCode(auth, inputCode)).willReturn(false);
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-
-        // when
-        command.runCommand(player, singletonList(inputCode));
-
-        // then
-        verifyNoInteractions(dataSource);
-        verify(messages, only()).send(player, MessageKey.TWO_FACTOR_INVALID_CODE);
-        verify(playerCache, only()).getAuth(name);
-    }
-
-    @Test
-    public void shouldHandleUserWithoutTotpKey() {
-        // given
-        String name = "cesar";
-        PlayerAuth auth = PlayerAuth.builder().name(name).build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-        String inputCode = "654684";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-
-        // when
-        command.runCommand(player, singletonList(inputCode));
-
-        // then
-        verifyNoInteractions(dataSource, totpAuthenticator);
-        verify(messages, only()).send(player, MessageKey.TWO_FACTOR_NOT_ENABLED_ERROR);
-        verify(playerCache, only()).getAuth(name);
-    }
-
-    @Test
-    public void shouldHandleNonLoggedInUser() {
-        // given
-        String name = "cesar";
-        given(playerCache.getAuth(name)).willReturn(null);
-        String inputCode = "654684";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-
-        // when
-        command.runCommand(player, singletonList(inputCode));
-
-        // then
-        verifyNoInteractions(dataSource, totpAuthenticator);
-        verify(messages, only()).send(player, MessageKey.NOT_LOGGED_IN);
-        verify(playerCache, only()).getAuth(name);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/totp/TotpBaseCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/totp/TotpBaseCommandTest.java
deleted file mode 100644
index 0e279f68..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/totp/TotpBaseCommandTest.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package fr.xephi.authme.command.executable.totp;
-
-import fr.xephi.authme.command.CommandMapper;
-import fr.xephi.authme.command.FoundCommandResult;
-import fr.xephi.authme.command.help.HelpProvider;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link TotpBaseCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class TotpBaseCommandTest {
-
-    @InjectMocks
-    private TotpBaseCommand command;
-
-    @Mock
-    private CommandMapper mapper;
-    @Mock
-    private HelpProvider helpProvider;
-
-    @Test
-    public void shouldOutputHelp() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        FoundCommandResult mappingResult = mock(FoundCommandResult.class);
-        given(mapper.mapPartsToCommand(sender, Collections.singletonList("totp"))).willReturn(mappingResult);
-
-        // when
-        command.executeCommand(sender, Collections.emptyList());
-
-        // then
-        verify(mapper).mapPartsToCommand(sender, Collections.singletonList("totp"));
-        verify(helpProvider).outputHelp(sender, mappingResult, HelpProvider.SHOW_CHILDREN);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/unregister/UnregisterCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/unregister/UnregisterCommandTest.java
deleted file mode 100644
index a0fc8d3d..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/unregister/UnregisterCommandTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-package fr.xephi.authme.command.executable.unregister;
-
-import fr.xephi.authme.data.VerificationCodeManager;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.command.CommandSender;
-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 java.util.Collections;
-
-import static org.hamcrest.Matchers.containsString;
-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;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link UnregisterCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class UnregisterCommandTest {
-
-    @InjectMocks
-    private UnregisterCommand command;
-
-    @Mock
-    private Management management;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private VerificationCodeManager codeManager;
-
-    @Test
-    public void shouldCatchUnauthenticatedUser() {
-        // given
-        String password = "mySecret123";
-        String name = "player77";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(password));
-
-        // then
-        verify(playerCache).isAuthenticated(name);
-        verify(commonService).send(player, MessageKey.NOT_LOGGED_IN);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldStopForMissingVerificationCode() {
-        // given
-        String name = "asldjf";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        given(playerCache.isAuthenticated(name)).willReturn(true);
-        given(codeManager.isVerificationRequired(player)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.singletonList("blergh"));
-
-        // then
-        verify(playerCache).isAuthenticated(name);
-        verify(codeManager).codeExistOrGenerateNew(name);
-        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_REQUIRED);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldForwardDataToAsyncTask() {
-        // given
-        String password = "p@ssw0rD";
-        String name = "jas0n_";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        given(playerCache.isAuthenticated(name)).willReturn(true);
-        given(codeManager.isVerificationRequired(player)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(password));
-
-        // then
-        verify(playerCache).isAuthenticated(name);
-        verify(management).performUnregister(player, password);
-        verify(codeManager).isVerificationRequired(player);
-    }
-
-    @Test
-    public void shouldStopIfSenderIsNotPlayer() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        command.executeCommand(sender, Collections.singletonList("password"));
-
-        // then
-        verifyNoInteractions(playerCache, management);
-        verify(sender).sendMessage(argThat(containsString("/authme unregister <player>")));
-    }
-
-    @Test
-    public void shouldDefineArgumentMismatchMessage() {
-        // given / when / then
-        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_UNREGISTER));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/executable/verification/VerificationCommandTest.java b/src/test/java/fr/xephi/authme/command/executable/verification/VerificationCommandTest.java
deleted file mode 100644
index d4b38f1a..00000000
--- a/src/test/java/fr/xephi/authme/command/executable/verification/VerificationCommandTest.java
+++ /dev/null
@@ -1,168 +0,0 @@
-package fr.xephi.authme.command.executable.verification;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.VerificationCodeManager;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.CommonService;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-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 VerificationCommand}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class VerificationCommandTest {
-
-    @InjectMocks
-    private VerificationCommand command;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private VerificationCodeManager codeManager;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldDetectIfMailHasASetup() {
-        // given
-        String name = "Alligator";
-        Player player = mockPlayerWithName(name);
-        given(codeManager.canSendMail()).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.singletonList("code"));
-
-        // then
-        verify(commonService).send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
-    }
-
-    @Test
-    public void shouldRequireAndAcceptCode() {
-        // given
-        String name = "Duck";
-        String code = "123932";
-        Player player = mockPlayerWithName(name);
-        given(codeManager.canSendMail()).willReturn(true);
-        given(codeManager.isVerificationRequired(player)).willReturn(true);
-        given(codeManager.isCodeRequired(name)).willReturn(true);
-        given(codeManager.checkCode(name, code)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(code));
-
-        // then
-        verify(codeManager).isVerificationRequired(player);
-        verify(codeManager).isCodeRequired(name);
-        verify(codeManager).checkCode(name, code);
-        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_VERIFIED);
-    }
-
-    @Test
-    public void shouldRejectCode() {
-        // given
-        String name = "Spider";
-        String code = "98345222";   // more than 6 digits
-        Player player = mockPlayerWithName(name);
-        given(codeManager.canSendMail()).willReturn(true);
-        given(codeManager.isVerificationRequired(player)).willReturn(true);
-        given(codeManager.isCodeRequired(name)).willReturn(true);
-        given(codeManager.checkCode(name, code)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(code));
-
-        // then
-        verify(codeManager).isVerificationRequired(player);
-        verify(codeManager).isCodeRequired(name);
-        verify(codeManager).checkCode(name, code);
-        verify(commonService).send(player, MessageKey.INCORRECT_VERIFICATION_CODE);
-    }
-
-    @Test
-    public void shouldRejectVerificationDueToExpiration() {
-        // given
-        String name = "Dog";
-        String code = "131552";
-        Player player = mockPlayerWithName(name);
-        given(codeManager.canSendMail()).willReturn(true);
-        given(codeManager.isVerificationRequired(player)).willReturn(true);
-        given(codeManager.isCodeRequired(name)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(code));
-
-        // then
-        verify(codeManager).isVerificationRequired(player);
-        verify(codeManager).isCodeRequired(name);
-        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_EXPIRED);
-    }
-
-    @Test
-    public void shouldRejectVerificationDueToVerifiedIdentity() {
-        // given
-        String name = "Cow";
-        String code = "973583";
-        Player player = mockPlayerWithName(name);
-        given(codeManager.canSendMail()).willReturn(true);
-        given(codeManager.isVerificationRequired(player)).willReturn(false);
-        given(codeManager.hasEmail(name)).willReturn(true);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(code));
-
-        // then
-        verify(codeManager).isVerificationRequired(player);
-        verify(codeManager).hasEmail(name);
-        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_ALREADY_VERIFIED);
-    }
-
-    @Test
-    public void shouldRejectVerificationDueToUndefinedEmail() {
-        // given
-        String name = "Frog";
-        String code = "774543";
-        Player player = mockPlayerWithName(name);
-        given(codeManager.canSendMail()).willReturn(true);
-        given(codeManager.isVerificationRequired(player)).willReturn(false);
-        given(codeManager.hasEmail(name)).willReturn(false);
-
-        // when
-        command.executeCommand(player, Collections.singletonList(code));
-
-        // then
-        verify(codeManager).isVerificationRequired(player);
-        verify(codeManager).hasEmail(name);
-        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_EMAIL_NEEDED);
-        verify(commonService).send(player, MessageKey.ADD_EMAIL_MESSAGE);
-    }
-
-    @Test
-    public void shouldDefineArgumentMismatchMessage() {
-        // given / when / then
-        assertThat(command.getArgumentsMismatchMessage(), equalTo(MessageKey.USAGE_VERIFICATION_CODE));
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/help/HelpMessageAndHelpSectionConsistencyTest.java b/src/test/java/fr/xephi/authme/command/help/HelpMessageAndHelpSectionConsistencyTest.java
deleted file mode 100644
index 02a42ba9..00000000
--- a/src/test/java/fr/xephi/authme/command/help/HelpMessageAndHelpSectionConsistencyTest.java
+++ /dev/null
@@ -1,39 +0,0 @@
-package fr.xephi.authme.command.help;
-
-import fr.xephi.authme.util.StringUtils;
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Test for enums {@link HelpMessage} and {@link HelpSection}.
- */
-public class HelpMessageAndHelpSectionConsistencyTest {
-
-    @Test
-    public void shouldHaveUniqueNonEmptyKeys() {
-        // given
-        Set<String> keys = new HashSet<>();
-
-        // when / then
-        for (HelpMessage message : HelpMessage.values()) {
-            assertThat("Key for message '" + message + "' is empty",
-                StringUtils.isBlank(message.getKey()), equalTo(false));
-            if (!keys.add(message.getKey())) {
-                fail("Key for message '" + message + "' is already used elsewhere");
-            }
-        }
-        for (HelpSection section : HelpSection.values()) {
-            assertThat("Key for section '" + section + "' is empty",
-                StringUtils.isBlank(section.getKey()), equalTo(false));
-            if (!keys.add(section.getKey())) {
-                fail("Key for section '" + section + "' is already used elsewhere");
-            }
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/help/HelpMessagesConsistencyTest.java b/src/test/java/fr/xephi/authme/command/help/HelpMessagesConsistencyTest.java
deleted file mode 100644
index 019e6c86..00000000
--- a/src/test/java/fr/xephi/authme/command/help/HelpMessagesConsistencyTest.java
+++ /dev/null
@@ -1,97 +0,0 @@
-package fr.xephi.authme.command.help;
-
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileReader;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.CommandInitializer;
-import fr.xephi.authme.message.MessagePathHelper;
-import org.bukkit.configuration.MemorySection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.junit.Test;
-
-import java.io.File;
-import java.util.Collection;
-import java.util.List;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertThat;
-
-/**
- * Tests that /messages/help_en.yml contains texts that correspond
- * to the texts provided in the CommandDescription.
- */
-public class HelpMessagesConsistencyTest {
-
-    private static final File DEFAULT_MESSAGES_FILE =
-        TestHelper.getJarFile("/" + MessagePathHelper.createHelpMessageFilePath(MessagePathHelper.DEFAULT_LANGUAGE));
-
-    @Test
-    public void shouldHaveIdenticalTexts() {
-        // given
-        CommandDescription description = getAuthMeRegisterDescription();
-        FileConfiguration configuration = YamlConfiguration.loadConfiguration(DEFAULT_MESSAGES_FILE);
-        final String path = "commands.authme.register.";
-
-        // when / then
-        assertThat(configuration.get(path + "description"), equalTo(description.getDescription()));
-        assertThat(configuration.get(path + "detailedDescription"), equalTo(description.getDetailedDescription()));
-        assertThat(configuration.get(path + "arg1.label"), equalTo(description.getArguments().get(0).getName()));
-        assertThat(configuration.get(path + "arg1.description"), equalTo(description.getArguments().get(0).getDescription()));
-        assertThat(configuration.get(path + "arg2.label"), equalTo(description.getArguments().get(1).getName()));
-        assertThat(configuration.get(path + "arg2.description"), equalTo(description.getArguments().get(1).getDescription()));
-    }
-
-    /**
-     * Since CommandInitializer contains all descriptions for commands in English, the help_en.yml file
-     * only contains an entry for one command as to provide an example.
-     */
-    @Test
-    public void shouldOnlyHaveDescriptionForOneCommand() {
-        // given
-        FileConfiguration configuration = YamlConfiguration.loadConfiguration(DEFAULT_MESSAGES_FILE);
-
-        // when
-        Object commands = configuration.get("commands");
-
-        // then
-        assertThat(commands, instanceOf(MemorySection.class));
-        assertThat(((MemorySection) commands).getKeys(false), contains("authme"));
-    }
-
-    @Test
-    public void shouldHaveEntryForEachHelpMessageKey() {
-        // given
-        PropertyReader reader = new YamlFileReader(DEFAULT_MESSAGES_FILE);
-
-        // when / then
-        for (HelpMessage message : HelpMessage.values()) {
-            assertThat("Default configuration should have entry for message '" + message + "'",
-                reader.contains(message.getKey()), equalTo(true));
-        }
-        for (HelpSection section : HelpSection.values()) {
-            assertThat("Default configuration should have entry for section '" + section + "'",
-                reader.contains(section.getKey()), equalTo(true));
-        }
-    }
-
-    /**
-     * @return the CommandDescription object for the {@code /authme register} command.
-     */
-    private static CommandDescription getAuthMeRegisterDescription() {
-        Collection<CommandDescription> commands = new CommandInitializer().getCommands();
-
-        List<CommandDescription> children = commands.stream()
-            .filter(command -> command.getLabels().contains("authme"))
-            .map(CommandDescription::getChildren)
-            .findFirst().get();
-
-        return children
-            .stream()
-            .filter(child -> child.getLabels().contains("register"))
-            .findFirst().get();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/help/HelpMessagesServiceTest.java b/src/test/java/fr/xephi/authme/command/help/HelpMessagesServiceTest.java
deleted file mode 100644
index 514724a9..00000000
--- a/src/test/java/fr/xephi/authme/command/help/HelpMessagesServiceTest.java
+++ /dev/null
@@ -1,160 +0,0 @@
-package fr.xephi.authme.command.help;
-
-import com.google.common.io.Files;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.TestCommandsUtil;
-import fr.xephi.authme.message.AbstractMessageFileHandler;
-import fr.xephi.authme.message.HelpMessagesFileHandler;
-import fr.xephi.authme.message.MessagePathHelper;
-import fr.xephi.authme.permission.DefaultPermission;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Collection;
-
-import static fr.xephi.authme.command.TestCommandsUtil.getCommandWithLabel;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.sameInstance;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link HelpMessagesService}.
- */
-public class HelpMessagesServiceTest {
-
-    private static final String TEST_FILE = TestHelper.PROJECT_ROOT + "command/help/help_test.yml";
-    private static final Collection<CommandDescription> COMMANDS = TestCommandsUtil.generateCommands();
-
-    private HelpMessagesService helpMessagesService;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-    private File dataFolder;
-
-    @Before
-    public void initializeHandler() throws IOException {
-        dataFolder = temporaryFolder.newFolder();
-        new File(dataFolder, "messages").mkdirs();
-        File messagesFile = new File(dataFolder, MessagePathHelper.createHelpMessageFilePath("test"));
-        Files.copy(TestHelper.getJarFile(TEST_FILE), messagesFile);
-
-        HelpMessagesFileHandler helpMessagesFileHandler = createMessagesFileHandler();
-        helpMessagesService = new HelpMessagesService(helpMessagesFileHandler);
-    }
-
-    @Test
-    public void shouldReturnLocalizedCommand() {
-        // given
-        CommandDescription command = getCommandWithLabel(COMMANDS, "authme", "register");
-
-        // when
-        CommandDescription localCommand = helpMessagesService.buildLocalizedDescription(command);
-
-        // then
-        assertThat(localCommand.getDescription(), equalTo("Registration"));
-        assertThat(localCommand.getDetailedDescription(), equalTo("Registers the player"));
-        assertThat(localCommand.getExecutableCommand(), equalTo(command.getExecutableCommand()));
-        assertThat(localCommand.getPermission(), equalTo(command.getPermission()));
-        assertThat(localCommand.getArguments(), hasSize(2));
-        assertThat(localCommand.getArguments().get(0).getName(), equalTo("password"));
-        assertThat(localCommand.getArguments().get(0).getDescription(), equalTo("The password"));
-        assertThat(localCommand.getArguments().get(1).getName(), equalTo("confirmation"));
-        assertThat(localCommand.getArguments().get(1).getDescription(), equalTo("The confirmation"));
-    }
-
-    @Test
-    public void shouldReturnLocalizedCommandWithDefaults() {
-        // given
-        CommandDescription command = getCommandWithLabel(COMMANDS, "authme", "login");
-
-        // when
-        CommandDescription localCommand = helpMessagesService.buildLocalizedDescription(command);
-
-        // then
-        assertThat(localCommand.getDescription(), equalTo("Logging in"));
-        assertThat(localCommand.getDetailedDescription(), equalTo("'login' test command"));
-        assertThat(localCommand.getArguments(), hasSize(1));
-        assertThat(localCommand.getArguments().get(0).getName(), equalTo("user password"));
-        assertThat(localCommand.getArguments().get(0).getDescription(), equalTo("'password' argument description"));
-    }
-
-    @Test
-    public void shouldReturnSameCommandForNoLocalization() {
-        // given
-        CommandDescription command = getCommandWithLabel(COMMANDS, "email");
-
-        // when
-        CommandDescription localCommand = helpMessagesService.buildLocalizedDescription(command);
-
-        // then
-        assertThat(localCommand, sameInstance(command));
-    }
-
-    @Test
-    public void shouldKeepChildrenInLocalCommand() {
-        // given
-        CommandDescription command = getCommandWithLabel(COMMANDS, "authme");
-
-        // when
-        CommandDescription localCommand = helpMessagesService.buildLocalizedDescription(command);
-
-        // then
-        assertThat(localCommand.getChildren(), equalTo(command.getChildren()));
-        assertThat(localCommand.getDescription(), equalTo("authme cmd"));
-        assertThat(localCommand.getDetailedDescription(), equalTo("Main command"));
-    }
-
-    @Test
-    public void shouldGetTranslationsForSectionAndMessage() {
-        // given / when / then
-        assertThat(helpMessagesService.getMessage(DefaultPermission.OP_ONLY), equalTo("only op"));
-        assertThat(helpMessagesService.getMessage(HelpMessage.RESULT), equalTo("res."));
-        assertThat(helpMessagesService.getMessage(HelpSection.ARGUMENTS), equalTo("arg."));
-    }
-
-    @Test
-    public void shouldGetLocalCommandDescription() {
-        // given
-        CommandDescription command = getCommandWithLabel(COMMANDS, "authme", "register");
-
-        // when
-        String description = helpMessagesService.getDescription(command);
-
-        // then
-        assertThat(description, equalTo("Registration"));
-    }
-
-    @Test
-    public void shouldFallbackToDescriptionOnCommandObject() {
-        // given
-        CommandDescription command = getCommandWithLabel(COMMANDS, "unregister");
-
-        // when
-        String description = helpMessagesService.getDescription(command);
-
-        // then
-        assertThat(description, equalTo(command.getDescription()));
-    }
-
-    private HelpMessagesFileHandler createMessagesFileHandler() {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(PluginSettings.MESSAGES_LANGUAGE)).willReturn("test");
-
-        HelpMessagesFileHandler messagesFileHandler = ReflectionTestUtils.newInstance(HelpMessagesFileHandler.class);
-        ReflectionTestUtils.setField(AbstractMessageFileHandler.class, messagesFileHandler, "settings", settings);
-        ReflectionTestUtils.setField(AbstractMessageFileHandler.class, messagesFileHandler, "dataFolder", dataFolder);
-        ReflectionTestUtils.invokePostConstructMethods(messagesFileHandler);
-        return messagesFileHandler;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/command/help/HelpProviderTest.java b/src/test/java/fr/xephi/authme/command/help/HelpProviderTest.java
deleted file mode 100644
index 8852387f..00000000
--- a/src/test/java/fr/xephi/authme/command/help/HelpProviderTest.java
+++ /dev/null
@@ -1,466 +0,0 @@
-package fr.xephi.authme.command.help;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.FoundCommandResult;
-import fr.xephi.authme.command.FoundResultStatus;
-import fr.xephi.authme.command.TestCommandsUtil;
-import fr.xephi.authme.permission.AdminPermission;
-import fr.xephi.authme.permission.DefaultPermission;
-import fr.xephi.authme.permission.PermissionsManager;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-import org.mockito.internal.stubbing.answers.ReturnsArgumentAt;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Locale;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.command.TestCommandsUtil.getCommandWithLabel;
-import static fr.xephi.authme.command.help.HelpProvider.ALL_OPTIONS;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_ALTERNATIVES;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_ARGUMENTS;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_CHILDREN;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_COMMAND;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_DESCRIPTION;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_LONG_DESCRIPTION;
-import static fr.xephi.authme.command.help.HelpProvider.SHOW_PERMISSIONS;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeastOnce;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link HelpProvider}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class HelpProviderTest {
-
-    private static Collection<CommandDescription> commands;
-
-    @InjectDelayed
-    private HelpProvider helpProvider;
-    @Mock
-    private PermissionsManager permissionsManager;
-    @Mock
-    private HelpMessagesService helpMessagesService;
-    @Mock
-    private CommandSender sender;
-
-    @BeforeClass
-    public static void setUpCommands() {
-        commands = TestCommandsUtil.generateCommands();
-    }
-
-    @BeforeInjecting
-    public void setInitialSettings() {
-        setDefaultHelpMessages(helpMessagesService);
-    }
-
-    @Test
-    public void shouldShowLongDescription() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme", "login");
-        FoundCommandResult result = newFoundResult(command, Arrays.asList("authme", "login"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_COMMAND | SHOW_LONG_DESCRIPTION | SHOW_DESCRIPTION);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(5));
-        assertThat(lines.get(0), containsString("Header"));
-        assertThat(lines.get(1), containsString("Command: /authme login <password>"));
-        assertThat(lines.get(2), containsString("Short description: login cmd"));
-        assertThat(lines.get(3), equalTo("Detailed description:"));
-        assertThat(lines.get(4), containsString("'login' test command"));
-    }
-
-    @Test
-    public void shouldShowArguments() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-        FoundCommandResult result = newFoundResult(command, Arrays.asList("authme", "reg"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_ARGUMENTS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(4));
-        assertThat(lines.get(0), containsString("Header"));
-        assertThat(lines.get(1), equalTo("Arguments:"));
-        assertThat(lines.get(2), containsString("password: 'password' argument description"));
-        assertThat(lines.get(3), containsString("confirmation: 'confirmation' argument description"));
-    }
-
-    @Test
-    public void shouldShowSpecifyIfArgumentIsOptional() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "email");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("email"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_ARGUMENTS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(3));
-        assertThat(lines.get(2), containsString("player: 'player' argument description (Optional)"));
-    }
-
-    /** Verifies that the "Arguments:" line is not shown if the command has no arguments. */
-    @Test
-    public void shouldNotShowAnythingIfCommandHasNoArguments() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("authme"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_ARGUMENTS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(1)); // only has the help banner
-    }
-
-    @Test
-    public void shouldShowAndEvaluatePermissions() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "unregister");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("unreg"));
-        given(sender.isOp()).willReturn(true);
-        given(permissionsManager.hasPermission(sender, AdminPermission.UNREGISTER)).willReturn(true);
-        given(permissionsManager.hasPermission(sender, command.getPermission())).willReturn(true);
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_PERMISSIONS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(5));
-        assertThat(lines.get(1), containsString("Permissions:"));
-        assertThat(lines.get(2),
-            containsString(AdminPermission.UNREGISTER.getNode() + " (Has permission)"));
-        assertThat(lines.get(3), containsString("Default: Op only (Has permission)"));
-        assertThat(lines.get(4), containsString("Result: Has permission"));
-    }
-
-    @Test
-    public void shouldShowAndEvaluateForbiddenPermissions() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "unregister");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("unregister"));
-        given(sender.isOp()).willReturn(false);
-        given(permissionsManager.hasPermission(sender, AdminPermission.UNREGISTER)).willReturn(false);
-        given(permissionsManager.hasPermission(sender, command.getPermission())).willReturn(false);
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_PERMISSIONS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(5));
-        assertThat(lines.get(1), containsString("Permissions:"));
-        assertThat(lines.get(2),
-            containsString(AdminPermission.UNREGISTER.getNode() + " (No permission)"));
-        assertThat(lines.get(3), containsString("Default: Op only (No permission)"));
-        assertThat(lines.get(4), containsString("Result: No permission"));
-    }
-
-    @Test
-    public void shouldNotShowAnythingForEmptyPermissions() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("authme"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_PERMISSIONS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(1));
-    }
-
-    @Test
-    public void shouldNotShowAnythingForNullPermissionsOnCommand() {
-        // given
-        CommandDescription command = mock(CommandDescription.class);
-        given(command.getPermission()).willReturn(null);
-        given(command.getLabels()).willReturn(Collections.singletonList("test"));
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("test"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_PERMISSIONS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(1));
-    }
-
-    @Test
-    public void shouldShowAlternatives() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-        FoundCommandResult result = newFoundResult(command, Arrays.asList("authme", "reg"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_ALTERNATIVES);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(4));
-        assertThat(lines.get(1), containsString("Alternatives:"));
-        assertThat(lines.get(2), containsString("/authme register <password> <confirmation>"));
-        assertThat(lines.get(3), containsString("/authme r <password> <confirmation>"));
-    }
-
-    @Test
-    public void shouldNotShowAnythingIfHasNoAlternatives() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme", "login");
-        FoundCommandResult result = newFoundResult(command, Arrays.asList("authme", "login"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_ALTERNATIVES);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(1));
-    }
-
-    @Test
-    public void shouldShowChildren() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("authme"));
-        given(helpMessagesService.getDescription(getCommandWithLabel(commands, "authme", "login")))
-            .willReturn("Command for login [localized]");
-        given(helpMessagesService.getDescription(getCommandWithLabel(commands, "authme", "register")))
-            .willReturn("Registration command [localized]");
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_CHILDREN);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(4));
-        assertThat(lines.get(1), equalTo("Children:"));
-        assertThat(lines.get(2), equalTo(" /authme login: Command for login [localized]"));
-        assertThat(lines.get(3), equalTo(" /authme register: Registration command [localized]"));
-    }
-
-    @Test
-    public void shouldNotShowCommandsTitleForCommandWithNoChildren() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("authme"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_CHILDREN);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(1));
-    }
-
-    @Test
-    public void shouldHandleUnboundFoundCommandResult() {
-        // given
-        FoundCommandResult result = new FoundCommandResult(null, Arrays.asList("authme", "test"),
-            Collections.emptyList(), 0.0, FoundResultStatus.UNKNOWN_LABEL);
-
-        // when
-        helpProvider.outputHelp(sender, result, ALL_OPTIONS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(1));
-        assertThat(lines.get(0), containsString("Failed to retrieve any help information"));
-    }
-
-    /**
-     * Since command parts may be mapped to a command description with labels that don't completely correspond to it,
-     * (e.g. suggest "register command" for /authme ragister), we need to check the labels and construct a correct list
-     */
-    @Test
-    public void shouldShowCommandSyntaxWithCorrectLabels() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-        FoundCommandResult result = newFoundResult(command, Arrays.asList("authme", "ragister"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_COMMAND);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(2));
-        assertThat(lines.get(0), containsString("Header"));
-        assertThat(lines.get(1), containsString("Command: /authme register <password> <confirmation>"));
-    }
-
-    @Test
-    public void shouldRetainCorrectLabels() {
-        // given
-        List<String> labels = Arrays.asList("authme", "reg");
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-
-        // when
-        List<String> result = HelpProvider.filterCorrectLabels(command, labels);
-
-        // then
-        assertThat(result, equalTo(labels));
-    }
-
-    @Test
-    public void shouldReplaceIncorrectLabels() {
-        // given
-        List<String> labels = Arrays.asList("authme", "wrong");
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-
-        // when
-        List<String> result = HelpProvider.filterCorrectLabels(command, labels);
-
-        // then
-        assertThat(result, contains("authme", "register"));
-    }
-
-    @Test
-    public void shouldDisableSectionsWithEmptyTranslations() {
-        // given
-        given(helpMessagesService.getMessage(HelpSection.DETAILED_DESCRIPTION)).willReturn("");
-        given(helpMessagesService.getMessage(HelpSection.ALTERNATIVES)).willReturn("");
-        given(helpMessagesService.getMessage(HelpSection.PERMISSIONS)).willReturn("");
-
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("authme"));
-
-        // when
-        helpProvider.outputHelp(sender, result, ALL_OPTIONS);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(6));
-        assertThat(lines.get(0), equalTo("Header"));
-        assertThat(lines.get(1), equalTo("Command: /authme register <password> <confirmation>"));
-        assertThat(lines.get(2), equalTo("Short description: register cmd"));
-        assertThat(lines.get(3), equalTo("Arguments:"));
-        assertThat(lines.get(4), containsString("'password' argument description"));
-        assertThat(lines.get(5), containsString("'confirmation' argument description"));
-    }
-
-    @Test
-    public void shouldNotReturnAnythingForAllDisabledSections() {
-        // given
-        given(helpMessagesService.getMessage(HelpSection.COMMAND)).willReturn("");
-        given(helpMessagesService.getMessage(HelpSection.ALTERNATIVES)).willReturn("");
-        given(helpMessagesService.getMessage(HelpSection.PERMISSIONS)).willReturn("");
-
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("authme"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_COMMAND | SHOW_ALTERNATIVES | SHOW_PERMISSIONS);
-
-        // then
-        verify(sender, never()).sendMessage(anyString());
-    }
-
-    @Test
-    public void shouldSkipEmptyHeader() {
-        // given
-        given(helpMessagesService.getMessage(HelpMessage.HEADER)).willReturn("");
-        CommandDescription command = getCommandWithLabel(commands, "authme", "register");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("authme"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_COMMAND);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(1));
-        assertThat(lines.get(0), equalTo("Command: /authme register <password> <confirmation>"));
-    }
-
-    @Test
-    public void shouldShowAlternativesForRootCommand() {
-        // given
-        CommandDescription command = getCommandWithLabel(commands, "unregister");
-        FoundCommandResult result = newFoundResult(command, Collections.singletonList("unreg"));
-
-        // when
-        helpProvider.outputHelp(sender, result, SHOW_COMMAND | SHOW_ALTERNATIVES);
-
-        // then
-        List<String> lines = getLines(sender);
-        assertThat(lines, hasSize(4));
-        assertThat(lines.get(0), equalTo("Header"));
-        assertThat(lines.get(1), equalTo("Command: /unreg <player>"));
-        assertThat(lines.get(2), equalTo("Alternatives:"));
-        assertThat(lines.get(3), equalTo(" /unregister <player>"));
-    }
-
-    /**
-     * Generate an instance of {@link FoundCommandResult} with the given command and labels. All other fields aren't
-     * retrieved by {@link HelpProvider} and so are initialized to default values for the tests.
-     *
-     * @param command The command description
-     * @param labels The labels of the command (as in a real use case, they do not have to be correct)
-     * @return The generated FoundCommandResult object
-     */
-    private static FoundCommandResult newFoundResult(CommandDescription command, List<String> labels) {
-        return new FoundCommandResult(command, labels, Collections.emptyList(), 0.0, FoundResultStatus.SUCCESS);
-    }
-
-    private static String removeColors(String str) {
-        for (ChatColor color : ChatColor.values()) {
-            str = str.replace(color.toString(), "");
-        }
-        return str;
-    }
-    
-    private static List<String> getLines(CommandSender sender) {
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(sender, atLeastOnce()).sendMessage(captor.capture());
-        return captor.getAllValues().stream().map(s -> removeColors(s)).collect(Collectors.toList());
-    }
-
-    private static void setDefaultHelpMessages(HelpMessagesService helpMessagesService) {
-        given(helpMessagesService.buildLocalizedDescription(any(CommandDescription.class)))
-            .willAnswer(new ReturnsArgumentAt(0));
-        for (HelpMessage key : HelpMessage.values()) {
-            String text = key.name().replace("_", " ").toLowerCase(Locale.ROOT);
-            given(helpMessagesService.getMessage(key))
-                .willReturn(text.substring(0, 1).toUpperCase(Locale.ROOT) + text.substring(1));
-        }
-        for (DefaultPermission permission : DefaultPermission.values()) {
-            String text = permission.name().replace("_", " ").toLowerCase(Locale.ROOT);
-            given(helpMessagesService.getMessage(permission))
-                .willReturn(text.substring(0, 1).toUpperCase(Locale.ROOT) + text.substring(1));
-        }
-        for (HelpSection section : HelpSection.values()) {
-            String text = section.name().replace("_", " ").toLowerCase(Locale.ROOT);
-            given(helpMessagesService.getMessage(section))
-                .willReturn(text.substring(0, 1).toUpperCase(Locale.ROOT) + text.substring(1));
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/data/QuickCommandsProtectionManagerTest.java b/src/test/java/fr/xephi/authme/data/QuickCommandsProtectionManagerTest.java
deleted file mode 100644
index 70407567..00000000
--- a/src/test/java/fr/xephi/authme/data/QuickCommandsProtectionManagerTest.java
+++ /dev/null
@@ -1,80 +0,0 @@
-package fr.xephi.authme.data;
-
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerPermission;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.ProtectionSettings;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link QuickCommandsProtectionManager}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class QuickCommandsProtectionManagerTest {
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Test
-    public void shouldAllowCommand() {
-        // given
-        String playername = "PlayerName";
-        Player player = mockPlayerWithName(playername);
-        given(settings.getProperty(ProtectionSettings.QUICK_COMMANDS_DENIED_BEFORE_MILLISECONDS)).willReturn(0);
-        given(permissionsManager.hasPermission(player, PlayerPermission.QUICK_COMMANDS_PROTECTION)).willReturn(true);
-
-        String name = "TestName";
-
-        QuickCommandsProtectionManager qcpm = createQuickCommandsProtectioneManager();
-        qcpm.processJoin(player);
-
-        // when
-        boolean test1 = qcpm.isAllowed(name);
-        boolean test2 = qcpm.isAllowed(playername);
-
-        // then
-        assertThat(test1, equalTo(true));
-        assertThat(test2, equalTo(true));
-    }
-
-    @Test
-    public void shouldDenyCommand() {
-        // given
-        String name = "TestName1";
-        Player player = mockPlayerWithName(name);
-        given(settings.getProperty(ProtectionSettings.QUICK_COMMANDS_DENIED_BEFORE_MILLISECONDS)).willReturn(5000);
-
-        QuickCommandsProtectionManager qcpm = createQuickCommandsProtectioneManager();
-        given(permissionsManager.hasPermission(player, PlayerPermission.QUICK_COMMANDS_PROTECTION)).willReturn(true);
-        qcpm.processJoin(player);
-
-        // when
-        boolean test = qcpm.isAllowed(name);
-
-        // then
-        assertThat(test, equalTo(false));
-    }
-
-    private QuickCommandsProtectionManager createQuickCommandsProtectioneManager() {
-        return new QuickCommandsProtectionManager(settings, permissionsManager);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/data/TempbanManagerTest.java b/src/test/java/fr/xephi/authme/data/TempbanManagerTest.java
deleted file mode 100644
index a186920a..00000000
--- a/src/test/java/fr/xephi/authme/data/TempbanManagerTest.java
+++ /dev/null
@@ -1,265 +0,0 @@
-package fr.xephi.authme.data;
-
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import fr.xephi.authme.util.expiring.TimedCounter;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Calendar;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Map;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncDelayedTask;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.lessThan;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link TempbanManager}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class TempbanManagerTest {
-
-    private static final long DATE_TOLERANCE_MILLISECONDS = 200L;
-    private static final long TEST_EXPIRATION_THRESHOLD = 120_000L;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private Messages messages;
-
-    @Test
-    public void shouldAddCounts() {
-        // given
-        Settings settings = mockSettings(3, 60, "");
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-        String address = "192.168.1.1";
-
-        // when
-        manager.increaseCount(address, "Bob");
-        manager.increaseCount(address, "Todd");
-
-        // then
-        assertThat(manager.shouldTempban(address), equalTo(false));
-        assertHasCount(manager, address, "Bob", 1);
-        assertHasCount(manager, address, "Todd", 1);
-        manager.increaseCount(address, "Bob");
-        assertThat(manager.shouldTempban(address), equalTo(true));
-        assertThat(manager.shouldTempban("10.0.0.1"), equalTo(false));
-    }
-
-    @Test
-    public void shouldIncreaseAndResetCount() {
-        // given
-        String address = "192.168.1.2";
-        Settings settings = mockSettings(3, 60, "");
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-
-        // when
-        manager.increaseCount(address, "test");
-        manager.increaseCount(address, "test");
-        manager.increaseCount(address, "test");
-
-        // then
-        assertThat(manager.shouldTempban(address), equalTo(true));
-        assertHasCount(manager, address, "test", 3);
-
-        // when 2
-        manager.resetCount(address, "test");
-
-        // then 2
-        assertThat(manager.shouldTempban(address), equalTo(false));
-        assertHasNoEntries(manager, address);
-    }
-
-    @Test
-    public void shouldNotIncreaseCountForDisabledTempban() {
-        // given
-        String address = "192.168.1.3";
-        Settings settings = mockSettings(1, 5, "");
-        given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(false);
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-
-        // when
-        manager.increaseCount(address, "username");
-
-        // then
-        assertThat(manager.shouldTempban(address), equalTo(false));
-        assertHasNoEntries(manager, address);
-    }
-
-    @Test
-    public void shouldNotCheckCountIfTempbanIsDisabled() {
-        // given
-        String address = "192.168.1.4";
-        Settings settings = mockSettings(1, 5, "");
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-        given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(false);
-
-        // when
-        manager.increaseCount(address, "username");
-        // assumptions
-        assertThat(manager.shouldTempban(address), equalTo(true));
-        assertHasCount(manager, address, "username", 1);
-        // end assumptions
-        manager.reload(settings);
-        boolean result = manager.shouldTempban(address);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldNotIssueBanIfDisabled() {
-        // given
-        Settings settings = mockSettings(0, 0, "");
-        given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(false);
-        Player player = mock(Player.class);
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-
-        // when
-        manager.tempbanPlayer(player);
-
-        // then
-        verifyNoInteractions(player, bukkitService);
-    }
-
-    @Test
-    public void shouldBanPlayerIp() {
-        // given
-        Player player = mock(Player.class);
-        String ip = "123.45.67.89";
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        String banReason = "IP ban too many logins";
-        given(messages.retrieveSingle(player, MessageKey.TEMPBAN_MAX_LOGINS)).willReturn(banReason);
-        Settings settings = mockSettings(2, 100, "");
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-        setBukkitServiceToScheduleSyncDelayedTask(bukkitService);
-
-        // when
-        manager.tempbanPlayer(player);
-
-        // then
-        verify(player).kickPlayer(banReason);
-        ArgumentCaptor<Date> captor = ArgumentCaptor.forClass(Date.class);
-        verify(bukkitService).banIp(eq(ip), eq(banReason), captor.capture(), eq("AuthMe"));
-
-        // Compute the expected expiration date and check that the actual date is within the difference tolerance
-        Calendar cal = Calendar.getInstance();
-        cal.add(Calendar.MINUTE, 100);
-        long expectedExpiration = cal.getTime().getTime();
-        assertThat(Math.abs(captor.getValue().getTime() - expectedExpiration), lessThan(DATE_TOLERANCE_MILLISECONDS));
-    }
-
-    @Test
-    public void shouldBanPlayerIpCustom() {
-        // given
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("Bob");
-        String ip = "143.45.77.89";
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        String banCommand = "banip %ip% 15d IP ban too many logins";
-        Settings settings = mockSettings(2, 100, banCommand);
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-        setBukkitServiceToScheduleSyncDelayedTask(bukkitService);
-
-        // when
-        manager.tempbanPlayer(player);
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand(banCommand.replace("%ip%", ip));
-    }
-
-    @Test
-    public void shouldResetCountAfterBan() {
-        // given
-        Player player = mock(Player.class);
-        String ip = "22.44.66.88";
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        String banReason = "kick msg";
-        given(messages.retrieveSingle(player, MessageKey.TEMPBAN_MAX_LOGINS)).willReturn(banReason);
-        Settings settings = mockSettings(10, 60, "");
-        TempbanManager manager = new TempbanManager(bukkitService, messages, settings);
-        manager.increaseCount(ip, "user");
-        manager.increaseCount(ip, "name2");
-        manager.increaseCount(ip, "user");
-        setBukkitServiceToScheduleSyncDelayedTask(bukkitService);
-
-        // when
-        manager.tempbanPlayer(player);
-
-        // then
-        verify(player).kickPlayer(banReason);
-        assertHasNoEntries(manager, ip);
-    }
-
-    @Test
-    public void shouldPerformCleanup() {
-        // given
-        Map<String, TimedCounter<String>> counts = new HashMap<>();
-        TimedCounter<String> counter1 = mockCounter();
-        given(counter1.isEmpty()).willReturn(true);
-        counts.put("11.11.11.11", counter1);
-        TimedCounter<String> counter2 = mockCounter();
-        given(counter2.isEmpty()).willReturn(false);
-        counts.put("33.33.33.33", counter2);
-
-        TempbanManager manager = new TempbanManager(bukkitService, messages, mockSettings(3, 10, ""));
-        ReflectionTestUtils.setField(TempbanManager.class, manager, "ipLoginFailureCounts", counts);
-
-        // when
-        manager.performCleanup();
-
-        // then
-        verify(counter1).removeExpiredEntries();
-        verify(counter2).removeExpiredEntries();
-        assertThat(counts.keySet(), contains("33.33.33.33"));
-    }
-
-    private static Settings mockSettings(int maxTries, int tempbanLength, String customCommand) {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(SecuritySettings.TEMPBAN_ON_MAX_LOGINS)).willReturn(true);
-        given(settings.getProperty(SecuritySettings.MAX_LOGIN_TEMPBAN)).willReturn(maxTries);
-        given(settings.getProperty(SecuritySettings.TEMPBAN_LENGTH)).willReturn(tempbanLength);
-        given(settings.getProperty(SecuritySettings.TEMPBAN_MINUTES_BEFORE_RESET))
-            .willReturn((int) TEST_EXPIRATION_THRESHOLD / 60_000);
-        given(settings.getProperty(SecuritySettings.TEMPBAN_CUSTOM_COMMAND)).willReturn(customCommand);
-        return settings;
-    }
-
-    private static void assertHasNoEntries(TempbanManager manager, String address) {
-        Map<String, TimedCounter<String>> playerCounts = ReflectionTestUtils
-            .getFieldValue(TempbanManager.class, manager, "ipLoginFailureCounts");
-        TimedCounter<String> counter = playerCounts.get(address);
-        assertThat(counter == null || counter.isEmpty(), equalTo(true));
-    }
-
-    private static void assertHasCount(TempbanManager manager, String address, String name, int count) {
-        Map<String, TimedCounter<String>> playerCounts = ReflectionTestUtils
-            .getFieldValue(TempbanManager.class, manager, "ipLoginFailureCounts");
-        assertThat(playerCounts.get(address).get(name), equalTo(count));
-    }
-
-    @SuppressWarnings("unchecked")
-    private static <T> TimedCounter<T> mockCounter() {
-        return mock(TimedCounter.class);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/VerificationCodeManagerTest.java b/src/test/java/fr/xephi/authme/data/VerificationCodeManagerTest.java
deleted file mode 100644
index 147b0dd0..00000000
--- a/src/test/java/fr/xephi/authme/data/VerificationCodeManagerTest.java
+++ /dev/null
@@ -1,171 +0,0 @@
-package fr.xephi.authme.data;
-
-import ch.jalu.datasourcecolumns.data.DataSourceValueImpl;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.mail.EmailService;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerPermission;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.bukkit.entity.Player;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-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.only;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link VerificationCodeManager}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class VerificationCodeManagerTest {
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private EmailService emailService;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Before
-    public void setUpBasicBehavior() {
-        given(emailService.hasAllInformation()).willReturn(true);
-        given(settings.getProperty(SecuritySettings.VERIFICATION_CODE_EXPIRATION_MINUTES)).willReturn(1);
-    }
-
-    @Test
-    public void shouldRequireVerification() {
-        // given
-        String name1 = "ILoveTests";
-        Player player1 = mockPlayerWithName(name1);
-        given(dataSource.getEmail(name1)).willReturn(DataSourceValueImpl.of("ilovetests@test.com"));
-        given(permissionsManager.hasPermission(player1, PlayerPermission.VERIFICATION_CODE)).willReturn(true);
-        String name2 = "StillLovingTests";
-        Player player2 = mockPlayerWithName(name2);
-
-        VerificationCodeManager codeManager = createCodeManager();
-        codeManager.verify(name2);
-
-        // when
-        boolean test1 = codeManager.isVerificationRequired(player1);
-        boolean test2 = codeManager.isVerificationRequired(player2);
-
-        // then
-        assertThat(test1, equalTo(true));
-        assertThat(test2, equalTo(false));
-        verify(dataSource, only()).getEmail(name1);
-        verify(permissionsManager, only()).hasPermission(player1, PlayerPermission.VERIFICATION_CODE);
-    }
-
-    @Test
-    public void shouldNotRequireVerificationIfEmailSettingsAreIncomplete() {
-        // given
-        given(emailService.hasAllInformation()).willReturn(false);
-        VerificationCodeManager codeManager = createCodeManager();
-        Player player = mock(Player.class);
-
-        // when
-        boolean result = codeManager.isVerificationRequired(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verifyNoInteractions(permissionsManager, dataSource);
-    }
-
-    @Test
-    public void shouldNotRequireVerificationForMissingPermission() {
-        // given
-        Player player = mockPlayerWithName("ILoveTests");
-        given(permissionsManager.hasPermission(player, PlayerPermission.VERIFICATION_CODE)).willReturn(false);
-        VerificationCodeManager codeManager = createCodeManager();
-
-        // when
-        boolean result = codeManager.isVerificationRequired(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(permissionsManager).hasPermission(player, PlayerPermission.VERIFICATION_CODE);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldGenerateCode() {
-        // given
-        String player = "ILoveTests";
-        String email = "ilovetests@test.com";
-        given(dataSource.getEmail(player)).willReturn(DataSourceValueImpl.of(email));
-        VerificationCodeManager codeManager1 = createCodeManager();
-        VerificationCodeManager codeManager2 = createCodeManager();
-        codeManager2.codeExistOrGenerateNew(player);
-
-        // when
-        boolean test1 = codeManager1.hasCode(player);
-        boolean test2 = codeManager2.hasCode(player);
-
-        // then
-        assertThat(test1, equalTo(false));
-        assertThat(test2, equalTo(true));
-    }
-
-    @Test
-    public void shouldRequireCode() {
-        // given
-        String player = "ILoveTests";
-        String email = "ilovetests@test.com";
-        given(dataSource.getEmail(player)).willReturn(DataSourceValueImpl.of(email));
-        VerificationCodeManager codeManager1 = createCodeManager();
-        VerificationCodeManager codeManager2 = createCodeManager();
-        codeManager2.codeExistOrGenerateNew(player);
-
-        // when
-        boolean test1 = codeManager1.isCodeRequired(player);
-        boolean test2 = codeManager2.isCodeRequired(player);
-
-        // then
-        assertThat(test1, equalTo(false));
-        assertThat(test2, equalTo(true));
-    }
-
-    @Test
-    public void shouldVerifyCode() {
-        // given
-        String player = "ILoveTests";
-        String code = "193458";
-        String email = "ilovetests@test.com";
-        given(dataSource.getEmail(player)).willReturn(DataSourceValueImpl.of(email));
-        VerificationCodeManager codeManager1 = createCodeManager();
-        VerificationCodeManager codeManager2 = createCodeManager();
-        codeManager1.codeExistOrGenerateNew(player);
-
-        // when
-        boolean test1 = codeManager1.checkCode(player, code);
-        boolean test2 = codeManager2.checkCode(player, code);
-
-        // then
-        assertThat(test1, equalTo(false));
-        assertThat(test2, equalTo(false));
-    }
-
-    private VerificationCodeManager createCodeManager() {
-        return new VerificationCodeManager(settings, dataSource, emailService, permissionsManager);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/auth/PlayerAuthTest.java b/src/test/java/fr/xephi/authme/data/auth/PlayerAuthTest.java
deleted file mode 100644
index 360abdc9..00000000
--- a/src/test/java/fr/xephi/authme/data/auth/PlayerAuthTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package fr.xephi.authme.data.auth;
-
-import org.junit.Test;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link PlayerAuth} and its builder.
- */
-public class PlayerAuthTest {
-
-    @Test
-    public void shouldRemoveDatabaseDefaults() {
-        // given / when
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("Bobby")
-            .lastLogin(0L)
-            .lastIp("127.0.0.1")
-            .email("your@email.com")
-            .build();
-
-        // then
-        assertThat(auth.getNickname(), equalTo("bobby"));
-        assertThat(auth.getLastLogin(), nullValue());
-        // Note ljacqu 20171020: Although 127.0.0.1 is the default value, we need to keep it because it might
-        // legitimately be the resolved IP of a player
-        assertThat(auth.getLastIp(), equalTo("127.0.0.1"));
-        assertThat(auth.getEmail(), nullValue());
-    }
-
-    @Test
-    public void shouldThrowForMissingName() {
-        try {
-            // given / when
-            PlayerAuth.builder()
-                .email("test@example.org")
-                .groupId(3)
-                .build();
-
-            // then
-            fail("Expected exception to be thrown");
-        } catch (NullPointerException e) {
-            // all good
-        }
-    }
-
-    @Test
-    public void shouldCreatePlayerAuthWithNullValues() {
-        // given / when
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("Charlie")
-            .email(null)
-            .lastLogin(null)
-            .lastIp(null)
-            .groupId(19)
-            .locPitch(123.004f)
-            .build();
-
-        // then
-        assertThat(auth.getEmail(), nullValue());
-        assertThat(auth.getLastLogin(), nullValue());
-        assertThat(auth.getLastIp(), nullValue());
-        assertThat(auth.getGroupId(), equalTo(19));
-        assertThat(auth.getPitch(), equalTo(123.004f));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/captcha/LoginCaptchaManagerTest.java b/src/test/java/fr/xephi/authme/data/captcha/LoginCaptchaManagerTest.java
deleted file mode 100644
index 31976345..00000000
--- a/src/test/java/fr/xephi/authme/data/captcha/LoginCaptchaManagerTest.java
+++ /dev/null
@@ -1,174 +0,0 @@
-package fr.xephi.authme.data.captcha;
-
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import fr.xephi.authme.util.expiring.TimedCounter;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-
-import java.util.Locale;
-
-import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link LoginCaptchaManager}.
- */
-public class LoginCaptchaManagerTest {
-
-    @Test
-    public void shouldAddCounts() {
-        // given
-        Settings settings = mockSettings(3, 4);
-        LoginCaptchaManager manager = new LoginCaptchaManager(settings);
-        String player = "tester";
-
-        // when
-        for (int i = 0; i < 2; ++i) {
-            manager.increaseLoginFailureCount(player);
-        }
-
-        // then
-        assertThat(manager.isCaptchaRequired(player), equalTo(false));
-        manager.increaseLoginFailureCount(player);
-        assertThat(manager.isCaptchaRequired(player.toUpperCase(Locale.ROOT)), equalTo(true));
-        assertThat(manager.isCaptchaRequired("otherPlayer"), equalTo(false));
-    }
-
-    @Test
-    public void shouldCreateAndCheckCaptcha() {
-        // given
-        String name = "Miner";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        Settings settings = mockSettings(1, 4);
-        LoginCaptchaManager manager = new LoginCaptchaManager(settings);
-        String captchaCode = manager.getCaptchaCodeOrGenerateNew(name);
-
-        // when
-        boolean result = manager.checkCode(player, captchaCode);
-
-        // then
-        assertThat(captchaCode, stringWithLength(4));
-        assertThat(result, equalTo(true));
-        // Supplying correct code should clear the entry, and a code should be invalid if no entry is present
-        assertThat(manager.checkCode(player, "bogus"), equalTo(false));
-    }
-
-    @Test
-    public void shouldGenerateNewCodeOnFailure() {
-        // given
-        String name = "Tarheel";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        Settings settings = mockSettings(1, 9);
-        LoginCaptchaManager manager = new LoginCaptchaManager(settings);
-        String captchaCode = manager.getCaptchaCodeOrGenerateNew(name);
-
-        // when
-        boolean result = manager.checkCode(player, "wrongcode");
-
-        // then
-        assertThat(captchaCode, stringWithLength(9));
-        assertThat(result, equalTo(false));
-        assertThat(manager.getCaptchaCodeOrGenerateNew(name), not(equalTo(captchaCode)));
-    }
-
-    @Test
-    public void shouldHaveSameCodeAfterGeneration() {
-        // given
-        String player = "Tester";
-        Settings settings = mockSettings(1, 5);
-        LoginCaptchaManager manager = new LoginCaptchaManager(settings);
-
-        // when
-        String code1 = manager.getCaptchaCodeOrGenerateNew(player);
-        String code2 = manager.getCaptchaCodeOrGenerateNew(player);
-        String code3 = manager.getCaptchaCodeOrGenerateNew(player);
-
-        // then
-        assertThat(code1.length(), equalTo(5));
-        assertThat(code2, equalTo(code1));
-        assertThat(code3, equalTo(code1));
-    }
-
-    @Test
-    public void shouldIncreaseAndResetCount() {
-        // given
-        String player = "plaYer";
-        Settings settings = mockSettings(2, 3);
-        LoginCaptchaManager manager = new LoginCaptchaManager(settings);
-
-        // when
-        manager.increaseLoginFailureCount(player);
-        manager.increaseLoginFailureCount(player);
-
-        // then
-        assertThat(manager.isCaptchaRequired(player), equalTo(true));
-        assertHasCount(manager, player, 2);
-
-        // when 2
-        manager.resetLoginFailureCount(player);
-
-        // then 2
-        assertThat(manager.isCaptchaRequired(player), equalTo(false));
-        assertHasCount(manager, player, 0);
-    }
-
-    @Test
-    public void shouldNotIncreaseCountForDisabledCaptcha() {
-        // given
-        String player = "someone_";
-        Settings settings = mockSettings(1, 3);
-        given(settings.getProperty(SecuritySettings.ENABLE_LOGIN_FAILURE_CAPTCHA)).willReturn(false);
-        LoginCaptchaManager manager = new LoginCaptchaManager(settings);
-
-        // when
-        manager.increaseLoginFailureCount(player);
-
-        // then
-        assertThat(manager.isCaptchaRequired(player), equalTo(false));
-        assertHasCount(manager, player, 0);
-    }
-
-    @Test
-    public void shouldNotCheckCountIfCaptchaIsDisabled() {
-        // given
-        String player = "Robert001";
-        Settings settings = mockSettings(1, 5);
-        LoginCaptchaManager manager = new LoginCaptchaManager(settings);
-        given(settings.getProperty(SecuritySettings.ENABLE_LOGIN_FAILURE_CAPTCHA)).willReturn(false);
-
-        // when
-        manager.increaseLoginFailureCount(player);
-        // assumptions
-        assertThat(manager.isCaptchaRequired(player), equalTo(true));
-        assertHasCount(manager, player, 1);
-        // end assumptions
-        manager.reload(settings);
-        boolean result = manager.isCaptchaRequired(player);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    private static Settings mockSettings(int maxTries, int captchaLength) {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(SecuritySettings.ENABLE_LOGIN_FAILURE_CAPTCHA)).willReturn(true);
-        given(settings.getProperty(SecuritySettings.MAX_LOGIN_TRIES_BEFORE_CAPTCHA)).willReturn(maxTries);
-        given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(captchaLength);
-        given(settings.getProperty(SecuritySettings.CAPTCHA_COUNT_MINUTES_BEFORE_RESET)).willReturn(30);
-        return settings;
-    }
-
-    private static void assertHasCount(LoginCaptchaManager manager, String player, Integer count) {
-        TimedCounter<String> playerCounts = ReflectionTestUtils
-            .getFieldValue(LoginCaptchaManager.class, manager, "playerCounts");
-        assertThat(playerCounts.get(player.toLowerCase(Locale.ROOT)), equalTo(count));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/captcha/RegistrationCaptchaManagerTest.java b/src/test/java/fr/xephi/authme/data/captcha/RegistrationCaptchaManagerTest.java
deleted file mode 100644
index 4a71ab2c..00000000
--- a/src/test/java/fr/xephi/authme/data/captcha/RegistrationCaptchaManagerTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-package fr.xephi.authme.data.captcha;
-
-import fr.xephi.authme.ReflectionTestUtils;
-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 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;
-
-/**
- * Test for {@link RegistrationCaptchaManager}.
- */
-public class RegistrationCaptchaManagerTest {
-
-    @Test
-    public void shouldBeDisabled() {
-        // given
-        Settings settings = mock(Settings.class);
-        // Return false first time, and true after that
-        given(settings.getProperty(SecuritySettings.ENABLE_CAPTCHA_FOR_REGISTRATION))
-            .willReturn(false).willReturn(true);
-        given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(12);
-
-        // when
-        RegistrationCaptchaManager captchaManager1 = new RegistrationCaptchaManager(settings);
-        RegistrationCaptchaManager captchaManager2 = new RegistrationCaptchaManager(settings);
-
-        // then
-        assertThat(captchaManager1.isCaptchaRequired("bob"), equalTo(false));
-        assertThat(captchaManager2.isCaptchaRequired("bob"), equalTo(true));
-    }
-
-    @Test
-    public void shouldVerifyCodeSuccessfully() {
-        // given
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(SecuritySettings.ENABLE_CAPTCHA_FOR_REGISTRATION)).willReturn(true);
-        given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(12);
-
-        String captcha = "abc3";
-        RegistrationCaptchaManager captchaManager = new RegistrationCaptchaManager(settings);
-        getCodeMap(captchaManager).put("test", captcha);
-
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("TeSt");
-
-        // when
-        boolean isSuccessful = captchaManager.checkCode(player, captcha);
-
-        // then
-        assertThat(isSuccessful, equalTo(true));
-        assertThat(getCodeMap(captchaManager).isEmpty(), equalTo(true));
-        assertThat(captchaManager.isCaptchaRequired("test"), equalTo(false));
-    }
-
-    @Test
-    public void shouldGenerateAndRetrieveCode() {
-        // given
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(SecuritySettings.ENABLE_CAPTCHA_FOR_REGISTRATION)).willReturn(true);
-        int captchaLength = 9;
-        given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(captchaLength);
-        RegistrationCaptchaManager captchaManager = new RegistrationCaptchaManager(settings);
-
-        // when
-        String captcha1 = captchaManager.getCaptchaCodeOrGenerateNew("toast");
-        String captcha2 = captchaManager.getCaptchaCodeOrGenerateNew("Toast");
-
-        // then
-        assertThat(captcha1, equalTo(captcha2));
-        assertThat(captcha1, stringWithLength(captchaLength));
-
-        // given (2)
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("toast");
-
-        // when (2) / then (2)
-        assertThat(captchaManager.checkCode(player, captcha1), equalTo(true));
-    }
-
-    @SuppressWarnings("unchecked")
-    private static ExpiringMap<String, String> getCodeMap(RegistrationCaptchaManager captchaManager) {
-        CaptchaCodeStorage captchaStorage = ReflectionTestUtils.getFieldValue(
-            RegistrationCaptchaManager.class, captchaManager, "captchaCodeStorage");
-        return ReflectionTestUtils.getFieldValue(CaptchaCodeStorage.class, captchaStorage, "captchaCodes");
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/AllowFlightRestoreTypeTest.java b/src/test/java/fr/xephi/authme/data/limbo/AllowFlightRestoreTypeTest.java
deleted file mode 100644
index eb7ee389..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/AllowFlightRestoreTypeTest.java
+++ /dev/null
@@ -1,109 +0,0 @@
-package fr.xephi.authme.data.limbo;
-
-import org.bukkit.entity.Player;
-import org.junit.Test;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link AllowFlightRestoreType}.
- */
-public class AllowFlightRestoreTypeTest {
-
-    @Test
-    public void shouldRestoreValue() {
-        // given
-        LimboPlayer limboWithFly = newLimboWithAllowFlight(true);
-        LimboPlayer limboWithoutFly = newLimboWithAllowFlight(false);
-        Player player1 = mock(Player.class);
-        Player player2 = mock(Player.class);
-
-        // when
-        AllowFlightRestoreType.RESTORE.restoreAllowFlight(player1, limboWithFly);
-        AllowFlightRestoreType.RESTORE.restoreAllowFlight(player2, limboWithoutFly);
-
-        // then
-        verify(player1).setAllowFlight(true);
-        verify(player2).setAllowFlight(false);
-    }
-
-    @Test
-    public void shouldEnableFlight() {
-        // given
-        LimboPlayer limboWithFly = newLimboWithAllowFlight(true);
-        LimboPlayer limboWithoutFly = newLimboWithAllowFlight(false);
-        Player player1 = mock(Player.class);
-        Player player2 = mock(Player.class);
-
-        // when
-        AllowFlightRestoreType.ENABLE.restoreAllowFlight(player1, limboWithFly);
-        AllowFlightRestoreType.ENABLE.restoreAllowFlight(player2, limboWithoutFly);
-
-        // then
-        verify(player1).setAllowFlight(true);
-        verify(player2).setAllowFlight(true);
-    }
-
-
-    @Test
-    public void shouldDisableFlight() {
-        // given
-        LimboPlayer limboWithFly = newLimboWithAllowFlight(true);
-        LimboPlayer limboWithoutFly = newLimboWithAllowFlight(false);
-        Player player1 = mock(Player.class);
-        Player player2 = mock(Player.class);
-
-        // when
-        AllowFlightRestoreType.DISABLE.restoreAllowFlight(player1, limboWithFly);
-        AllowFlightRestoreType.DISABLE.restoreAllowFlight(player2, limboWithoutFly);
-
-        // then
-        verify(player1).setAllowFlight(false);
-        verify(player2).setAllowFlight(false);
-    }
-
-    @Test
-    public void shouldNotInteractWithPlayer() {
-        // given
-        LimboPlayer limboWithFly = newLimboWithAllowFlight(true);
-        LimboPlayer limboWithoutFly = newLimboWithAllowFlight(false);
-        Player player1 = mock(Player.class);
-        Player player2 = mock(Player.class);
-
-        // when
-        AllowFlightRestoreType.NOTHING.restoreAllowFlight(player1, limboWithFly);
-        AllowFlightRestoreType.NOTHING.restoreAllowFlight(player2, limboWithoutFly);
-
-        // then
-        verifyNoInteractions(player1, player2);
-    }
-
-    @Test
-    public void shouldRemoveFlightExceptForNothingType() {
-        // given
-        AllowFlightRestoreType noInteractionType = AllowFlightRestoreType.NOTHING;
-
-        for (AllowFlightRestoreType type : AllowFlightRestoreType.values()) {
-            Player player = mock(Player.class);
-
-            // when
-            type.processPlayer(player);
-
-            // then
-            if (type == noInteractionType) {
-                verifyNoInteractions(player);
-            } else {
-                verify(player).setAllowFlight(false);
-            }
-        }
-    }
-
-    private static LimboPlayer newLimboWithAllowFlight(boolean allowFlight) {
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        given(limbo.isCanFly()).willReturn(allowFlight);
-        return limbo;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerMatchers.java b/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerMatchers.java
deleted file mode 100644
index e2bc6808..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerMatchers.java
+++ /dev/null
@@ -1,137 +0,0 @@
-package fr.xephi.authme.data.limbo;
-
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-
-import static java.lang.String.format;
-import static java.util.stream.Collectors.toList;
-import static org.hamcrest.collection.IsIterableContainingInOrder.contains;
-
-/**
- * Contains matchers for LimboPlayer.
- */
-// Justification: Javadoc would be huge because of the many parameters
-@SuppressWarnings("checkstyle:MissingJavadocMethod")
-public final class LimboPlayerMatchers {
-
-    private LimboPlayerMatchers() {
-    }
-
-    public static Matcher<LimboPlayer> isLimbo(LimboPlayer limbo) {
-        UserGroup[] groups = limbo.getGroups().toArray(new UserGroup[limbo.getGroups().size()]);
-        return isLimbo(limbo.isOperator(), limbo.isCanFly(), limbo.getWalkSpeed(), limbo.getFlySpeed(), groups);
-    }
-
-    public static Matcher<LimboPlayer> isLimbo(boolean isOp, boolean canFly, float walkSpeed, float flySpeed,
-                                               UserGroup... groups) {
-        return new TypeSafeMatcher<LimboPlayer>() {
-            @Override
-            protected boolean matchesSafely(LimboPlayer item) {
-                return item.isOperator() == isOp
-                    && collectionContains(item.getGroups(), groups)
-                    && item.isCanFly() == canFly
-                    && walkSpeed == item.getWalkSpeed()
-                    && flySpeed == item.getFlySpeed();
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                List<String> groupNames = Arrays.stream(groups).map(UserGroup::getGroupName).collect(toList());
-                description.appendText(format("Limbo with isOp=%s, groups={%s}, canFly=%s, walkSpeed=%f, flySpeed=%f",
-                    isOp, String.join(" ,", groupNames), canFly, walkSpeed, flySpeed));
-            }
-
-            @Override
-            public void describeMismatchSafely(LimboPlayer item, Description description) {
-                List<String> groupNames = item.getGroups().stream()
-                    .map(UserGroup::getGroupName)
-                    .collect(toList());
-
-                description.appendText(format("Limbo with isOp=%s, groups={%s}, canFly=%s, walkSpeed=%f, flySpeed=%f",
-                    item.isOperator(), String.join(" ,", groupNames), item.isCanFly(),
-                    item.getWalkSpeed(), item.getFlySpeed()));
-            }
-        };
-    }
-
-    public static Matcher<LimboPlayer> hasLocation(String world, double x, double y, double z) {
-        return new TypeSafeMatcher<LimboPlayer>() {
-            @Override
-            protected boolean matchesSafely(LimboPlayer item) {
-                Location location = item.getLocation();
-                return location.getWorld().getName().equals(world)
-                    && location.getX() == x && location.getY() == y && location.getZ() == z;
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f",
-                    world, x, y, z));
-            }
-
-            @Override
-            public void describeMismatchSafely(LimboPlayer item, Description description) {
-                Location location = item.getLocation();
-                if (location == null) {
-                    description.appendText("Limbo with location = null");
-                } else {
-                    description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f",
-                        location.getWorld().getName(), location.getX(), location.getY(), location.getZ()));
-                }
-            }
-        };
-    }
-
-    public static Matcher<LimboPlayer> hasLocation(World world, double x, double y, double z) {
-        return hasLocation(world.getName(), x, y, z);
-    }
-
-    public static Matcher<LimboPlayer> hasLocation(String world, double x, double y, double z, float yaw, float pitch) {
-        return new TypeSafeMatcher<LimboPlayer>() {
-            @Override
-            protected boolean matchesSafely(LimboPlayer item) {
-                Location location = item.getLocation();
-                return hasLocation(location.getWorld(), location.getX(), location.getY(), location.getZ()).matches(item)
-                    && location.getYaw() == yaw && location.getPitch() == pitch;
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f, yaw=%f, pitch=%f",
-                    world, x, y, z, yaw, pitch));
-            }
-
-            @Override
-            public void describeMismatchSafely(LimboPlayer item, Description description) {
-                Location location = item.getLocation();
-                if (location == null) {
-                    description.appendText("Limbo with location = null");
-                } else {
-                    description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f, yaw=%f, pitch=%f",
-                        location.getWorld().getName(), location.getX(), location.getY(), location.getZ(),
-                        location.getYaw(), location.getPitch()));
-                }
-            }
-        };
-    }
-
-    public static Matcher<LimboPlayer> hasLocation(Location location) {
-        return hasLocation(location.getWorld().getName(), location.getX(), location.getY(), location.getZ(),
-            location.getYaw(), location.getPitch());
-    }
-
-    // Hamcrest's contains() doesn't like it when there are no items, so we need to check for the empty case explicitly
-    private static boolean collectionContains(Collection<UserGroup> givenItems, UserGroup... expectedItems) {
-        if (expectedItems.length == 0) {
-            return givenItems.isEmpty();
-        }
-        return contains(expectedItems).matches(givenItems);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManagerTest.java b/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManagerTest.java
deleted file mode 100644
index 5cbbb1ff..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManagerTest.java
+++ /dev/null
@@ -1,200 +0,0 @@
-package fr.xephi.authme.data.limbo;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.data.captcha.RegistrationCaptchaManager;
-import fr.xephi.authme.message.MessageKey;
-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.RestrictionSettings;
-import fr.xephi.authme.task.MessageTask;
-import fr.xephi.authme.task.TimeoutTask;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitTask;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static fr.xephi.authme.service.BukkitService.TICKS_PER_SECOND;
-import static org.hamcrest.Matchers.equalTo;
-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.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link LimboPlayerTaskManager}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class LimboPlayerTaskManagerTest {
-
-    @InjectMocks
-    private LimboPlayerTaskManager limboPlayerTaskManager;
-
-    @Mock
-    private Messages messages;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private RegistrationCaptchaManager registrationCaptchaManager;
-
-    @BeforeClass
-    public static void setupLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldRegisterMessageTask() {
-        // given
-        Player player = mock(Player.class);
-        LimboPlayer limboPlayer = mock(LimboPlayer.class);
-        MessageKey key = MessageKey.REGISTER_MESSAGE;
-        given(messages.retrieveSingle(player, key)).willReturn("Please register!");
-        int interval = 12;
-        given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(interval);
-
-        // when
-        limboPlayerTaskManager.registerMessageTask(player, limboPlayer, LimboMessageType.REGISTER);
-
-        // then
-        verify(limboPlayer).setMessageTask(any(MessageTask.class));
-        verify(messages).retrieveSingle(player, key);
-        verify(bukkitService).runTaskTimer(
-            any(MessageTask.class), eq(2L * TICKS_PER_SECOND), eq((long) interval * TICKS_PER_SECOND));
-    }
-
-    @Test
-    public void shouldNotScheduleTaskForZeroAsInterval() {
-        // given
-        Player player = mock(Player.class);
-        LimboPlayer limboPlayer = mock(LimboPlayer.class);
-
-        given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(0);
-
-        // when
-        limboPlayerTaskManager.registerMessageTask(player, limboPlayer, LimboMessageType.LOG_IN);
-
-        // then
-        verifyNoInteractions(limboPlayer, bukkitService);
-    }
-
-    @Test
-    public void shouldCancelExistingMessageTask() {
-        // given
-        String name = "rats";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        LimboPlayer limboPlayer = new LimboPlayer(null, true, Collections.singletonList(new UserGroup("grp")), false, 0.1f, 0.0f);
-        MessageTask existingMessageTask = mock(MessageTask.class);
-        limboPlayer.setMessageTask(existingMessageTask);
-        given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(8);
-        given(messages.retrieveSingle(player, MessageKey.REGISTER_MESSAGE)).willReturn("Please register!");
-
-        // when
-        limboPlayerTaskManager.registerMessageTask(player, limboPlayer, LimboMessageType.REGISTER);
-
-        // then
-        assertThat(limboPlayer.getMessageTask(), not(nullValue()));
-        assertThat(limboPlayer.getMessageTask(), not(sameInstance(existingMessageTask)));
-        verify(registrationCaptchaManager).isCaptchaRequired(name);
-        verify(messages).retrieveSingle(player, MessageKey.REGISTER_MESSAGE);
-        verify(existingMessageTask).cancel();
-    }
-
-    @Test
-    public void shouldInitializeMessageTaskWithCaptchaMessage() {
-        // given
-        String name = "race";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        LimboPlayer limboPlayer = new LimboPlayer(null, true, Collections.singletonList(new UserGroup("grp")), false, 0.1f, 0.0f);
-        given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(12);
-        given(registrationCaptchaManager.isCaptchaRequired(name)).willReturn(true);
-        String captcha = "M032";
-        given(registrationCaptchaManager.getCaptchaCodeOrGenerateNew(name)).willReturn(captcha);
-        given(messages.retrieveSingle(player, MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, captcha)).willReturn("Need to use captcha");
-
-        // when
-        limboPlayerTaskManager.registerMessageTask(player, limboPlayer, LimboMessageType.REGISTER);
-
-        // then
-        assertThat(limboPlayer.getMessageTask(), not(nullValue()));
-        verify(messages).retrieveSingle(player, MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, captcha);
-    }
-
-    @Test
-    public void shouldRegisterTimeoutTask() {
-        // given
-        Player player = mock(Player.class);
-        LimboPlayer limboPlayer = mock(LimboPlayer.class);
-        given(settings.getProperty(RestrictionSettings.TIMEOUT)).willReturn(30);
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(bukkitService.runTaskLater(any(TimeoutTask.class), anyLong())).willReturn(bukkitTask);
-
-        // when
-        limboPlayerTaskManager.registerTimeoutTask(player, limboPlayer);
-
-        // then
-        verify(limboPlayer).setTimeoutTask(bukkitTask);
-        verify(bukkitService).runTaskLater(any(TimeoutTask.class), eq(600L)); // 30 * TICKS_PER_SECOND
-        verify(messages).retrieveSingle(player, MessageKey.LOGIN_TIMEOUT_ERROR);
-    }
-
-    @Test
-    public void shouldNotRegisterTimeoutTaskForZeroTimeout() {
-        // given
-        Player player = mock(Player.class);
-        LimboPlayer limboPlayer = mock(LimboPlayer.class);
-        given(settings.getProperty(RestrictionSettings.TIMEOUT)).willReturn(0);
-
-        // when
-        limboPlayerTaskManager.registerTimeoutTask(player, limboPlayer);
-
-        // then
-        verifyNoInteractions(limboPlayer, bukkitService);
-    }
-
-    @Test
-    public void shouldCancelExistingTimeoutTask() {
-        // given
-        Player player = mock(Player.class);
-        LimboPlayer limboPlayer = new LimboPlayer(null, false, Collections.emptyList(), true, 0.3f, 0.1f);
-        BukkitTask existingTask = mock(BukkitTask.class);
-        limboPlayer.setTimeoutTask(existingTask);
-        given(settings.getProperty(RestrictionSettings.TIMEOUT)).willReturn(18);
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(bukkitService.runTaskLater(any(TimeoutTask.class), anyLong())).willReturn(bukkitTask);
-
-        // when
-        limboPlayerTaskManager.registerTimeoutTask(player, limboPlayer);
-
-        // then
-        verify(existingTask).cancel();
-        assertThat(limboPlayer.getTimeoutTask(), equalTo(bukkitTask));
-        verify(bukkitService).runTaskLater(any(TimeoutTask.class), eq(360L)); // 18 * TICKS_PER_SECOND
-        verify(messages).retrieveSingle(player, MessageKey.LOGIN_TIMEOUT_ERROR);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/LimboServiceHelperTest.java b/src/test/java/fr/xephi/authme/data/limbo/LimboServiceHelperTest.java
deleted file mode 100644
index 418ce698..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/LimboServiceHelperTest.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package fr.xephi.authme.data.limbo;
-
-import fr.xephi.authme.TestHelper;
-import org.bukkit.Location;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Collections;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link LimboServiceHelper}.
- * <p>
- * Note: some methods are tested directly where they are used via {@link LimboServiceTest}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class LimboServiceHelperTest {
-
-    @InjectMocks
-    private LimboServiceHelper limboServiceHelper;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldMergeLimboPlayers() {
-        // given
-        Location newLocation = mock(Location.class);
-        LimboPlayer newLimbo = new LimboPlayer(newLocation, false, Collections.singletonList(new UserGroup("grp-new")), false, 0.0f, 0.0f);
-        Location oldLocation = mock(Location.class);
-        LimboPlayer oldLimbo = new LimboPlayer(oldLocation, true, Collections.singletonList(new UserGroup("grp-old")), true, 0.1f, 0.8f);
-
-        // when
-        LimboPlayer result = limboServiceHelper.merge(newLimbo, oldLimbo);
-
-        // then
-        assertThat(result.getLocation(), equalTo(oldLocation));
-        assertThat(result.isOperator(), equalTo(true));
-        assertThat(result.getGroups(), contains(new UserGroup("grp-old")));
-        assertThat(result.isCanFly(), equalTo(true));
-        assertThat(result.getWalkSpeed(), equalTo(0.1f));
-        assertThat(result.getFlySpeed(), equalTo(0.8f));
-    }
-
-    @Test
-    public void shouldFallBackToNewLimboForMissingData() {
-        // given
-        Location newLocation = mock(Location.class);
-        LimboPlayer newLimbo = new LimboPlayer(newLocation, false, Collections.singletonList(new UserGroup("grp-new")), true, 0.3f, 0.0f);
-        LimboPlayer oldLimbo = new LimboPlayer(null, false, Collections.emptyList(), false, 0.1f, 0.1f);
-
-        // when
-        LimboPlayer result = limboServiceHelper.merge(newLimbo, oldLimbo);
-
-        // then
-        assertThat(result.getLocation(), equalTo(newLocation));
-        assertThat(result.isOperator(), equalTo(false));
-        assertThat(result.getGroups(), contains(new UserGroup("grp-new")));
-        assertThat(result.isCanFly(), equalTo(true));
-        assertThat(result.getWalkSpeed(), equalTo(0.3f));
-        assertThat(result.getFlySpeed(), equalTo(0.1f));
-    }
-
-    @Test
-    public void shouldHandleNullInputs() {
-        // given
-        LimboPlayer limbo = mock(LimboPlayer.class);
-
-        // when
-        LimboPlayer result1 = limboServiceHelper.merge(limbo, null);
-        LimboPlayer result2 = limboServiceHelper.merge(null, limbo);
-        LimboPlayer result3 = limboServiceHelper.merge(null, null);
-
-        // then
-        verifyNoInteractions(limbo);
-        assertThat(result1, equalTo(limbo));
-        assertThat(result2, equalTo(limbo));
-        assertThat(result3, nullValue());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/LimboServiceTest.java b/src/test/java/fr/xephi/authme/data/limbo/LimboServiceTest.java
deleted file mode 100644
index 44839c13..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/LimboServiceTest.java
+++ /dev/null
@@ -1,252 +0,0 @@
-package fr.xephi.authme.data.limbo;
-
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.limbo.persistence.LimboPersistence;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.SpawnLoader;
-import fr.xephi.authme.settings.properties.LimboSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Map;
-
-import static org.hamcrest.Matchers.equalTo;
-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.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-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.verifyNoInteractions;
-
-/**
- * Test for {@link LimboService}, and {@link LimboServiceHelper}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class LimboServiceTest {
-
-    @InjectDelayed
-    private LimboService limboService;
-
-    @InjectDelayed
-    private LimboServiceHelper limboServiceHelper;
-
-    @Mock
-    private SpawnLoader spawnLoader;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private LimboPlayerTaskManager taskManager;
-
-    @Mock
-    private LimboPersistence limboPersistence;
-
-    @Mock
-    private AuthGroupHandler authGroupHandler;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Before
-    public void mockSettings() {
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(false);
-    }
-
-    @Test
-    public void shouldCreateLimboPlayer() {
-        // given
-        Player player = newPlayer("Bobby", true, 0.3f, false, 0.2f);
-        Location playerLoc = mock(Location.class);
-        given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(playerLoc);
-        given(permissionsManager.hasGroupSupport()).willReturn(true);
-        given(permissionsManager.getGroups(player)).willReturn(Collections.singletonList(new UserGroup("permgrwp")));
-        given(settings.getProperty(LimboSettings.RESTORE_ALLOW_FLIGHT)).willReturn(AllowFlightRestoreType.ENABLE);
-
-        // when
-        limboService.createLimboPlayer(player, true);
-
-        // then
-        verify(taskManager).registerMessageTask(eq(player), any(LimboPlayer.class), eq(LimboMessageType.LOG_IN));
-        verify(taskManager).registerTimeoutTask(eq(player), any(LimboPlayer.class));
-        verify(player).setAllowFlight(false);
-        verify(player).setFlySpeed(0.0f);
-        verify(player).setWalkSpeed(0.0f);
-
-        assertThat(limboService.hasLimboPlayer("Bobby"), equalTo(true));
-        LimboPlayer limbo = limboService.getLimboPlayer("Bobby");
-        verify(authGroupHandler).setGroup(player, limbo, AuthGroupType.REGISTERED_UNAUTHENTICATED);
-        assertThat(limbo, not(nullValue()));
-        assertThat(limbo.isOperator(), equalTo(true));
-        assertThat(limbo.getWalkSpeed(), equalTo(0.3f));
-        assertThat(limbo.isCanFly(), equalTo(false));
-        assertThat(limbo.getFlySpeed(), equalTo(0.2f));
-        assertThat(limbo.getLocation(), equalTo(playerLoc));
-        assertThat(limbo.getGroups(), equalTo(Collections.singletonList(new UserGroup("permgrwp"))));
-    }
-
-    @Test
-    public void shouldNotKeepOpStatusForUnregisteredPlayer() {
-        // given
-        Player player = newPlayer("CharleS", true, 0.1f, true, 0.4f);
-        Location playerLoc = mock(Location.class);
-        given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(playerLoc);
-        given(permissionsManager.hasGroupSupport()).willReturn(false);
-        given(settings.getProperty(LimboSettings.RESTORE_ALLOW_FLIGHT)).willReturn(AllowFlightRestoreType.RESTORE);
-
-        // when
-        limboService.createLimboPlayer(player, false);
-
-        // then
-        verify(taskManager).registerMessageTask(eq(player), any(LimboPlayer.class), eq(LimboMessageType.REGISTER));
-        verify(taskManager).registerTimeoutTask(eq(player), any(LimboPlayer.class));
-        verify(permissionsManager, only()).hasGroupSupport();
-        verify(player).setAllowFlight(false);
-        verify(player).setFlySpeed(0.0f);
-        verify(player).setWalkSpeed(0.0f);
-
-        LimboPlayer limbo = limboService.getLimboPlayer("charles");
-        verify(authGroupHandler).setGroup(player, limbo, AuthGroupType.UNREGISTERED);
-        assertThat(limbo, not(nullValue()));
-        assertThat(limbo.isOperator(), equalTo(false));
-        assertThat(limbo.getWalkSpeed(), equalTo(0.1f));
-        assertThat(limbo.isCanFly(), equalTo(true));
-        assertThat(limbo.getFlySpeed(), equalTo(0.4f));
-        assertThat(limbo.getLocation(), equalTo(playerLoc));
-        assertThat(limbo.getGroups(), equalTo(Collections.emptyList()));
-    }
-
-    @Test
-    public void shouldClearTasksOnAlreadyExistingLimbo() {
-        // given
-        LimboPlayer existingLimbo = mock(LimboPlayer.class);
-        getLimboMap().put("carlos", existingLimbo);
-        Player player = newPlayer("Carlos");
-        given(settings.getProperty(LimboSettings.RESTORE_ALLOW_FLIGHT)).willReturn(AllowFlightRestoreType.ENABLE);
-
-        // when
-        limboService.createLimboPlayer(player, false);
-
-        // then
-        verify(existingLimbo).clearTasks();
-        LimboPlayer newLimbo = limboService.getLimboPlayer("Carlos");
-        verify(authGroupHandler).setGroup(player, newLimbo, AuthGroupType.UNREGISTERED);
-        assertThat(newLimbo, not(nullValue()));
-        assertThat(newLimbo, not(sameInstance(existingLimbo)));
-    }
-
-    @Test
-    public void shouldRestoreData() {
-        // given
-        LimboPlayer limbo = Mockito.spy(convertToLimboPlayer(
-            newPlayer("John", true, 0.4f, false, 0.0f), null, Collections.emptyList()));
-        getLimboMap().put("john", limbo);
-        Player player = newPlayer("John", false, 0.2f, false, 0.7f);
-
-        given(settings.getProperty(LimboSettings.RESTORE_ALLOW_FLIGHT)).willReturn(AllowFlightRestoreType.ENABLE);
-        given(settings.getProperty(LimboSettings.RESTORE_WALK_SPEED)).willReturn(WalkFlySpeedRestoreType.RESTORE);
-        given(settings.getProperty(LimboSettings.RESTORE_FLY_SPEED)).willReturn(WalkFlySpeedRestoreType.RESTORE_NO_ZERO);
-
-        // when
-        limboService.restoreData(player);
-
-        // then
-        verify(player).setOp(true);
-        verify(player).setWalkSpeed(0.4f);
-        verify(player).setAllowFlight(true);
-        verify(player).setFlySpeed(LimboPlayer.DEFAULT_FLY_SPEED);
-        verify(limbo).clearTasks();
-        verify(authGroupHandler).setGroup(player, limbo, AuthGroupType.LOGGED_IN);
-        assertThat(limboService.hasLimboPlayer("John"), equalTo(false));
-    }
-
-    @Test
-    public void shouldHandleMissingLimboPlayerWhileRestoring() {
-        // given
-        Player player = newPlayer("Test");
-
-        // when
-        limboService.restoreData(player);
-
-        // then
-        verify(player, only()).getName();
-        verify(authGroupHandler).setGroup(player, null, AuthGroupType.LOGGED_IN);
-    }
-
-    @Test
-    public void shouldReplaceTasks() {
-        // given
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        getLimboMap().put("jeff", limbo);
-        Player player = newPlayer("JEFF");
-
-
-        // when
-        limboService.replaceTasksAfterRegistration(player);
-
-        // then
-        verify(taskManager).registerTimeoutTask(player, limbo);
-        verify(taskManager).registerMessageTask(player, limbo, LimboMessageType.LOG_IN);
-        verify(authGroupHandler).setGroup(player, limbo, AuthGroupType.REGISTERED_UNAUTHENTICATED);
-    }
-
-    @Test
-    public void shouldHandleMissingLimboForReplaceTasks() {
-        // given
-        Player player = newPlayer("ghost");
-
-        // when
-        limboService.replaceTasksAfterRegistration(player);
-
-        // then
-        verifyNoInteractions(taskManager);
-        verify(authGroupHandler).setGroup(player, null, AuthGroupType.REGISTERED_UNAUTHENTICATED);
-    }
-
-    private static Player newPlayer(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-
-    private static Player newPlayer(String name, boolean isOp, float walkSpeed, boolean canFly, float flySpeed) {
-        Player player = newPlayer(name);
-        given(player.isOp()).willReturn(isOp);
-        given(player.getWalkSpeed()).willReturn(walkSpeed);
-        given(player.getAllowFlight()).willReturn(canFly);
-        given(player.getFlySpeed()).willReturn(flySpeed);
-        return player;
-    }
-
-    private static LimboPlayer convertToLimboPlayer(Player player, Location location, Collection<UserGroup> groups) {
-        return new LimboPlayer(location, player.isOp(), groups, player.getAllowFlight(),
-            player.getWalkSpeed(), player.getFlySpeed());
-    }
-
-    private Map<String, LimboPlayer> getLimboMap() {
-        return ReflectionTestUtils.getFieldValue(LimboService.class, limboService, "entries");
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/WalkFlySpeedRestoreTypeTest.java b/src/test/java/fr/xephi/authme/data/limbo/WalkFlySpeedRestoreTypeTest.java
deleted file mode 100644
index f8aa2719..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/WalkFlySpeedRestoreTypeTest.java
+++ /dev/null
@@ -1,108 +0,0 @@
-package fr.xephi.authme.data.limbo;
-
-import org.bukkit.entity.Player;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.data.limbo.LimboPlayer.DEFAULT_FLY_SPEED;
-import static fr.xephi.authme.data.limbo.LimboPlayer.DEFAULT_WALK_SPEED;
-import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.DEFAULT;
-import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.MAX_RESTORE;
-import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.RESTORE;
-import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.RESTORE_NO_ZERO;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link WalkFlySpeedRestoreType}.
- */
-@RunWith(Parameterized.class)
-public class WalkFlySpeedRestoreTypeTest {
-
-    private final TestParameters parameters;
-
-    public WalkFlySpeedRestoreTypeTest(TestParameters parameters) {
-        this.parameters = parameters;
-    }
-
-    @Test
-    public void shouldRestoreToExpectedValue() {
-        // given
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        given(limbo.getWalkSpeed()).willReturn(parameters.givenLimboWalkSpeed);
-        given(limbo.getFlySpeed()).willReturn(parameters.givenLimboFlySpeed);
-
-        Player player = mock(Player.class);
-        given(player.getWalkSpeed()).willReturn(parameters.givenPlayerWalkSpeed);
-        given(player.getFlySpeed()).willReturn(parameters.givenPlayerFlySpeed);
-
-        // when
-        parameters.testedType.restoreWalkSpeed(player, limbo);
-        parameters.testedType.restoreFlySpeed(player, limbo);
-
-        // then
-        verify(player).setWalkSpeed(parameters.expectedWalkSpeed);
-        verify(player).setFlySpeed(parameters.expectedFlySpeed);
-    }
-    
-    @Parameterized.Parameters(name = "{0}")
-    public static List<Object[]> buildParams() {
-        List<TestParameters> parameters = Arrays.asList(
-            create(RESTORE).withLimbo(0.1f, 0.4f).withPlayer(0.3f, 0.9f).expect(0.1f, 0.4f),
-            create(RESTORE).withLimbo(0.9f, 0.2f).withPlayer(0.3f, 0.0f).expect(0.9f, 0.2f),
-            create(MAX_RESTORE).withLimbo(0.3f, 0.8f).withPlayer(0.5f, 0.2f).expect(0.5f, 0.8f),
-            create(MAX_RESTORE).withLimbo(0.4f, 0.2f).withPlayer(0.1f, 0.4f).expect(0.4f, 0.4f),
-            create(RESTORE_NO_ZERO).withLimbo(0.1f, 0.2f).withPlayer(0.5f, 0.1f).expect(0.1f, 0.2f),
-            create(RESTORE_NO_ZERO).withLimbo(0.0f, 0.005f).withPlayer(0.4f, 0.8f).expect(DEFAULT_WALK_SPEED, DEFAULT_FLY_SPEED),
-            create(DEFAULT).withLimbo(0.1f, 0.7f).withPlayer(0.4f, 0.0f).expect(DEFAULT_WALK_SPEED, DEFAULT_FLY_SPEED)
-        );
-
-        // Convert List<TestParameters> to List<Object[]>
-        return parameters.stream().map(p -> new Object[]{p}).collect(Collectors.toList());
-    }
-
-    private static TestParameters create(WalkFlySpeedRestoreType testedType) {
-        TestParameters params = new TestParameters();
-        params.testedType = testedType;
-        return params;
-    }
-
-    private static final class TestParameters {
-        private WalkFlySpeedRestoreType testedType;
-        private float givenLimboWalkSpeed;
-        private float givenLimboFlySpeed;
-        private float givenPlayerWalkSpeed;
-        private float givenPlayerFlySpeed;
-        private float expectedWalkSpeed;
-        private float expectedFlySpeed;
-        
-        TestParameters withLimbo(float walkSpeed, float flySpeed) {
-            this.givenLimboWalkSpeed = walkSpeed;
-            this.givenLimboFlySpeed = flySpeed;
-            return this;
-        }
-        
-        TestParameters withPlayer(float walkSpeed, float flySpeed) {
-            this.givenPlayerWalkSpeed = walkSpeed;
-            this.givenPlayerFlySpeed = flySpeed;
-            return this;
-        }
-        
-        TestParameters expect(float walkSpeed, float flySpeed) {
-            this.expectedWalkSpeed = walkSpeed;
-            this.expectedFlySpeed = flySpeed;
-            return this;
-        }
-
-        @Override
-        public String toString() {
-            return testedType + " {" + expectedWalkSpeed + ", " + expectedFlySpeed + "}";
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/persistence/DistributedFilesPersistenceHandlerTest.java b/src/test/java/fr/xephi/authme/data/limbo/persistence/DistributedFilesPersistenceHandlerTest.java
deleted file mode 100644
index f223bdf1..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/persistence/DistributedFilesPersistenceHandlerTest.java
+++ /dev/null
@@ -1,216 +0,0 @@
-package fr.xephi.authme.data.limbo.persistence;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.limbo.LimboPlayer;
-import fr.xephi.authme.data.limbo.UserGroup;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.LimboSettings;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.hamcrest.Matcher;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Collections;
-import java.util.UUID;
-
-import static fr.xephi.authme.TestHelper.PROJECT_ROOT;
-import static fr.xephi.authme.TestHelper.TEST_RESOURCES_FOLDER;
-import static fr.xephi.authme.data.limbo.LimboPlayerMatchers.hasLocation;
-import static fr.xephi.authme.data.limbo.LimboPlayerMatchers.isLimbo;
-import static java.util.UUID.fromString;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.arrayContainingInAnyOrder;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link DistributedFilesPersistenceHandler}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class DistributedFilesPersistenceHandlerTest {
-
-    /** Player is in seg32-10110 and should be migrated into seg16-f. */
-    private static final UUID MIGRATED_UUID = fromString("f6a97c88-7c8f-c12e-4931-6206d4ca067d");
-    private static final Matcher<LimboPlayer> MIGRATED_LIMBO_MATCHER =
-        isLimbo(false, true, 0.2f, 0.1f, new UserGroup("noob"));
-
-    /** Existing player in seg16-f. */
-    private static final UUID UUID_FAB69 = fromString("fab69c88-2cd0-1fed-f00d-dead14ca067d");
-    private static final Matcher<LimboPlayer> FAB69_MATCHER =
-        isLimbo(false, false, 0.2f, 0.1f, new UserGroup(""));
-
-    /** Player in seg16-8. */
-    private static final UUID UUID_STAFF = fromString("88897c88-7c8f-c12e-4931-6206d4ca067d");
-    private static final Matcher<LimboPlayer> STAFF_MATCHER =
-        isLimbo(true, false, 0.3f, 0.1f, new UserGroup("staff"), new UserGroup("mod"));
-
-    /** Player in seg16-8. */
-    private static final UUID UUID_8C679 = fromString("8c679491-1234-abcd-9102-1fa6e0cc3f81");
-    private static final Matcher<LimboPlayer> SC679_MATCHER =
-        isLimbo(false, true, 0.1f, 0.0f, new UserGroup("primary"));
-
-    /** UUID for which no data is stored (belongs to a segment file that does not exist, seg16-4). */
-    private static final UUID UNKNOWN_UUID = fromString("42d1cc0b-8f12-d04a-e7ba-a067d05cdc39");
-
-    /** UUID for which no data is stored (belongs to an existing segment file: seg16-8). */
-    private static final UUID UNKNOWN_UUID2 = fromString("84d1cc0b-8f12-d04a-e7ba-a067d05cdc39");
-
-
-    @InjectDelayed
-    private DistributedFilesPersistenceHandler persistenceHandler;
-
-    @Mock
-    private Settings settings;
-    @Mock
-    private BukkitService bukkitService;
-    @DataFolder
-    private File dataFolder;
-    private File playerDataFolder;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    public void setUpClasses() throws IOException {
-        given(settings.getProperty(LimboSettings.DISTRIBUTION_SIZE)).willReturn(SegmentSize.SIXTEEN);
-        dataFolder = temporaryFolder.newFolder();
-        playerDataFolder = new File(dataFolder, "playerdata");
-        playerDataFolder.mkdir();
-
-        File limboFilesFolder = new File(TEST_RESOURCES_FOLDER + PROJECT_ROOT + "data/limbo");
-        for (File file : limboFilesFolder.listFiles()) {
-            File from = new File(playerDataFolder, file.getName());
-            Files.copy(file, from);
-        }
-
-        given(bukkitService.getWorld(anyString()))
-            .willAnswer(invocation -> {
-                World world = mock(World.class);
-                given(world.getName()).willReturn(invocation.getArgument(0));
-                return world;
-            });
-    }
-
-    // Note ljacqu 20170314: These tests are a little slow to set up; therefore we sometimes
-    // test things in one test that would traditionally belong into two separate tests
-
-    @Test
-    public void shouldMigrateOldSegmentFilesOnStartup() {
-        // Ensure that only the files of the current segmenting scheme remain
-        assertThat(playerDataFolder.list(), arrayContainingInAnyOrder("seg16-8-limbo.json", "seg16-f-limbo.json"));
-
-        // Check that the expected limbo players can be read
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(MIGRATED_UUID)), MIGRATED_LIMBO_MATCHER);
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_FAB69)), FAB69_MATCHER);
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_STAFF)), STAFF_MATCHER);
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_8C679)), SC679_MATCHER);
-
-        // Check that unknown players are null (whose segment file exists and does not exist)
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UNKNOWN_UUID)), nullValue());
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UNKNOWN_UUID2)), nullValue());
-    }
-
-    @Test
-    public void shouldRemovePlayer() {
-        // given
-        Player playerToRemove = mockPlayerWithUuid(UUID_STAFF);
-        Player unknownPlayerToRemove = mockPlayerWithUuid(UNKNOWN_UUID);
-
-        // when
-        persistenceHandler.removeLimboPlayer(playerToRemove);
-        persistenceHandler.removeLimboPlayer(unknownPlayerToRemove);
-
-        // then
-        assertThat(persistenceHandler.getLimboPlayer(playerToRemove), nullValue());
-        assertThat(persistenceHandler.getLimboPlayer(unknownPlayerToRemove), nullValue());
-        // Player in same segment should still exist...
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_8C679)), SC679_MATCHER);
-
-        // Check that we didn't create seg16-4 by deleting UNKNOWN_UUID.
-        assertThat(playerDataFolder.list(), arrayContainingInAnyOrder("seg16-8-limbo.json", "seg16-f-limbo.json"));
-    }
-
-    @Test
-    public void shouldAddPlayer() {
-        // given
-        Player uuidToAdd1 = mockPlayerWithUuid(UNKNOWN_UUID);
-        Location location1 = mockLocation("1world");
-        LimboPlayer limbo1 = new LimboPlayer(location1, false, Collections.singletonList(new UserGroup("group-1")), true, 0.1f, 0.2f);
-        Player uuidToAdd2 = mockPlayerWithUuid(UNKNOWN_UUID2);
-        Location location2 = mockLocation("2world");
-        LimboPlayer limbo2 = new LimboPlayer(location2, true, Collections.emptyList(), false, 0.0f, 0.25f);
-
-        // when
-        persistenceHandler.saveLimboPlayer(uuidToAdd1, limbo1);
-        persistenceHandler.saveLimboPlayer(uuidToAdd2, limbo2);
-
-        // then
-        LimboPlayer addedPlayer1 = persistenceHandler.getLimboPlayer(uuidToAdd1);
-        assertThat(addedPlayer1, isLimbo(limbo1));
-        assertThat(addedPlayer1, hasLocation(location1));
-        LimboPlayer addedPlayer2 = persistenceHandler.getLimboPlayer(uuidToAdd2);
-        assertThat(addedPlayer2, isLimbo(limbo2));
-        assertThat(addedPlayer2, hasLocation(location2));
-
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(MIGRATED_UUID)), MIGRATED_LIMBO_MATCHER);
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_FAB69)), FAB69_MATCHER);
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_STAFF)), STAFF_MATCHER);
-        assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_8C679)), SC679_MATCHER);
-    }
-
-    @Test
-    public void shouldHandleReadErrorGracefully() throws IOException {
-        // given
-        // assumption
-        File invalidFile = new File(playerDataFolder, "seg16-4-limbo.json");
-        assertThat(invalidFile.exists(), equalTo(false));
-        Files.write("not valid json".getBytes(), invalidFile);
-
-        // when
-        LimboPlayer result = persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UNKNOWN_UUID));
-
-        // then
-        assertThat(result, nullValue());
-    }
-
-    private static Player mockPlayerWithUuid(UUID uuid) {
-        Player player = mock(Player.class);
-        given(player.getUniqueId()).willReturn(uuid);
-        return player;
-    }
-
-    private static World mockWorldWithName(String name) {
-        World world = mock(World.class);
-        given(world.getName()).willReturn(name);
-        return world;
-    }
-
-    private static Location mockLocation(String worldName) {
-        World world = mockWorldWithName(worldName);
-        Location location = mock(Location.class);
-        given(location.getWorld()).willReturn(world);
-        return location;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/persistence/IndividualFilesPersistenceHandlerTest.java b/src/test/java/fr/xephi/authme/data/limbo/persistence/IndividualFilesPersistenceHandlerTest.java
deleted file mode 100644
index 77af8567..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/persistence/IndividualFilesPersistenceHandlerTest.java
+++ /dev/null
@@ -1,129 +0,0 @@
-package fr.xephi.authme.data.limbo.persistence;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.limbo.LimboPlayer;
-import fr.xephi.authme.data.limbo.UserGroup;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.util.FileUtils;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.util.Collections;
-import java.util.UUID;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link IndividualFilesPersistenceHandler}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class IndividualFilesPersistenceHandlerTest {
-
-    private static final UUID SAMPLE_UUID = UUID.nameUUIDFromBytes("PersistenceTest".getBytes());
-    private static final String SOURCE_FOLDER = TestHelper.PROJECT_ROOT + "data/backup/";
-
-    @InjectDelayed
-    private IndividualFilesPersistenceHandler handler;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @DataFolder
-    private File dataFolder;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeInjecting
-    public void copyTestFiles() throws IOException {
-        dataFolder = temporaryFolder.newFolder();
-        File playerFolder = new File(dataFolder, FileUtils.makePath("playerdata", SAMPLE_UUID.toString()));
-        if (!playerFolder.mkdirs()) {
-            throw new IllegalStateException("Cannot create '" + playerFolder.getAbsolutePath() + "'");
-        }
-        Files.copy(TestHelper.getJarPath(FileUtils.makePath(SOURCE_FOLDER, "sample-folder", "data.json")),
-            new File(playerFolder, "data.json").toPath());
-    }
-
-    @Test
-    public void shouldReadDataFromFile() {
-        // given
-        Player player = mock(Player.class);
-        given(player.getUniqueId()).willReturn(SAMPLE_UUID);
-        World world = mock(World.class);
-        given(bukkitService.getWorld("nether")).willReturn(world);
-
-        // when
-        LimboPlayer data = handler.getLimboPlayer(player);
-
-        // then
-        assertThat(data, not(nullValue()));
-        assertThat(data.isOperator(), equalTo(true));
-        assertThat(data.isCanFly(), equalTo(true));
-        assertThat(data.getWalkSpeed(), equalTo(0.2f));
-        assertThat(data.getFlySpeed(), equalTo(0.1f));
-        assertThat(data.getGroups(), contains(new UserGroup("players")));
-        Location location = data.getLocation();
-        assertThat(location.getX(), equalTo(-113.219));
-        assertThat(location.getY(), equalTo(72.0));
-        assertThat(location.getZ(), equalTo(130.637));
-        assertThat(location.getWorld(), equalTo(world));
-        assertThat(location.getPitch(), equalTo(24.15f));
-        assertThat(location.getYaw(), equalTo(-292.484f));
-    }
-
-    @Test
-    public void shouldReturnNullForUnavailablePlayer() {
-        // given
-        Player player = mock(Player.class);
-        given(player.getUniqueId()).willReturn(UUID.nameUUIDFromBytes("other-player".getBytes()));
-
-        // when
-        LimboPlayer data = handler.getLimboPlayer(player);
-
-        // then
-        assertThat(data, nullValue());
-    }
-
-    @Test
-    public void shouldSavePlayerData() {
-        // given
-        Player player = mock(Player.class);
-        UUID uuid = UUID.nameUUIDFromBytes("New player".getBytes());
-        given(player.getUniqueId()).willReturn(uuid);
-
-
-        World world = mock(World.class);
-        given(world.getName()).willReturn("player-world");
-        Location location = new Location(world, 0.2, 102.25, -89.28, 3.02f, 90.13f);
-        LimboPlayer limbo = new LimboPlayer(location, true, Collections.singletonList(new UserGroup("primary-grp")), true, 1.2f, 0.8f);
-
-        // when
-        handler.saveLimboPlayer(player, limbo);
-
-        // then
-        File playerFile = new File(dataFolder, FileUtils.makePath("playerdata", uuid.toString(), "data.json"));
-        assertThat(playerFile.exists(), equalTo(true));
-        // TODO ljacqu 20160711: Check contents of file
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceTest.java b/src/test/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceTest.java
deleted file mode 100644
index b9ac1cd8..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceTest.java
+++ /dev/null
@@ -1,158 +0,0 @@
-package fr.xephi.authme.data.limbo.persistence;
-
-import ch.jalu.injector.factory.Factory;
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.limbo.LimboPlayer;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.LimboSettings;
-import org.bukkit.entity.Player;
-import org.hamcrest.Matcher;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.util.logging.Logger;
-
-import static org.hamcrest.Matchers.both;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.instanceOf;
-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.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link LimboPersistence}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class LimboPersistenceTest {
-
-    @InjectDelayed
-    private LimboPersistence limboPersistence;
-
-    @Mock
-    private Factory<LimboPersistenceHandler> handlerFactory;
-
-    @Mock
-    private Settings settings;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    @SuppressWarnings("unchecked")
-    public void setUpMocks() {
-        given(settings.getProperty(LimboSettings.LIMBO_PERSISTENCE_TYPE)).willReturn(LimboPersistenceType.DISABLED);
-        given(handlerFactory.newInstance(any(Class.class)))
-            .willAnswer(invocation -> mock(invocation.getArgument(0)));
-    }
-
-    @Test
-    public void shouldInitializeProperly() {
-        // given / when / then
-        assertThat(getHandler(), instanceOf(NoOpPersistenceHandler.class));
-    }
-
-    @Test
-    public void shouldDelegateToHandler() {
-        // given
-        Player player = mock(Player.class);
-        LimboPersistenceHandler handler = getHandler();
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        given(handler.getLimboPlayer(player)).willReturn(limbo);
-
-        // when
-        LimboPlayer result = limboPersistence.getLimboPlayer(player);
-        limboPersistence.saveLimboPlayer(player, mock(LimboPlayer.class));
-        limboPersistence.removeLimboPlayer(mock(Player.class));
-
-        // then
-        assertThat(result, equalTo(limbo));
-        verify(handler).getLimboPlayer(player);
-        verify(handler).saveLimboPlayer(eq(player), argThat(notNullAndDifferentFrom(limbo)));
-        verify(handler).removeLimboPlayer(argThat(notNullAndDifferentFrom(player)));
-    }
-
-    @Test
-    public void shouldReloadProperly() {
-        // given
-        given(settings.getProperty(LimboSettings.LIMBO_PERSISTENCE_TYPE))
-            .willReturn(LimboPersistenceType.INDIVIDUAL_FILES);
-
-        // when
-        limboPersistence.reload(settings);
-
-        // then
-        assertThat(getHandler(), instanceOf(LimboPersistenceType.INDIVIDUAL_FILES.getImplementationClass()));
-    }
-
-    @Test
-    public void shouldHandleExceptionWhenGettingLimbo() {
-        // given
-        Player player = mock(Player.class);
-        Logger logger = TestHelper.setupLogger();
-        LimboPersistenceHandler handler = getHandler();
-        doThrow(RuntimeException.class).when(handler).getLimboPlayer(player);
-
-        // when
-        LimboPlayer result = limboPersistence.getLimboPlayer(player);
-
-        // then
-        assertThat(result, nullValue());
-        verify(logger).warning(argThat(containsString("[RuntimeException]")));
-    }
-
-    @Test
-    public void shouldHandleExceptionWhenSavingLimbo() {
-        // given
-        Player player = mock(Player.class);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        Logger logger = TestHelper.setupLogger();
-        LimboPersistenceHandler handler = getHandler();
-        doThrow(IllegalStateException.class).when(handler).saveLimboPlayer(player, limbo);
-
-        // when
-        limboPersistence.saveLimboPlayer(player, limbo);
-
-        // then
-        verify(logger).warning(argThat(containsString("[IllegalStateException]")));
-    }
-
-    @Test
-    public void shouldHandleExceptionWhenRemovingLimbo() {
-        // given
-        Player player = mock(Player.class);
-        Logger logger = TestHelper.setupLogger();
-        LimboPersistenceHandler handler = getHandler();
-        doThrow(UnsupportedOperationException.class).when(handler).removeLimboPlayer(player);
-
-        // when
-        limboPersistence.removeLimboPlayer(player);
-
-        // then
-        verify(logger).warning(argThat(containsString("[UnsupportedOperationException]")));
-    }
-
-    private LimboPersistenceHandler getHandler() {
-        return ReflectionTestUtils.getFieldValue(LimboPersistence.class, limboPersistence, "handler");
-    }
-
-    private static <T> Matcher<T> notNullAndDifferentFrom(T o) {
-        return both(not(sameInstance(o))).and(not(nullValue()));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceTypeTest.java b/src/test/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceTypeTest.java
deleted file mode 100644
index 248ab9c1..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/persistence/LimboPersistenceTypeTest.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package fr.xephi.authme.data.limbo.persistence;
-
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link LimboPersistenceType}.
- */
-public class LimboPersistenceTypeTest {
-
-    @Test
-    public void shouldHaveUniqueImplementationClasses() {
-        // given
-        Set<Class<?>> classes = new HashSet<>();
-
-        // when / then
-        for (LimboPersistenceType persistenceType : LimboPersistenceType.values()) {
-            if (!classes.add(persistenceType.getImplementationClass())) {
-                fail("Implementation class '" + persistenceType.getImplementationClass() + "' from '"
-                    + persistenceType + "' already encountered previously");
-            }
-        }
-    }
-
-    @Test
-    public void shouldHaveTypeReturnedFromImplementationClass() {
-        for (LimboPersistenceType persistenceType : LimboPersistenceType.values()) {
-            // given
-            LimboPersistenceHandler implementationMock = mock(persistenceType.getImplementationClass());
-            given(implementationMock.getType()).willCallRealMethod();
-
-            // when
-            LimboPersistenceType returnedType = implementationMock.getType();
-
-            // then
-            assertThat(returnedType, equalTo(persistenceType));
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentNameBuilderTest.java b/src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentNameBuilderTest.java
deleted file mode 100644
index d5cf31a9..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentNameBuilderTest.java
+++ /dev/null
@@ -1,141 +0,0 @@
-package fr.xephi.authme.data.limbo.persistence;
-
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static fr.xephi.authme.data.limbo.persistence.SegmentSize.EIGHT;
-import static fr.xephi.authme.data.limbo.persistence.SegmentSize.FOUR;
-import static fr.xephi.authme.data.limbo.persistence.SegmentSize.ONE;
-import static fr.xephi.authme.data.limbo.persistence.SegmentSize.SIXTEEN;
-import static fr.xephi.authme.data.limbo.persistence.SegmentSize.SIXTY_FOUR;
-import static fr.xephi.authme.data.limbo.persistence.SegmentSize.THIRTY_TWO;
-import static fr.xephi.authme.data.limbo.persistence.SegmentSize.TWO_FIFTY;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link SegmentNameBuilder}.
- */
-public class SegmentNameBuilderTest {
-
-    /**
-     * Checks that using a given segment size really produces as many segments as defined.
-     * E.g. if we partition with {@link SegmentSize#EIGHT} we expect eight different buckets.
-     */
-    @Test
-    public void shouldCreatePromisedSizeOfSegments() {
-        for (SegmentSize part : SegmentSize.values()) {
-            // Perform this check only for `length` <= 5 because the test creates all hex numbers with `length` digits.
-            if (part.getLength() <= 5) {
-                checkTotalSegmentsProduced(part);
-            }
-        }
-    }
-
-    private void checkTotalSegmentsProduced(SegmentSize part) {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(part);
-        Set<String> encounteredSegments = new HashSet<>();
-        int shift = part.getLength() * 4;
-        // e.g. (1 << 16) - 1 = 0xFFFF. (Number of digits = shift/4, since 16 = 2^4)
-        int max = (1 << shift) - 1;
-
-        // when
-        for (int i = 0; i <= max; ++i) {
-            String uuid = toPaddedHex(i, part.getLength());
-            encounteredSegments.add(nameBuilder.createSegmentName(uuid));
-        }
-
-        // then
-        assertThat(encounteredSegments, hasSize(part.getTotalSegments()));
-    }
-
-    private static String toPaddedHex(int dec, int padLength) {
-        String hexResult = Integer.toString(dec, 16);
-        while (hexResult.length() < padLength) {
-            hexResult = "0" + hexResult;
-        }
-        return hexResult;
-    }
-
-    @Test
-    public void shouldCreateOneSegment() {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(ONE);
-
-        // when / then
-        assertThat(nameBuilder.createSegmentName("abc"), equalTo("seg1-0"));
-        assertThat(nameBuilder.createSegmentName("f0e"), equalTo("seg1-0"));
-        assertThat(nameBuilder.createSegmentName("329"), equalTo("seg1-0"));
-    }
-
-    @Test
-    public void shouldCreateFourSegments() {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(FOUR);
-
-        // when / then
-        assertThat(nameBuilder.createSegmentName("f9cc"), equalTo("seg4-3"));
-        assertThat(nameBuilder.createSegmentName("84c9"), equalTo("seg4-2"));
-        assertThat(nameBuilder.createSegmentName("3799"), equalTo("seg4-0"));
-    }
-
-    @Test
-    public void shouldCreateEightSegments() {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(EIGHT);
-
-        // when / then
-        assertThat(nameBuilder.createSegmentName("fc9c"), equalTo("seg8-7"));
-        assertThat(nameBuilder.createSegmentName("90ad"), equalTo("seg8-4"));
-        assertThat(nameBuilder.createSegmentName("35e4"), equalTo("seg8-1"));
-        assertThat(nameBuilder.createSegmentName("a39f"), equalTo("seg8-5"));
-    }
-
-    @Test
-    public void shouldCreateSixteenSegments() {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(SIXTEEN);
-
-        // when / then
-        assertThat(nameBuilder.createSegmentName("fc9a054"), equalTo("seg16-f"));
-        assertThat(nameBuilder.createSegmentName("b0a945e"), equalTo("seg16-b"));
-        assertThat(nameBuilder.createSegmentName("7afebab"), equalTo("seg16-7"));
-    }
-
-    @Test
-    public void shouldCreateThirtyTwoSegments() {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(THIRTY_TWO);
-
-        // when / then
-        assertThat(nameBuilder.createSegmentName("f890c9"), equalTo("seg32-11101"));
-        assertThat(nameBuilder.createSegmentName("49c39a"), equalTo("seg32-01101"));
-        assertThat(nameBuilder.createSegmentName("b75d09"), equalTo("seg32-10010"));
-    }
-
-    @Test
-    public void shouldCreateSixtyFourSegments() {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(SIXTY_FOUR);
-
-        // when / then
-        assertThat(nameBuilder.createSegmentName("82f"), equalTo("seg64-203"));
-        assertThat(nameBuilder.createSegmentName("9b4"), equalTo("seg64-221"));
-        assertThat(nameBuilder.createSegmentName("068"), equalTo("seg64-012"));
-    }
-
-    @Test
-    public void shouldCreate256Segments() {
-        // given
-        SegmentNameBuilder nameBuilder = new SegmentNameBuilder(TWO_FIFTY);
-
-        // when / then
-        assertThat(nameBuilder.createSegmentName("a813c"), equalTo("seg256-a8"));
-        assertThat(nameBuilder.createSegmentName("b4d01"), equalTo("seg256-b4"));
-        assertThat(nameBuilder.createSegmentName("7122f"), equalTo("seg256-71"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentSizeTest.java b/src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentSizeTest.java
deleted file mode 100644
index 1cc34693..00000000
--- a/src/test/java/fr/xephi/authme/data/limbo/persistence/SegmentSizeTest.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package fr.xephi.authme.data.limbo.persistence;
-
-import com.google.common.collect.ImmutableSet;
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link SegmentSize}.
- */
-public class SegmentSizeTest {
-
-    @Test
-    public void shouldHaveDistributionThatIsPowerOf2() {
-        // given
-        Set<Integer> allowedDistributions = ImmutableSet.of(1, 2, 4, 8, 16);
-
-        // when / then
-        for (SegmentSize entry : SegmentSize.values()) {
-            if (!allowedDistributions.contains(entry.getDistribution())) {
-                fail("Distribution must be a power of 2 and within [1, 16]. Offending item: " + entry);
-            }
-        }
-    }
-
-    @Test
-    public void shouldHaveDifferentSegmentSizes() {
-        // given
-        Set<Integer> segmentTotals = new HashSet<>();
-
-        // when / then
-        for (SegmentSize entry : SegmentSize.values()) {
-            int totalSegments = entry.getTotalSegments();
-            assertThat(entry + " must have a positive segment size",
-                totalSegments, greaterThan(0));
-
-            assertThat(entry + " has a segment total that was already encountered (" + totalSegments + ")",
-                segmentTotals.add(totalSegments), equalTo(true));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/AbstractDataSourceIntegrationTest.java b/src/test/java/fr/xephi/authme/datasource/AbstractDataSourceIntegrationTest.java
deleted file mode 100644
index a5e50cb9..00000000
--- a/src/test/java/fr/xephi/authme/datasource/AbstractDataSourceIntegrationTest.java
+++ /dev/null
@@ -1,535 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import ch.jalu.datasourcecolumns.data.DataSourceValue;
-import ch.jalu.datasourcecolumns.data.DataSourceValueImpl;
-import com.google.common.collect.Lists;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Stream;
-
-import static fr.xephi.authme.AuthMeMatchers.equalToHash;
-import static fr.xephi.authme.AuthMeMatchers.hasAuthBasicData;
-import static fr.xephi.authme.AuthMeMatchers.hasAuthLocation;
-import static fr.xephi.authme.AuthMeMatchers.hasRegistrationInfo;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasItem;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.is;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assume.assumeThat;
-
-/**
- * Abstract class for data source integration tests.
- */
-public abstract class AbstractDataSourceIntegrationTest {
-
-    protected DataSource getDataSource() {
-        return getDataSource("salt");
-    }
-
-    protected abstract DataSource getDataSource(String saltColumn);
-
-    @Test
-    public void shouldReturnIfAuthIsAvailableOrNot() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        boolean isBobbyAvailable = dataSource.isAuthAvailable("bobby");
-        boolean isChrisAvailable = dataSource.isAuthAvailable("chris");
-        boolean isUserAvailable = dataSource.isAuthAvailable("USER");
-
-        // then
-        assertThat(isBobbyAvailable, equalTo(true));
-        assertThat(isChrisAvailable, equalTo(false));
-        assertThat(isUserAvailable, equalTo(true));
-    }
-
-    @Test
-    public void shouldReturnPassword() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        HashedPassword bobbyPassword = dataSource.getPassword("bobby");
-        HashedPassword invalidPassword = dataSource.getPassword("doesNotExist");
-        HashedPassword userPassword = dataSource.getPassword("User");
-
-        // then
-        assertThat(bobbyPassword, equalToHash("$SHA$11aa0706173d7272$dbba966"));
-        assertThat(invalidPassword, nullValue());
-        assertThat(userPassword, equalToHash("b28c32f624a4eb161d6adc9acb5bfc5b", "f750ba32"));
-    }
-
-    @Test
-    public void shouldReturnPasswordWithEmptySaltColumn() {
-        // given
-        DataSource dataSource = getDataSource("");
-
-        // when
-        HashedPassword bobbyPassword = dataSource.getPassword("bobby");
-        HashedPassword invalidPassword = dataSource.getPassword("doesNotExist");
-        HashedPassword userPassword = dataSource.getPassword("user");
-
-        // then
-        assertThat(bobbyPassword, equalToHash("$SHA$11aa0706173d7272$dbba966"));
-        assertThat(invalidPassword, nullValue());
-        assertThat(userPassword, equalToHash("b28c32f624a4eb161d6adc9acb5bfc5b"));
-    }
-
-    @Test
-    public void shouldGetAuth() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        PlayerAuth invalidAuth = dataSource.getAuth("notInDB");
-        PlayerAuth bobbyAuth = dataSource.getAuth("Bobby");
-        PlayerAuth userAuth = dataSource.getAuth("user");
-
-        // then
-        assertThat(invalidAuth, nullValue());
-
-        assertThat(bobbyAuth, hasAuthBasicData("bobby", "Bobby", null, "123.45.67.89"));
-        assertThat(bobbyAuth, hasAuthLocation(1.05, 2.1, 4.2, "world", -0.44f, 2.77f));
-        assertThat(bobbyAuth, hasRegistrationInfo("127.0.4.22", 1436778723L));
-        assertThat(bobbyAuth.getLastLogin(), equalTo(1449136800L));
-        assertThat(bobbyAuth.getPassword(), equalToHash("$SHA$11aa0706173d7272$dbba966"));
-        assertThat(bobbyAuth.getTotpKey(), equalTo("JBSWY3DPEHPK3PXP"));
-
-        assertThat(userAuth, hasAuthBasicData("user", "user", "user@example.org", "34.56.78.90"));
-        assertThat(userAuth, hasAuthLocation(124.1, 76.3, -127.8, "nether", 0.23f, 4.88f));
-        assertThat(userAuth, hasRegistrationInfo(null, 0));
-        assertThat(userAuth.getLastLogin(), equalTo(1453242857L));
-        assertThat(userAuth.getPassword(), equalToHash("b28c32f624a4eb161d6adc9acb5bfc5b", "f750ba32"));
-        assertThat(userAuth.getTotpKey(), nullValue());
-    }
-
-    @Test
-    public void shouldCountAuthsByEmail() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        int userMailCount = dataSource.countAuthsByEmail("user@example.ORG");
-        int invalidMailCount = dataSource.countAuthsByEmail("not.in.db@example.com");
-        boolean response = dataSource.saveAuth(
-            PlayerAuth.builder().name("Test").email("user@EXAMPLE.org").build());
-        int newUserCount = dataSource.countAuthsByEmail("user@Example.org");
-
-        // then
-        assertThat(userMailCount, equalTo(1));
-        assertThat(invalidMailCount, equalTo(0));
-        assertThat(response, equalTo(true));
-        assertThat(newUserCount, equalTo(2));
-    }
-
-    @Test
-    public void shouldReturnAllAuths() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        List<PlayerAuth> authList = dataSource.getAllAuths();
-        boolean response = dataSource.saveAuth(
-            PlayerAuth.builder().name("Test").email("user@EXAMPLE.org").build());
-        List<PlayerAuth> newAuthList = dataSource.getAllAuths();
-
-        // then
-        assertThat(response, equalTo(true));
-        assertThat(authList, hasSize(2));
-        assertThat(authList, hasItem(hasAuthBasicData("bobby", "Bobby", null, "123.45.67.89")));
-        assertThat(newAuthList, hasSize(3));
-        assertThat(newAuthList, hasItem(hasAuthBasicData("bobby", "Bobby", null, "123.45.67.89")));
-    }
-
-    @Test
-    public void shouldUpdatePassword() {
-        // given
-        DataSource dataSource = getDataSource();
-        HashedPassword newHash = new HashedPassword("new_hash");
-
-        // when
-        boolean response1 = dataSource.updatePassword("user", newHash);
-        boolean response2 = dataSource.updatePassword("non-existent-name", new HashedPassword("sd"));
-
-        // then
-        assertThat(response1, equalTo(true));
-        assertThat(response2, equalTo(false)); // no record modified
-        assertThat(dataSource.getPassword("user"), equalToHash(newHash));
-    }
-
-    @Test
-    public void shouldUpdatePasswordWithNoSalt() {
-        // given
-        DataSource dataSource = getDataSource("");
-        HashedPassword newHash = new HashedPassword("new_hash", "1241");
-
-        // when
-        boolean response1 = dataSource.updatePassword("user", newHash);
-        boolean response2 = dataSource.updatePassword("non-existent-name", new HashedPassword("asdfasdf", "a1f34ec"));
-
-        // then
-        assertThat(response1, equalTo(true));
-        assertThat(response2, equalTo(false)); // no record modified
-        assertThat(dataSource.getPassword("user"), equalToHash("new_hash"));
-    }
-
-    @Test
-    public void shouldUpdatePasswordWithPlayerAuth() {
-        // given
-        DataSource dataSource = getDataSource("salt");
-        PlayerAuth bobbyAuth = PlayerAuth.builder().name("bobby").password(new HashedPassword("tt", "cc")).build();
-        PlayerAuth invalidAuth = PlayerAuth.builder().name("invalid").password(new HashedPassword("tt", "cc")).build();
-
-        // when
-        boolean response1 = dataSource.updatePassword(bobbyAuth);
-        boolean response2 = dataSource.updatePassword(invalidAuth);
-
-        // then
-        assertThat(response1, equalTo(true));
-        assertThat(response2, equalTo(false)); // no record modified
-        assertThat(dataSource.getPassword("bobby"), equalToHash("tt", "cc"));
-    }
-
-    @Test
-    public void shouldRemovePlayerAuth() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        boolean response1 = dataSource.removeAuth("Bobby");
-        boolean response2 = dataSource.removeAuth("does-not-exist");
-
-        // then
-        assertThat(response1 && response2, equalTo(true));
-        assertThat(dataSource.getAuth("bobby"), nullValue());
-        assertThat(dataSource.isAuthAvailable("bobby"), equalTo(false));
-    }
-
-    @Test
-    public void shouldUpdateSession() {
-        // given
-        DataSource dataSource = getDataSource();
-        PlayerAuth bobby = PlayerAuth.builder()
-            .name("bobby").realName("BOBBY").lastLogin(123L)
-            .lastIp("12.12.12.12").build();
-
-        // when
-        boolean response = dataSource.updateSession(bobby);
-
-        // then
-        assertThat(response, equalTo(true));
-        PlayerAuth result = dataSource.getAuth("bobby");
-        assertThat(result, hasAuthBasicData("bobby", "BOBBY", null, "12.12.12.12"));
-        assertThat(result.getLastLogin(), equalTo(123L));
-    }
-
-    @Test
-    public void shouldUpdateLastLoc() {
-        // given
-        DataSource dataSource = getDataSource();
-        PlayerAuth user = PlayerAuth.builder()
-            .name("user").locX(143).locY(-42.12).locZ(29.47)
-            .locWorld("the_end").locYaw(2.2f).locPitch(0.45f).build();
-
-        // when
-        boolean response = dataSource.updateQuitLoc(user);
-
-        // then
-        assertThat(response, equalTo(true));
-        assertThat(dataSource.getAuth("user"), hasAuthLocation(user));
-    }
-
-    @Test
-    public void shouldDeletePlayers() {
-        // given
-        DataSource dataSource = getDataSource();
-        Set<String> playersToDelete = new HashSet<>(Arrays.asList("bobby", "doesNotExist"));
-        assumeThat(dataSource.getAccountsRegistered(), equalTo(2));
-
-        // when
-        dataSource.purgeRecords(playersToDelete);
-
-        // then
-        assertThat(dataSource.getAccountsRegistered(), equalTo(1));
-        assertThat(dataSource.isAuthAvailable("bobby"), equalTo(false));
-        assertThat(dataSource.isAuthAvailable("user"), equalTo(true));
-    }
-
-    @Test
-    public void shouldUpdateEmail() {
-        // given
-        DataSource dataSource = getDataSource();
-        String email = "new-user@mail.tld";
-        PlayerAuth userAuth = PlayerAuth.builder().name("user").email(email).build();
-        PlayerAuth invalidAuth = PlayerAuth.builder().name("invalid").email("addr@example.com").build();
-
-        // when
-        boolean response1 = dataSource.updateEmail(userAuth);
-        boolean response2 = dataSource.updateEmail(invalidAuth);
-
-        // then
-        assertThat(response1, equalTo(true));
-        assertThat(response2, equalTo(false)); // no record modified
-        assertThat(dataSource.getAllAuths(), hasItem(hasAuthBasicData("user", "user", email, "34.56.78.90")));
-    }
-
-    @Test
-    public void shouldCountAuths() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        int initialCount = dataSource.getAccountsRegistered();
-        for (int i = 0; i < 4; ++i) {
-            dataSource.saveAuth(PlayerAuth.builder().name("test-" + i).build());
-        }
-        int endCount = dataSource.getAccountsRegistered();
-
-        // then
-        assertThat(initialCount, equalTo(2));
-        assertThat(endCount, equalTo(6));
-    }
-
-    @Test
-    public void shouldGetAllUsersByIp() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        List<String> initialList = dataSource.getAllAuthsByIp("123.45.67.89");
-        List<String> emptyList = dataSource.getAllAuthsByIp("8.8.8.8");
-        for (int i = 0; i < 3; ++i) {
-            PlayerAuth auth = PlayerAuth.builder().name("test-" + i).lastIp("123.45.67.89").build();
-            dataSource.saveAuth(auth);
-            dataSource.updateSession(auth); // trigger storage of last IP
-        }
-        List<String> updatedList = dataSource.getAllAuthsByIp("123.45.67.89");
-
-        // then
-        assertThat(initialList, hasSize(1));
-        assertThat(initialList.get(0), equalTo("bobby"));
-        assertThat(emptyList, hasSize(0));
-        assertThat(updatedList, hasSize(4));
-        assertThat(updatedList, hasItem(equalTo("bobby")));
-        assertThat(updatedList, hasItem(equalTo("test-1")));
-    }
-
-    @Test
-    public void shouldUpdateRealName() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        boolean response1 = dataSource.updateRealName("bobby", "BOBBY");
-        boolean response2 = dataSource.updateRealName("notExists", "NOTEXISTS");
-
-        // then
-        assertThat(response1, equalTo(true));
-        assertThat(response2, equalTo(false)); // no record modified
-        assertThat(dataSource.getAuth("bobby"), hasAuthBasicData("bobby", "BOBBY", null, "123.45.67.89"));
-    }
-
-    @Test
-    public void shouldGetRecordsToPurge() {
-        // given
-        DataSource dataSource = getDataSource();
-        // 1453242857 -> user, 1449136800 -> bobby
-
-        PlayerAuth potato = PlayerAuth.builder().name("potato")
-            .registrationDate(0L).lastLogin(1_455_000_000L).build();
-        PlayerAuth tomato = PlayerAuth.builder().name("tomato")
-            .registrationDate(1_457_000_000L).lastLogin(null).build();
-        PlayerAuth lettuce = PlayerAuth.builder().name("Lettuce")
-            .registrationDate(1_400_000_000L).lastLogin(1_453_000_000L).build();
-        PlayerAuth onion = PlayerAuth.builder().name("onion")
-            .registrationDate(1_200_000_000L).lastLogin(1_300_000_000L).build();
-        Stream.of(potato, tomato, lettuce, onion).forEach(auth -> {
-            dataSource.saveAuth(auth);
-            dataSource.updateSession(auth);
-        });
-
-        // when
-        Set<String> records1 = dataSource.getRecordsToPurge(1_450_000_000);
-        Set<String> records2 = dataSource.getRecordsToPurge(1_460_000_000);
-
-        // then
-        assertThat(records1, containsInAnyOrder("bobby", "onion"));
-        assertThat(records2, containsInAnyOrder("bobby", "onion", "user", "tomato", "potato", "lettuce"));
-        // check that the entry was not deleted because of running this command
-        assertThat(dataSource.isAuthAvailable("bobby"), equalTo(true));
-        assertThat(dataSource.isAuthAvailable("tomato"), equalTo(true));
-        assertThat(dataSource.isAuthAvailable("Lettuce"), equalTo(true));
-    }
-
-    @Test
-    public void shouldPerformOperationsOnIsLoggedColumnSuccessfully() {
-        DataSource dataSource = getDataSource();
-        // on startup no one should be marked as logged
-        assertThat(dataSource.isLogged("user"), equalTo(false));
-        assertThat(dataSource.isLogged("bobby"), equalTo(false));
-
-        // Mark user as logged
-        dataSource.setLogged("user");
-        // non-existent user should not break database
-        dataSource.setLogged("does-not-exist");
-
-        assertThat(dataSource.isLogged("user"), equalTo(true));
-        assertThat(dataSource.isLogged("bobby"), equalTo(false));
-
-        // Set bobby logged and unlog user
-        dataSource.setLogged("bobby");
-        dataSource.setUnlogged("user");
-
-        assertThat(dataSource.isLogged("user"), equalTo(false));
-        assertThat(dataSource.isLogged("bobby"), equalTo(true));
-
-        // Set both as logged (even if Bobby already is logged)
-        dataSource.setLogged("user");
-        dataSource.setLogged("bobby");
-        dataSource.purgeLogged();
-        assertThat(dataSource.isLogged("user"), equalTo(false));
-        assertThat(dataSource.isLogged("bobby"), equalTo(false));
-    }
-
-    @Test
-    public void shouldPerformPurgeOperation() {
-        // given
-        List<String> names = Arrays.asList("Bobby", "USER", "DoesnotExist");
-        DataSource dataSource = getDataSource();
-
-        // when
-        dataSource.purgeRecords(names);
-
-        // then
-        assertThat(dataSource.getAllAuths(), empty());
-    }
-
-    @Test
-    public void shouldFetchEmail() {
-        // given
-        String user1 = "user";
-        String user2 = "Bogus";
-        DataSource dataSource = getDataSource();
-
-        // when
-        DataSourceValue<String> email1 = dataSource.getEmail(user1);
-        DataSourceValue<String> email2 = dataSource.getEmail(user2);
-
-        // then
-        assertThat(email1.getValue(), equalTo("user@example.org"));
-        assertThat(email2, is(DataSourceValueImpl.unknownRow()));
-    }
-
-    @Test
-    public void shouldGetLoggedPlayersWithoutEmail() {
-        // given
-        DataSource dataSource = getDataSource();
-        dataSource.setLogged("bobby");
-        dataSource.setLogged("user");
-
-        // when
-        List<String> loggedPlayersWithEmptyMail = dataSource.getLoggedPlayersWithEmptyMail();
-
-        // then
-        assertThat(loggedPlayersWithEmptyMail, contains("Bobby"));
-    }
-
-    @Test
-    public void shouldGrantAndRetrieveSessionFlag() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        dataSource.grantSession("Bobby");
-        dataSource.grantSession("doesNotExist");
-
-        // then
-        assertThat(dataSource.hasSession("bobby"), equalTo(true));
-        assertThat(dataSource.hasSession("user"), equalTo(false));
-        assertThat(dataSource.hasSession("bogus"), equalTo(false));
-    }
-
-    @Test
-    public void shouldRevokeSession() {
-        // given
-        DataSource dataSource = getDataSource();
-        dataSource.grantSession("bobby");
-        dataSource.grantSession("user");
-
-        // when
-        dataSource.revokeSession("bobby");
-        dataSource.revokeSession("userNotInDatabase");
-
-        // then
-        assertThat(dataSource.hasSession("bobby"), equalTo(false));
-        assertThat(dataSource.hasSession("user"), equalTo(true));
-        assertThat(dataSource.hasSession("nonExistentName"), equalTo(false));
-    }
-
-    @Test
-    public void shouldGetRecentlyLoggedInPlayers() {
-        // given
-        DataSource dataSource = getDataSource();
-        String[] names = {"user3", "user8", "user2", "user4", "user7",
-            "user11", "user14", "user12", "user18", "user16",
-            "user28", "user29", "user22", "user20", "user24"};
-        long timestamp = 1461024000; // 2016-04-19 00:00:00
-        for (int i = 0; i < names.length; ++i) {
-            PlayerAuth auth = PlayerAuth.builder().name(names[i])
-                .registrationDate(1234567)
-                .lastLogin(timestamp + i * 3600)
-                .build();
-            dataSource.saveAuth(auth);
-            dataSource.updateSession(auth);
-        }
-
-        // when
-        List<PlayerAuth> recentPlayers = dataSource.getRecentlyLoggedInPlayers();
-
-        // then
-        assertThat(Lists.transform(recentPlayers, PlayerAuth::getNickname),
-            contains("user24", "user20", "user22", "user29", "user28",
-                "user16", "user18", "user12", "user14", "user11"));
-    }
-
-    @Test
-    public void shouldSetTotpKey() {
-        // given
-        DataSource dataSource = getDataSource();
-        String newTotpKey = "My new TOTP key";
-
-        // when
-        dataSource.setTotpKey("BObBy", newTotpKey);
-        dataSource.setTotpKey("does-not-exist", "bogus");
-
-        // then
-        assertThat(dataSource.getAuth("bobby").getTotpKey(), equalTo(newTotpKey));
-    }
-
-    @Test
-    public void shouldRemoveTotpKey() {
-        // given
-        DataSource dataSource = getDataSource();
-
-        // when
-        dataSource.removeTotpKey("BoBBy");
-        dataSource.removeTotpKey("user");
-        dataSource.removeTotpKey("does-not-exist");
-
-        // then
-        assertThat(dataSource.getAuth("bobby").getTotpKey(), nullValue());
-        assertThat(dataSource.getAuth("user").getTotpKey(), nullValue());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/AbstractResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/AbstractResourceClosingTest.java
deleted file mode 100644
index 5b2dca58..00000000
--- a/src/test/java/fr/xephi/authme/datasource/AbstractResourceClosingTest.java
+++ /dev/null
@@ -1,255 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableMap;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.sql.Blob;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test class which runs through objects interacting with a database and verifies that all
- * instances of {@link AutoCloseable} that are created in the calls are closed again.
- * <p>
- * Instead of an actual connection to a datasource, we pass a mock Connection object
- * which is set to create additional mocks on demand for Statement and ResultSet objects.
- * This test ensures that all such objects that are created will be closed again by
- * keeping a list of mocks ({@link #closeables}) and then verifying that all have been
- * closed ({@link #verifyHaveMocksBeenClosed()}).
- */
-@RunWith(Parameterized.class)
-public abstract class AbstractResourceClosingTest {
-
-    /** Collection of values to use to call methods with the parameters they expect. */
-    private static final Map<Class<?>, Object> PARAM_VALUES = getDefaultParameters();
-
-    /** The DataSource method to test. */
-    private Method method;
-
-    /** Keeps track of the closeables which are created during the tested call. */
-    private List<AutoCloseable> closeables = new ArrayList<>();
-
-    private boolean hasCreatedConnection = false;
-
-    /**
-     * Constructor for the test instance verifying the given method.
-     *
-     * @param method The DataSource method to test
-     * @param name The name of the method
-     */
-    public AbstractResourceClosingTest(Method method, String name) {
-        // Note ljacqu 20160227: The name parameter is necessary as we pass it from the @Parameters method;
-        // we use the method name in the annotation to name the test sensibly
-        this.method = method;
-    }
-
-    @BeforeClass
-    public static void initializeLogger() {
-        TestHelper.setupLogger();
-    }
-
-    /**
-     * The actual test -- executes the method given through the constructor and then verifies that all
-     * AutoCloseable mocks it constructed have been closed.
-     */
-    @Test
-    public void shouldCloseResources() throws IllegalAccessException, InvocationTargetException {
-        method.invoke(getObjectUnderTest(), buildParamListForMethod(method));
-        verifyHaveMocksBeenClosed();
-    }
-
-    protected abstract Object getObjectUnderTest();
-
-    /**
-     * Verify that all AutoCloseables that have been created during the method execution have been closed.
-     */
-    private void verifyHaveMocksBeenClosed() {
-        if (closeables.isEmpty()) {
-            System.out.println("Note: detected no AutoCloseables for method '" + method.getName() + "'");
-        }
-        try {
-            for (AutoCloseable autoCloseable : closeables) {
-                verify(autoCloseable).close();
-            }
-        } catch (Exception e) {
-            throw new IllegalStateException("Error verifying if autoCloseable was closed", e);
-        }
-    }
-
-    /**
-     * Helper method for building a list of test values to satisfy a method's signature.
-     *
-     * @param method The method to create a valid parameter list for
-     * @return Parameter list to invoke the given method with
-     */
-    private Object[] buildParamListForMethod(Method method) {
-        List<Object> params = new ArrayList<>();
-        int index = 0;
-        for (Class<?> paramType : method.getParameterTypes()) {
-            // Checking List.class == paramType instead of Class#isAssignableFrom means we really only accept List,
-            // but that is a sensible assumption and makes our life much easier later on when juggling with Type
-            Object param = Collection.class.isAssignableFrom(paramType)
-                ? getTypedCollection(method.getGenericParameterTypes()[index])
-                : getMethodParameter(paramType);
-            Preconditions.checkNotNull(param, "No param type for " + paramType);
-            params.add(param);
-            ++index;
-        }
-        return params.toArray();
-    }
-
-    private Object getMethodParameter(Class<?> paramType) {
-        if (paramType.equals(Connection.class)) {
-            Preconditions.checkArgument(!hasCreatedConnection, "A Connection object was already created in this test run");
-            hasCreatedConnection = true;
-            return initConnection();
-        }
-        return PARAM_VALUES.get(paramType);
-    }
-
-    /**
-     * Return a collection of the required type with some test elements that correspond to the
-     * collection's generic type.
-     *
-     * @param type The collection type to process and build a test collection for
-     * @return Test collection with sample elements of the correct type
-     */
-    private static Collection<?> getTypedCollection(Type type) {
-        if (type instanceof ParameterizedType) {
-            ParameterizedType parameterizedType = (ParameterizedType) type;
-            Preconditions.checkArgument(Collection.class.isAssignableFrom((Class<?>) parameterizedType.getRawType()),
-                type + " should extend from Collection");
-            Type genericType = parameterizedType.getActualTypeArguments()[0];
-
-            Object element = PARAM_VALUES.get(genericType);
-            Preconditions.checkNotNull(element, "No sample element for list of generic type " + genericType);
-            if (isAssignableFrom(parameterizedType.getRawType(), List.class)) {
-                return Arrays.asList(element, element, element);
-            } else if (Set.class == parameterizedType.getRawType()) {
-                return new HashSet<>(Arrays.asList(element, element, element));
-            }
-            throw new IllegalStateException("Unknown collection type " + parameterizedType.getRawType());
-        }
-        throw new IllegalStateException("Cannot build list for unexpected Type: " + type);
-    }
-
-    private static boolean isAssignableFrom(Type type, Class<?> fromType) {
-        return (type instanceof Class<?>)
-            && ((Class<?>) type).isAssignableFrom(fromType);
-    }
-
-    /* Initialize the map of test values to pass to methods to satisfy their signature. */
-    private static Map<Class<?>, Object> getDefaultParameters() {
-        HashedPassword hash = new HashedPassword("test", "test");
-        return ImmutableMap.<Class<?>, Object>builder()
-            .put(String.class, "test")
-            .put(int.class, 3)
-            .put(long.class, 102L)
-            .put(boolean.class, true)
-            .put(PlayerAuth.class, PlayerAuth.builder().name("test").realName("test").password(hash).build())
-            .put(HashedPassword.class, hash)
-            .build();
-    }
-
-    // ---------------------
-    // Mock initialization
-    // ---------------------
-    /**
-     * Initializes the connection mock which produces additional AutoCloseable mocks and records them.
-     *
-     * @return Connection mock
-     */
-    protected Connection initConnection() {
-        Connection connection = mock(Connection.class);
-        try {
-            given(connection.prepareStatement(anyString())).willAnswer(preparedStatementAnswer());
-            given(connection.createStatement()).willAnswer(preparedStatementAnswer());
-            given(connection.createBlob()).willReturn(mock(Blob.class));
-            return connection;
-        } catch (SQLException e) {
-            throw new IllegalStateException("Could not initialize connection mock", e);
-        }
-    }
-
-    /* Create Answer that returns a PreparedStatement mock. */
-    private Answer<PreparedStatement> preparedStatementAnswer() {
-        return new Answer<PreparedStatement>() {
-            @Override
-            public PreparedStatement answer(InvocationOnMock invocation) throws SQLException {
-                PreparedStatement pst = mock(PreparedStatement.class);
-                closeables.add(pst);
-                given(pst.executeQuery()).willAnswer(resultSetAnswer());
-                given(pst.executeQuery(anyString())).willAnswer(resultSetAnswer());
-                return pst;
-            }
-        };
-    }
-
-    /* Create Answer that returns a ResultSet mock. */
-    private Answer<ResultSet> resultSetAnswer() throws SQLException {
-        return new Answer<ResultSet>() {
-            @Override
-            public ResultSet answer(InvocationOnMock invocation) throws Throwable {
-                ResultSet rs = initResultSet();
-                closeables.add(rs);
-                return rs;
-            }
-        };
-    }
-
-    /* Create a ResultSet mock. */
-    private ResultSet initResultSet() throws SQLException {
-        ResultSet rs = mock(ResultSet.class);
-        // Return true for ResultSet#next the first time to make sure we execute all code
-        given(rs.next()).willAnswer(new Answer<Boolean>() {
-            boolean isInitial = true;
-            @Override
-            public Boolean answer(InvocationOnMock invocation) {
-                if (isInitial) {
-                    isInitial = false;
-                    return true;
-                }
-                return false;
-            }
-        });
-        given(rs.getString(anyInt())).willReturn("test");
-        given(rs.getString(anyString())).willReturn("test");
-
-        Blob blob = mock(Blob.class);
-        given(blob.getBytes(anyLong(), anyInt())).willReturn(new byte[]{});
-        given(blob.length()).willReturn(0L);
-        given(rs.getBlob(anyInt())).willReturn(blob);
-        given(rs.getBlob(anyString())).willReturn(blob);
-        return rs;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/AbstractSqlDataSourceResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/AbstractSqlDataSourceResourceClosingTest.java
deleted file mode 100644
index 4443c54c..00000000
--- a/src/test/java/fr/xephi/authme/datasource/AbstractSqlDataSourceResourceClosingTest.java
+++ /dev/null
@@ -1,73 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import com.google.common.collect.ImmutableSet;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.Settings;
-import org.junit.BeforeClass;
-import org.junit.runners.Parameterized;
-
-import java.lang.reflect.Method;
-import java.sql.Connection;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static org.mockito.Mockito.mock;
-
-/**
- * Resource-closing test for SQL data sources.
- */
-public abstract class AbstractSqlDataSourceResourceClosingTest extends AbstractResourceClosingTest {
-
-    /** List of DataSource method names not to test. */
-    private static final Set<String> IGNORED_METHODS = ImmutableSet.of("reload", "getType", "isCached");
-
-    private static Settings settings;
-
-    AbstractSqlDataSourceResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @BeforeClass
-    public static void initializeSettings() {
-        settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-        TestHelper.setupLogger();
-    }
-
-    protected DataSource getObjectUnderTest() {
-        try {
-            return createDataSource(settings, initConnection());
-        } catch (Exception e) {
-            throw new IllegalStateException(e);
-        }
-    }
-
-    /* Create a DataSource instance with the given mock settings and mock connection. */
-    protected abstract DataSource createDataSource(Settings settings, Connection connection) throws Exception;
-
-    /**
-     * Initialization method -- provides the parameters to run the test with by scanning all DataSource methods.
-     *
-     * @return Test parameters
-     */
-    @Parameterized.Parameters(name = "{1}")
-    public static Collection<Object[]> data() {
-        List<Method> methods = getDataSourceMethods();
-        List<Object[]> data = new ArrayList<>();
-        for (Method method : methods) {
-            data.add(new Object[]{method, method.getName()});
-        }
-        return data;
-    }
-
-    /* Get all methods of the DataSource interface, minus the ones in the ignored list. */
-    private static List<Method> getDataSourceMethods() {
-        return Arrays.stream(DataSource.class.getDeclaredMethods())
-            .filter(method -> !IGNORED_METHODS.contains(method.getName()) && !method.isSynthetic())
-            .collect(Collectors.toList());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/MySqlIntegrationTest.java b/src/test/java/fr/xephi/authme/datasource/MySqlIntegrationTest.java
deleted file mode 100644
index 02760823..00000000
--- a/src/test/java/fr/xephi/authme/datasource/MySqlIntegrationTest.java
+++ /dev/null
@@ -1,94 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import ch.jalu.configme.properties.Property;
-import com.zaxxer.hikari.HikariConfig;
-import com.zaxxer.hikari.HikariDataSource;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.DatabaseSettings;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-/**
- * Integration test for {@link MySQL}.
- */
-public class MySqlIntegrationTest extends AbstractDataSourceIntegrationTest {
-
-    /** Mock of a settings instance. */
-    private static Settings settings;
-    /** SQL statement to execute before running a test. */
-    private static String sqlInitialize;
-    /** Connection to the H2 test database. */
-    private HikariDataSource hikariSource;
-
-    /**
-     * Set up the settings mock to return specific values for database settings and load {@link #sqlInitialize}.
-     */
-    @BeforeClass
-    public static void initializeSettings() throws IOException, ClassNotFoundException {
-        // Check that we have an H2 driver
-        Class.forName("org.h2.jdbcx.JdbcDataSource");
-
-        settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-        set(DatabaseSettings.MYSQL_DATABASE, "h2_test");
-        set(DatabaseSettings.MYSQL_TABLE, "authme");
-        TestHelper.setRealLogger();
-
-        Path sqlInitFile = TestHelper.getJarPath(TestHelper.PROJECT_ROOT + "datasource/sql-initialize.sql");
-        sqlInitialize = new String(Files.readAllBytes(sqlInitFile));
-    }
-
-    @Before
-    public void initializeConnectionAndTable() throws SQLException {
-        HikariConfig config = new HikariConfig();
-        config.setDataSourceClassName("org.h2.jdbcx.JdbcDataSource");
-        config.setConnectionTestQuery("VALUES 1");
-        // Note "ignorecase=true": H2 does not support `COLLATE NOCASE` for case-insensitive equals queries.
-        // MySQL is by default case-insensitive so this is OK to make as an assumption.
-        config.addDataSourceProperty("URL", "jdbc:h2:mem:test;ignorecase=true");
-        config.addDataSourceProperty("user", "sa");
-        config.addDataSourceProperty("password", "sa");
-        HikariDataSource ds = new HikariDataSource(config);
-        Connection connection = ds.getConnection();
-
-        try (Statement st = connection.createStatement()) {
-            st.execute("DROP TABLE IF EXISTS authme");
-            st.execute(sqlInitialize);
-        }
-        hikariSource = ds;
-    }
-
-    @After
-    public void closeConnection() {
-        silentClose(hikariSource);
-    }
-
-    @Override
-    protected DataSource getDataSource(String saltColumn) {
-        when(settings.getProperty(DatabaseSettings.MYSQL_COL_SALT)).thenReturn(saltColumn);
-        return SqlDataSourceTestUtil.createMySql(settings, hikariSource);
-    }
-
-    private static <T> void set(Property<T> property, T value) {
-        when(settings.getProperty(property)).thenReturn(value);
-    }
-
-    private static void silentClose(HikariDataSource con) {
-        if (con != null && !con.isClosed()) {
-            con.close();
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/MySqlResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/MySqlResourceClosingTest.java
deleted file mode 100644
index 3500560b..00000000
--- a/src/test/java/fr/xephi/authme/datasource/MySqlResourceClosingTest.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import com.zaxxer.hikari.HikariDataSource;
-import fr.xephi.authme.datasource.mysqlextensions.MySqlExtension;
-import fr.xephi.authme.datasource.mysqlextensions.MySqlExtensionsFactory;
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.reflect.Method;
-import java.sql.Connection;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Resource closing test for {@link MySQL}.
- */
-public class MySqlResourceClosingTest extends AbstractSqlDataSourceResourceClosingTest {
-
-    public MySqlResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @Override
-    protected DataSource createDataSource(Settings settings, Connection connection) throws Exception {
-        HikariDataSource hikariDataSource = mock(HikariDataSource.class);
-        given(hikariDataSource.getConnection()).willReturn(connection);
-        MySqlExtensionsFactory extensionsFactory = mock(MySqlExtensionsFactory.class);
-        given(extensionsFactory.buildExtension(any(Columns.class))).willReturn(mock(MySqlExtension.class));
-        return new MySQL(settings, hikariDataSource, extensionsFactory);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/PostgreSqlIntegrationTest.java b/src/test/java/fr/xephi/authme/datasource/PostgreSqlIntegrationTest.java
deleted file mode 100644
index 54a00bf4..00000000
--- a/src/test/java/fr/xephi/authme/datasource/PostgreSqlIntegrationTest.java
+++ /dev/null
@@ -1,92 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import ch.jalu.configme.properties.Property;
-import com.zaxxer.hikari.HikariConfig;
-import com.zaxxer.hikari.HikariDataSource;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.DatabaseSettings;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-/**
- * Integration test for {@link PostgreSqlDataSource}.
- */
-public class PostgreSqlIntegrationTest extends AbstractDataSourceIntegrationTest {
-
-    /** Mock of a settings instance. */
-    private static Settings settings;
-    /** SQL statement to execute before running a test. */
-    private static String sqlInitialize;
-    /** Connection to the H2 test database. */
-    private HikariDataSource hikariSource;
-
-    /**
-     * Set up the settings mock to return specific values for database settings and load {@link #sqlInitialize}.
-     */
-    @BeforeClass
-    public static void initializeSettings() throws IOException, ClassNotFoundException {
-        // Check that we have an H2 driver
-        Class.forName("org.h2.jdbcx.JdbcDataSource");
-
-        settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-        set(DatabaseSettings.MYSQL_DATABASE, "h2_test");
-        set(DatabaseSettings.MYSQL_TABLE, "authme");
-        TestHelper.setRealLogger();
-
-        Path sqlInitFile = TestHelper.getJarPath(TestHelper.PROJECT_ROOT + "datasource/sql-initialize.sql");
-        sqlInitialize = new String(Files.readAllBytes(sqlInitFile));
-    }
-
-    @Before
-    public void initializeConnectionAndTable() throws SQLException {
-        HikariConfig config = new HikariConfig();
-        config.setDataSourceClassName("org.h2.jdbcx.JdbcDataSource");
-        config.setConnectionTestQuery("VALUES 1");
-        config.addDataSourceProperty("URL", "jdbc:h2:mem:test;ignorecase=true");
-        config.addDataSourceProperty("user", "sa");
-        config.addDataSourceProperty("password", "sa");
-        HikariDataSource ds = new HikariDataSource(config);
-        Connection connection = ds.getConnection();
-
-        try (Statement st = connection.createStatement()) {
-            st.execute("DROP TABLE IF EXISTS authme");
-            st.execute(sqlInitialize);
-        }
-        hikariSource = ds;
-    }
-
-    @After
-    public void closeConnection() {
-        silentClose(hikariSource);
-    }
-
-    @Override
-    protected DataSource getDataSource(String saltColumn) {
-        when(settings.getProperty(DatabaseSettings.MYSQL_COL_SALT)).thenReturn(saltColumn);
-        return SqlDataSourceTestUtil.createPostgres(settings, hikariSource);
-    }
-
-    private static <T> void set(Property<T> property, T value) {
-        when(settings.getProperty(property)).thenReturn(value);
-    }
-
-    private static void silentClose(HikariDataSource con) {
-        if (con != null && !con.isClosed()) {
-            con.close();
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/PostgreSqlResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/PostgreSqlResourceClosingTest.java
deleted file mode 100644
index 40a1d391..00000000
--- a/src/test/java/fr/xephi/authme/datasource/PostgreSqlResourceClosingTest.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import com.zaxxer.hikari.HikariDataSource;
-import fr.xephi.authme.datasource.mysqlextensions.MySqlExtension;
-import fr.xephi.authme.datasource.mysqlextensions.MySqlExtensionsFactory;
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.reflect.Method;
-import java.sql.Connection;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Resource closing test for {@link PostgreSqlDataSource}.
- */
-public class PostgreSqlResourceClosingTest extends AbstractSqlDataSourceResourceClosingTest {
-
-    public PostgreSqlResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @Override
-    protected DataSource createDataSource(Settings settings, Connection connection) throws Exception {
-        HikariDataSource hikariDataSource = mock(HikariDataSource.class);
-        given(hikariDataSource.getConnection()).willReturn(connection);
-        MySqlExtensionsFactory extensionsFactory = mock(MySqlExtensionsFactory.class);
-        given(extensionsFactory.buildExtension(any(Columns.class))).willReturn(mock(MySqlExtension.class));
-        return new PostgreSqlDataSource(settings, hikariDataSource, extensionsFactory);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/SQLiteIntegrationTest.java b/src/test/java/fr/xephi/authme/datasource/SQLiteIntegrationTest.java
deleted file mode 100644
index 06e60eeb..00000000
--- a/src/test/java/fr/xephi/authme/datasource/SQLiteIntegrationTest.java
+++ /dev/null
@@ -1,135 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import ch.jalu.configme.properties.Property;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.DatabaseSettings;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static org.hamcrest.Matchers.hasSize;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-/**
- * Integration test for {@link SQLite}.
- */
-public class SQLiteIntegrationTest extends AbstractDataSourceIntegrationTest {
-
-    /** Mock of a settings instance. */
-    private static Settings settings;
-    /** Collection of SQL statements to execute for initialization of a test. */
-    private static String[] sqlInitialize;
-    /** Connection to the SQLite test database. */
-    private Connection con;
-
-    /**
-     * Set up the settings mock to return specific values for database settings and load {@link #sqlInitialize}.
-     */
-    @BeforeClass
-    public static void initializeSettings() throws IOException, ClassNotFoundException {
-        // Check that we have an implementation for SQLite
-        Class.forName("org.sqlite.JDBC");
-
-        settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-        set(DatabaseSettings.MYSQL_DATABASE, "sqlite-test");
-        set(DatabaseSettings.MYSQL_TABLE, "authme");
-        TestHelper.setupLogger();
-
-        Path sqlInitFile = TestHelper.getJarPath(TestHelper.PROJECT_ROOT + "datasource/sql-initialize.sql");
-        // Note ljacqu 20160221: It appears that we can only run one statement per Statement.execute() so we split
-        // the SQL file by ";\n" as to get the individual statements
-        sqlInitialize = new String(Files.readAllBytes(sqlInitFile)).split(";(\\r?)\\n");
-    }
-
-    @Before
-    public void initializeConnectionAndTable() throws SQLException {
-        Connection connection = DriverManager.getConnection("jdbc:sqlite::memory:");
-        try (Statement st = connection.createStatement()) {
-            st.execute("DROP TABLE IF EXISTS authme");
-            for (String statement : sqlInitialize) {
-                st.execute(statement);
-            }
-        }
-        con = connection;
-    }
-
-    @After
-    public void closeConnection() {
-        silentClose(con);
-    }
-
-    @Test
-    public void shouldSetUpTableIfMissing() throws SQLException {
-        // given
-        Statement st = con.createStatement();
-        // table is absent
-        st.execute("DROP TABLE authme");
-        SQLite sqLite = new SQLite(settings, null, con);
-
-        // when
-        sqLite.setup();
-
-        // then
-        // Save some player to verify database is operational
-        sqLite.saveAuth(PlayerAuth.builder().name("Name").build());
-        assertThat(sqLite.getAllAuths(), hasSize(1));
-    }
-
-    @Test
-    public void shouldCreateMissingColumns() throws SQLException {
-        // given
-        Statement st = con.createStatement();
-        // drop table and create one with only some of the columns: SQLite doesn't support ALTER TABLE t DROP COLUMN c
-        st.execute("DROP TABLE authme");
-        st.execute("CREATE TABLE authme ("
-            + "id bigint, "
-            + "username varchar(255) unique, "
-            + "password varchar(255) not null, "
-            + "primary key (id));");
-        SQLite sqLite = new SQLite(settings, null, con);
-
-        // when
-        sqLite.setup();
-
-        // then
-        // Save some player to verify database is operational
-        sqLite.saveAuth(PlayerAuth.builder().name("Name").build());
-        assertThat(sqLite.getAllAuths(), hasSize(1));
-    }
-
-    @Override
-    protected DataSource getDataSource(String saltColumn) {
-        when(settings.getProperty(DatabaseSettings.MYSQL_COL_SALT)).thenReturn(saltColumn);
-        return new SQLite(settings, null, con);
-    }
-
-    private static <T> void set(Property<T> property, T value) {
-        when(settings.getProperty(property)).thenReturn(value);
-    }
-
-    private static void silentClose(Connection con) {
-        if (con != null) {
-            try {
-                if (!con.isClosed()) {
-                    con.close();
-                }
-            } catch (SQLException e) {
-                // silent
-            }
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/SQLiteResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/SQLiteResourceClosingTest.java
deleted file mode 100644
index 2c8fe5dc..00000000
--- a/src/test/java/fr/xephi/authme/datasource/SQLiteResourceClosingTest.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.reflect.Method;
-import java.sql.Connection;
-
-/**
- * Resource closing test for {@link SQLite}.
- */
-public class SQLiteResourceClosingTest extends AbstractSqlDataSourceResourceClosingTest {
-
-    public SQLiteResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @Override
-    protected DataSource createDataSource(Settings settings, Connection connection) throws Exception {
-        return new SQLite(settings, null, connection);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/SqLiteMigraterIntegrationTest.java b/src/test/java/fr/xephi/authme/datasource/SqLiteMigraterIntegrationTest.java
deleted file mode 100644
index b95a0b81..00000000
--- a/src/test/java/fr/xephi/authme/datasource/SqLiteMigraterIntegrationTest.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import com.google.common.collect.Lists;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.settings.Settings;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-import java.sql.Connection;
-import java.sql.DriverManager;
-import java.sql.SQLException;
-import java.util.List;
-
-import static fr.xephi.authme.AuthMeMatchers.hasAuthBasicData;
-import static fr.xephi.authme.AuthMeMatchers.hasAuthLocation;
-import static fr.xephi.authme.datasource.SqlDataSourceTestUtil.createSqlite;
-import static org.hamcrest.Matchers.arrayContaining;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-
-/**
- * Integration test for {@link SqLiteMigrater}. Uses a real SQLite database.
- */
-public class SqLiteMigraterIntegrationTest {
-
-    private File dataFolder;
-    private SQLite sqLite;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @Before
-    public void setup() throws SQLException, IOException, NoSuchMethodException {
-        TestHelper.setupLogger();
-
-        Settings settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-
-        File sqliteDbFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "datasource/sqlite.april2016.db");
-        dataFolder = temporaryFolder.newFolder();
-        File tempFile = new File(dataFolder, "authme.db");
-        Files.copy(sqliteDbFile, tempFile);
-
-        Connection con = DriverManager.getConnection("jdbc:sqlite:" + tempFile.getPath());
-        sqLite = createSqlite(settings, dataFolder, con);
-
-    }
-
-    @Test
-    public void shouldRun() throws ClassNotFoundException, SQLException {
-        // given / when
-        sqLite.setup();
-        sqLite.migrateIfNeeded();
-
-        // then
-        List<PlayerAuth> auths = sqLite.getAllAuths();
-        assertThat(Lists.transform(auths, PlayerAuth::getNickname),
-            containsInAnyOrder("mysql1", "mysql2", "mysql3", "mysql4", "mysql5", "mysql6"));
-        PlayerAuth auth1 = getByNameOrFail("mysql1", auths);
-        assertThat(auth1, hasAuthBasicData("mysql1", "mysql1", "user1@example.com", "192.168.4.41"));
-        assertThat(auth1, hasAuthLocation(0, 0, 0, "world1", 0, 0));
-        assertThat(auth1.getLastLogin(), equalTo(1472992664137L));
-        PlayerAuth auth2 = getByNameOrFail("mysql2", auths);
-        assertThat(auth2, hasAuthBasicData("mysql2", "Player", "user2@example.com", null));
-        assertThat(auth2, hasAuthLocation(0, 0, 0, "world2", 0, 0));
-        assertThat(auth2.getLastLogin(), equalTo(1472992668391L));
-        PlayerAuth auth3 = getByNameOrFail("mysql3", auths);
-        assertThat(auth3, hasAuthBasicData("mysql3", "mysql3", null, "132.54.76.98"));
-        assertThat(auth3, hasAuthLocation(0, 0, 0, "world3", 0, 0));
-        assertThat(auth3.getLastLogin(), equalTo(1472992672790L));
-        PlayerAuth auth4 = getByNameOrFail("mysql4", auths);
-        assertThat(auth4, hasAuthBasicData("mysql4", "MySQL4", null, null));
-        assertThat(auth4, hasAuthLocation(25, 4, 17, "world4", 0, 0));
-        assertThat(auth4.getLastLogin(), equalTo(1472992676790L));
-        PlayerAuth auth5 = getByNameOrFail("mysql5", auths);
-        assertThat(auth5, hasAuthBasicData("mysql5", "mysql5", null, null));
-        assertThat(auth5, hasAuthLocation(0, 0, 0, "world5", 0, 0));
-        assertThat(auth5.getLastLogin(), equalTo(1472992680922L));
-        PlayerAuth auth6 = getByNameOrFail("mysql6", auths);
-        assertThat(auth6, hasAuthBasicData("mysql6", "MySql6", "user6@example.com", "44.45.67.188"));
-        assertThat(auth6, hasAuthLocation(28.5, 53.43, -147.23, "world6", 0, 0));
-        assertThat(auth6.getLastLogin(), equalTo(1472992686300L));
-
-        // Check that backup was made
-        File backupsFolder = new File(dataFolder, "backups");
-        assertThat(backupsFolder.exists(), equalTo(true));
-        assertThat(backupsFolder.isDirectory(), equalTo(true));
-        assertThat(backupsFolder.list(), arrayContaining(containsString("authme")));
-    }
-
-    private static PlayerAuth getByNameOrFail(String name, List<PlayerAuth> auths) {
-        return auths.stream()
-            .filter(auth -> name.equals(auth.getNickname()))
-            .findFirst().orElseThrow(() -> new IllegalStateException("No PlayerAuth with name '" + name + "'"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/SqlDataSourceTestUtil.java b/src/test/java/fr/xephi/authme/datasource/SqlDataSourceTestUtil.java
deleted file mode 100644
index 48ecb8b1..00000000
--- a/src/test/java/fr/xephi/authme/datasource/SqlDataSourceTestUtil.java
+++ /dev/null
@@ -1,64 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import com.zaxxer.hikari.HikariDataSource;
-import fr.xephi.authme.datasource.mysqlextensions.MySqlExtension;
-import fr.xephi.authme.datasource.mysqlextensions.MySqlExtensionsFactory;
-import fr.xephi.authme.settings.Settings;
-
-import java.io.File;
-import java.sql.Connection;
-import java.sql.SQLException;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test util for the SQL data sources.
- */
-public final class SqlDataSourceTestUtil {
-
-    private SqlDataSourceTestUtil() {
-    }
-
-    public static MySQL createMySql(Settings settings, HikariDataSource hikariDataSource) {
-        MySqlExtensionsFactory extensionsFactory = mock(MySqlExtensionsFactory.class);
-        given(extensionsFactory.buildExtension(any())).willReturn(mock(MySqlExtension.class));
-        return new MySQL(settings, hikariDataSource, extensionsFactory);
-    }
-
-    public static PostgreSqlDataSource createPostgres(Settings settings, HikariDataSource hikariDataSource) {
-        MySqlExtensionsFactory extensionsFactory = mock(MySqlExtensionsFactory.class);
-        given(extensionsFactory.buildExtension(any())).willReturn(mock(MySqlExtension.class));
-        return new PostgreSqlDataSource(settings, hikariDataSource, extensionsFactory);
-    }
-
-    /**
-     * Creates a SQLite implementation for testing purposes. Methods are overridden so the
-     * provided connection is never overridden.
-     *
-     * @param settings settings instance
-     * @param dataFolder data folder
-     * @param connection connection to use
-     * @return the created SQLite instance
-     */
-    public static SQLite createSqlite(Settings settings, File dataFolder, Connection connection) {
-        return new SQLite(settings, dataFolder, connection) {
-            // Override reload() so it doesn't run SQLite#connect, since we're given a specific Connection to use
-            @Override
-            public void reload() {
-                try {
-                    this.setup();
-                    this.migrateIfNeeded();
-                } catch (SQLException e) {
-                    throw new IllegalStateException(e);
-                }
-            }
-
-            @Override
-            protected void connect() {
-                // noop
-            }
-        };
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/SqlDataSourceUtilsTest.java b/src/test/java/fr/xephi/authme/datasource/SqlDataSourceUtilsTest.java
deleted file mode 100644
index ae297408..00000000
--- a/src/test/java/fr/xephi/authme/datasource/SqlDataSourceUtilsTest.java
+++ /dev/null
@@ -1,149 +0,0 @@
-package fr.xephi.authme.datasource;
-
-import fr.xephi.authme.TestHelper;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.sql.DatabaseMetaData;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.logging.Logger;
-
-import static org.hamcrest.Matchers.containsString;
-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;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link SqlDataSourceUtils}.
- */
-public class SqlDataSourceUtilsTest {
-
-    private Logger logger;
-
-    @Before
-    public void initLogger() {
-        logger = TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldLogException() {
-        // given
-        String msg = "Hocus pocus did not work";
-        SQLException ex = new SQLException(msg);
-
-        // when
-        SqlDataSourceUtils.logSqlException(ex);
-
-        // then
-        verify(logger).warning(argThat(containsString(msg)));
-    }
-
-    @Test
-    public void shouldFetchNullableStatus() throws SQLException {
-        // given
-        String tableName = "data";
-        String columnName = "category";
-        ResultSet resultSet = mock(ResultSet.class);
-        given(resultSet.getInt("NULLABLE")).willReturn(DatabaseMetaData.columnNullable);
-        given(resultSet.next()).willReturn(true);
-        DatabaseMetaData metaData = mock(DatabaseMetaData.class);
-        given(metaData.getColumns(null, null, tableName, columnName)).willReturn(resultSet);
-
-        // when
-        boolean result = SqlDataSourceUtils.isNotNullColumn(metaData, tableName, columnName);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldReturnFalseForUnknownNullableStatus() throws SQLException {
-        // given
-        String tableName = "comments";
-        String columnName = "author";
-        ResultSet resultSet = mock(ResultSet.class);
-        given(resultSet.getInt("NULLABLE")).willReturn(DatabaseMetaData.columnNullableUnknown);
-        given(resultSet.next()).willReturn(true);
-        DatabaseMetaData metaData = mock(DatabaseMetaData.class);
-        given(metaData.getColumns(null, null, tableName, columnName)).willReturn(resultSet);
-
-        // when
-        boolean result = SqlDataSourceUtils.isNotNullColumn(metaData, tableName, columnName);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test(expected = IllegalStateException.class)
-    public void shouldThrowForUnknownColumnInNullableCheck() throws SQLException {
-        // given
-        String tableName = "data";
-        String columnName = "unknown";
-        ResultSet resultSet = mock(ResultSet.class);
-        given(resultSet.next()).willReturn(false);
-        DatabaseMetaData metaData = mock(DatabaseMetaData.class);
-        given(metaData.getColumns(null, null, tableName, columnName)).willReturn(resultSet);
-
-        // when
-        SqlDataSourceUtils.isNotNullColumn(metaData, tableName, columnName);
-
-        // then - expect exception
-    }
-
-    @Test
-    public void shouldGetDefaultValue() throws SQLException {
-        // given
-        String tableName = "data";
-        String columnName = "category";
-        ResultSet resultSet = mock(ResultSet.class);
-        given(resultSet.getObject("COLUMN_DEF")).willReturn("Literature");
-        given(resultSet.next()).willReturn(true);
-        DatabaseMetaData metaData = mock(DatabaseMetaData.class);
-        given(metaData.getColumns(null, null, tableName, columnName)).willReturn(resultSet);
-
-        // when
-        Object defaultValue = SqlDataSourceUtils.getColumnDefaultValue(metaData, tableName, columnName);
-
-        // then
-        assertThat(defaultValue, equalTo("Literature"));
-    }
-
-    @Test(expected = IllegalStateException.class)
-    public void shouldThrowForUnknownColumnInDefaultValueRetrieval() throws SQLException {
-        // given
-        String tableName = "data";
-        String columnName = "unknown";
-        ResultSet resultSet = mock(ResultSet.class);
-        given(resultSet.next()).willReturn(false);
-        DatabaseMetaData metaData = mock(DatabaseMetaData.class);
-        given(metaData.getColumns(null, null, tableName, columnName)).willReturn(resultSet);
-
-        // when
-        SqlDataSourceUtils.getColumnDefaultValue(metaData, tableName, columnName);
-
-        // then - expect exception
-    }
-
-    @Test
-    public void shouldHandleNullDefaultValue() throws SQLException {
-        // given
-        String tableName = "data";
-        String columnName = "category";
-        ResultSet resultSet = mock(ResultSet.class);
-        given(resultSet.getObject("COLUMN_DEF")).willReturn(null);
-        given(resultSet.next()).willReturn(true);
-        DatabaseMetaData metaData = mock(DatabaseMetaData.class);
-        given(metaData.getColumns(null, null, tableName, columnName)).willReturn(resultSet);
-
-        // when
-        Object defaultValue = SqlDataSourceUtils.getColumnDefaultValue(metaData, tableName, columnName);
-
-        // then
-        assertThat(defaultValue, nullValue());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/converter/AbstractDataSourceConverterTest.java b/src/test/java/fr/xephi/authme/datasource/converter/AbstractDataSourceConverterTest.java
deleted file mode 100644
index 5dd03244..00000000
--- a/src/test/java/fr/xephi/authme/datasource/converter/AbstractDataSourceConverterTest.java
+++ /dev/null
@@ -1,127 +0,0 @@
-package fr.xephi.authme.datasource.converter;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.datasource.DataSourceType;
-import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.mockito.Mockito;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link AbstractDataSourceConverter}.
- */
-public class AbstractDataSourceConverterTest {
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldThrowForDestinationTypeMismatch() {
-        // given
-        DataSource destination = mock(DataSource.class);
-        given(destination.getType()).willReturn(DataSourceType.MYSQL);
-        DataSourceType destinationType = DataSourceType.SQLITE;
-        DataSource source = mock(DataSource.class);
-        Converter converter = new DataSourceConverterTestImpl<>(source, destination, destinationType);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        converter.execute(sender);
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Please configure your connection to SQLITE")));
-        verify(destination, only()).getType();
-        verifyNoInteractions(source);
-    }
-
-    @Test
-    public void shouldHandleSourceThrowingException() {
-        // given
-        DataSource source = mock(DataSource.class);
-        DataSource destination = mock(DataSource.class);
-        DataSourceType destinationType = DataSourceType.SQLITE;
-        given(destination.getType()).willReturn(destinationType);
-        DataSourceConverterTestImpl<DataSource> converter =
-            Mockito.spy(new DataSourceConverterTestImpl<>(source, destination, destinationType));
-        doThrow(IllegalStateException.class).when(converter).getSource();
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        converter.execute(sender);
-
-        // then
-        verify(sender).sendMessage("The data source to convert from could not be initialized");
-        verify(destination, only()).getType();
-        verifyNoInteractions(source);
-    }
-
-    @Test
-    public void shouldConvertAndSkipExistingPlayers() {
-        // given
-        DataSource source = mock(DataSource.class);
-        DataSource destination = mock(DataSource.class);
-        DataSourceType destinationType = DataSourceType.MYSQL;
-        given(destination.getType()).willReturn(destinationType);
-
-        List<PlayerAuth> auths =
-            Arrays.asList(mockAuthWithName("Steven"), mockAuthWithName("bobby"), mockAuthWithName("Jack"));
-        given(source.getAllAuths()).willReturn(auths);
-        given(destination.isAuthAvailable(auths.get(0).getNickname())).willReturn(true);
-
-        Converter converter = new DataSourceConverterTestImpl<>(source, destination, destinationType);
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        converter.execute(sender);
-
-        // then
-        verify(destination).getType();
-        verify(destination, times(3)).isAuthAvailable(anyString());
-        verify(destination, times(2)).saveAuth(any(PlayerAuth.class));
-        verify(destination, times(2)).updateSession(any(PlayerAuth.class));
-        verify(destination, times(2)).updateQuitLoc(any(PlayerAuth.class));
-        verifyNoMoreInteractions(destination);
-        verify(sender).sendMessage(argThat(containsString(auths.get(0).getNickname())));
-        verify(sender).sendMessage(argThat(containsString("successfully converted")));
-    }
-
-    private static PlayerAuth mockAuthWithName(String name) {
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getNickname()).willReturn(name);
-        return auth;
-    }
-
-    private static class DataSourceConverterTestImpl<S extends DataSource> extends AbstractDataSourceConverter<S> {
-        private final S source;
-
-        DataSourceConverterTestImpl(S source, DataSource destination, DataSourceType destinationType) {
-            super(destination, destinationType);
-            this.source = source;
-        }
-
-        @Override
-        protected S getSource() {
-          return source;
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/converter/CrazyLoginConverterTest.java b/src/test/java/fr/xephi/authme/datasource/converter/CrazyLoginConverterTest.java
deleted file mode 100644
index 8819772d..00000000
--- a/src/test/java/fr/xephi/authme/datasource/converter/CrazyLoginConverterTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-package fr.xephi.authme.datasource.converter;
-
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.ConverterSettings;
-import org.bukkit.command.CommandSender;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.util.List;
-
-import static fr.xephi.authme.AuthMeMatchers.equalToHash;
-import static org.hamcrest.Matchers.containsString;
-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.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link CrazyLoginConverter}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class CrazyLoginConverterTest {
-
-    @InjectDelayed
-    private CrazyLoginConverter crazyLoginConverter;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private Settings settings;
-
-    @DataFolder
-    private File dataFolder = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "/datasource/converter/");
-
-    @BeforeClass
-    public static void initializeLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldImportUsers() {
-        // given
-        given(settings.getProperty(ConverterSettings.CRAZYLOGIN_FILE_NAME)).willReturn("crazylogin.db");
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        crazyLoginConverter.execute(sender);
-
-        // then
-        ArgumentCaptor<PlayerAuth> authCaptor = ArgumentCaptor.forClass(PlayerAuth.class);
-        verify(dataSource, times(2)).saveAuth(authCaptor.capture());
-        List<PlayerAuth> savedAuths = authCaptor.getAllValues();
-        assertNameAndRealName(savedAuths.get(0), "qotato", "qotaTo");
-        assertThat(savedAuths.get(0).getPassword(), equalToHash("8267663ab198a96437b9f455429a2c1b6c943111613c217bf2703c14d08a309d34e510ddb5549507b1500759dbcf9d4a99bc765ff37b32bd31adbb1e92e74ac5"));
-        assertNameAndRealName(savedAuths.get(1), "bobby", "Bobby");
-        assertThat(savedAuths.get(1).getPassword(), equalToHash("ad50dbc841e6321210530801f5219a5ffb4c7c41f11878d465374a4b8db2965c50f69b6098918a58e4adea312e3633c7724b15e24a217009e6fa2b3c299d55f2"));
-    }
-
-    @Test
-    public void shouldStopForNonExistentFile() {
-        // given
-        given(settings.getProperty(ConverterSettings.CRAZYLOGIN_FILE_NAME)).willReturn("invalid-file");
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        crazyLoginConverter.execute(sender);
-
-        // then
-        verifyNoInteractions(dataSource);
-        verify(sender).sendMessage(argThat(containsString("file not found")));
-    }
-
-    private static void assertNameAndRealName(PlayerAuth auth, String name, String realName) {
-        assertThat(auth.getNickname(), equalTo(name));
-        assertThat(auth.getRealName(), equalTo(realName));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/converter/LoginSecurityConverterTest.java b/src/test/java/fr/xephi/authme/datasource/converter/LoginSecurityConverterTest.java
deleted file mode 100644
index 54201fb7..00000000
--- a/src/test/java/fr/xephi/authme/datasource/converter/LoginSecurityConverterTest.java
+++ /dev/null
@@ -1,147 +0,0 @@
-package fr.xephi.authme.datasource.converter;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import com.zaxxer.hikari.HikariConfig;
-import com.zaxxer.hikari.HikariDataSource;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.ConverterSettings;
-import org.bukkit.command.CommandSender;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.sql.Statement;
-
-import static fr.xephi.authme.AuthMeMatchers.equalToHash;
-import static fr.xephi.authme.AuthMeMatchers.hasAuthLocation;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link LoginSecurityConverter}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class LoginSecurityConverterTest {
-
-    @InjectDelayed
-    private LoginSecurityConverter converter;
-
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private Settings settings;
-    @DataFolder
-    private File dataFolder = new File("."); // not used but required for injection
-
-    @BeforeInjecting
-    public void initMocks() {
-        TestHelper.setupLogger();
-        given(settings.getProperty(ConverterSettings.LOGINSECURITY_USE_SQLITE)).willReturn(true);
-    }
-
-    @Test
-    public void shouldConvertFromSqlite() throws SQLException {
-        // given
-        Connection connection = converter.createSqliteConnection(
-            TestHelper.TEST_RESOURCES_FOLDER + TestHelper.PROJECT_ROOT + "datasource/converter/LoginSecurity.db");
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        converter.performConversion(sender, connection);
-
-        // then
-        ArgumentCaptor<PlayerAuth> captor = ArgumentCaptor.forClass(PlayerAuth.class);
-        verify(dataSource, times(3)).saveAuth(captor.capture());
-        assertThat(captor.getAllValues().get(0).getNickname(), equalTo("player1"));
-        assertThat(captor.getAllValues().get(0).getRealName(), equalTo("Player1"));
-        assertThat(captor.getAllValues().get(0).getLastLogin(), equalTo(1494242093652L));
-        assertThat(captor.getAllValues().get(0).getRegistrationDate(), equalTo(1494242093400L));
-        assertThat(captor.getAllValues().get(0).getPassword(), equalToHash("$2a$10$E1Ri7XKeIIBv4qVaiPplgepT7QH9xGFh3hbHfcmCjq7hiW.UBTiGK"));
-        assertThat(captor.getAllValues().get(0).getLastIp(), nullValue());
-
-        assertThat(captor.getAllValues().get(1).getNickname(), equalTo("player2"));
-        assertThat(captor.getAllValues().get(1).getLastLogin(), equalTo(1494242174589L));
-        assertThat(captor.getAllValues().get(1).getLastIp(), equalTo("127.4.5.6"));
-
-        assertThat(captor.getAllValues().get(2).getRealName(), equalTo("Player3"));
-        assertThat(captor.getAllValues().get(2).getPassword(), equalToHash("$2a$10$WFui8KSXMLDOVXKFpCLyPukPi4M82w1cv/rNojsAnwJjba3pp8sba"));
-        assertThat(captor.getAllValues().get(2), hasAuthLocation(14.24, 67.99, -12.83, "hubb", -10f, 185f));
-        assertThat(captor.getAllValues().get(2).getLastIp(), nullValue());
-        assertIsCloseTo(captor.getAllValues().get(2).getRegistrationDate(), System.currentTimeMillis(), 500L);
-    }
-
-    // Note ljacqu 20171014: JDBC mapping of a Date column to a java.sql.Date is difficult to handle,
-    // cf. https://stackoverflow.com/questions/9202857/timezones-in-sql-date-vs-java-sql-date
-    // For H2 it looks like Date#getTime returns the millis of the date at 12AM in the system's timezone,
-    // so we check with a margin of 12 hours to cover most cases...
-    @Test
-    public void shouldConvertFromMySql() throws IOException, SQLException {
-        // given
-        Connection connection = initializeMySqlTable();
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        converter.performConversion(sender, connection);
-
-        // then
-        ArgumentCaptor<PlayerAuth> captor = ArgumentCaptor.forClass(PlayerAuth.class);
-        verify(dataSource, times(3)).saveAuth(captor.capture());
-        assertThat(captor.getAllValues().get(0).getNickname(), equalTo("player1"));
-        assertThat(captor.getAllValues().get(0).getRealName(), equalTo("Player1"));
-        assertThat(captor.getAllValues().get(0).getLastLogin(), equalTo(1494242093000L));
-        assertThat(captor.getAllValues().get(0).getPassword(), equalToHash("$2a$10$E1Ri7XKeIIBv4qVaiPplgepT7QH9xGFh3hbHfcmCjq7hiW.UBTiGK"));
-        assertThat(captor.getAllValues().get(0).getLastIp(), nullValue());
-        assertIsCloseTo(captor.getAllValues().get(0).getRegistrationDate(), 1494201600000L, 12 * 60 * 60 * 1000);
-
-        assertThat(captor.getAllValues().get(1).getNickname(), equalTo("player2"));
-        assertThat(captor.getAllValues().get(1).getLastLogin(), equalTo(1489317753000L));
-        assertThat(captor.getAllValues().get(1).getLastIp(), equalTo("127.4.5.6"));
-
-        assertThat(captor.getAllValues().get(2).getRealName(), equalTo("Player3"));
-        assertThat(captor.getAllValues().get(2).getPassword(), equalToHash("$2a$10$WFui8KSXMLDOVXKFpCLyPukPi4M82w1cv/rNojsAnwJjba3pp8sba"));
-        assertThat(captor.getAllValues().get(2), hasAuthLocation(14.24, 67.99, -12.83, "hubb", -10f, 185f));
-    }
-
-    private Connection initializeMySqlTable() throws IOException, SQLException {
-        File sqlInitFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "datasource/converter/loginsecurity.sql");
-        String initStatement = new String(Files.readAllBytes(sqlInitFile.toPath()));
-
-        HikariConfig config = new HikariConfig();
-        config.setDataSourceClassName("org.h2.jdbcx.JdbcDataSource");
-        config.setConnectionTestQuery("VALUES 1");
-        config.addDataSourceProperty("URL", "jdbc:h2:mem:test");
-        config.addDataSourceProperty("user", "sa");
-        config.addDataSourceProperty("password", "sa");
-        HikariDataSource ds = new HikariDataSource(config);
-        Connection connection = ds.getConnection();
-
-        try (Statement st = connection.createStatement()) {
-            st.execute("DROP TABLE IF EXISTS authme");
-            st.execute(initStatement);
-        }
-        return connection;
-    }
-
-    private static void assertIsCloseTo(long value1, long value2, long tolerance) {
-        assertThat(Math.abs(value1 - value2), not(greaterThan(tolerance)));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/AbstractMySqlExtensionResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/mysqlextensions/AbstractMySqlExtensionResourceClosingTest.java
deleted file mode 100644
index 3089e8b9..00000000
--- a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/AbstractMySqlExtensionResourceClosingTest.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package fr.xephi.authme.datasource.mysqlextensions;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.AbstractResourceClosingTest;
-import fr.xephi.authme.datasource.Columns;
-import fr.xephi.authme.settings.Settings;
-import org.junit.BeforeClass;
-import org.junit.runners.Parameterized;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static org.mockito.Mockito.mock;
-
-/**
- * Checks that SQL resources are closed properly in {@link MySqlExtension} implementations.
- */
-public abstract class AbstractMySqlExtensionResourceClosingTest extends AbstractResourceClosingTest {
-
-    private static Settings settings;
-    private static Columns columns;
-
-    public AbstractMySqlExtensionResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @BeforeClass
-    public static void initSettings() {
-        settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-        columns = new Columns(settings);
-    }
-
-    @Override
-    protected MySqlExtension getObjectUnderTest() {
-        return createExtension(settings, columns);
-    }
-
-    protected abstract MySqlExtension createExtension(Settings settings, Columns columns);
-
-    @Parameterized.Parameters(name = "{1}")
-    public static List<Object[]> createParameters() {
-        return Arrays.stream(MySqlExtension.class.getDeclaredMethods())
-            .filter(m -> Modifier.isPublic(m.getModifiers()))
-            .map(m -> new Object[]{m, m.getName()})
-            .collect(Collectors.toList());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/Ipb4ExtensionResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/mysqlextensions/Ipb4ExtensionResourceClosingTest.java
deleted file mode 100644
index 8629a6a7..00000000
--- a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/Ipb4ExtensionResourceClosingTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package fr.xephi.authme.datasource.mysqlextensions;
-
-import fr.xephi.authme.datasource.Columns;
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.reflect.Method;
-
-/**
- * Resource closing test for {@link Ipb4Extension}.
- */
-public class Ipb4ExtensionResourceClosingTest extends AbstractMySqlExtensionResourceClosingTest {
-
-    public Ipb4ExtensionResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @Override
-    protected MySqlExtension createExtension(Settings settings, Columns columns) {
-        return new Ipb4Extension(settings, columns);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/NoOpExtensionTest.java b/src/test/java/fr/xephi/authme/datasource/mysqlextensions/NoOpExtensionTest.java
deleted file mode 100644
index 40f98247..00000000
--- a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/NoOpExtensionTest.java
+++ /dev/null
@@ -1,54 +0,0 @@
-package fr.xephi.authme.datasource.mysqlextensions;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.Columns;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.settings.Settings;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link NoOpExtension}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class NoOpExtensionTest {
-
-    private NoOpExtension extension;
-
-    @Before
-    public void createExtension() {
-        Settings settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-        Columns columns = new Columns(settings);
-        extension = new NoOpExtension(settings, columns);
-    }
-
-    @Test
-    public void shouldNotHaveAnyInteractionsWithConnection() throws SQLException {
-        // given
-        Connection connection = mock(Connection.class);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        int id = 3;
-        String name = "Bobby";
-        HashedPassword password = new HashedPassword("test", "toast");
-
-
-        // when
-        extension.extendAuth(auth, id, connection);
-        extension.changePassword(name, password, connection);
-        extension.removeAuth(name, connection);
-        extension.saveAuth(auth, connection);
-
-        // then
-        verifyNoInteractions(connection, auth);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/PhpBbExtensionResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/mysqlextensions/PhpBbExtensionResourceClosingTest.java
deleted file mode 100644
index d1f43e1f..00000000
--- a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/PhpBbExtensionResourceClosingTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package fr.xephi.authme.datasource.mysqlextensions;
-
-import fr.xephi.authme.datasource.Columns;
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.reflect.Method;
-
-/**
- * Resource closing test for {@link PhpBbExtension}.
- */
-public class PhpBbExtensionResourceClosingTest extends AbstractMySqlExtensionResourceClosingTest {
-
-    public PhpBbExtensionResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @Override
-    protected MySqlExtension createExtension(Settings settings, Columns columns) {
-        return new PhpBbExtension(settings, columns);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/WordpressExtensionResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/mysqlextensions/WordpressExtensionResourceClosingTest.java
deleted file mode 100644
index 1ee141ff..00000000
--- a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/WordpressExtensionResourceClosingTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package fr.xephi.authme.datasource.mysqlextensions;
-
-import fr.xephi.authme.datasource.Columns;
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.reflect.Method;
-
-/**
- * Resource closing test for {@link WordpressExtension}.
- */
-public class WordpressExtensionResourceClosingTest extends AbstractMySqlExtensionResourceClosingTest {
-
-    public WordpressExtensionResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @Override
-    protected MySqlExtension createExtension(Settings settings, Columns columns) {
-        return new WordpressExtension(settings, columns);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/XfBcryptExtensionResourceClosingTest.java b/src/test/java/fr/xephi/authme/datasource/mysqlextensions/XfBcryptExtensionResourceClosingTest.java
deleted file mode 100644
index 7da4fb19..00000000
--- a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/XfBcryptExtensionResourceClosingTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package fr.xephi.authme.datasource.mysqlextensions;
-
-import fr.xephi.authme.datasource.Columns;
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.reflect.Method;
-
-/**
- * Resource closing test for {@link XfBcryptExtension}.
- */
-public class XfBcryptExtensionResourceClosingTest extends AbstractMySqlExtensionResourceClosingTest {
-
-    public XfBcryptExtensionResourceClosingTest(Method method, String name) {
-        super(method, name);
-    }
-
-    @Override
-    protected MySqlExtension createExtension(Settings settings, Columns columns) {
-        return new XfBcryptExtension(settings, columns);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/events/EventsConsistencyTest.java b/src/test/java/fr/xephi/authme/events/EventsConsistencyTest.java
deleted file mode 100644
index bb722d3e..00000000
--- a/src/test/java/fr/xephi/authme/events/EventsConsistencyTest.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package fr.xephi.authme.events;
-
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import org.bukkit.event.Event;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.List;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Checks the consistency of the AuthMe event classes.
- */
-public class EventsConsistencyTest {
-
-    private static final String EVENTS_FOLDER = TestHelper.PROJECT_ROOT + "events/";
-    private static List<Class<? extends Event>> classes;
-
-    @BeforeClass
-    public static void scanEventClasses() {
-        ClassCollector classCollector = new ClassCollector(TestHelper.SOURCES_FOLDER, EVENTS_FOLDER);
-        classes = classCollector.collectClasses(Event.class);
-
-        if (classes.isEmpty()) {
-            throw new IllegalStateException("Did not find any AuthMe event classes. Is the folder correct?");
-        }
-    }
-
-    @Test
-    public void shouldExtendFromCustomEvent() {
-        for (Class<?> clazz : classes) {
-            assertThat("Class " + clazz.getSimpleName() + " is subtype of CustomEvent",
-                CustomEvent.class.isAssignableFrom(clazz), equalTo(true));
-        }
-    }
-
-    /**
-     * Bukkit requires a static getHandlerList() method on all event classes, see {@link Event}.
-     * This test checks that such a method is present, and that it is <i>absent</i> if the class
-     * is not instantiable (abstract class).
-     */
-    @Test
-    public void shouldHaveStaticEventHandlerMethod() {
-        for (Class<?> clazz : classes) {
-            Method handlerListMethod = null;
-            try {
-                handlerListMethod = clazz.getMethod("getHandlerList");
-            } catch (NoSuchMethodException ignored) {
-            }
-            if (canBeInstantiated(clazz)) {
-                assertThat("Class " + clazz.getSimpleName() + " has static method getHandlerList()",
-                    handlerListMethod != null && Modifier.isStatic(handlerListMethod.getModifiers()), equalTo(true));
-            } else {
-                assertThat("Non-instantiable class " + clazz.getSimpleName() + " does not have static getHandlerList()",
-                    handlerListMethod, nullValue());
-            }
-        }
-    }
-
-    private static boolean canBeInstantiated(Class<?> clazz) {
-        return !clazz.isInterface() && !clazz.isEnum() && !Modifier.isAbstract(clazz.getModifiers());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/initialization/TaskCloserTest.java b/src/test/java/fr/xephi/authme/initialization/TaskCloserTest.java
deleted file mode 100644
index 16613c13..00000000
--- a/src/test/java/fr/xephi/authme/initialization/TaskCloserTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-package fr.xephi.authme.initialization;
-
-import fr.xephi.authme.AuthMe;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.datasource.DataSource;
-import org.bukkit.Server;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginLogger;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.bukkit.scheduler.BukkitScheduler;
-import org.bukkit.scheduler.BukkitWorker;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import static org.hamcrest.Matchers.contains;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doNothing;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link TaskCloser}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class TaskCloserTest {
-
-    private static final int[] ACTIVE_WORKERS_ID = {2, 5};
-
-    private TaskCloser taskCloser;
-    @Mock
-    private AuthMe authMe;
-    @Mock
-    private PluginLogger logger;
-    @Mock
-    private BukkitScheduler bukkitScheduler;
-    @Mock
-    private DataSource dataSource;
-
-    @Before
-    public void initAuthMe() {
-        Server server = mock(Server.class);
-        given(server.getScheduler()).willReturn(bukkitScheduler);
-        ReflectionTestUtils.setField(JavaPlugin.class, authMe, "server", server);
-        given(authMe.getLogger()).willReturn(logger);
-        taskCloser = spy(new TaskCloser(authMe, dataSource));
-    }
-
-    @Test
-    public void shouldWaitForTasksToClose() throws InterruptedException {
-        // given
-        doNothing().when(taskCloser).sleep(); // avoid sleeping in tests
-        mockActiveWorkers();
-        given(bukkitScheduler.isCurrentlyRunning(ACTIVE_WORKERS_ID[0])).willReturn(false);
-        given(bukkitScheduler.isCurrentlyRunning(ACTIVE_WORKERS_ID[1]))
-            .willReturn(true) // first time
-            .willReturn(false); // second time
-
-        // when
-        taskCloser.run();
-
-        // then
-        verify(bukkitScheduler, times(3)).isQueued(anyInt());
-        ArgumentCaptor<Integer> taskIds = ArgumentCaptor.forClass(Integer.class);
-        verify(bukkitScheduler, times(3)).isCurrentlyRunning(taskIds.capture());
-        assertThat(taskIds.getAllValues(), contains(ACTIVE_WORKERS_ID[0], ACTIVE_WORKERS_ID[1], ACTIVE_WORKERS_ID[1]));
-        verify(taskCloser, times(2)).sleep();
-        verify(dataSource).closeConnection();
-    }
-
-    @Test
-    public void shouldAbortForNeverEndingTask() throws InterruptedException {
-        // given
-        doNothing().when(taskCloser).sleep(); // avoid sleeping in tests
-        mockActiveWorkers();
-        // This task never ends
-        given(bukkitScheduler.isCurrentlyRunning(ACTIVE_WORKERS_ID[0])).willReturn(true);
-        given(bukkitScheduler.isCurrentlyRunning(ACTIVE_WORKERS_ID[1])).willReturn(false);
-
-        // when
-        taskCloser.run();
-
-        // then
-        verify(bukkitScheduler, times(3)).isQueued(anyInt());
-        verify(bukkitScheduler, times(61)).isCurrentlyRunning(anyInt());
-        verify(taskCloser, times(60)).sleep();
-        verify(dataSource).closeConnection();
-    }
-
-    @Test
-    public void shouldStopForInterruptedThread() throws InterruptedException, ExecutionException {
-        // Note ljacqu 20160827: This test must be run in its own thread because we throw an InterruptedException.
-        // Somehow the java.nio.Files API used in tests that are run subsequently don't like this and fail otherwise.
-        ExecutorService executor = Executors.newSingleThreadExecutor();
-        executor.submit(new Runnable() {
-            @Override
-            public void run() {
-                try {
-                    shouldStopForInterruptedThread0();
-                } catch (Exception e) {
-                    throw new IllegalStateException(e);
-                }
-            }
-        }).get();
-    }
-
-    /** Test implementation for {@link #shouldStopForInterruptedThread()}. */
-    private void shouldStopForInterruptedThread0() throws InterruptedException {
-        // given
-        taskCloser = spy(new TaskCloser(authMe, null));
-        // First two times do nothing, third time throw exception when we sleep
-        doNothing().doNothing().doThrow(InterruptedException.class).when(taskCloser).sleep();
-        mockActiveWorkers();
-        given(bukkitScheduler.isCurrentlyRunning(anyInt())).willReturn(true);
-
-        // when
-        taskCloser.run();
-
-        // then
-        verify(bukkitScheduler, times(4)).isCurrentlyRunning(anyInt());
-        verify(taskCloser, times(3)).sleep();
-    }
-
-    private void mockActiveWorkers() {
-        Plugin otherOwner = mock(Plugin.class);
-        List<BukkitWorker> tasks = Arrays.asList(
-            mockBukkitWorker(authMe, ACTIVE_WORKERS_ID[0], false),
-            mockBukkitWorker(otherOwner, 3, false),
-            mockBukkitWorker(authMe, ACTIVE_WORKERS_ID[1], false),
-            mockBukkitWorker(authMe, 7, true),
-            mockBukkitWorker(otherOwner, 11, true));
-        given(bukkitScheduler.getActiveWorkers()).willReturn(tasks);
-    }
-
-    private BukkitWorker mockBukkitWorker(Plugin owner, int taskId, boolean isQueued) {
-        BukkitWorker worker = mock(BukkitWorker.class);
-        given(worker.getOwner()).willReturn(owner);
-        given(worker.getTaskId()).willReturn(taskId);
-        given(bukkitScheduler.isQueued(taskId)).willReturn(isQueued);
-        return worker;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/listener/BlockListenerTest.java b/src/test/java/fr/xephi/authme/listener/BlockListenerTest.java
deleted file mode 100644
index 6925343a..00000000
--- a/src/test/java/fr/xephi/authme/listener/BlockListenerTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package fr.xephi.authme.listener;
-
-import org.bukkit.entity.Player;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-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.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link BlockListener}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class BlockListenerTest {
-
-    @InjectMocks
-    private BlockListener listener;
-
-    @Mock
-    private ListenerService listenerService;
-
-    @Test
-    public void shouldAllowPlaceEvent() {
-        // given
-        Player player = mock(Player.class);
-        BlockPlaceEvent event = mock(BlockPlaceEvent.class);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onBlockPlace(event);
-
-        // then
-        verify(event).getPlayer();
-        verifyNoMoreInteractions(event);
-    }
-
-    @Test
-    public void shouldDenyPlaceEvent() {
-        // given
-        Player player = mock(Player.class);
-        BlockPlaceEvent event = mock(BlockPlaceEvent.class);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-
-        // when
-        listener.onBlockPlace(event);
-
-        // then
-        verify(event).setCancelled(true);
-        verify(event).getPlayer();
-        verifyNoMoreInteractions(event);
-    }
-
-    @Test
-    public void shouldAllowBreakEvent() {
-        // given
-        Player player = mock(Player.class);
-        BlockBreakEvent event = mock(BlockBreakEvent.class);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onBlockBreak(event);
-
-        // then
-        verify(event).getPlayer();
-        verifyNoMoreInteractions(event);
-    }
-
-    @Test
-    public void shouldDenyBreakEvent() {
-        // given
-        Player player = mock(Player.class);
-        BlockBreakEvent event = mock(BlockBreakEvent.class);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-
-        // when
-        listener.onBlockBreak(event);
-
-        // then
-        verify(event).setCancelled(true);
-        verify(event).getPlayer();
-        verifyNoMoreInteractions(event);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/listener/EntityListenerTest.java b/src/test/java/fr/xephi/authme/listener/EntityListenerTest.java
deleted file mode 100644
index ce9fabb0..00000000
--- a/src/test/java/fr/xephi/authme/listener/EntityListenerTest.java
+++ /dev/null
@@ -1,247 +0,0 @@
-package fr.xephi.authme.listener;
-
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Projectile;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.entity.EntityInteractEvent;
-import org.bukkit.event.entity.EntityRegainHealthEvent;
-import org.bukkit.event.entity.EntityShootBowEvent;
-import org.bukkit.event.entity.EntityTargetEvent;
-import org.bukkit.event.entity.FoodLevelChangeEvent;
-import org.bukkit.event.entity.ProjectileLaunchEvent;
-import org.bukkit.projectiles.ProjectileSource;
-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.listener.EventCancelVerifier.withServiceMock;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link EntityListener}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class EntityListenerTest {
-
-    @InjectMocks
-    private EntityListener listener;
-
-    @Mock
-    private ListenerService listenerService;
-
-    @Test
-    public void shouldHandleSimpleEvents() {
-        withServiceMock(listenerService)
-            .check(listener::onFoodLevelChange, FoodLevelChangeEvent.class)
-            .check(listener::onShoot, EntityShootBowEvent.class)
-            .check(listener::onEntityInteract, EntityInteractEvent.class)
-            .check(listener::onLowestEntityInteract, EntityInteractEvent.class);
-    }
-
-    @Test
-    public void shouldCancelRegainHealthEvent() {
-        // given
-        EntityRegainHealthEvent event = mock(EntityRegainHealthEvent.class);
-        given(listenerService.shouldCancelEvent(event)).willReturn(true);
-
-        // when
-        listener.entityRegainHealthEvent(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event);
-        verify(event).setCancelled(true);
-        verify(event).setAmount(0);
-    }
-
-    @Test
-    public void shouldNotCancelRegainedHealth() {
-        // given
-        EntityRegainHealthEvent event = mock(EntityRegainHealthEvent.class);
-        given(listenerService.shouldCancelEvent(event)).willReturn(false);
-
-        // when
-        listener.entityRegainHealthEvent(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event);
-        verifyNoInteractions(event);
-    }
-
-    @Test
-    public void shouldCancelEntityDamageByEntityEvent() {
-        // given
-        EntityDamageByEntityEvent event = mock(EntityDamageByEntityEvent.class);
-        Entity player = mock(Player.class);
-        given(event.getDamager()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-
-        // when
-        listener.onAttack(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(event).setCancelled(true);
-    }
-
-    @Test
-    public void shouldNotCancelEntityDamageByEntityEvent() {
-        // given
-        EntityDamageByEntityEvent event = mock(EntityDamageByEntityEvent.class);
-        Entity player = mock(Player.class);
-        given(event.getDamager()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onAttack(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(event, only()).getDamager();
-    }
-
-    @Test
-    public void shouldCancelEntityDamageEvent() {
-        // given
-        EntityDamageEvent event = mock(EntityDamageEvent.class);
-        Entity entity = mock(Entity.class);
-        given(event.getEntity()).willReturn(entity);
-        given(listenerService.shouldCancelEvent(event)).willReturn(true);
-
-        // when
-        listener.onDamage(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event);
-        verify(event).setCancelled(true);
-        verify(event).setDamage(0);
-        verify(entity).setFireTicks(0);
-    }
-
-    @Test
-    public void shouldNotCancelEntityDamageEvent() {
-        // given
-        EntityDamageEvent event = mock(EntityDamageEvent.class);
-        given(listenerService.shouldCancelEvent(event)).willReturn(false);
-
-        // when
-        listener.onDamage(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event);
-        verifyNoInteractions(event);
-    }
-
-    @Test
-    public void shouldAllowProjectileLaunchFromNonHuman() {
-        // given
-        Projectile projectile = mock(Projectile.class);
-        ProjectileSource source = mock(ProjectileSource.class);
-        given(projectile.getShooter()).willReturn(source);
-        ProjectileLaunchEvent event = mock(ProjectileLaunchEvent.class);
-        given(event.getEntity()).willReturn(projectile);
-
-        // when
-        listener.onProjectileLaunch(event);
-
-        // then
-        verifyNoInteractions(listenerService);
-        verify(event, never()).setCancelled(anyBoolean());
-    }
-
-    @Test
-    public void shouldAllowProjectileLaunchFromAuthedHuman() {
-        // given
-        Projectile projectile = mock(Projectile.class);
-        Player player = mock(Player.class);
-        given(projectile.getShooter()).willReturn(player);
-        ProjectileLaunchEvent event = mock(ProjectileLaunchEvent.class);
-        given(event.getEntity()).willReturn(projectile);
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onProjectileLaunch(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(event, never()).setCancelled(anyBoolean());
-    }
-
-    @Test
-    public void shouldRejectProjectileLaunchFromUnauthed() {
-        // given
-        Projectile projectile = mock(Projectile.class);
-        Player player = mock(Player.class);
-        given(projectile.getShooter()).willReturn(player);
-        ProjectileLaunchEvent event = mock(ProjectileLaunchEvent.class);
-        given(event.getEntity()).willReturn(projectile);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-
-        // when
-        listener.onProjectileLaunch(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(event).setCancelled(true);
-    }
-
-    @Test
-    public void shouldHandleOldShooterMethod() {
-        // given
-        Projectile projectile = mock(Projectile.class);
-        Player shooter = mock(Player.class);
-        given(projectile.getShooter()).willReturn(shooter);
-        ProjectileLaunchEvent event = new ProjectileLaunchEvent(projectile);
-        given(listenerService.shouldCancelEvent(shooter)).willReturn(true);
-
-        // when
-        listener.onProjectileLaunch(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(shooter);
-        assertThat(event.isCancelled(), equalTo(true));
-    }
-
-    @Test
-    public void shouldCancelEntityTargetEvent() {
-        // given
-        EntityTargetEvent event = mock(EntityTargetEvent.class);
-        Entity target = mock(Entity.class);
-        given(event.getTarget()).willReturn(target);
-        given(listenerService.shouldCancelEvent(target)).willReturn(true);
-
-        // when
-        listener.onEntityTarget(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(target);
-        verify(event).setCancelled(true);
-    }
-
-    @Test
-    public void shouldNotCancelEntityTargetEvent() {
-        // given
-        EntityTargetEvent event = mock(EntityTargetEvent.class);
-        Entity target = mock(Entity.class);
-        given(event.getTarget()).willReturn(target);
-        given(listenerService.shouldCancelEvent(target)).willReturn(false);
-
-        // when
-        listener.onEntityTarget(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(target);
-        verify(event, only()).getTarget();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/listener/EventCancelVerifier.java b/src/test/java/fr/xephi/authme/listener/EventCancelVerifier.java
deleted file mode 100644
index 351013c3..00000000
--- a/src/test/java/fr/xephi/authme/listener/EventCancelVerifier.java
+++ /dev/null
@@ -1,79 +0,0 @@
-package fr.xephi.authme.listener;
-
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.Event;
-import org.bukkit.event.entity.EntityEvent;
-import org.bukkit.event.player.PlayerEvent;
-
-import java.util.function.Consumer;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Tests simple listener methods that should cancel an event when the listener service says so.
- */
-public final class EventCancelVerifier {
-
-    private final ListenerService listenerService;
-
-    private EventCancelVerifier(ListenerService listenerService) {
-        this.listenerService = listenerService;
-    }
-
-    /**
-     * Creates a new verifier that uses the given ListenerService mock (needs to be the same instance
-     * as used in the listener class to test).
-     *
-     * @param listenerService the listener service mock
-     * @return new verifier
-     */
-    public static EventCancelVerifier withServiceMock(ListenerService listenerService) {
-        return new EventCancelVerifier(listenerService);
-    }
-
-    /**
-     * Tests a simple event handler that checks with the {@link ListenerService}
-     * if the event should be canceled or not. This method tests that the event is
-     * canceled when the service says so and the other way around. Do not use this
-     * method if the handler method has additional behavior.
-     *
-     * @param listenerMethod the listener method to test
-     * @param clazz the event class to test the handler method for
-     * @param <T> the event type
-     * @return the verifier (for chaining of methods)
-     */
-    public <T extends Event & Cancellable> EventCancelVerifier check(Consumer<T> listenerMethod, Class<T> clazz) {
-        T event = mock(clazz);
-        mockShouldCancel(true, listenerService, event);
-        listenerMethod.accept(event);
-        verify(event).setCancelled(true);
-
-        event = mock(clazz);
-        mockShouldCancel(false, listenerService, event);
-        listenerMethod.accept(event);
-        verifyNoInteractions(event);
-
-        return this;
-    }
-
-    /**
-     * Mocks, based on the given event, the correct method in {@link ListenerService} to return
-     * the provided {@code result}.
-     *
-     * @param result the result the service should return
-     * @param listenerService the service to mock
-     * @param event the event
-     */
-    private static void mockShouldCancel(boolean result, ListenerService listenerService, Event event) {
-        if (event instanceof PlayerEvent) {
-            given(listenerService.shouldCancelEvent((PlayerEvent) event)).willReturn(result);
-        } else if (event instanceof EntityEvent) {
-            given(listenerService.shouldCancelEvent((EntityEvent) event)).willReturn(result);
-        } else {
-            throw new IllegalStateException("Found event with unsupported type: " + event.getClass());
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/listener/ListenerConsistencyTest.java b/src/test/java/fr/xephi/authme/listener/ListenerConsistencyTest.java
deleted file mode 100644
index 7f320516..00000000
--- a/src/test/java/fr/xephi/authme/listener/ListenerConsistencyTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-package fr.xephi.authme.listener;
-
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import org.bukkit.event.Cancellable;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Test for verifying that AuthMe listener methods are well-formed.
- */
-public final class ListenerConsistencyTest {
-
-    private static List<Class<? extends Listener>> classes;
-
-    @BeforeClass
-    public static void collectListenerClasses() {
-        ClassCollector collector = new ClassCollector(TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT + "listener");
-        classes = collector.collectClasses(Listener.class);
-
-        if (classes.isEmpty()) {
-            throw new IllegalStateException("Did not find any Listener classes. Is the folder correct?");
-        }
-    }
-
-    @Test
-    public void shouldSetIgnoreCancelledToTrue() {
-        for (Class<?> listener : classes) {
-            checkCanceledAttribute(listener);
-        }
-    }
-
-    @Test
-    public void shouldHaveOnlyEventListenersAsPublicMembers() {
-        for (Class<?> listener : classes) {
-            checkPublicMethodsAreListeners(listener);
-        }
-    }
-
-    // #367: Event listeners with EventPriority.MONITOR should not change events
-    @Test
-    public void shouldNotHaveMonitorLevelEventHandlers() {
-        for (Class<?> listener : classes) {
-            verifyListenerIsNotUsingMonitorPriority(listener);
-        }
-    }
-
-    @Test
-    public void shouldNotHaveMultipleMethodsWithSameName() {
-        Set<String> events = new HashSet<>();
-        for (Class<?> listener : classes) {
-            for (Method method : listener.getDeclaredMethods()) {
-                if (isTestableMethod(method) && events.contains(method.getName())) {
-                    fail("More than one method '" + method.getName() + "' exists (e.g. class: " + listener + ")");
-                }
-                events.add(method.getName());
-            }
-        }
-    }
-
-    private static void checkCanceledAttribute(Class<?> listenerClass) {
-        final String clazz = listenerClass.getSimpleName();
-        Method[] methods = listenerClass.getDeclaredMethods();
-        for (Method method : methods) {
-            if (isTestableMethod(method) && method.isAnnotationPresent(EventHandler.class)) {
-                if (!method.getParameterTypes()[0].isAssignableFrom(Cancellable.class)) {
-                    continue;
-                }
-
-                EventHandler eventHandlerAnnotation = method.getAnnotation(EventHandler.class);
-                assertThat("Method " + clazz + "#" + method.getName() + " should have ignoreCancelled = true",
-                    eventHandlerAnnotation.ignoreCancelled(), equalTo(true));
-            }
-        }
-    }
-
-    private static void checkPublicMethodsAreListeners(Class<?> listenerClass) {
-        final String clazz = listenerClass.getSimpleName();
-        Method[] methods = listenerClass.getDeclaredMethods();
-        for (Method method : methods) {
-            if (isTestableMethod(method) && !method.isAnnotationPresent(EventHandler.class)) {
-                fail("Expected @EventHandler annotation on non-private method " + clazz + "#" + method.getName());
-            }
-        }
-    }
-
-    private static void verifyListenerIsNotUsingMonitorPriority(Class<?> listenerClass) {
-        final String clazz = listenerClass.getSimpleName();
-        for (Method method : listenerClass.getDeclaredMethods()) {
-            if (isTestableMethod(method) && method.isAnnotationPresent(EventHandler.class)) {
-                EventHandler eventHandlerAnnotation = method.getAnnotation(EventHandler.class);
-                assertThat("Method " + clazz + "#" + method.getName() + " does not use EventPriority.MONITOR",
-                    eventHandlerAnnotation.priority(), not(equalTo(EventPriority.MONITOR)));
-            }
-        }
-    }
-
-    private static boolean isTestableMethod(Method method) {
-        // Exclude getters and synthetic methods
-        String methodName = method.getName();
-        if (Modifier.isPrivate(method.getModifiers()) || method.isSynthetic() || methodName.startsWith("get") || methodName.startsWith("is")) {
-            return false;
-        }
-        // Skip reload() method (implementation of Reloadable interface)
-        return !"reload".equals(method.getName()) || method.getParameterTypes().length > 0;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/listener/ListenerServiceTest.java b/src/test/java/fr/xephi/authme/listener/ListenerServiceTest.java
deleted file mode 100644
index 76877fca..00000000
--- a/src/test/java/fr/xephi/authme/listener/ListenerServiceTest.java
+++ /dev/null
@@ -1,235 +0,0 @@
-package fr.xephi.authme.listener;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.RegistrationSettings;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.entity.EntityEvent;
-import org.bukkit.event.player.PlayerEvent;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-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;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link ListenerService}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class ListenerServiceTest {
-
-    @InjectDelayed
-    private ListenerService listenerService;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private ValidationService validationService;
-
-    @BeforeInjecting
-    public void initializeDefaultSettings() {
-        given(settings.getProperty(RegistrationSettings.FORCE)).willReturn(true);
-    }
-
-    @Test
-    public void shouldHandleEventWithNullEntity() {
-        // given
-        EntityEvent event = mock(EntityEvent.class);
-        given(event.getEntity()).willReturn(null);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldHandleEntityEventWithNonPlayerEntity() {
-        // given
-        EntityEvent event = mock(EntityEvent.class);
-        given(event.getEntity()).willReturn(mock(Entity.class));
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldAllowAuthenticatedPlayer() {
-        // given
-        String playerName = "Bobby";
-        Player player = mockPlayerWithName(playerName);
-        given(playerCache.isAuthenticated(playerName)).willReturn(true);
-        EntityEvent event = mock(EntityEvent.class);
-        given(event.getEntity()).willReturn(player);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(playerCache).isAuthenticated(playerName);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldDenyUnLoggedPlayer() {
-        // given
-        String playerName = "Tester";
-        Player player = mockPlayerWithName(playerName);
-        given(playerCache.isAuthenticated(playerName)).willReturn(false);
-        EntityEvent event = mock(EntityEvent.class);
-        given(event.getEntity()).willReturn(player);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(playerCache).isAuthenticated(playerName);
-        // makes sure the setting is checked first = avoid unnecessary DB operation
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldAllowUnloggedPlayerForOptionalRegistration() {
-        // given
-        String playerName = "myPlayer1";
-        Player player = mockPlayerWithName(playerName);
-        given(playerCache.isAuthenticated(playerName)).willReturn(false);
-        given(settings.getProperty(RegistrationSettings.FORCE)).willReturn(false);
-        EntityEvent event = mock(EntityEvent.class);
-        given(event.getEntity()).willReturn(player);
-        listenerService.reload(settings);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(playerCache).isAuthenticated(playerName);
-        verify(dataSource).isAuthAvailable(playerName);
-    }
-
-    @Test
-    public void shouldAllowUnrestrictedName() {
-        // given
-        String playerName = "Npc2";
-        Player player = mockPlayerWithName(playerName);
-        EntityEvent event = mock(EntityEvent.class);
-        given(event.getEntity()).willReturn(player);
-        given(validationService.isUnrestricted(playerName)).willReturn(true);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldAllowNpcPlayer() {
-        // given
-        String playerName = "other_npc";
-        Player player = mockPlayerWithName(playerName);
-        EntityEvent event = mock(EntityEvent.class);
-        given(event.getEntity()).willReturn(player);
-        given(player.hasMetadata("NPC")).willReturn(true);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(player).hasMetadata("NPC");
-    }
-
-    @Test
-    // This simply forwards to shouldCancelEvent(Player), so the rest is already tested
-    public void shouldHandlePlayerEvent() {
-        // given
-        String playerName = "example";
-        Player player = mockPlayerWithName(playerName);
-        PlayerEvent event = new TestPlayerEvent(player);
-        given(playerCache.isAuthenticated(playerName)).willReturn(true);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(playerCache).isAuthenticated(playerName);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldHandlePlayerEventWithNullPlayer() {
-        // given
-        PlayerEvent event = new TestPlayerEvent(null);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(event);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    // The previous tests verify most of shouldCancelEvent(Player)
-    public void shouldVerifyBasedOnPlayer() {
-        // given
-        String playerName = "player";
-        Player player = mockPlayerWithName(playerName);
-
-        // when
-        boolean result = listenerService.shouldCancelEvent(player);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(playerCache).isAuthenticated(playerName);
-        verifyNoInteractions(dataSource);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-
-    /**
-     * Test implementation of {@link PlayerEvent}.
-     */
-    private static final class TestPlayerEvent extends PlayerEvent {
-        public TestPlayerEvent(Player player) {
-            super(player);
-        }
-
-        @Override
-        public HandlerList getHandlers() {
-            return null;
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/listener/OnJoinVerifierTest.java b/src/test/java/fr/xephi/authme/listener/OnJoinVerifierTest.java
deleted file mode 100644
index 3667e1be..00000000
--- a/src/test/java/fr/xephi/authme/listener/OnJoinVerifierTest.java
+++ /dev/null
@@ -1,523 +0,0 @@
-package fr.xephi.authme.listener;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerStatePermission;
-import fr.xephi.authme.service.AntiBotService;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.ProtectionSettings;
-import fr.xephi.authme.settings.properties.RegistrationSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link OnJoinVerifier}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class OnJoinVerifierTest {
-
-    @InjectMocks
-    private OnJoinVerifier onJoinVerifier;
-
-    @Mock
-    private Settings settings;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private Messages messages;
-    @Mock
-    private PermissionsManager permissionsManager;
-    @Mock
-    private AntiBotService antiBotService;
-    @Mock
-    private ValidationService validationService;
-    @Mock
-    private BukkitService bukkitService;
-    @Mock
-    private Server server;
-
-    @Rule
-    public ExpectedException expectedException = ExpectedException.none();
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldNotDoAnythingForNormalEvent() {
-        // given
-        PlayerLoginEvent event = mock(PlayerLoginEvent.class);
-        given(event.getResult()).willReturn(PlayerLoginEvent.Result.ALLOWED);
-
-        // when
-        boolean result = onJoinVerifier.refusePlayerForFullServer(event);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(event).getResult();
-        verifyNoMoreInteractions(event);
-        verifyNoInteractions(bukkitService, dataSource, permissionsManager);
-    }
-
-    @Test
-    public void shouldRefuseNonVipPlayerForFullServer() {
-        // given
-        Player player = mock(Player.class);
-        PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
-        event.setResult(PlayerLoginEvent.Result.KICK_FULL);
-        given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(false);
-        String serverFullMessage = "server is full";
-        given(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER)).willReturn(serverFullMessage);
-
-        // when
-        boolean result = onJoinVerifier.refusePlayerForFullServer(event);
-
-        // then
-        assertThat(result, equalTo(true));
-        assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
-        assertThat(event.getKickMessage(), equalTo(serverFullMessage));
-        verifyNoInteractions(bukkitService, dataSource);
-    }
-
-    @Test
-    public void shouldKickNonVipForJoiningVipPlayer() {
-        // given
-        Player player = mock(Player.class);
-        PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
-        event.setResult(PlayerLoginEvent.Result.KICK_FULL);
-        given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(true);
-        List<Player> onlinePlayers = Arrays.asList(mock(Player.class), mock(Player.class));
-        given(permissionsManager.hasPermission(onlinePlayers.get(0), PlayerStatePermission.IS_VIP)).willReturn(true);
-        given(permissionsManager.hasPermission(onlinePlayers.get(1), PlayerStatePermission.IS_VIP)).willReturn(false);
-        given(bukkitService.getOnlinePlayers()).willReturn(onlinePlayers);
-        given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
-        given(messages.retrieveSingle(player, MessageKey.KICK_FOR_VIP)).willReturn("kick for vip");
-
-        // when
-        boolean result = onJoinVerifier.refusePlayerForFullServer(event);
-
-        // then
-        assertThat(result, equalTo(false));
-        assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.ALLOWED));
-        // First player is VIP, so expect no interactions there and second player to have been kicked
-        verifyNoInteractions(onlinePlayers.get(0));
-        verify(onlinePlayers.get(1)).kickPlayer("kick for vip");
-    }
-
-    @Test
-    public void shouldKickVipPlayerIfNoPlayerCanBeKicked() {
-        // given
-        Player player = mock(Player.class);
-        PlayerLoginEvent event = new PlayerLoginEvent(player, "hostname", null);
-        event.setResult(PlayerLoginEvent.Result.KICK_FULL);
-        given(permissionsManager.hasPermission(player, PlayerStatePermission.IS_VIP)).willReturn(true);
-        List<Player> onlinePlayers = Collections.singletonList(mock(Player.class));
-        given(permissionsManager.hasPermission(onlinePlayers.get(0), PlayerStatePermission.IS_VIP)).willReturn(true);
-        given(bukkitService.getOnlinePlayers()).willReturn(onlinePlayers);
-        given(server.getMaxPlayers()).willReturn(onlinePlayers.size());
-        given(messages.retrieveSingle(player, MessageKey.KICK_FULL_SERVER)).willReturn("kick full server");
-
-        // when
-        boolean result = onJoinVerifier.refusePlayerForFullServer(event);
-
-        // then
-        assertThat(result, equalTo(true));
-        assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
-        assertThat(event.getKickMessage(), equalTo("kick full server"));
-        verifyNoInteractions(onlinePlayers.get(0));
-    }
-
-    @Test
-    public void shouldKickNonRegistered() throws FailedVerificationException {
-        // given
-        given(settings.getProperty(RestrictionSettings.KICK_NON_REGISTERED)).willReturn(true);
-
-        // expect
-        expectValidationExceptionWith(MessageKey.MUST_REGISTER_MESSAGE);
-
-        // when
-        onJoinVerifier.checkKickNonRegistered(false);
-    }
-
-    @Test
-    public void shouldNotKickRegisteredPlayer() throws FailedVerificationException {
-        // given / when / then
-        onJoinVerifier.checkKickNonRegistered(true);
-    }
-
-    @Test
-    public void shouldNotKickUnregisteredPlayer() throws FailedVerificationException {
-        // given
-        given(settings.getProperty(RestrictionSettings.KICK_NON_REGISTERED)).willReturn(false);
-
-        // when
-        onJoinVerifier.checkKickNonRegistered(false);
-    }
-
-    @Test
-    public void shouldAllowValidName() throws FailedVerificationException {
-        // given
-        given(settings.getProperty(RestrictionSettings.MIN_NICKNAME_LENGTH)).willReturn(4);
-        given(settings.getProperty(RestrictionSettings.MAX_NICKNAME_LENGTH)).willReturn(8);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_NICKNAME_CHARACTERS)).willReturn("[a-zA-Z0-9]+");
-        onJoinVerifier.reload(); // @PostConstruct method
-
-        // when
-        onJoinVerifier.checkIsValidName("Bobby5");
-    }
-
-    @Test
-    public void shouldRejectTooLongName() throws FailedVerificationException {
-        // given
-        given(settings.getProperty(RestrictionSettings.MAX_NICKNAME_LENGTH)).willReturn(8);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_NICKNAME_CHARACTERS)).willReturn("[a-zA-Z0-9]+");
-        onJoinVerifier.reload(); // @PostConstruct method
-
-        // expect
-        expectValidationExceptionWith(MessageKey.INVALID_NAME_LENGTH);
-
-        // when
-        onJoinVerifier.checkIsValidName("longerthaneight");
-    }
-
-    @Test
-    public void shouldRejectTooShortName() throws FailedVerificationException {
-        // given
-        given(settings.getProperty(RestrictionSettings.MIN_NICKNAME_LENGTH)).willReturn(4);
-        given(settings.getProperty(RestrictionSettings.MAX_NICKNAME_LENGTH)).willReturn(8);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_NICKNAME_CHARACTERS)).willReturn("[a-zA-Z0-9]+");
-        onJoinVerifier.reload(); // @PostConstruct method
-
-        // expect
-        expectValidationExceptionWith(MessageKey.INVALID_NAME_LENGTH);
-
-        // when
-        onJoinVerifier.checkIsValidName("abc");
-    }
-
-    @Test
-    public void shouldRejectNameWithInvalidCharacters() throws FailedVerificationException {
-        // given
-        given(settings.getProperty(RestrictionSettings.MIN_NICKNAME_LENGTH)).willReturn(4);
-        given(settings.getProperty(RestrictionSettings.MAX_NICKNAME_LENGTH)).willReturn(8);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_NICKNAME_CHARACTERS)).willReturn("[a-zA-Z0-9]+");
-        onJoinVerifier.reload(); // @PostConstruct method
-
-        // expect
-        expectValidationExceptionWith(MessageKey.INVALID_NAME_CHARACTERS, "[a-zA-Z0-9]+");
-
-        // when
-        onJoinVerifier.checkIsValidName("Tester!");
-    }
-
-    @Test
-    public void shouldAllowProperlyCasedName() throws FailedVerificationException {
-        // given
-        String name = "Bobby";
-        PlayerAuth auth = PlayerAuth.builder().name("bobby").realName("Bobby").build();
-        given(settings.getProperty(RegistrationSettings.PREVENT_OTHER_CASE)).willReturn(true);
-
-        // when
-        onJoinVerifier.checkNameCasing(name, auth);
-
-        // then
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldRejectNameWithWrongCasing() throws FailedVerificationException {
-        // given
-        String name = "Tester";
-        PlayerAuth auth = PlayerAuth.builder().name("tester").realName("testeR").build();
-        given(settings.getProperty(RegistrationSettings.PREVENT_OTHER_CASE)).willReturn(true);
-
-        // expect
-        expectValidationExceptionWith(MessageKey.INVALID_NAME_CASE, "testeR", "Tester");
-
-        // when / then
-        onJoinVerifier.checkNameCasing(name, auth);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldUpdateMissingRealName() throws FailedVerificationException {
-        // given
-        String name = "Authme";
-        PlayerAuth auth = PlayerAuth.builder().name("authme").realName("").build();
-        given(settings.getProperty(RegistrationSettings.PREVENT_OTHER_CASE)).willReturn(true);
-
-        // when
-        onJoinVerifier.checkNameCasing(name, auth);
-
-        // then
-        verify(dataSource).updateRealName("authme", "Authme");
-    }
-
-    @Test
-    public void shouldUpdateDefaultRealName() throws FailedVerificationException {
-        // given
-        String name = "SOMEONE";
-        PlayerAuth auth = PlayerAuth.builder().name("someone").realName("Player").build();
-        given(settings.getProperty(RegistrationSettings.PREVENT_OTHER_CASE)).willReturn(true);
-
-        // when
-        onJoinVerifier.checkNameCasing(name, auth);
-
-        // then
-        verify(dataSource).updateRealName("someone", "SOMEONE");
-    }
-
-    @Test
-    public void shouldAcceptCasingMismatchForDisabledSetting() throws FailedVerificationException {
-        // given
-        String name = "Test";
-        PlayerAuth auth = PlayerAuth.builder().name("test").realName("TEST").build();
-        given(settings.getProperty(RegistrationSettings.PREVENT_OTHER_CASE)).willReturn(false);
-
-        // when
-        onJoinVerifier.checkNameCasing(name, auth);
-
-        // then
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldAcceptNameForUnregisteredAccount() throws FailedVerificationException {
-        // given
-        String name = "MyPlayer";
-        PlayerAuth auth = null;
-
-        // when
-        onJoinVerifier.checkNameCasing(name, auth);
-
-        // then
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldAcceptNameThatIsNotOnline() throws FailedVerificationException {
-        // given
-        String name = "bobby";
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(true);
-        given(bukkitService.getPlayerExact("bobby")).willReturn(null);
-
-        // when
-        onJoinVerifier.checkSingleSession(name);
-
-        // then
-        verify(bukkitService).getPlayerExact(name);
-    }
-
-    @Test
-    public void shouldRejectNameAlreadyOnline() throws FailedVerificationException {
-        // given
-        String name = "Charlie";
-
-        Player onlinePlayer = mock(Player.class);
-
-        given(bukkitService.getPlayerExact("Charlie")).willReturn(onlinePlayer);
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(true);
-
-        // expect
-        expectValidationExceptionWith(MessageKey.USERNAME_ALREADY_ONLINE_ERROR);
-
-        // when / then
-        onJoinVerifier.checkSingleSession(name);
-    }
-
-    @Test
-    public void shouldAcceptAlreadyOnlineNameForDisabledSetting() throws FailedVerificationException {
-        // given
-        String name = "Felipe";
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(false);
-
-        // when
-        onJoinVerifier.checkSingleSession(name);
-
-        // then
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldAllowUser() throws FailedVerificationException {
-        // given
-        String name = "Bobby";
-        boolean isAuthAvailable = false;
-        given(permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(false);
-        given(antiBotService.shouldKick()).willReturn(false);
-
-        // when
-        onJoinVerifier.checkAntibot(name, isAuthAvailable);
-
-        // then
-        verify(permissionsManager).hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT);
-        verify(antiBotService).shouldKick();
-    }
-
-    @Test
-    public void shouldAllowUserWithAuth() throws FailedVerificationException {
-        // given
-        String name = "Lacey";
-        boolean isAuthAvailable = true;
-
-        // when
-        onJoinVerifier.checkAntibot(name, isAuthAvailable);
-
-        // then
-        verifyNoInteractions(permissionsManager, antiBotService);
-    }
-
-    @Test
-    public void shouldAllowUserWithBypassPermission() throws FailedVerificationException {
-        // given
-        String name = "Steward";
-        boolean isAuthAvailable = false;
-        given(permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(true);
-
-        // when
-        onJoinVerifier.checkAntibot(name, isAuthAvailable);
-
-        // then
-        verify(permissionsManager).hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT);
-        verifyNoInteractions(antiBotService);
-    }
-
-    @Test
-    public void shouldKickUserForFailedAntibotCheck() {
-        // given
-        String name = "D3";
-        boolean isAuthAvailable = false;
-        given(permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT)).willReturn(false);
-        given(antiBotService.shouldKick()).willReturn(true);
-
-        // when / then
-        try {
-            onJoinVerifier.checkAntibot(name, isAuthAvailable);
-            fail("Expected exception to be thrown");
-        } catch (FailedVerificationException e) {
-            verify(permissionsManager).hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT);
-            verify(antiBotService).shouldKick();
-        }
-
-    }
-
-    /**
-     * Tests various scenarios in which the country check should not take place.
-     */
-    @Test
-    public void shouldNotCheckCountry() throws FailedVerificationException {
-        // given
-        String name = "david";
-        String ip = "127.0.0.1";
-
-        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(false);
-        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION_REGISTERED)).willReturn(true);
-
-        // when
-        onJoinVerifier.checkPlayerCountry(name, ip, false);
-        onJoinVerifier.checkPlayerCountry(name, ip, true);
-
-        // then
-        verifyNoInteractions(validationService);
-    }
-
-    @Test
-    public void shouldCheckAndAcceptUnregisteredPlayerCountry() throws FailedVerificationException {
-        // given
-        String ip = "192.168.0.1";
-        String name = "lucas";
-        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(true);
-        given(validationService.isCountryAdmitted(ip)).willReturn(true);
-
-        // when
-        onJoinVerifier.checkPlayerCountry(name, ip, false);
-
-        // then
-        verify(validationService).isCountryAdmitted(ip);
-    }
-
-    @Test
-    public void shouldCheckAndAcceptRegisteredPlayerCountry() throws FailedVerificationException {
-        // given
-        String ip = "192.168.10.24";
-        String name = "gabriel";
-        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(true);
-        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION_REGISTERED)).willReturn(true);
-        given(validationService.isCountryAdmitted(ip)).willReturn(true);
-
-        // when
-        onJoinVerifier.checkPlayerCountry(name, ip, true);
-
-        // then
-        verify(validationService).isCountryAdmitted(ip);
-    }
-
-    @Test
-    public void shouldThrowForBannedCountry() throws FailedVerificationException {
-        // given
-        String ip = "192.168.40.0";
-        String name = "bob";
-        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(true);
-        given(validationService.isCountryAdmitted(ip)).willReturn(false);
-
-        // expect
-        expectValidationExceptionWith(MessageKey.COUNTRY_BANNED_ERROR);
-
-        // when
-        onJoinVerifier.checkPlayerCountry(name, ip, false);
-    }
-
-    private void expectValidationExceptionWith(MessageKey messageKey, String... args) {
-        expectedException.expect(exceptionWithData(messageKey, args));
-    }
-
-    private static Matcher<FailedVerificationException> exceptionWithData(final MessageKey messageKey,
-                                                                          final String... args) {
-        return new TypeSafeMatcher<FailedVerificationException>() {
-            @Override
-            protected boolean matchesSafely(FailedVerificationException item) {
-                return messageKey.equals(item.getReason()) && Arrays.equals(args, item.getArgs());
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendValue("VerificationFailedException: reason=" + messageKey + ";args="
-                    + (args == null ? "null" : String.join(", ", args)));
-            }
-        };
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/listener/PlayerListener111Test.java b/src/test/java/fr/xephi/authme/listener/PlayerListener111Test.java
deleted file mode 100644
index b7b2c605..00000000
--- a/src/test/java/fr/xephi/authme/listener/PlayerListener111Test.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package fr.xephi.authme.listener;
-
-import org.bukkit.event.entity.EntityAirChangeEvent;
-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.listener.EventCancelVerifier.withServiceMock;
-
-/**
- * Test for {@link PlayerListener111}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PlayerListener111Test {
-
-    @InjectMocks
-    private PlayerListener111 listener;
-
-    @Mock
-    private ListenerService listenerService;
-
-    @Test
-    public void shouldCancelEvent() {
-        withServiceMock(listenerService)
-            .check(listener::onPlayerAirChange, EntityAirChangeEvent.class);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/listener/PlayerListener19Test.java b/src/test/java/fr/xephi/authme/listener/PlayerListener19Test.java
deleted file mode 100644
index b870ac06..00000000
--- a/src/test/java/fr/xephi/authme/listener/PlayerListener19Test.java
+++ /dev/null
@@ -1,30 +0,0 @@
-package fr.xephi.authme.listener;
-
-import org.bukkit.event.player.PlayerSwapHandItemsEvent;
-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.listener.EventCancelVerifier.withServiceMock;
-
-/**
- * Test for {@link PlayerListener19}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PlayerListener19Test {
-
-    @InjectMocks
-    private PlayerListener19 listener;
-
-    @Mock
-    private ListenerService listenerService;
-
-    @Test
-    public void shouldCancelEvent() {
-        withServiceMock(listenerService)
-            .check(listener::onPlayerSwapHandItems, PlayerSwapHandItemsEvent.class);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/listener/PlayerListenerTest.java b/src/test/java/fr/xephi/authme/listener/PlayerListenerTest.java
deleted file mode 100644
index 6ea29973..00000000
--- a/src/test/java/fr/xephi/authme/listener/PlayerListenerTest.java
+++ /dev/null
@@ -1,1115 +0,0 @@
-package fr.xephi.authme.listener;
-
-import fr.xephi.authme.data.QuickCommandsProtectionManager;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerStatePermission;
-import fr.xephi.authme.process.Management;
-import fr.xephi.authme.service.AntiBotService;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.JoinMessageService;
-import fr.xephi.authme.service.TeleportationService;
-import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.SpawnLoader;
-import fr.xephi.authme.settings.properties.HooksSettings;
-import fr.xephi.authme.settings.properties.RegistrationSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import org.bukkit.Location;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.block.SignChangeEvent;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.inventory.InventoryOpenEvent;
-import org.bukkit.event.player.AsyncPlayerChatEvent;
-import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
-import org.bukkit.event.player.PlayerBedEnterEvent;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.event.player.PlayerEditBookEvent;
-import org.bukkit.event.player.PlayerFishEvent;
-import org.bukkit.event.player.PlayerInteractAtEntityEvent;
-import org.bukkit.event.player.PlayerInteractEntityEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerItemConsumeEvent;
-import org.bukkit.event.player.PlayerItemHeldEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerKickEvent;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerMoveEvent;
-import org.bukkit.event.player.PlayerPickupItemEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.event.player.PlayerRespawnEvent;
-import org.bukkit.event.player.PlayerShearEntityEvent;
-import org.bukkit.inventory.InventoryView;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.net.InetAddress;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.UUID;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static fr.xephi.authme.listener.EventCancelVerifier.withServiceMock;
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncDelayedTaskWithDelay;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyBoolean;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.atLeast;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link PlayerListener}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PlayerListenerTest {
-
-    @InjectMocks
-    private PlayerListener listener;
-
-    @Mock
-    private Settings settings;
-    @Mock
-    private Messages messages;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private AntiBotService antiBotService;
-    @Mock
-    private Management management;
-    @Mock
-    private BukkitService bukkitService;
-    @Mock
-    private SpawnLoader spawnLoader;
-    @Mock
-    private OnJoinVerifier onJoinVerifier;
-    @Mock
-    private ListenerService listenerService;
-    @Mock
-    private TeleportationService teleportationService;
-    @Mock
-    private ValidationService validationService;
-    @Mock
-    private JoinMessageService joinMessageService;
-    @Mock
-    private QuickCommandsProtectionManager quickCommandsProtectionManager;
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    /**
-     * #831: If a player is kicked because of "logged in from another location", the kick
-     * should be CANCELED when single session is enabled.
-     */
-    @Test
-    public void shouldCancelKick() {
-        // given
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(true);
-        Player player = mock(Player.class);
-        PlayerKickEvent event = new PlayerKickEvent(player, "You logged in from another location", "");
-
-        // when
-        listener.onPlayerKick(event);
-
-        // then
-        assertThat(event.isCancelled(), equalTo(true));
-        verifyNoInteractions(player, management, antiBotService);
-    }
-
-    @Test
-    public void shouldNotCancelKick() {
-        // given
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(false);
-        String name = "Bobby";
-        Player player = mockPlayerWithName(name);
-        PlayerKickEvent event = new PlayerKickEvent(player, "You logged in from another location", "");
-        given(antiBotService.wasPlayerKicked(name)).willReturn(false);
-
-        // when
-        listener.onPlayerKick(event);
-
-        // then
-        assertThat(event.isCancelled(), equalTo(false));
-        verify(antiBotService).wasPlayerKicked(name);
-        verify(management).performQuit(player);
-    }
-
-    @Test
-    public void shouldNotCancelOrdinaryKick() {
-        // given
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(true);
-        String name = "Bobby";
-        Player player = mockPlayerWithName(name);
-        PlayerKickEvent event = new PlayerKickEvent(player, "No longer desired here!", "");
-        given(antiBotService.wasPlayerKicked(name)).willReturn(true);
-
-        // when
-        listener.onPlayerKick(event);
-
-        // then
-        assertThat(event.isCancelled(), equalTo(false));
-        verify(antiBotService).wasPlayerKicked(name);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldHandleSimpleCancelableEvents() {
-        withServiceMock(listenerService)
-            .check(listener::onPlayerShear, PlayerShearEntityEvent.class)
-            .check(listener::onPlayerFish, PlayerFishEvent.class)
-            .check(listener::onPlayerBedEnter, PlayerBedEnterEvent.class)
-            .check(listener::onPlayerDropItem, PlayerDropItemEvent.class)
-            .check(listener::onPlayerHitPlayerEvent, EntityDamageByEntityEvent.class)
-            .check(listener::onPlayerConsumeItem, PlayerItemConsumeEvent.class)
-            .check(listener::onPlayerInteract, PlayerInteractEvent.class)
-            .check(listener::onPlayerPickupItem, PlayerPickupItemEvent.class)
-            .check(listener::onPlayerInteractEntity, PlayerInteractEntityEvent.class)
-            .check(listener::onPlayerHeldItem, PlayerItemHeldEvent.class);
-    }
-
-    @Test
-    public void shouldAllowEssentialsMotd() {
-        // given
-        given(settings.getProperty(HooksSettings.USE_ESSENTIALS_MOTD)).willReturn(true);
-        PlayerCommandPreprocessEvent event = mockCommandEvent("/MOTD");
-
-        // when
-        listener.onPlayerCommandPreprocess(event);
-
-        // then
-        verify(event, only()).getMessage();
-        verifyNoInteractions(listenerService, messages);
-    }
-
-    @Test
-    public void shouldNotStopAllowedCommand() {
-        // given
-        given(settings.getProperty(HooksSettings.USE_ESSENTIALS_MOTD)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.ALLOW_COMMANDS)).willReturn(newHashSet("/plugins", "/mail", "/msg"));
-        PlayerCommandPreprocessEvent event = mockCommandEvent("/Mail send test Test");
-
-        // when
-        listener.onPlayerCommandPreprocess(event);
-
-        // then
-        verify(event, only()).getMessage();
-        verifyNoInteractions(listenerService, messages);
-    }
-
-    @Test
-    public void shouldNotCancelEventForAuthenticatedPlayer() {
-        // given
-        given(settings.getProperty(HooksSettings.USE_ESSENTIALS_MOTD)).willReturn(false);
-        given(settings.getProperty(RestrictionSettings.ALLOW_COMMANDS)).willReturn(Collections.emptySet());
-        Player player = playerWithMockedServer();
-        // PlayerCommandPreprocessEvent#getPlayer is final, so create a spy instead of a mock
-        PlayerCommandPreprocessEvent event = spy(new PlayerCommandPreprocessEvent(player, "/hub"));
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-        given(quickCommandsProtectionManager.isAllowed(player.getName())).willReturn(true);
-
-        // when
-        listener.onPlayerCommandPreprocess(event);
-
-        // then
-        verify(event).getMessage();
-        verifyNoMoreInteractions(event);
-        verify(listenerService).shouldCancelEvent(player);
-        verifyNoInteractions(messages);
-    }
-
-    @Test
-    public void shouldCancelCommandEvent() {
-        // given
-        given(settings.getProperty(HooksSettings.USE_ESSENTIALS_MOTD)).willReturn(false);
-        given(settings.getProperty(RestrictionSettings.ALLOW_COMMANDS)).willReturn(newHashSet("/spawn", "/help"));
-        Player player = playerWithMockedServer();
-        PlayerCommandPreprocessEvent event = spy(new PlayerCommandPreprocessEvent(player, "/hub"));
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-        given(quickCommandsProtectionManager.isAllowed(player.getName())).willReturn(true);
-
-        // when
-        listener.onPlayerCommandPreprocess(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(event).setCancelled(true);
-        verify(messages).send(player, MessageKey.DENIED_COMMAND);
-    }
-
-    @Test
-    public void shouldCancelFastCommandEvent() {
-        // given
-        given(settings.getProperty(HooksSettings.USE_ESSENTIALS_MOTD)).willReturn(false);
-        given(settings.getProperty(RestrictionSettings.ALLOW_COMMANDS)).willReturn(newHashSet("/spawn", "/help"));
-        Player player = playerWithMockedServer();
-        PlayerCommandPreprocessEvent event = spy(new PlayerCommandPreprocessEvent(player, "/hub"));
-        given(quickCommandsProtectionManager.isAllowed(player.getName())).willReturn(false);
-
-        // when
-        listener.onPlayerCommandPreprocess(event);
-
-        // then
-        verify(event).setCancelled(true);
-        verify(player).kickPlayer(messages.retrieveSingle(player, MessageKey.QUICK_COMMAND_PROTECTION_KICK));
-    }
-
-    @Test
-    public void shouldAllowChat() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_CHAT)).willReturn(true);
-        AsyncPlayerChatEvent event = mock(AsyncPlayerChatEvent.class);
-
-        // when
-        listener.onPlayerChat(event);
-
-        // then
-        verifyNoInteractions(event, listenerService, messages);
-    }
-
-    @Test
-    public void shouldCancelChatForUnauthedPlayer() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_CHAT)).willReturn(false);
-        AsyncPlayerChatEvent event = newAsyncChatEvent();
-        given(listenerService.shouldCancelEvent(event.getPlayer())).willReturn(true);
-        given(permissionsManager.hasPermission(event.getPlayer(), PlayerStatePermission.ALLOW_CHAT_BEFORE_LOGIN)).willReturn(false);
-
-        // when
-        listener.onPlayerChat(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event.getPlayer());
-        verify(permissionsManager).hasPermission(event.getPlayer(), PlayerStatePermission.ALLOW_CHAT_BEFORE_LOGIN);
-        verify(event).setCancelled(true);
-        verify(messages).send(event.getPlayer(), MessageKey.DENIED_CHAT);
-    }
-
-    @Test
-    public void shouldSendChatToEveryone() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_CHAT)).willReturn(false);
-        AsyncPlayerChatEvent event = newAsyncChatEvent();
-        given(listenerService.shouldCancelEvent(event.getPlayer())).willReturn(false);
-        given(settings.getProperty(RestrictionSettings.HIDE_CHAT)).willReturn(false);
-
-        // when
-        listener.onPlayerChat(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event.getPlayer());
-        verifyNoInteractions(event, messages);
-    }
-
-    @Test
-    public void shouldHideChatFromUnauthed() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_CHAT)).willReturn(false);
-        AsyncPlayerChatEvent event = newAsyncChatEvent();
-        given(listenerService.shouldCancelEvent(event.getPlayer())).willReturn(false);
-        given(settings.getProperty(RestrictionSettings.HIDE_CHAT)).willReturn(true);
-        List<Player> recipients = new ArrayList<>(event.getRecipients());
-        given(listenerService.shouldCancelEvent(recipients.get(0))).willReturn(true);
-
-        // when
-        listener.onPlayerChat(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event.getPlayer());
-        // message sender + 3 recipients = 4
-        verify(listenerService, times(4)).shouldCancelEvent(any(Player.class));
-        verify(event, never()).setCancelled(anyBoolean());
-        assertThat(event.getRecipients(), containsInAnyOrder(recipients.get(1), recipients.get(2)));
-    }
-
-    @Test
-    public void shouldCancelChatEventForNoRemainingRecipients() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_CHAT)).willReturn(false);
-        AsyncPlayerChatEvent event = newAsyncChatEvent();
-        given(listenerService.shouldCancelEvent(any(Player.class))).willReturn(true);
-        given(listenerService.shouldCancelEvent(event.getPlayer())).willReturn(false);
-        given(settings.getProperty(RestrictionSettings.HIDE_CHAT)).willReturn(true);
-
-        // when
-        listener.onPlayerChat(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(event.getPlayer());
-        // message sender + 3 recipients = 4
-        verify(listenerService, times(4)).shouldCancelEvent(any(Player.class));
-        verify(event).setCancelled(true);
-        assertThat(event.getRecipients(), empty());
-    }
-
-    @Test
-    public void shouldAllowChatForBypassPermission() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_CHAT)).willReturn(false);
-        AsyncPlayerChatEvent event = newAsyncChatEvent();
-        given(listenerService.shouldCancelEvent(event.getPlayer())).willReturn(true);
-        given(permissionsManager.hasPermission(event.getPlayer(), PlayerStatePermission.ALLOW_CHAT_BEFORE_LOGIN)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.HIDE_CHAT)).willReturn(false);
-
-        // when
-        listener.onPlayerChat(event);
-
-        // then
-        assertThat(event.isCancelled(), equalTo(false));
-        verify(listenerService).shouldCancelEvent(event.getPlayer());
-        verify(permissionsManager).hasPermission(event.getPlayer(), PlayerStatePermission.ALLOW_CHAT_BEFORE_LOGIN);
-        assertThat(event.getRecipients(), hasSize(3));
-    }
-
-    @Test
-    public void shouldAllowUnlimitedMovement() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_MOVEMENT_RADIUS)).willReturn(0);
-        Player player = mock(Player.class);
-        Location location = mock(Location.class);
-        PlayerMoveEvent event = spy(new PlayerMoveEvent(player, location, location));
-
-        // when
-        listener.onPlayerMove(event);
-
-        // then
-        verifyNoInteractions(event);
-    }
-
-    @Test
-    public void shouldAllowFalling() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(false);
-        Player player = mock(Player.class);
-        Location from = new Location(null, 100, 90, 200);
-        Location to = new Location(null, 100, 88, 200);
-        PlayerMoveEvent event = spy(new PlayerMoveEvent(player, from, to));
-
-        // when
-        listener.onPlayerMove(event);
-
-        // then
-        verifyNoModifyingCalls(event);
-    }
-
-    @Test
-    public void shouldAllowMovementForAuthedPlayer() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(false);
-        Player player = mock(Player.class);
-        Location from = new Location(null, 100, 90, 200);
-        Location to = new Location(null, 99, 90, 200);
-        PlayerMoveEvent event = spy(new PlayerMoveEvent(player, from, to));
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onPlayerMove(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verifyNoModifyingCalls(event);
-    }
-
-    @Test
-    public void shouldCancelEventForDisabledUnauthedMovement() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(false);
-        Player player = mock(Player.class);
-        World world = mock(World.class);
-        Location from = new Location(world, 200, 70, 200);
-        Location to = new Location(world, 199, 70, 199);
-        PlayerMoveEvent event = spy(new PlayerMoveEvent(player, from, to));
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-
-        // when
-        listener.onPlayerMove(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(event).setTo(from);
-    }
-
-    @Test
-    public void shouldTeleportPlayerInDifferentWorldToSpawn() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_MOVEMENT_RADIUS)).willReturn(20);
-        World playerWorld = mock(World.class);
-        Player player = mock(Player.class);
-        given(player.getWorld()).willReturn(playerWorld);
-        Location from = new Location(null, 200, 70, 200);
-        Location to = new Location(null, 199, 70, 199);
-        PlayerMoveEvent event = spy(new PlayerMoveEvent(player, from, to));
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-        World world = mock(World.class);
-        Location spawn = new Location(world, 0, 90, 0);
-        given(spawnLoader.getSpawnLocation(player)).willReturn(spawn);
-
-        // when
-        listener.onPlayerMove(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(player).teleport(spawn);
-        verify(spawnLoader).getSpawnLocation(player);
-        verifyNoModifyingCalls(event);
-    }
-
-    @Test
-    public void shouldAllowMovementWithinRadius() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_MOVEMENT_RADIUS)).willReturn(12);
-        World world = mock(World.class);
-        Player player = mock(Player.class);
-        given(player.getWorld()).willReturn(world);
-        Location from = new Location(world, 200, 70, 200);
-        Location to = new Location(world, 199, 69, 201);
-        PlayerMoveEvent event = spy(new PlayerMoveEvent(player, from, to));
-        given(player.getLocation()).willReturn(from);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-        // sqrt(10^2 + 2^2 + 4^2) = 11 < 12 (allowed movement radius)
-        Location spawn = new Location(world, 190, 72, 204);
-        given(spawnLoader.getSpawnLocation(player)).willReturn(spawn);
-
-        // when
-        listener.onPlayerMove(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(player, never()).teleport(any(Location.class));
-        verify(spawnLoader).getSpawnLocation(player);
-        verifyNoModifyingCalls(event);
-    }
-
-    @Test
-    public void shouldRejectMovementOutsideOfRadius() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.ALLOWED_MOVEMENT_RADIUS)).willReturn(12);
-        World world = mock(World.class);
-        Player player = mock(Player.class);
-        given(player.getWorld()).willReturn(world);
-        Location from = new Location(world, 200, 70, 200);
-        Location to = new Location(world, 199, 69, 201);
-        PlayerMoveEvent event = spy(new PlayerMoveEvent(player, from, to));
-        given(player.getLocation()).willReturn(from);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-        // sqrt(15^2 + 2^2 + 4^2) = 16 > 12 (allowed movement radius)
-        Location spawn = new Location(world, 185, 72, 204);
-        given(spawnLoader.getSpawnLocation(player)).willReturn(spawn);
-
-        // when
-        listener.onPlayerMove(event);
-
-        // then
-        verify(listenerService).shouldCancelEvent(player);
-        verify(player).teleport(spawn);
-        verify(spawnLoader).getSpawnLocation(player);
-        verifyNoModifyingCalls(event);
-    }
-
-    @Test
-    public void shouldIgnorePlayerRespawnWithNoTeleport() {
-        // given
-        Player player = mock(Player.class);
-        Location respawnLocation = mock(Location.class);
-        PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, respawnLocation, false));
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(true);
-
-        // when
-        listener.onPlayerRespawn(event);
-
-        // then
-        verifyNoInteractions(listenerService);
-        verify(event, never()).setRespawnLocation(any());
-    }
-
-    @Test
-    public void shouldIgnorePlayerRespawn() {
-        // given
-        Player player = mock(Player.class);
-        Location respawnLocation = mock(Location.class);
-        PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, respawnLocation, false));
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-        given(listenerService.shouldCancelEvent(event)).willReturn(false);
-
-        // when
-        listener.onPlayerRespawn(event);
-
-        // then
-        verifyNoInteractions(spawnLoader);
-        verify(event, never()).setRespawnLocation(any());
-    }
-
-    @Test
-    public void shouldHandlePlayerRespawn() {
-        // given
-        Player player = mock(Player.class);
-        Location originalLocation = mock(Location.class);
-        Location newLocation = mock(Location.class);
-        World world = mock(World.class);
-        given(newLocation.getWorld()).willReturn(world);
-        PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-        given(listenerService.shouldCancelEvent(event)).willReturn(true);
-        given(spawnLoader.getSpawnLocation(player)).willReturn(newLocation);
-
-        // when
-        listener.onPlayerRespawn(event);
-
-        // then
-        verify(spawnLoader).getSpawnLocation(player);
-        verify(event).setRespawnLocation(newLocation);
-    }
-
-    @Test
-    public void shouldIgnorePlayerRespawnUnloadedWorld() {
-        // given
-        Player player = mock(Player.class);
-        Location originalLocation = mock(Location.class);
-        Location newLocation = mock(Location.class);
-        given(newLocation.getWorld()).willReturn(null);
-        PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-        given(listenerService.shouldCancelEvent(event)).willReturn(true);
-        given(spawnLoader.getSpawnLocation(player)).willReturn(newLocation);
-
-        // when
-        listener.onPlayerRespawn(event);
-
-        // then
-        verify(spawnLoader).getSpawnLocation(player);
-        verify(event, never()).setRespawnLocation(any());
-    }
-
-    @Test
-    public void shouldHandlePlayerRespawnNoChanges() {
-        // given
-        Player player = mock(Player.class);
-        Location originalLocation = mock(Location.class);
-        PlayerRespawnEvent event = spy(new PlayerRespawnEvent(player, originalLocation, false));
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-        given(listenerService.shouldCancelEvent(event)).willReturn(true);
-        given(spawnLoader.getSpawnLocation(player)).willReturn(null);
-
-        // when
-        listener.onPlayerRespawn(event);
-
-        // then
-        verify(spawnLoader).getSpawnLocation(player);
-        verify(event, never()).setRespawnLocation(any());
-    }
-
-    @Test
-    public void shouldHandlePlayerJoining() {
-        // given
-        Player player = mock(Player.class);
-        PlayerJoinEvent event = new PlayerJoinEvent(player, "join message");
-
-        // when
-        listener.onPlayerJoin(event);
-
-        // then
-        verify(teleportationService).teleportNewPlayerToFirstSpawn(player);
-        verify(management).performJoin(player);
-    }
-
-    @Test
-    public void shouldNotInterfereWithUnrestrictedUser() throws FailedVerificationException {
-        // given
-        String name = "Player01";
-        Player player = mockPlayerWithName(name);
-        PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", null));
-        given(validationService.isUnrestricted(name)).willReturn(true);
-
-        // when
-        listener.onPlayerLogin(event);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        verify(onJoinVerifier).checkSingleSession(name);
-        verifyNoModifyingCalls(event);
-        verifyNoMoreInteractions(onJoinVerifier);
-    }
-
-    @Test
-    public void shouldStopHandlingForFullServer() throws FailedVerificationException {
-        // given
-        String name = "someone";
-        Player player = mockPlayerWithName(name);
-        PlayerLoginEvent event = spy(new PlayerLoginEvent(player, "", null));
-        given(validationService.isUnrestricted(name)).willReturn(false);
-        given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(true);
-
-        // when
-        listener.onPlayerLogin(event);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        verify(onJoinVerifier).checkSingleSession(name);
-        verify(onJoinVerifier).refusePlayerForFullServer(event);
-        verifyNoMoreInteractions(onJoinVerifier);
-        verifyNoModifyingCalls(event);
-    }
-
-    @Test
-    public void shouldStopHandlingEventForBadResult() throws FailedVerificationException {
-        // given
-        String name = "someone";
-        Player player = mockPlayerWithName(name);
-        PlayerLoginEvent event = new PlayerLoginEvent(player, "", null);
-        event.setResult(PlayerLoginEvent.Result.KICK_BANNED);
-        event = spy(event);
-        given(validationService.isUnrestricted(name)).willReturn(false);
-        given(onJoinVerifier.refusePlayerForFullServer(event)).willReturn(false);
-
-        // when
-        listener.onPlayerLogin(event);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        verify(onJoinVerifier).checkSingleSession(name);
-        verify(onJoinVerifier).refusePlayerForFullServer(event);
-        verifyNoModifyingCalls(event);
-    }
-
-    @Test
-    public void shouldPerformAllJoinVerificationsSuccessfullyPreLoginLowest() throws FailedVerificationException {
-        // given
-        String name = "someone";
-        UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
-        String ip = "12.34.56.78";
-
-        AsyncPlayerPreLoginEvent preLoginEvent = spy(new AsyncPlayerPreLoginEvent(name, mockAddrWithIp(ip), uniqueId));
-        given(validationService.isUnrestricted(name)).willReturn(false);
-
-        // when
-        listener.onAsyncPlayerPreLoginEventLowest(preLoginEvent);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        verify(onJoinVerifier).checkIsValidName(name);
-        verifyNoInteractions(dataSource);
-        verifyNoModifyingCalls(preLoginEvent);
-    }
-
-    @Test
-    public void shouldKickPreLoginLowestUnresolvedHostname() {
-        // given
-        String name = "someone";
-        UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
-    
-        @SuppressWarnings("ConstantConditions")
-        AsyncPlayerPreLoginEvent preLoginEvent = spy(new AsyncPlayerPreLoginEvent(name, null, uniqueId));
-        given(messages.retrieveSingle(name, MessageKey.KICK_UNRESOLVED_HOSTNAME)).willReturn("Unresolved hostname");
-
-        // when
-        listener.onAsyncPlayerPreLoginEventLowest(preLoginEvent);
-
-        // then
-        verify(preLoginEvent).disallow(AsyncPlayerPreLoginEvent.Result.KICK_OTHER, "Unresolved hostname");
-        verifyNoMoreInteractions(onJoinVerifier);
-    }
-
-    @Test
-    public void shouldPerformAllJoinVerificationsSuccessfullyPreLoginHighest() throws FailedVerificationException {
-        // given
-        String name = "someone";
-        UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
-        String ip = "12.34.56.78";
-
-        AsyncPlayerPreLoginEvent preLoginEvent = spy(new AsyncPlayerPreLoginEvent(name, mockAddrWithIp(ip), uniqueId));
-        given(validationService.isUnrestricted(name)).willReturn(false);
-        PlayerAuth auth = PlayerAuth.builder().name(name).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        listener.onAsyncPlayerPreLoginEventHighest(preLoginEvent);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        verify(onJoinVerifier).checkKickNonRegistered(true);
-        verify(onJoinVerifier).checkAntibot(name, true);
-        verify(onJoinVerifier).checkNameCasing(name, auth);
-        verify(onJoinVerifier).checkPlayerCountry(name, ip, true);
-        verifyNoModifyingCalls(preLoginEvent);
-    }
-
-    @Test
-    public void shouldPerformAllJoinVerificationsSuccessfullyLogin() {
-        // given
-        String name = "someone";
-        Player player = mockPlayerWithName(name);
-        String ip = "12.34.56.78";
-
-        PlayerLoginEvent loginEvent = spy(new PlayerLoginEvent(player, "", mockAddrWithIp(ip)));
-        given(validationService.isUnrestricted(name)).willReturn(false);
-        given(onJoinVerifier.refusePlayerForFullServer(loginEvent)).willReturn(false);
-
-        // when
-        listener.onPlayerLogin(loginEvent);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        verify(onJoinVerifier).refusePlayerForFullServer(loginEvent);
-        verifyNoInteractions(dataSource);
-        verifyNoModifyingCalls(loginEvent);
-    }
-
-    @Test
-    public void shouldAbortPlayerJoinForInvalidName() throws FailedVerificationException {
-        // given
-        String name = "inval!dName";
-        UUID uniqueId = UUID.fromString("753493c9-33ba-4a4a-bf61-1bce9d3c9a71");
-        InetAddress ip = mockAddrWithIp("33.32.33.33");
-        AsyncPlayerPreLoginEvent event = spy(new AsyncPlayerPreLoginEvent(name, ip, uniqueId));
-        given(validationService.isUnrestricted(name)).willReturn(false);
-        FailedVerificationException exception = new FailedVerificationException(
-            MessageKey.INVALID_NAME_CHARACTERS, "[a-z]");
-        doThrow(exception).when(onJoinVerifier).checkIsValidName(name);
-        String message = "Invalid characters!";
-        given(messages.retrieveSingle(name, exception.getReason(), exception.getArgs())).willReturn(message);
-
-        // when
-        listener.onAsyncPlayerPreLoginEventLowest(event);
-
-        // then
-        verify(validationService).isUnrestricted(name);
-        verify(onJoinVerifier).checkIsValidName(name);
-        // Check that we don't talk with the data source before performing checks that don't require it
-        verifyNoInteractions(dataSource);
-        verify(event).setKickMessage(message);
-        verify(event).setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
-    }
-
-    @Test
-    public void shouldRemoveMessageOnQuit() {
-        // given
-        given(settings.getProperty(RegistrationSettings.REMOVE_LEAVE_MESSAGE)).willReturn(true);
-        given(antiBotService.wasPlayerKicked(anyString())).willReturn(false);
-        Player player = mockPlayerWithName("Billy");
-        PlayerQuitEvent event = new PlayerQuitEvent(player, "Player has quit the server");
-
-        // when
-        listener.onPlayerQuit(event);
-
-        // then
-        assertThat(event.getQuitMessage(), nullValue());
-        verify(antiBotService).wasPlayerKicked("Billy");
-        verify(management).performQuit(player);
-    }
-
-    @Test
-    public void shouldRemoveMessageForUnloggedUser() {
-        // given
-        given(settings.getProperty(RegistrationSettings.REMOVE_LEAVE_MESSAGE)).willReturn(false);
-        given(settings.getProperty(RegistrationSettings.REMOVE_UNLOGGED_LEAVE_MESSAGE)).willReturn(true);
-        String name = "Joel";
-        given(antiBotService.wasPlayerKicked(name)).willReturn(true);
-        Player player = mockPlayerWithName(name);
-        PlayerQuitEvent event = new PlayerQuitEvent(player, "Joel exits the party");
-        given(listenerService.shouldCancelEvent(event)).willReturn(true);
-
-        // when
-        listener.onPlayerQuit(event);
-
-        // then
-        assertThat(event.getQuitMessage(), nullValue());
-        verify(antiBotService).wasPlayerKicked(name);
-        verifyNoInteractions(management);
-    }
-
-    @Test
-    public void shouldProcessPlayerAndKeepQuitMessage() {
-        // given
-        String name = "Louis";
-        Player player = mockPlayerWithName(name);
-        given(settings.getProperty(RegistrationSettings.REMOVE_LEAVE_MESSAGE)).willReturn(false);
-        given(settings.getProperty(RegistrationSettings.REMOVE_UNLOGGED_LEAVE_MESSAGE)).willReturn(false);
-        given(antiBotService.wasPlayerKicked(name)).willReturn(false);
-        String quitMessage = "The player has left the server.";
-        PlayerQuitEvent event = new PlayerQuitEvent(player, quitMessage);
-
-        // when
-        listener.onPlayerQuit(event);
-
-        // then
-        assertThat(event.getQuitMessage(), equalTo(quitMessage));
-        verify(antiBotService).wasPlayerKicked(name);
-        verify(management).performQuit(player);
-    }
-
-    @Test
-    public void shouldCancelInventoryClickEvent() {
-        // given
-        InventoryClickEvent event = mock(InventoryClickEvent.class);
-        HumanEntity player = mock(Player.class);
-        given(event.getWhoClicked()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-
-        // when
-        listener.onPlayerInventoryClick(event);
-
-        // then
-        verify(event).setCancelled(true);
-    }
-
-    @Test
-    public void shouldAllowInventoryClickEvent() {
-        // given
-        InventoryClickEvent event = mock(InventoryClickEvent.class);
-        HumanEntity player = mock(Player.class);
-        given(event.getWhoClicked()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onPlayerInventoryClick(event);
-
-        // then
-        verify(event, only()).getWhoClicked();
-    }
-
-    @Test
-    public void shouldAllowSignChangeEvent() {
-        // given
-        SignChangeEvent event = mock(SignChangeEvent.class);
-        Player player = mock(Player.class);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onSignChange(event);
-
-        // then
-        verify(event, only()).getPlayer();
-    }
-
-    @Test
-    public void shouldCancelSignChangeEvent() {
-        // given
-        SignChangeEvent event = mock(SignChangeEvent.class);
-        Player player = mock(Player.class);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-
-        // when
-        listener.onSignChange(event);
-
-        // then
-        verify(event).setCancelled(true);
-    }
-
-    @Test
-    public void shouldAllowInventoryOpen() {
-        // given
-        HumanEntity player = mock(Player.class);
-        InventoryView transaction = mock(InventoryView.class);
-        InventoryOpenEvent event = new InventoryOpenEvent(transaction);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(false);
-
-        // when
-        listener.onPlayerInventoryOpen(event);
-
-        // then
-        assertThat(event.isCancelled(), equalTo(false));
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldCancelInventoryOpen() {
-        // given
-        HumanEntity player = mock(Player.class);
-        InventoryView transaction = mock(InventoryView.class);
-        given(transaction.getTitle()).willReturn("Spawn");
-        given(settings.getProperty(RestrictionSettings.UNRESTRICTED_INVENTORIES)).willReturn(Collections.emptySet());
-        InventoryOpenEvent event = new InventoryOpenEvent(transaction);
-        given(event.getPlayer()).willReturn(player);
-        given(listenerService.shouldCancelEvent(player)).willReturn(true);
-        setBukkitServiceToScheduleSyncDelayedTaskWithDelay(bukkitService);
-
-        // when
-        listener.onPlayerInventoryOpen(event);
-
-        // then
-        assertThat(event.isCancelled(), equalTo(true));
-        verify(player).closeInventory();
-    }
-
-    @Test
-    public void shouldNotModifyJoinMessage() {
-        // given
-        Player player = mock(Player.class);
-        String joinMsg = "The player joined";
-        PlayerJoinEvent event = new PlayerJoinEvent(player, joinMsg);
-        given(settings.getProperty(RegistrationSettings.REMOVE_JOIN_MESSAGE)).willReturn(false);
-        given(settings.getProperty(RegistrationSettings.CUSTOM_JOIN_MESSAGE)).willReturn("");
-        given(settings.getProperty(RegistrationSettings.DELAY_JOIN_MESSAGE)).willReturn(false);
-
-        // when
-        listener.onJoinMessage(event);
-
-        // then
-        assertThat(event.getJoinMessage(), equalTo(joinMsg));
-        verifyNoInteractions(joinMessageService);
-    }
-
-    @Test
-    public void shouldRemoveJoinMessage() {
-        // given
-        Player player = mock(Player.class);
-        String joinMsg = "The player joined";
-        PlayerJoinEvent event = new PlayerJoinEvent(player, joinMsg);
-        given(settings.getProperty(RegistrationSettings.REMOVE_JOIN_MESSAGE)).willReturn(true);
-
-        // when
-        listener.onJoinMessage(event);
-
-        // then
-        assertThat(event.getJoinMessage(), nullValue());
-        verifyNoInteractions(joinMessageService);
-    }
-
-    @Test
-    public void shouldUseCustomMessage() {
-        // given
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("doooew");
-        given(player.getDisplayName()).willReturn("Displ");
-        String joinMsg = "The player joined";
-        PlayerJoinEvent event = new PlayerJoinEvent(player, joinMsg);
-        given(settings.getProperty(RegistrationSettings.REMOVE_JOIN_MESSAGE)).willReturn(false);
-        given(settings.getProperty(RegistrationSettings.CUSTOM_JOIN_MESSAGE))
-            .willReturn("Hello {PLAYERNAME} (aka {DISPLAYNAME})");
-        given(settings.getProperty(RegistrationSettings.DELAY_JOIN_MESSAGE)).willReturn(false);
-
-        // when
-        listener.onJoinMessage(event);
-
-        // then
-        assertThat(event.getJoinMessage(), equalTo("Hello doooew (aka Displ)"));
-        verifyNoInteractions(joinMessageService);
-    }
-
-    @Test
-    public void shouldDelayJoinMessage() {
-        // given
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("thename0");
-        given(player.getDisplayName()).willReturn("(not used)");
-        String joinMsg = "The player joined";
-        PlayerJoinEvent event = new PlayerJoinEvent(player, joinMsg);
-        given(settings.getProperty(RegistrationSettings.REMOVE_JOIN_MESSAGE)).willReturn(false);
-        given(settings.getProperty(RegistrationSettings.CUSTOM_JOIN_MESSAGE))
-            .willReturn("{PLAYERNAME} is joining us");
-        given(settings.getProperty(RegistrationSettings.DELAY_JOIN_MESSAGE)).willReturn(true);
-
-        // when
-        listener.onJoinMessage(event);
-
-        // then
-        assertThat(event.getJoinMessage(), nullValue());
-        verify(joinMessageService).putMessage("thename0", "thename0 is joining us");
-    }
-
-    @Test
-    public void shouldCancelPlayerEditBookEvent() {
-        withServiceMock(listenerService)
-            .check(listener::onPlayerEditBook, PlayerEditBookEvent.class);
-    }
-
-    @Test
-    public void shouldCancelPlayerInteractAtEntityEvent() {
-        withServiceMock(listenerService)
-            .check(listener::onPlayerInteractAtEntity, PlayerInteractAtEntityEvent.class);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-
-    /**
-     * {@link PlayerCommandPreprocessEvent} gets the list of online players from the player's server.
-     * This method creates a Player mock with all necessary mocked behavior.
-     *
-     * @return Player mock
-     */
-    @SuppressWarnings("unchecked")
-    private static Player playerWithMockedServer() {
-        Server server = mock(Server.class);
-        given(server.getOnlinePlayers()).willReturn(Collections.EMPTY_LIST);
-        Player player = mock(Player.class);
-        given(player.getServer()).willReturn(server);
-        return player;
-    }
-
-    private static PlayerCommandPreprocessEvent mockCommandEvent(String message) {
-        PlayerCommandPreprocessEvent commandEvent = mock(PlayerCommandPreprocessEvent.class);
-        given(commandEvent.getMessage()).willReturn(message);
-        return commandEvent;
-    }
-
-    private static AsyncPlayerChatEvent newAsyncChatEvent() {
-        Player player = mock(Player.class);
-        List<Player> recipients = Arrays.asList(mock(Player.class), mock(Player.class), mock(Player.class));
-        return spy(new AsyncPlayerChatEvent(true, player, "Test message", new HashSet<>(recipients)));
-    }
-
-    private static void verifyNoModifyingCalls(PlayerMoveEvent event) {
-        verify(event, atLeast(0)).getFrom();
-        verify(event, atLeast(0)).getTo();
-        verifyNoMoreInteractions(event);
-    }
-
-    private static void verifyNoModifyingCalls(PlayerLoginEvent event) {
-        verify(event, atLeast(0)).getResult();
-        verify(event, atLeast(0)).getAddress();
-        verifyNoMoreInteractions(event);
-    }
-
-    private static void verifyNoModifyingCalls(AsyncPlayerPreLoginEvent event) {
-        verify(event, atLeast(0)).getLoginResult();
-        verify(event, atLeast(0)).getAddress();
-        verify(event, atLeast(0)).getName();
-        verifyNoMoreInteractions(event);
-    }
-
-    private static InetAddress mockAddrWithIp(String ip) {
-        InetAddress addr = mock(InetAddress.class);
-        given(addr.getHostAddress()).willReturn(ip);
-        return addr;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/listener/ServerListenerTest.java b/src/test/java/fr/xephi/authme/listener/ServerListenerTest.java
deleted file mode 100644
index 51ce46f0..00000000
--- a/src/test/java/fr/xephi/authme/listener/ServerListenerTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-package fr.xephi.authme.listener;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.listener.protocollib.ProtocolLibService;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.service.PluginHookService;
-import fr.xephi.authme.settings.SpawnLoader;
-import org.bukkit.event.server.PluginDisableEvent;
-import org.bukkit.event.server.PluginEnableEvent;
-import org.bukkit.event.server.PluginEvent;
-import org.bukkit.plugin.Plugin;
-import org.junit.BeforeClass;
-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.reset;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link ServerListener}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class ServerListenerTest {
-
-    private static final String ESSENTIALS = "Essentials";
-    private static final String ESSENTIALS_SPAWN = "EssentialsSpawn";
-    private static final String CMI = "CMI";
-    private static final String MULTIVERSE = "Multiverse-Core";
-    private static final String PROTOCOL_LIB = "ProtocolLib";
-
-    @InjectMocks
-    private ServerListener serverListener;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Mock
-    private PluginHookService pluginHookService;
-
-    @Mock
-    private ProtocolLibService protocolLibService;
-
-    @Mock
-    private SpawnLoader spawnLoader;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldForwardPluginNameOnEnable() {
-        checkEnableHandling(ESSENTIALS,       () -> verify(pluginHookService).tryHookToEssentials());
-        checkEnableHandling(ESSENTIALS_SPAWN, () -> verify(spawnLoader).loadEssentialsSpawn());
-        checkEnableHandling(CMI,              () -> {
-            verify(pluginHookService).tryHookToCmi();
-            verify(spawnLoader).loadCmiSpawn();
-        });
-        checkEnableHandling(MULTIVERSE,       () -> verify(pluginHookService).tryHookToMultiverse());
-        checkEnableHandling(PROTOCOL_LIB,     () -> verify(protocolLibService).setup());
-        checkEnableHandling("UnknownPlugin",  () -> verifyNoInteractions(pluginHookService, spawnLoader));
-    }
-
-    @Test
-    public void shouldForwardPluginNameOnDisable() {
-        checkDisableHandling(ESSENTIALS,       () -> verify(pluginHookService).unhookEssentials());
-        checkDisableHandling(ESSENTIALS_SPAWN, () -> verify(spawnLoader).unloadEssentialsSpawn());
-        checkDisableHandling(CMI,              () -> {
-            verify(pluginHookService).unhookCmi();
-            verify(spawnLoader).unloadCmiSpawn();
-        });
-        checkDisableHandling(MULTIVERSE,       () -> verify(pluginHookService).unhookMultiverse());
-        checkDisableHandling(PROTOCOL_LIB,     () -> verify(protocolLibService).disable());
-        checkDisableHandling("UnknownPlugin",  () -> verifyNoInteractions(pluginHookService, spawnLoader));
-    }
-
-    private void checkEnableHandling(String pluginName, Runnable verifier) {
-        PluginEnableEvent event = mockEventWithPluginName(PluginEnableEvent.class, pluginName);
-        serverListener.onPluginEnable(event);
-        verifier.run();
-        verify(permissionsManager).onPluginEnable(pluginName);
-        verifyNoMoreInteractionsAndReset();
-    }
-
-    private void checkDisableHandling(String pluginName, Runnable verifier) {
-        PluginDisableEvent event = mockEventWithPluginName(PluginDisableEvent.class, pluginName);
-        serverListener.onPluginDisable(event);
-        verifier.run();
-        verify(permissionsManager).onPluginDisable(pluginName);
-        verifyNoMoreInteractionsAndReset();
-    }
-
-    private void verifyNoMoreInteractionsAndReset() {
-        verifyNoMoreInteractions(permissionsManager, pluginHookService, protocolLibService, spawnLoader);
-        reset(permissionsManager, pluginHookService, protocolLibService, spawnLoader);
-    }
-
-    private static  <T extends PluginEvent> T mockEventWithPluginName(Class<T> eventClass, String name) {
-        T event = mock(eventClass);
-        Plugin plugin = mock(Plugin.class);
-        given(plugin.getName()).willReturn(name);
-        given(event.getPlugin()).willReturn(plugin);
-        return event;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/mail/EmailServiceTest.java b/src/test/java/fr/xephi/authme/mail/EmailServiceTest.java
deleted file mode 100644
index 96492daa..00000000
--- a/src/test/java/fr/xephi/authme/mail/EmailServiceTest.java
+++ /dev/null
@@ -1,188 +0,0 @@
-package fr.xephi.authme.mail;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.EmailSettings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.apache.commons.mail.EmailException;
-import org.apache.commons.mail.HtmlEmail;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.io.IOException;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link EmailService}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class EmailServiceTest {
-
-    @InjectDelayed
-    private EmailService emailService;
-
-    @Mock
-    private Settings settings;
-    @Mock
-    private SendMailSsl sendMailSsl;
-    @DataFolder
-    private File dataFolder;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    public void initFields() throws IOException {
-        dataFolder = temporaryFolder.newFolder();
-        given(settings.getProperty(PluginSettings.SERVER_NAME)).willReturn("serverName");
-        given(settings.getProperty(EmailSettings.MAIL_ACCOUNT)).willReturn("mail@example.org");
-        given(settings.getProperty(EmailSettings.MAIL_PASSWORD)).willReturn("pass1234");
-        given(sendMailSsl.hasAllInformation()).willReturn(true);
-    }
-
-    @Test
-    public void shouldHaveAllInformation() {
-        // given / when / then
-        assertThat(emailService.hasAllInformation(), equalTo(true));
-    }
-
-    @Test
-    public void shouldSendPasswordMail() throws EmailException {
-        // given
-        given(settings.getPasswordEmailMessage())
-            .willReturn("Hi <playername />, your new password for <servername /> is <generatedpass />");
-        given(settings.getProperty(EmailSettings.PASSWORD_AS_IMAGE)).willReturn(false);
-        HtmlEmail email = mock(HtmlEmail.class);
-        given(sendMailSsl.initializeMail(anyString())).willReturn(email);
-        given(sendMailSsl.sendEmail(anyString(), eq(email))).willReturn(true);
-
-        // when
-        boolean result = emailService.sendPasswordMail("Player", "user@example.com", "new_password");
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(sendMailSsl).initializeMail("user@example.com");
-        ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sendMailSsl).sendEmail(messageCaptor.capture(), eq(email));
-        assertThat(messageCaptor.getValue(),
-            equalTo("Hi Player, your new password for serverName is new_password"));
-    }
-
-    @Test
-    public void shouldHandleMailCreationError() throws EmailException {
-        // given
-        doThrow(EmailException.class).when(sendMailSsl).initializeMail(anyString());
-
-        // when
-        boolean result = emailService.sendPasswordMail("Player", "user@example.com", "new_password");
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(sendMailSsl).initializeMail("user@example.com");
-        verify(sendMailSsl, never()).sendEmail(anyString(), any(HtmlEmail.class));
-    }
-
-    @Test
-    public void shouldHandleMailSendingFailure() throws EmailException {
-        // given
-        given(settings.getPasswordEmailMessage()).willReturn("Hi <playername />, your new pass is <generatedpass />");
-        given(settings.getProperty(EmailSettings.PASSWORD_AS_IMAGE)).willReturn(false);
-        HtmlEmail email = mock(HtmlEmail.class);
-        given(sendMailSsl.initializeMail(anyString())).willReturn(email);
-        given(sendMailSsl.sendEmail(anyString(), any(HtmlEmail.class))).willReturn(false);
-
-        // when
-        boolean result = emailService.sendPasswordMail("bobby", "user@example.com", "myPassw0rd");
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(sendMailSsl).initializeMail("user@example.com");
-        ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sendMailSsl).sendEmail(messageCaptor.capture(), eq(email));
-        assertThat(messageCaptor.getValue(), equalTo("Hi bobby, your new pass is myPassw0rd"));
-    }
-
-    @Test
-    public void shouldSendRecoveryCode() throws EmailException {
-        // given
-        given(settings.getProperty(SecuritySettings.RECOVERY_CODE_HOURS_VALID)).willReturn(7);
-        given(settings.getRecoveryCodeEmailMessage())
-            .willReturn("Hi <playername />, your code on <servername /> is <recoverycode /> (valid <hoursvalid /> hours)");
-        HtmlEmail email = mock(HtmlEmail.class);
-        given(sendMailSsl.initializeMail(anyString())).willReturn(email);
-        given(sendMailSsl.sendEmail(anyString(), any(HtmlEmail.class))).willReturn(true);
-
-        // when
-        boolean result = emailService.sendRecoveryCode("Timmy", "tim@example.com", "12C56A");
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(sendMailSsl).initializeMail("tim@example.com");
-        ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sendMailSsl).sendEmail(messageCaptor.capture(), eq(email));
-        assertThat(messageCaptor.getValue(), equalTo("Hi Timmy, your code on serverName is 12C56A (valid 7 hours)"));
-    }
-
-    @Test
-    public void shouldHandleMailCreationErrorForRecoveryCode() throws EmailException {
-        // given
-        given(sendMailSsl.initializeMail(anyString())).willThrow(EmailException.class);
-
-        // when
-        boolean result = emailService.sendRecoveryCode("Player", "player@example.org", "ABC1234");
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(sendMailSsl).initializeMail("player@example.org");
-        verify(sendMailSsl, never()).sendEmail(anyString(), any(HtmlEmail.class));
-    }
-
-    @Test
-    public void shouldHandleFailureToSendRecoveryCode() throws EmailException {
-        // given
-        given(settings.getProperty(SecuritySettings.RECOVERY_CODE_HOURS_VALID)).willReturn(7);
-        given(settings.getRecoveryCodeEmailMessage()).willReturn("Hi <playername />, your code is <recoverycode />");
-        EmailService sendMailSpy = spy(emailService);
-        HtmlEmail email = mock(HtmlEmail.class);
-        given(sendMailSsl.initializeMail(anyString())).willReturn(email);
-        given(sendMailSsl.sendEmail(anyString(), any(HtmlEmail.class))).willReturn(false);
-
-        // when
-        boolean result = sendMailSpy.sendRecoveryCode("John", "user@example.com", "1DEF77");
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(sendMailSsl).initializeMail("user@example.com");
-        ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
-        verify(sendMailSsl).sendEmail(messageCaptor.capture(), eq(email));
-        assertThat(messageCaptor.getValue(), equalTo("Hi John, your code is 1DEF77"));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/mail/SendMailSslTest.java b/src/test/java/fr/xephi/authme/mail/SendMailSslTest.java
deleted file mode 100644
index cd5b2152..00000000
--- a/src/test/java/fr/xephi/authme/mail/SendMailSslTest.java
+++ /dev/null
@@ -1,140 +0,0 @@
-package fr.xephi.authme.mail;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.output.LogLevel;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.EmailSettings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import org.apache.commons.mail.EmailException;
-import org.apache.commons.mail.HtmlEmail;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.io.IOException;
-import java.util.Properties;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-
-/**
- * Test for {@link SendMailSsl}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class SendMailSslTest {
-
-    @InjectDelayed
-    private SendMailSsl sendMailSsl;
-
-    @Mock
-    private Settings settings;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    public void initFields() throws IOException {
-        given(settings.getProperty(EmailSettings.MAIL_ACCOUNT)).willReturn("mail@example.org");
-        given(settings.getProperty(EmailSettings.MAIL_PASSWORD)).willReturn("pass1234");
-        given(settings.getProperty(PluginSettings.LOG_LEVEL)).willReturn(LogLevel.INFO);
-    }
-
-    @Test
-    public void shouldHaveAllInformation() {
-        // given / when / then
-        assertThat(sendMailSsl.hasAllInformation(), equalTo(true));
-    }
-
-    @Test
-    public void shouldCreateEmailObject() throws EmailException {
-        // given
-        given(settings.getProperty(EmailSettings.SMTP_PORT)).willReturn(465);
-        String smtpHost = "mail.example.com";
-        given(settings.getProperty(EmailSettings.SMTP_HOST)).willReturn(smtpHost);
-        String senderAccount = "sender@example.org";
-        given(settings.getProperty(EmailSettings.MAIL_ACCOUNT)).willReturn(senderAccount);
-        String senderName = "Server administration";
-        given(settings.getProperty(EmailSettings.MAIL_SENDER_NAME)).willReturn(senderName);
-        given(settings.getProperty(PluginSettings.LOG_LEVEL)).willReturn(LogLevel.DEBUG);
-
-        // when
-        HtmlEmail email = sendMailSsl.initializeMail("recipient@example.com");
-
-        // then
-        assertThat(email, not(nullValue()));
-        assertThat(email.getToAddresses(), hasSize(1));
-        assertThat(email.getToAddresses().get(0).getAddress(), equalTo("recipient@example.com"));
-        assertThat(email.getFromAddress().getAddress(), equalTo(senderAccount));
-        assertThat(email.getFromAddress().getPersonal(), equalTo(senderName));
-        assertThat(email.getHostName(), equalTo(smtpHost));
-        assertThat(email.getSmtpPort(), equalTo("465"));
-    }
-
-    @Test
-    public void shouldCreateEmailObjectWithAddress() throws EmailException {
-        // given
-        given(settings.getProperty(EmailSettings.SMTP_PORT)).willReturn(465);
-        String smtpHost = "mail.example.com";
-        given(settings.getProperty(EmailSettings.SMTP_HOST)).willReturn(smtpHost);
-        String senderAccount = "exampleAccount";
-        given(settings.getProperty(EmailSettings.MAIL_ACCOUNT)).willReturn(senderAccount);
-        String senderAddress = "mail@example.com";
-        given(settings.getProperty(EmailSettings.MAIL_ADDRESS)).willReturn(senderAddress);
-        String senderName = "Server administration";
-        given(settings.getProperty(EmailSettings.MAIL_SENDER_NAME)).willReturn(senderName);
-
-        // when
-        HtmlEmail email = sendMailSsl.initializeMail("recipient@example.com");
-
-        // then
-        assertThat(email, not(nullValue()));
-        assertThat(email.getToAddresses(), hasSize(1));
-        assertThat(email.getToAddresses().get(0).getAddress(), equalTo("recipient@example.com"));
-        assertThat(email.getFromAddress().getAddress(), equalTo(senderAddress));
-        assertThat(email.getFromAddress().getPersonal(), equalTo(senderName));
-        assertThat(email.getHostName(), equalTo(smtpHost));
-        assertThat(email.getSmtpPort(), equalTo("465"));
-    }
-
-    @Test
-    public void shouldCreateEmailObjectWithOAuth2() throws EmailException {
-        // given
-        given(settings.getProperty(EmailSettings.SMTP_PORT)).willReturn(587);
-        given(settings.getProperty(EmailSettings.OAUTH2_TOKEN)).willReturn("oAuth2 token");
-        String smtpHost = "mail.example.com";
-        given(settings.getProperty(EmailSettings.SMTP_HOST)).willReturn(smtpHost);
-        String senderMail = "sender@example.org";
-        given(settings.getProperty(EmailSettings.MAIL_ACCOUNT)).willReturn(senderMail);
-
-        // when
-        HtmlEmail email = sendMailSsl.initializeMail("recipient@example.com");
-
-        // then
-        assertThat(email, not(nullValue()));
-        assertThat(email.getToAddresses(), hasSize(1));
-        assertThat(email.getToAddresses().get(0).getAddress(), equalTo("recipient@example.com"));
-        assertThat(email.getFromAddress().getAddress(), equalTo(senderMail));
-        assertThat(email.getHostName(), equalTo(smtpHost));
-        assertThat(email.getSmtpPort(), equalTo("587"));
-
-        Properties mailProperties = email.getMailSession().getProperties();
-        assertThat(mailProperties.getProperty("mail.smtp.auth.mechanisms"), equalTo("XOAUTH2"));
-        assertThat(mailProperties.getProperty("mail.smtp.auth.plain.disable"), equalTo("true"));
-        assertThat(mailProperties.getProperty(OAuth2SaslClientFactory.OAUTH_TOKEN_PROP), equalTo("oAuth2 token"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/HelpMessageConsistencyTest.java b/src/test/java/fr/xephi/authme/message/HelpMessageConsistencyTest.java
deleted file mode 100644
index b6fcba7c..00000000
--- a/src/test/java/fr/xephi/authme/message/HelpMessageConsistencyTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package fr.xephi.authme.message;
-
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileReader;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.command.help.HelpMessage;
-import fr.xephi.authme.command.help.HelpSection;
-import fr.xephi.authme.permission.DefaultPermission;
-import org.hamcrest.Matcher;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.File;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.message.MessagePathHelper.MESSAGES_FOLDER;
-import static org.hamcrest.Matchers.both;
-import static org.hamcrest.Matchers.emptyString;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Tests that all help_xx.yml files contain all entries for
- * {@link HelpSection}, {@link HelpMessage} and {@link DefaultPermission}.
- */
-public class HelpMessageConsistencyTest {
-
-    private List<File> helpFiles;
-
-    @Before
-    public void findHelpMessagesFiles() {
-        File folder = TestHelper.getJarFile("/" + MESSAGES_FOLDER);
-        File[] files = folder.listFiles();
-        if (files == null || files.length == 0) {
-            throw new IllegalStateException("Could not get files from '" + MESSAGES_FOLDER + "'");
-        }
-        helpFiles = Arrays.stream(files)
-            .filter(file -> MessagePathHelper.isHelpFile(file.getName()))
-            .collect(Collectors.toList());
-    }
-
-    @Test
-    public void shouldHaveRequiredEntries() {
-        for (File file : helpFiles) {
-            // given
-            PropertyReader reader = new YamlFileReader(file);
-
-            // when / then
-            assertHasAllHelpSectionEntries(file.getName(), reader);
-        }
-    }
-
-    private void assertHasAllHelpSectionEntries(String filename, PropertyReader reader) {
-        for (HelpSection section : HelpSection.values()) {
-            assertThat(filename + " should have entry for HelpSection '" + section + "'",
-                reader.getString(section.getKey()), notEmptyString());
-        }
-
-        for (HelpMessage message : HelpMessage.values()) {
-            assertThat(filename + " should have entry for HelpMessage '" + message + "'",
-                reader.getString(message.getKey()), notEmptyString());
-        }
-
-        for (DefaultPermission defaultPermission : DefaultPermission.values()) {
-            assertThat(filename + " should have entry for DefaultPermission '" + defaultPermission + "'",
-                reader.getString(getPathForDefaultPermission(defaultPermission)), notEmptyString());
-        }
-    }
-
-    private static String getPathForDefaultPermission(DefaultPermission defaultPermission) {
-        String path = "common.defaultPermissions.";
-        switch (defaultPermission) {
-            case ALLOWED:
-                return path + "allowed";
-            case NOT_ALLOWED:
-                return path + "notAllowed";
-            case OP_ONLY:
-                return path + "opOnly";
-            default:
-                throw new IllegalStateException("Unknown default permission '" + defaultPermission + "'");
-        }
-    }
-
-    private static Matcher<String> notEmptyString() {
-        return both(not(emptyString())).and(not(nullValue()));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/MessageFilePlaceholderTest.java b/src/test/java/fr/xephi/authme/message/MessageFilePlaceholderTest.java
deleted file mode 100644
index 0966902b..00000000
--- a/src/test/java/fr/xephi/authme/message/MessageFilePlaceholderTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package fr.xephi.authme.message;
-
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileReader;
-import com.google.common.collect.ImmutableMultimap;
-import com.google.common.collect.Multimap;
-import fr.xephi.authme.TestHelper;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.message.MessagePathHelper.MESSAGES_FOLDER;
-import static org.junit.Assert.fail;
-import static tools.utils.FileIoUtils.listFilesOrThrow;
-
-/**
- * Checks that the entries in messages_xx.yml files have the {@link MessageKey#getTags() placeholders}
- * that are defined for the given message.
- */
-@RunWith(Parameterized.class)
-public class MessageFilePlaceholderTest {
-
-    /** Defines exclusions: a (key, tag) pair in this map will not be checked in the test. */
-    private static final Multimap<MessageKey, String> EXCLUSIONS = ImmutableMultimap.<MessageKey, String>builder()
-        .put(MessageKey.INCORRECT_RECOVERY_CODE, "%count")
-        .putAll(MessageKey.MAX_REGISTER_EXCEEDED, "%max_acc", "%reg_count", "%reg_names")
-        .build();
-
-    private File messagesFile;
-    private String messagesFilename;
-
-    // Note ljacqu 20170506: We pass the file name separately so we can reference it for the name in @Parameters
-    public MessageFilePlaceholderTest(File messagesFile, String name) {
-        this.messagesFile = messagesFile;
-        this.messagesFilename = name;
-    }
-
-    @Test
-    public void shouldHaveAllPlaceholders() {
-        // given
-        PropertyReader reader = new YamlFileReader(messagesFile);
-        List<String> errors = new ArrayList<>(0);
-
-        // when
-        for (MessageKey key : MessageKey.values()) {
-            List<String> missingTags = findMissingTags(key, reader);
-            if (!missingTags.isEmpty()) {
-                errors.add("Message key '" + key + "' should have tags: " + String.join(", ", missingTags));
-            }
-        }
-
-        // then
-        if (!errors.isEmpty()) {
-            fail("Errors while validating '" + messagesFilename + "':\n- " + String.join("\n- ", errors));
-        }
-    }
-
-    private List<String> findMissingTags(MessageKey key, PropertyReader reader) {
-        if (key.getTags().length > 0 && reader.contains(key.getKey())) {
-            String message = reader.getString(key.getKey());
-            return Arrays.stream(key.getTags())
-                .filter(tag -> !EXCLUSIONS.get(key).contains(tag) && !message.contains(tag))
-                .collect(Collectors.toList());
-        }
-        return Collections.emptyList();
-    }
-
-    @Parameterized.Parameters(name = "{1}")
-    public static List<Object[]> buildParams() {
-        File folder = TestHelper.getJarFile("/" + MESSAGES_FOLDER);
-
-        List<Object[]> messageFiles = Arrays.stream(listFilesOrThrow(folder))
-            .filter(file -> MessagePathHelper.isMessagesFile(file.getName()))
-            .map(file -> new Object[]{file, file.getName()})
-            .collect(Collectors.toList());
-        if (messageFiles.isEmpty()) {
-            throw new IllegalStateException("Found zero messages files (is the folder correct?)");
-        }
-        return messageFiles;
-    }
-
-
-}
diff --git a/src/test/java/fr/xephi/authme/message/MessageKeyTest.java b/src/test/java/fr/xephi/authme/message/MessageKeyTest.java
deleted file mode 100644
index c60305d6..00000000
--- a/src/test/java/fr/xephi/authme/message/MessageKeyTest.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package fr.xephi.authme.message;
-
-import fr.xephi.authme.util.StringUtils;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.matchesPattern;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link MessageKey}.
- */
-public class MessageKeyTest {
-
-    @Test
-    public void shouldHaveUniqueMessageKeys() {
-        // given
-        MessageKey[] messageKeys = MessageKey.values();
-        Set<String> keys = new HashSet<>();
-
-        // when / then
-        for (MessageKey messageKey : messageKeys) {
-            String key = messageKey.getKey();
-            if (!keys.add(key)) {
-                fail("Found key '" + messageKey.getKey() + "' twice!");
-            } else if (StringUtils.isBlank(key)) {
-                fail("Key for message key '" + messageKey + "' is empty");
-            }
-        }
-    }
-
-    @Test
-    public void shouldHaveWellFormedPlaceholders() {
-        // given
-        MessageKey[] messageKeys = MessageKey.values();
-
-        // when / then
-        for (MessageKey messageKey : messageKeys) {
-            String[] tags = messageKey.getTags();
-            Arrays.stream(tags)
-                .forEach(tag -> assertThat("Tag '" + tag + "' corresponds to valid format for key '" + messageKey + "'",
-                    tag, matchesPattern("^%[a-z_]+$")));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/MessagePathHelperTest.java b/src/test/java/fr/xephi/authme/message/MessagePathHelperTest.java
deleted file mode 100644
index 7e12aa4f..00000000
--- a/src/test/java/fr/xephi/authme/message/MessagePathHelperTest.java
+++ /dev/null
@@ -1,67 +0,0 @@
-package fr.xephi.authme.message;
-
-import fr.xephi.authme.settings.properties.PluginSettings;
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link MessagePathHelper}.
- */
-public class MessagePathHelperTest {
-
-    @Test
-    public void shouldHaveLanguageInSyncWithConfigurations() {
-        // given / when / then
-        assertThat(MessagePathHelper.DEFAULT_LANGUAGE, equalTo(PluginSettings.MESSAGES_LANGUAGE.getDefaultValue()));
-        assertThat(MessagePathHelper.DEFAULT_MESSAGES_FILE, equalTo(MessagePathHelper.createMessageFilePath(MessagePathHelper.DEFAULT_LANGUAGE)));
-    }
-
-    @Test
-    public void shouldBuildTextFilePaths() {
-        // given / when / then
-        assertThat(MessagePathHelper.createMessageFilePath("qq"), equalTo(MessagePathHelper.MESSAGES_FOLDER + "messages_qq.yml"));
-        assertThat(MessagePathHelper.createHelpMessageFilePath("qq"), equalTo(MessagePathHelper.MESSAGES_FOLDER + "help_qq.yml"));
-    }
-
-    @Test
-    public void shouldRecognizeIfIsMessagesFile() {
-        // given / when / then
-        assertThat(MessagePathHelper.isMessagesFile("messages_nl.yml"), equalTo(true));
-        assertThat(MessagePathHelper.isMessagesFile("messages_testtest.yml"), equalTo(true));
-
-        assertThat(MessagePathHelper.isMessagesFile("messages/messages_fr.yml"), equalTo(false));
-        assertThat(MessagePathHelper.isMessagesFile("Messages_fr.yml"), equalTo(false));
-        assertThat(MessagePathHelper.isMessagesFile("otherfile.txt"), equalTo(false));
-        assertThat(MessagePathHelper.isMessagesFile("messages_de.txt"), equalTo(false));
-        assertThat(MessagePathHelper.isMessagesFile(""), equalTo(false));
-    }
-
-    @Test
-    public void shouldReturnLanguageForMessagesFile() {
-        // given / when / then
-        assertThat(MessagePathHelper.getLanguageIfIsMessagesFile("messages_nl.yml"), equalTo("nl"));
-        assertThat(MessagePathHelper.getLanguageIfIsMessagesFile("messages_testtest.yml"), equalTo("testtest"));
-
-        assertThat(MessagePathHelper.getLanguageIfIsMessagesFile("messages/messages_fr.yml"), nullValue());
-        assertThat(MessagePathHelper.getLanguageIfIsMessagesFile("Messages_fr.yml"), nullValue());
-        assertThat(MessagePathHelper.getLanguageIfIsMessagesFile("otherfile.txt"), nullValue());
-        assertThat(MessagePathHelper.getLanguageIfIsMessagesFile("messages_de.txt"), nullValue());
-        assertThat(MessagePathHelper.getLanguageIfIsMessagesFile(""), nullValue());
-    }
-
-    @Test
-    public void shouldRecognizeIfIsHelpFile() {
-        // given / when / then
-        assertThat(MessagePathHelper.isHelpFile("help_nl.yml"), equalTo(true));
-        assertThat(MessagePathHelper.isHelpFile("help_testtest.yml"), equalTo(true));
-
-        assertThat(MessagePathHelper.isHelpFile("messages/help_fr.yml"), equalTo(false));
-        assertThat(MessagePathHelper.isHelpFile("Help_fr.yml"), equalTo(false));
-        assertThat(MessagePathHelper.isHelpFile("otherfile.txt"), equalTo(false));
-        assertThat(MessagePathHelper.isHelpFile("help_de.txt"), equalTo(false));
-        assertThat(MessagePathHelper.isHelpFile(""), equalTo(false));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/MessagesFileConsistencyTest.java b/src/test/java/fr/xephi/authme/message/MessagesFileConsistencyTest.java
deleted file mode 100644
index 5243528f..00000000
--- a/src/test/java/fr/xephi/authme/message/MessagesFileConsistencyTest.java
+++ /dev/null
@@ -1,61 +0,0 @@
-package fr.xephi.authme.message;
-
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileReader;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.util.StringUtils;
-import org.junit.Test;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.junit.Assert.fail;
-
-/**
- * Tests that the project's default language file contains a text for all message keys.
- * <p>
- * Translators can change the file name in {@link #MESSAGES_FILE} to validate their translation.
- */
-public class MessagesFileConsistencyTest {
-
-    private static final String MESSAGES_FILE = MessagePathHelper.DEFAULT_MESSAGES_FILE;
-
-    @Test
-    public void shouldHaveAllMessages() {
-        File file = TestHelper.getJarFile("/" + MESSAGES_FILE);
-        PropertyReader reader = new YamlFileReader(file);
-        List<String> errors = new ArrayList<>();
-        for (MessageKey messageKey : MessageKey.values()) {
-            validateMessage(messageKey, reader, errors);
-        }
-
-        if (!errors.isEmpty()) {
-            fail("Validation errors in " + MESSAGES_FILE + ":\n- "
-                + String.join("\n- ", errors));
-        }
-    }
-
-    private static void validateMessage(MessageKey messageKey, PropertyReader reader, List<String> errors) {
-        final String key = messageKey.getKey();
-        final String message = reader.getString(key);
-
-        if (StringUtils.isBlank(message)) {
-            errors.add("Messages file should have message for key '" + key + "'");
-            return;
-        }
-
-        List<String> missingTags = new ArrayList<>();
-        for (String tag : messageKey.getTags()) {
-            if (!message.contains(tag)) {
-                missingTags.add(tag);
-            }
-        }
-
-        if (!missingTags.isEmpty()) {
-            String pluralS = missingTags.size() > 1 ? "s" : "";
-            errors.add(String.format("Message with key '%s' missing tag%s: %s", key, pluralS,
-                String.join(", ", missingTags)));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/MessagesIntegrationTest.java b/src/test/java/fr/xephi/authme/message/MessagesIntegrationTest.java
deleted file mode 100644
index bc1e9769..00000000
--- a/src/test/java/fr/xephi/authme/message/MessagesIntegrationTest.java
+++ /dev/null
@@ -1,318 +0,0 @@
-package fr.xephi.authme.message;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.io.Files;
-import fr.xephi.authme.ConsoleLogger;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.message.updater.MessageUpdater;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.util.FileUtils;
-import fr.xephi.authme.util.expiring.Duration;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.AfterClass;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mockito;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-import java.util.logging.Logger;
-
-import static org.hamcrest.Matchers.arrayWithSize;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsString;
-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.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link Messages}.
- */
-public class MessagesIntegrationTest {
-
-    private static final String TEST_MESSAGES_LOCAL_PATH = "message/messages_test.yml";
-    private static final String YML_TEST_FILE = TestHelper.PROJECT_ROOT + TEST_MESSAGES_LOCAL_PATH;
-    private Messages messages;
-    private MessagesFileHandler messagesFileHandler;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-    private File dataFolder;
-
-    @BeforeClass
-    public static void setup() {
-        TestHelper.setupLogger();
-    }
-
-    /**
-     * Loads the messages in the file {@code messages_test.yml} in the test resources folder.
-     * The file does not contain all messages defined in {@link MessageKey} and its contents
-     * reflect various test cases -- not what the keys stand for.
-     * <p>
-     * Similarly, the {@code messages_default.yml} from the test resources represents a default
-     * file that should contain all messages, but again, for testing, it just contains a few.
-     */
-    @Before
-    public void setUpMessages() throws IOException {
-        dataFolder = temporaryFolder.newFolder();
-        File testFile = new File(dataFolder, MessagePathHelper.createMessageFilePath("test"));
-        new File(dataFolder, MessagePathHelper.MESSAGES_FOLDER).mkdirs();
-        FileUtils.create(testFile);
-        Files.copy(TestHelper.getJarFile(YML_TEST_FILE), testFile);
-
-        messagesFileHandler = createMessagesFileHandler();
-        messages = new Messages(messagesFileHandler);
-    }
-
-    @AfterClass
-    public static void removeLoggerReferences() {
-        ConsoleLogger.initialize(null, null);
-    }
-
-    @Test
-    public void shouldLoadMessageAndSplitAtNewLines() {
-        // given
-        MessageKey key = MessageKey.UNKNOWN_USER;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        String[] message = messages.retrieve(key, sender);
-
-        // then
-        String[] lines = new String[]{"We've got", "new lines", "and ' apostrophes"};
-        assertThat(message, equalTo(lines));
-    }
-
-    @Test
-    public void shouldLoadMessageAsStringWithNewLines() {
-        // given
-        MessageKey key = MessageKey.UNKNOWN_USER;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        String message = messages.retrieveSingle(sender, key);
-
-        // then
-        assertThat(message, equalTo("We've got\nnew lines\nand ' apostrophes"));
-    }
-
-    @Test
-    public void shouldFormatColorCodes() {
-        // given
-        MessageKey key = MessageKey.LOGIN_SUCCESS;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        String[] message = messages.retrieve(key, sender);
-
-        // then
-        assertThat(message, arrayWithSize(1));
-        assertThat(message[0], equalTo("§cHere we have§bdefined some colors §dand some other §lthings"));
-    }
-
-    @Test
-    public void shouldNotSendEmptyMessage() {
-        // given
-        MessageKey key = MessageKey.EMAIL_ALREADY_USED_ERROR;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        messages.send(sender, key);
-
-        // then
-        verify(sender, never()).sendMessage(anyString());
-    }
-
-    @Test
-    public void shouldSendMessageToPlayer() {
-        // given
-        MessageKey key = MessageKey.LOGIN_SUCCESS;
-        Player player = Mockito.mock(Player.class);
-        given(player.getName()).willReturn("Tester");
-        given(player.getDisplayName()).willReturn("§cTesty");
-
-        // when
-        messages.send(player, key);
-
-        // then
-        verify(player).sendMessage("§cHere we have§bdefined some colors §dand some other §lthings");
-    }
-
-    @Test
-    public void shouldSendMultiLineMessageToPlayer() {
-        // given
-        MessageKey key = MessageKey.UNKNOWN_USER;
-        Player player = Mockito.mock(Player.class);
-        given(player.getName()).willReturn("Tester");
-        given(player.getDisplayName()).willReturn("§cTesty");
-
-        // when
-        messages.send(player, key);
-
-        // then
-        String[] lines = new String[]{"We've got", "new lines", "and ' apostrophes"};
-        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
-        verify(player, times(3)).sendMessage(captor.capture());
-        assertThat(captor.getAllValues(), contains(lines));
-    }
-
-    @Test
-    public void shouldSendMessageToPlayerWithNameReplacement() {
-        // given
-        MessageKey key = MessageKey.REGISTER_MESSAGE;
-        Player player = Mockito.mock(Player.class);
-        given(player.getName()).willReturn("Tester");
-        given(player.getDisplayName()).willReturn("§cTesty");
-
-        // when
-        messages.send(player, key);
-
-        // then
-        verify(player).sendMessage("§3Please Tester, register to the §cTesty§3.");
-    }
-
-    @Test
-    public void shouldSendMessageToPlayerWithTagReplacement() {
-        // given
-        MessageKey key = MessageKey.CAPTCHA_WRONG_ERROR;
-        CommandSender sender = Mockito.mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        messages.send(sender, key, "1234");
-
-        // then
-        verify(sender, times(1)).sendMessage("Use /captcha 1234 to solve the captcha");
-    }
-
-    @Test
-    public void shouldNotLogErrorForKeyWithNoTagReplacements() {
-        // given
-        MessageKey key = MessageKey.CAPTCHA_WRONG_ERROR;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        messages.send(sender, key);
-
-        // then
-        verify(sender).sendMessage("Use /captcha %captcha_code to solve the captcha");
-    }
-
-    @Test
-    public void shouldLogErrorForInvalidReplacementCount() {
-        // given
-        Logger logger = mock(Logger.class);
-        ConsoleLogger.initialize(logger, null);
-        MessageKey key = MessageKey.CAPTCHA_WRONG_ERROR;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        messages.send(sender, key, "rep", "rep2");
-
-        // then
-        verify(logger).warning(argThat(containsString("Invalid number of replacements")));
-    }
-
-    @Test
-    public void shouldSendErrorForReplacementsOnKeyWithNoTags() {
-        // given
-        Logger logger = mock(Logger.class);
-        ConsoleLogger.initialize(logger, null);
-        MessageKey key = MessageKey.UNKNOWN_USER;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        messages.send(sender, key, "Replacement");
-
-        // then
-        verify(logger).warning(argThat(containsString("Invalid number of replacements")));
-    }
-
-    @Test
-    public void shouldNotUseMessageFromDefaultFile() {
-        // given
-        // Key is present in both files
-        MessageKey key = MessageKey.WRONG_PASSWORD;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        String message = messages.retrieveSingle(sender, key);
-
-        // then
-        assertThat(message, equalTo("§cWrong password!"));
-    }
-
-    @Test
-    public void shouldRetrieveMessageWithReplacements() {
-        // given
-        MessageKey key = MessageKey.CAPTCHA_WRONG_ERROR;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.getName()).willReturn("Tester");
-
-        // when
-        String result = messages.retrieveSingle(sender.getName(), key, "24680");
-
-        // then
-        assertThat(result, equalTo("Use /captcha 24680 to solve the captcha"));
-    }
-
-    @Test
-    public void shouldFormatDurationObjects() throws IOException {
-        // given
-        // Use the JAR's messages_en.yml file for this, so copy to the file we're using and reload the file handler
-        File testFile = new File(dataFolder, MessagePathHelper.createMessageFilePath("test"));
-        Files.copy(TestHelper.getJarFile("/" + MessagePathHelper.DEFAULT_MESSAGES_FILE), testFile);
-        messagesFileHandler.reload();
-
-        Map<Duration, String> expectedTexts = ImmutableMap.<Duration, String>builder()
-            .put(new Duration(1, TimeUnit.SECONDS), "1 second")
-            .put(new Duration(12, TimeUnit.SECONDS), "12 seconds")
-            .put(new Duration(1, TimeUnit.MINUTES), "1 minute")
-            .put(new Duration(0, TimeUnit.MINUTES), "0 minutes")
-            .put(new Duration(1, TimeUnit.HOURS), "1 hour")
-            .put(new Duration(-4, TimeUnit.HOURS), "-4 hours")
-            .put(new Duration(1, TimeUnit.DAYS), "1 day")
-            .put(new Duration(44, TimeUnit.DAYS), "44 days")
-            .build();
-
-        // when / then
-        for (Map.Entry<Duration, String> entry : expectedTexts.entrySet()) {
-            assertThat(messages.formatDuration(entry.getKey()), equalTo(entry.getValue()));
-        }
-    }
-
-    private MessagesFileHandler createMessagesFileHandler() {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(PluginSettings.MESSAGES_LANGUAGE)).willReturn("test");
-
-        MessagesFileHandler messagesFileHandler = new MessagesFileHandler();
-        ReflectionTestUtils.setField(AbstractMessageFileHandler.class, messagesFileHandler, "settings", settings);
-        ReflectionTestUtils.setField(AbstractMessageFileHandler.class, messagesFileHandler, "dataFolder", dataFolder);
-        ReflectionTestUtils.setField(MessagesFileHandler.class, messagesFileHandler, "messageUpdater", mock(MessageUpdater.class));
-        ReflectionTestUtils.invokePostConstructMethods(messagesFileHandler);
-        return messagesFileHandler;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/YamlTextFileCheckerTest.java b/src/test/java/fr/xephi/authme/message/YamlTextFileCheckerTest.java
deleted file mode 100644
index 59c7b1b5..00000000
--- a/src/test/java/fr/xephi/authme/message/YamlTextFileCheckerTest.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package fr.xephi.authme.message;
-
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileReader;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.command.help.HelpSection;
-import fr.xephi.authme.util.ExceptionUtils;
-import fr.xephi.authme.util.StringUtils;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Predicate;
-
-import static fr.xephi.authme.message.MessagePathHelper.MESSAGES_FOLDER;
-import static org.junit.Assert.fail;
-import static tools.utils.FileIoUtils.listFilesOrThrow;
-
-/**
- * Tests that all YML text files can be loaded.
- */
-public class YamlTextFileCheckerTest {
-
-    /** Contains all files of the MESSAGES_FOLDER. */
-    private static File[] messageFiles;
-
-    @BeforeClass
-    public static void loadMessagesFiles() {
-        File folder = TestHelper.getJarFile("/" + MESSAGES_FOLDER);
-        messageFiles = listFilesOrThrow(folder);
-    }
-
-    @Test
-    public void testAllMessagesYmlFiles() {
-        checkFiles(
-            MessagePathHelper::isMessagesFile,
-            MessageKey.LOGIN_MESSAGE.getKey());
-    }
-
-    @Test
-    public void testAllHelpYmlFiles() {
-        checkFiles(
-            MessagePathHelper::isHelpFile,
-            HelpSection.ALTERNATIVES.getKey());
-    }
-
-    /**
-     * Checks all files in the messages folder that match the given pattern.
-     *
-     * @param isRelevantFilePredicate predicate determining which files should be tested
-     * @param mandatoryKey key present in all matched files
-     */
-    private void checkFiles(Predicate<String> isRelevantFilePredicate, String mandatoryKey) {
-        List<String> errors = new ArrayList<>();
-
-        boolean hasMatch = false;
-        for (File file : messageFiles) {
-            if (isRelevantFilePredicate.test(file.getName())) {
-                checkFile(file, mandatoryKey, errors);
-                hasMatch = true;
-            }
-        }
-
-        if (!errors.isEmpty()) {
-            fail("Errors while checking files\n-" + String.join("\n-", errors));
-        } else if (!hasMatch) {
-            fail("Could not find any files matching criteria");
-        }
-    }
-
-    /**
-     * Checks that the provided YAML file can be loaded and that it contains a non-empty text
-     * for the provided mandatory key.
-     *
-     * @param file the file to check
-     * @param mandatoryKey the key for which text must be present
-     * @param errors collection of errors to add to if the verification fails
-     */
-    private void checkFile(File file, String mandatoryKey, List<String> errors) {
-        try {
-            PropertyReader reader = new YamlFileReader(file);
-            if (StringUtils.isBlank(reader.getString(mandatoryKey))) {
-                errors.add("Message for '" + mandatoryKey + "' is empty");
-            }
-        } catch (Exception e) {
-            errors.add("Could not load file: " + ExceptionUtils.formatException(e));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/updater/MessageUpdaterTest.java b/src/test/java/fr/xephi/authme/message/updater/MessageUpdaterTest.java
deleted file mode 100644
index eac3b67e..00000000
--- a/src/test/java/fr/xephi/authme/message/updater/MessageUpdaterTest.java
+++ /dev/null
@@ -1,149 +0,0 @@
-package fr.xephi.authme.message.updater;
-
-import ch.jalu.configme.properties.Property;
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileReader;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.message.MessageKey;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.message.MessagePathHelper.DEFAULT_MESSAGES_FILE;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link MessageUpdater}.
- */
-public class MessageUpdaterTest {
-
-    private MessageUpdater messageUpdater = new MessageUpdater();
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldNotUpdateDefaultFile() throws IOException {
-        // given
-        String messagesFilePath = DEFAULT_MESSAGES_FILE;
-        File messagesFile = temporaryFolder.newFile();
-        Files.copy(TestHelper.getJarFile("/" + messagesFilePath), messagesFile);
-        long modifiedDate = messagesFile.lastModified();
-
-        // when
-        boolean wasChanged = messageUpdater.migrateAndSave(messagesFile, messagesFilePath, messagesFilePath);
-
-        // then
-        assertThat(wasChanged, equalTo(false));
-        assertThat(messagesFile.lastModified(), equalTo(modifiedDate));
-    }
-    
-    @Test
-    public void shouldAddMissingKeys() throws IOException {
-        // given
-        File messagesFile = temporaryFolder.newFile();
-        Files.copy(TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "message/messages_test.yml"), messagesFile);
-        
-        // when
-        boolean wasChanged = messageUpdater.migrateAndSave(messagesFile, "does-not-exist", DEFAULT_MESSAGES_FILE);
-
-        // then
-        assertThat(wasChanged, equalTo(true));
-        PropertyReader reader = new YamlFileReader(messagesFile);
-        // Existing keys should not be overridden
-        assertThat(reader.getString(MessageKey.LOGIN_SUCCESS.getKey()), equalTo("&cHere we have&bdefined some colors &dand some other &lthings"));
-        assertThat(reader.getString(MessageKey.EMAIL_ALREADY_USED_ERROR.getKey()), equalTo(""));
-        // Check that new keys were added
-        assertThat(reader.getString(MessageKey.SECOND.getKey()), equalTo("second"));
-        assertThat(reader.getString(MessageKey.ERROR.getKey()), equalTo("&4An unexpected error occurred, please contact an administrator!"));
-    }
-
-    @Test
-    public void shouldMigrateOldEntries() throws IOException {
-        // given
-        File messagesFile = temporaryFolder.newFile();
-        Files.copy(TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "message/messages_en_old.yml"), messagesFile);
-
-        // when
-        boolean wasChanged = messageUpdater.migrateAndSave(messagesFile, DEFAULT_MESSAGES_FILE, DEFAULT_MESSAGES_FILE);
-
-        // then
-        assertThat(wasChanged, equalTo(true));
-        PropertyReader reader = new YamlFileReader(messagesFile);
-        assertThat(reader.getString(MessageKey.PASSWORD_MATCH_ERROR.getKey()),
-            equalTo("Password error message"));
-        assertThat(reader.getString(MessageKey.INVALID_NAME_CHARACTERS.getKey()),
-            equalTo("not valid username: Allowed chars are %valid_chars"));
-        assertThat(reader.getString(MessageKey.INVALID_OLD_EMAIL.getKey()),
-            equalTo("Email (old) is not valid!!"));
-        assertThat(reader.getString(MessageKey.CAPTCHA_WRONG_ERROR.getKey()),
-            equalTo("The captcha code is %captcha_code for you"));
-        assertThat(reader.getString(MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED.getKey()),
-            equalTo("Now type /captcha %captcha_code"));
-        assertThat(reader.getString(MessageKey.SECONDS.getKey()),
-            equalTo("seconds in plural"));
-    }
-
-    @Test
-    public void shouldPerformNewerMigrations() throws IOException {
-        // given
-        File messagesFile = temporaryFolder.newFile();
-        Files.copy(TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "message/messages_test2.yml"), messagesFile);
-
-        // when
-        boolean wasChanged = messageUpdater.migrateAndSave(messagesFile, DEFAULT_MESSAGES_FILE, DEFAULT_MESSAGES_FILE);
-
-        // then
-        assertThat(wasChanged, equalTo(true));
-        PropertyReader reader = new YamlFileReader(messagesFile);
-        assertThat(reader.getString(MessageKey.TWO_FACTOR_CREATE.getKey()), equalTo("Old 2fa create text"));
-        assertThat(reader.getString(MessageKey.WRONG_PASSWORD.getKey()), equalTo("test2 - wrong password")); // from pre-5.5 key
-        assertThat(reader.getString(MessageKey.SECOND.getKey()), equalTo("second")); // from messages_en.yml
-    }
-
-    @Test
-    public void shouldHaveAllKeysInConfigurationData() {
-        // given
-        Set<String> messageKeysFromEnum = Arrays.stream(MessageKey.values())
-            .map(MessageKey::getKey)
-            .collect(Collectors.toSet());
-
-        // when
-        Set<String> messageKeysFromConfigData = MessageUpdater.createConfigurationData().getProperties().stream()
-            .map(Property::getPath)
-            .collect(Collectors.toSet());
-
-        // then
-        assertThat(messageKeysFromConfigData, equalTo(messageKeysFromEnum));
-    }
-
-    @Test
-    public void shouldHaveCommentForAllRootPathsInConfigurationData() {
-        // given
-        Set<String> rootPaths = Arrays.stream(MessageKey.values())
-            .map(key -> key.getKey().split("\\.")[0])
-            .collect(Collectors.toSet());
-
-        // when
-        Map<String, List<String>> comments = MessageUpdater.createConfigurationData().getAllComments();
-
-        // then
-        assertThat(comments.keySet(), equalTo(rootPaths));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/updater/MigraterYamlFileResourceTest.java b/src/test/java/fr/xephi/authme/message/updater/MigraterYamlFileResourceTest.java
deleted file mode 100644
index 03d79e71..00000000
--- a/src/test/java/fr/xephi/authme/message/updater/MigraterYamlFileResourceTest.java
+++ /dev/null
@@ -1,75 +0,0 @@
-package fr.xephi.authme.message.updater;
-
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
-import ch.jalu.configme.properties.Property;
-import ch.jalu.configme.properties.StringProperty;
-import ch.jalu.configme.resource.PropertyReader;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link MigraterYamlFileResource}.
- */
-public class MigraterYamlFileResourceTest {
-
-    private static final String CHINESE_MESSAGES_FILE = TestHelper.PROJECT_ROOT + "message/chinese_texts.yml";
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @Test
-    public void shouldReadChineseFile() {
-        // given
-        File file = TestHelper.getJarFile(CHINESE_MESSAGES_FILE);
-        MigraterYamlFileResource resource = new MigraterYamlFileResource(file);
-
-        // when
-        PropertyReader reader = resource.createReader();
-
-        // then
-        assertThat(reader.getString("first"), equalTo("错误的密码"));
-        assertThat(reader.getString("second"), equalTo("为了验证您的身份，您需要将一个电子邮件地址与您的帐户绑定！"));
-        assertThat(reader.getString("third"), equalTo("您已经可以在当前会话中执行任何敏感命令！"));
-    }
-
-    @Test
-    public void shouldWriteWithCorrectCharset() throws IOException {
-        // given
-        File file = temporaryFolder.newFile();
-        Files.copy(TestHelper.getJarFile(CHINESE_MESSAGES_FILE), file);
-        MigraterYamlFileResource resource = new MigraterYamlFileResource(file);
-        ConfigurationData configurationData = buildConfigurationData();
-        configurationData.initializeValues(resource.createReader());
-        String newMessage = "您当前并没有任何邮箱与该账号绑定";
-        configurationData.setValue(new StringProperty("third", ""), newMessage);
-
-        // when
-        resource.exportProperties(configurationData);
-
-        // then
-        PropertyReader reader = resource.createReader();
-        assertThat(reader.getString("first"), equalTo("错误的密码"));
-        assertThat(reader.getString("second"), equalTo("为了验证您的身份，您需要将一个电子邮件地址与您的帐户绑定！"));
-        assertThat(reader.getString("third"), equalTo(newMessage));
-    }
-
-    private static ConfigurationData buildConfigurationData() {
-        List<Property<String>> properties = Arrays.asList(
-            new StringProperty("first", "first"),
-            new StringProperty("second", "second"),
-            new StringProperty("third", "third"));
-        return ConfigurationDataBuilder.createConfiguration(properties);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/message/updater/OldMessageKeysMigraterTest.java b/src/test/java/fr/xephi/authme/message/updater/OldMessageKeysMigraterTest.java
deleted file mode 100644
index be10559e..00000000
--- a/src/test/java/fr/xephi/authme/message/updater/OldMessageKeysMigraterTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-package fr.xephi.authme.message.updater;
-
-import fr.xephi.authme.message.MessageKey;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link OldMessageKeysMigrater}.
- */
-public class OldMessageKeysMigraterTest {
-
-    @Test
-    public void shouldHasOldKeysThatAreNewParentsFirstInMap() {
-        // given
-        Set<String> parentPaths = collectParentPathsFromMessageKeys();
-        Set<String> encounteredParents = new HashSet<>();
-
-        // when / then
-        for (Map.Entry<MessageKey, String> entry : OldMessageKeysMigrater.KEYS_TO_OLD_PATH.entrySet()) {
-            if (parentPaths.contains(entry.getValue()) && encounteredParents.contains(entry.getValue())) {
-                fail("Entry migrating old path '" + entry.getValue()
-                    + "' should come before any new paths with it as parent");
-            }
-            String parent = entry.getKey().getKey().split("\\.")[0];
-            encounteredParents.add(parent);
-        }
-    }
-
-    private Set<String> collectParentPathsFromMessageKeys() {
-        return Arrays.stream(MessageKey.values())
-            .map(mk -> mk.getKey().split("\\.")[0])
-            .collect(Collectors.toSet());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/output/ConsoleFilterTest.java b/src/test/java/fr/xephi/authme/output/ConsoleFilterTest.java
deleted file mode 100644
index 8975068f..00000000
--- a/src/test/java/fr/xephi/authme/output/ConsoleFilterTest.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package fr.xephi.authme.output;
-
-import org.junit.Test;
-import org.mockito.Mockito;
-
-import java.util.logging.LogRecord;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-/**
- * Test for {@link ConsoleFilter}.
- */
-public class ConsoleFilterTest {
-
-    private final ConsoleFilter filter = new ConsoleFilter();
-
-    private static final String SENSITIVE_COMMAND = "User issued server command: /login test test";
-    private static final String NORMAL_COMMAND = "User issued server command: /motd 2";
-
-
-    @Test
-    public void shouldReplaceSensitiveRecord() {
-        // given
-        LogRecord record = createRecord(SENSITIVE_COMMAND);
-
-        // when
-        boolean result = filter.isLoggable(record);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(record).setMessage("User issued an AuthMe command");
-    }
-
-    @Test
-    public void shouldNotFilterRegularCommand() {
-        // given
-        LogRecord record = createRecord(NORMAL_COMMAND);
-
-        // when
-        boolean result = filter.isLoggable(record);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(record, never()).setMessage("User issued an AuthMe command");
-    }
-
-    @Test
-    public void shouldManageRecordWithNullMessage() {
-        // given
-        LogRecord record = createRecord(null);
-
-        // when
-        boolean result = filter.isLoggable(record);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(record, never()).setMessage("User issued an AuthMe command");
-    }
-
-
-    /**
-     * Creates a mock of {@link LogRecord} and sets it to return the given message.
-     *
-     * @param message The message to set.
-     *
-     * @return Mock of LogRecord
-     */
-    private static LogRecord createRecord(String message) {
-        LogRecord record = Mockito.mock(LogRecord.class);
-        when(record.getMessage()).thenReturn(message);
-        return record;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/output/ConsoleLoggerFactoryTest.java b/src/test/java/fr/xephi/authme/output/ConsoleLoggerFactoryTest.java
deleted file mode 100644
index fe53383b..00000000
--- a/src/test/java/fr/xephi/authme/output/ConsoleLoggerFactoryTest.java
+++ /dev/null
@@ -1,93 +0,0 @@
-package fr.xephi.authme.output;
-
-import fr.xephi.authme.AuthMe;
-import fr.xephi.authme.ConsoleLogger;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.junit.After;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.Map;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.sameInstance;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link ConsoleLoggerFactory}.
- */
-public class ConsoleLoggerFactoryTest {
-
-    @BeforeClass
-    public static void initLogger() {
-        removeSettingsAndClearMap();
-        TestHelper.setupLogger();
-    }
-
-    @After
-    public void resetConsoleLoggerFactoryToDefaults() {
-        removeSettingsAndClearMap();
-    }
-
-    private static void removeSettingsAndClearMap() {
-        setSettings(null);
-        getConsoleLoggerMap().clear();
-    }
-
-    @Test
-    public void shouldCreateLoggerWithProperNameAndDefaultLogLevel() {
-        // given / when
-        ConsoleLogger logger = ConsoleLoggerFactory.get(AuthMe.class);
-
-        // then
-        assertThat(logger.getName(), equalTo("fr.xephi.authme.AuthMe"));
-        assertThat(logger.getLogLevel(), equalTo(LogLevel.INFO));
-        assertThat(getConsoleLoggerMap().keySet(), contains("fr.xephi.authme.AuthMe"));
-    }
-
-    @Test
-    public void shouldReturnSameInstanceForName() {
-        // given / when
-        ConsoleLogger logger1 = ConsoleLoggerFactory.get(String.class);
-        ConsoleLogger logger2 = ConsoleLoggerFactory.get(Number.class);
-        ConsoleLogger logger3 = ConsoleLoggerFactory.get(String.class);
-
-        // then
-        assertThat(ConsoleLoggerFactory.getTotalLoggers(), equalTo(2));
-        assertThat(logger3, sameInstance(logger1));
-        assertThat(logger2, not(sameInstance(logger1)));
-    }
-
-    @Test
-    public void shouldInitializeAccordingToSettings() {
-        // given
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(PluginSettings.LOG_LEVEL)).willReturn(LogLevel.FINE);
-        given(settings.getProperty(SecuritySettings.USE_LOGGING)).willReturn(false);
-        ConsoleLogger existingLogger = ConsoleLoggerFactory.get(String.class);
-
-        // when
-        ConsoleLoggerFactory.reloadSettings(settings);
-        ConsoleLogger newLogger = ConsoleLoggerFactory.get(AuthMe.class);
-
-        // then
-        assertThat(existingLogger.getLogLevel(), equalTo(LogLevel.FINE));
-        assertThat(newLogger.getLogLevel(), equalTo(LogLevel.FINE));
-    }
-
-    private static void setSettings(Settings settings) {
-        ReflectionTestUtils.setField(ConsoleLoggerFactory.class, null, "settings", settings);
-    }
-
-    private static Map<String, ConsoleLogger> getConsoleLoggerMap() {
-        return ReflectionTestUtils.getFieldValue(ConsoleLoggerFactory.class, null, "consoleLoggers");
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/output/Log4JFilterTest.java b/src/test/java/fr/xephi/authme/output/Log4JFilterTest.java
deleted file mode 100644
index 91228c5f..00000000
--- a/src/test/java/fr/xephi/authme/output/Log4JFilterTest.java
+++ /dev/null
@@ -1,233 +0,0 @@
-package fr.xephi.authme.output;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.when;
-
-import org.apache.logging.log4j.Level;
-import org.apache.logging.log4j.Marker;
-import org.apache.logging.log4j.core.Filter.Result;
-import org.apache.logging.log4j.core.LogEvent;
-import org.apache.logging.log4j.core.Logger;
-import org.apache.logging.log4j.message.Message;
-import org.junit.Test;
-import org.mockito.Mockito;
-
-/**
- * Test for {@link Log4JFilter}.
- */
-public class Log4JFilterTest {
-	
-	private final Log4JFilter log4JFilter = new Log4JFilter();
-	
-	private static final String SENSITIVE_COMMAND = "User issued server command: /login pass pass";
-	private static final String NORMAL_COMMAND = "User issued server command: /help";
-	private static final String OTHER_COMMAND = "Starting the server... Write /l for logs";
-
-	// ---------
-	// Test the filter(LogEvent) method
-	// ---------
-	@Test
-	public void shouldFilterSensitiveLogEvent() {
-		// given
-		Message message = mockMessage(SENSITIVE_COMMAND);
-		LogEvent event = Mockito.mock(LogEvent.class);
-		when(event.getMessage()).thenReturn(message);
-		
-		// when
-		Result result = log4JFilter.filter(event);
-		
-		// then
-		assertThat(result, equalTo(Result.DENY));
-	}
-	
-	@Test
-	public void shouldNotFilterIrrelevantLogEvent() {
-		// given
-		Message message = mockMessage(NORMAL_COMMAND);
-		LogEvent event = Mockito.mock(LogEvent.class);
-		when(event.getMessage()).thenReturn(message);
-		
-		// when
-		Result result = log4JFilter.filter(event);
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterNonCommandLogEvent() {
-		// given
-		Message message = mockMessage(OTHER_COMMAND);
-		LogEvent event = Mockito.mock(LogEvent.class);
-		when(event.getMessage()).thenReturn(message);
-		
-		// when
-		Result result = log4JFilter.filter(event);
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterLogEventWithNullMessage() {
-		// given
-		Message message = mockMessage(null);
-		LogEvent event = Mockito.mock(LogEvent.class);
-		when(event.getMessage()).thenReturn(message);
-		
-		// when
-		Result result = log4JFilter.filter(event);
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterWhenLogEventIsNull() {
-		// given / when
-		Result result = log4JFilter.filter(null);
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	// ----------
-	// Test filter(Logger, Level, Marker, String, Object...)
-	// ----------
-	@Test
-	public void shouldFilterSensitiveStringMessage() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, SENSITIVE_COMMAND);
-		
-		// then
-		assertThat(result, equalTo(Result.DENY));
-	}
-	
-	@Test
-	public void shouldNotFilterNormalStringMessage() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, NORMAL_COMMAND);
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterNonCommandStringMessage() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, OTHER_COMMAND);
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldReturnNeutralForNullMessage() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, null);
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	// --------
-	// Test filter(Logger, Level, Marker, Object, Throwable)
-	// --------
-	@Test
-	public void shouldFilterSensitiveObjectMessage() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, (Object) SENSITIVE_COMMAND, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.DENY));
-	}
-	
-	@Test
-	public void shouldNotFilterNullObjectParam() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, (Object) null, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterIrrelevantMessage() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, (Object) OTHER_COMMAND, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterNonSensitiveCommand() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, (Object) NORMAL_COMMAND, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	// --------
-	// Test filter(Logger, Level, Marker, Message, Throwable)
-	// --------
-	@Test
-	public void shouldFilterSensitiveMessage() {
-		// given
-		Message message = mockMessage(SENSITIVE_COMMAND);
-		
-		// when
-		Result result = log4JFilter.filter(null, null, null, message, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.DENY));
-	}
-	
-	@Test
-	public void shouldNotFilterNonSensitiveMessage() {
-		// given
-		Message message = mockMessage(NORMAL_COMMAND);
-		
-		// when
-		Result result = log4JFilter.filter(null, null, null, message, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterNonCommandMessage() {
-		// given
-		Message message = mockMessage(OTHER_COMMAND);
-		
-		// when
-		Result result = log4JFilter.filter(null, null, null, message, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	@Test
-	public void shouldNotFilterNullMessage() {
-		// given / when
-		Result result = log4JFilter.filter(null, null, null, (Object) null, new Exception());
-		
-		// then
-		assertThat(result, equalTo(Result.NEUTRAL));
-	}
-	
-	/**
-	 * Mocks a {@link Message} object and makes it return the given formatted message.
-	 *
-	 * @param formattedMessage the formatted message the mock should return
-	 * @return Message mock
-     */
-	private static Message mockMessage(String formattedMessage) {
-		Message message = Mockito.mock(Message.class);
-		when(message.getFormattedMessage()).thenReturn(formattedMessage);
-		return message;
-	}
-
-}
diff --git a/src/test/java/fr/xephi/authme/output/LogFilterHelperTest.java b/src/test/java/fr/xephi/authme/output/LogFilterHelperTest.java
deleted file mode 100644
index 302345fb..00000000
--- a/src/test/java/fr/xephi/authme/output/LogFilterHelperTest.java
+++ /dev/null
@@ -1,89 +0,0 @@
-package fr.xephi.authme.output;
-
-import com.google.common.collect.Lists;
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.CommandInitializer;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link LogFilterHelper}.
- */
-public class LogFilterHelperTest {
-
-    private static final List<CommandDescription> ALL_COMMANDS = new CommandInitializer().getCommands();
-
-    /**
-     * Checks that {@link LogFilterHelper#COMMANDS_TO_SKIP} contains the entries we expect
-     * (commands with password argument).
-     */
-    @Test
-    public void shouldBlacklistAllSensitiveCommands() {
-        // given
-        List<CommandDescription> sensitiveCommands = Arrays.asList(
-            getCommand("register"), getCommand("login"), getCommand("changepassword"), getCommand("unregister"),
-            getCommand("authme", "register"), getCommand("authme", "changepassword"),
-            getCommand("email", "setpassword")
-        );
-        // Build array with entries like "/register ", "/authme cp ", "/authme changepass "
-        String[] expectedEntries = sensitiveCommands.stream()
-            .map(cmd -> buildCommandSyntaxes(cmd))
-            .flatMap(List::stream)
-            .map(syntax -> syntax + " ")
-            .toArray(String[]::new);
-
-        // when / then
-        assertThat(LogFilterHelper.COMMANDS_TO_SKIP, containsInAnyOrder(expectedEntries));
-
-    }
-
-    private static CommandDescription getCommand(String label) {
-        return findCommandWithLabel(label, ALL_COMMANDS);
-    }
-
-    private static CommandDescription getCommand(String parentLabel, String childLabel) {
-        CommandDescription parent = getCommand(parentLabel);
-        return findCommandWithLabel(childLabel, parent.getChildren());
-    }
-
-    private static CommandDescription findCommandWithLabel(String label, List<CommandDescription> commands) {
-        return commands.stream()
-            .filter(cmd -> cmd.getLabels().contains(label))
-            .findFirst().orElseThrow(() -> new IllegalArgumentException(label));
-    }
-
-    /**
-     * Returns all "command syntaxes" from which the given command can be reached.
-     * For example, the result might be a List containing "/authme changepassword", "/authme changepass",
-     * "/authme cp", "/authme:authme changepassword" etc.
-     *
-     * @param command the command to build syntaxes for
-     * @return command syntaxes
-     */
-    private static List<String> buildCommandSyntaxes(CommandDescription command) {
-        List<String> prefixes = getCommandPrefixes(command);
-
-        return command.getLabels()
-            .stream()
-            .map(label -> Lists.transform(prefixes, p -> p + label))
-            .flatMap(List::stream)
-            .collect(Collectors.toList());
-    }
-
-    private static List<String> getCommandPrefixes(CommandDescription command) {
-        if (command.getParent() == null) {
-            return Arrays.asList("/", "/authme:");
-        }
-        return command.getParent().getLabels()
-            .stream()
-            .map(label -> new String[]{"/" + label + " ", "/authme:" + label + " "})
-            .flatMap(Arrays::stream)
-            .collect(Collectors.toList());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/output/LogLevelTest.java b/src/test/java/fr/xephi/authme/output/LogLevelTest.java
deleted file mode 100644
index aa313ae7..00000000
--- a/src/test/java/fr/xephi/authme/output/LogLevelTest.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package fr.xephi.authme.output;
-
-import org.junit.Test;
-
-import static java.lang.String.format;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link LogLevel}.
- */
-public class LogLevelTest {
-
-    @Test
-    public void shouldIncludeProperLevels() {
-        checkLevelInclusion(LogLevel.INFO, true, false, false);
-        checkLevelInclusion(LogLevel.FINE, true, true, false);
-        checkLevelInclusion(LogLevel.DEBUG, true, true, true);
-    }
-
-    private void checkLevelInclusion(LogLevel level, boolean... expectedValues) {
-        LogLevel[] levels = LogLevel.values();
-        assertThat("Number of expected values corresponds to number of log levels",
-            expectedValues.length, equalTo(levels.length));
-        for (int i = 0; i < levels.length; ++i) {
-            assertThat(format("%s.includes(%s) should be %b", level, levels[i], expectedValues[i]),
-                level.includes(levels[i]), equalTo(expectedValues[i]));
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/permission/AbstractPermissionsEnumTest.java b/src/test/java/fr/xephi/authme/permission/AbstractPermissionsEnumTest.java
deleted file mode 100644
index 4b327ec4..00000000
--- a/src/test/java/fr/xephi/authme/permission/AbstractPermissionsEnumTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package fr.xephi.authme.permission;
-
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.junit.Assert.fail;
-
-/**
- * Has common tests for enums implementing {@link PermissionNode}.
- */
-public abstract class AbstractPermissionsEnumTest {
-
-    @Test
-    public void shouldAllStartWitRequiredPrefix() {
-        // given
-        String requiredPrefix = getRequiredPrefix();
-
-        // when/then
-        for (PermissionNode permission : getPermissionNodes()) {
-            if (!permission.getNode().startsWith(requiredPrefix)) {
-                fail("The permission '" + permission + "' does not start with the required prefix '"
-                    + requiredPrefix + "'");
-            }
-        }
-    }
-
-    @Test
-    public void shouldHaveUniqueNodes() {
-        // given
-        Set<String> nodes = new HashSet<>();
-
-        // when/then
-        for (PermissionNode permission : getPermissionNodes()) {
-            if (!nodes.add(permission.getNode())) {
-                fail("More than one enum value defines the node '" + permission.getNode() + "'");
-            }
-        }
-    }
-
-    /**
-     * @return the permission nodes to test
-     */
-    protected abstract PermissionNode[] getPermissionNodes();
-
-    /**
-     * @return text with which all permission nodes must start with
-     */
-    protected abstract String getRequiredPrefix();
-
-}
diff --git a/src/test/java/fr/xephi/authme/permission/AdminPermissionTest.java b/src/test/java/fr/xephi/authme/permission/AdminPermissionTest.java
deleted file mode 100644
index f3e4f1fd..00000000
--- a/src/test/java/fr/xephi/authme/permission/AdminPermissionTest.java
+++ /dev/null
@@ -1,18 +0,0 @@
-package fr.xephi.authme.permission;
-
-/**
- * Test for {@link AdminPermission}.
- */
-public class AdminPermissionTest extends AbstractPermissionsEnumTest {
-
-    @Override
-    protected PermissionNode[] getPermissionNodes() {
-        return AdminPermission.values();
-    }
-
-    @Override
-    protected String getRequiredPrefix() {
-        return "authme.admin.";
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/permission/DebugSectionPermissionsTest.java b/src/test/java/fr/xephi/authme/permission/DebugSectionPermissionsTest.java
deleted file mode 100644
index 3e0a9f01..00000000
--- a/src/test/java/fr/xephi/authme/permission/DebugSectionPermissionsTest.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package fr.xephi.authme.permission;
-
-/**
- * Test for {@link DebugSectionPermissions}.
- */
-public class DebugSectionPermissionsTest extends AbstractPermissionsEnumTest {
-
-    @Override
-    protected PermissionNode[] getPermissionNodes() {
-        return DebugSectionPermissions.values();
-    }
-
-    @Override
-    protected String getRequiredPrefix() {
-        return "authme.debug.";
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/permission/PermissionConsistencyTest.java b/src/test/java/fr/xephi/authme/permission/PermissionConsistencyTest.java
deleted file mode 100644
index 6d7a37e2..00000000
--- a/src/test/java/fr/xephi/authme/permission/PermissionConsistencyTest.java
+++ /dev/null
@@ -1,283 +0,0 @@
-package fr.xephi.authme.permission;
-
-import com.google.common.collect.ImmutableMap;
-import com.google.common.collect.ImmutableSet;
-import com.google.common.collect.Sets;
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import org.bukkit.configuration.MemorySection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.TestHelper.getJarFile;
-import static org.junit.Assert.fail;
-
-/**
- * Tests that the permissions listed in plugin.yml correspond to the ones in the code.
- */
-public class PermissionConsistencyTest {
-
-    /** Wildcard permissions (present in plugin.yml but not in the codebase). */
-    private static final Set<String> PLUGIN_YML_PERMISSIONS_WILDCARDS =
-        ImmutableSet.of("authme.admin.*", "authme.player.*", "authme.player.email", "authme.debug");
-
-    /** Name of the fields that make up a permission entry in plugin.yml. */
-    private static final Set<String> PERMISSION_FIELDS = ImmutableSet.of("description", "default", "children");
-
-    /** All classes defining permission nodes. */
-    private static List<Class<? extends PermissionNode>> permissionClasses;
-
-    /** All known PermissionNode objects. */
-    private static List<PermissionNode> permissionNodes;
-
-    /** All permissions listed in plugin.yml. */
-    private static Map<String, PermissionDefinition> pluginYmlPermissions;
-
-    @BeforeClass
-    public static void gatherPermissionNodes() {
-        permissionClasses = new ClassCollector(TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT + "permission")
-            .collectClasses(PermissionNode.class).stream()
-            .filter(clz -> !clz.isInterface())
-            .collect(Collectors.toList());
-        permissionNodes = getPermissionsFromClasses();
-        pluginYmlPermissions = getPermissionsFromPluginYmlFile();
-    }
-
-    @Test
-    public void shouldHaveAllPermissionsInPluginYml() {
-        // given
-        List<String> errors = new ArrayList<>();
-
-        // when
-        for (PermissionNode node : permissionNodes) {
-            PermissionDefinition permDef = pluginYmlPermissions.get(node.getNode());
-            if (permDef == null) {
-                errors.add("Permission '" + node.getNode() + "' does not exist in plugin.yml");
-            } else if (!node.getDefaultPermission().equals(permDef.expectedDefault)) {
-                errors.add("Default value for '" + node.getNode() + "' has different default value");
-            }
-        }
-
-        // then
-        if (!errors.isEmpty()) {
-            fail("Found consistency issues!\n" + String.join("\n", errors));
-        }
-    }
-
-    @Test
-    public void shouldNotHaveUnknownPermissionsInPluginYml() {
-        // given
-        List<String> errors = new ArrayList<>();
-
-        // when
-        for (PermissionDefinition def : pluginYmlPermissions.values()) {
-            if (PLUGIN_YML_PERMISSIONS_WILDCARDS.contains(def.node)) {
-                validateChildren(def, errors);
-            } else {
-                if (!doesPermissionExist(def.node, permissionNodes)) {
-                    errors.add("Permission '" + def.node + "' in plugin.yml does not exist in the codebase");
-                } else if (!def.children.isEmpty()) {
-                    errors.add("Permission '" + def.node + "' has children in plugin.yml "
-                        + "but is not a wildcard permission");
-                }
-            }
-        }
-
-        // then
-        if (!errors.isEmpty()) {
-            fail("Found consistency issues!\n" + String.join("\n", errors));
-        }
-    }
-
-    private static boolean doesPermissionExist(String key, List<PermissionNode> nodes) {
-        for (PermissionNode node : nodes) {
-            if (key.equals(node.getNode())) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Returns all {@link PermissionNode} fields from the permission node classes.
-     *
-     * @return collection of all permission nodes in the code
-     */
-    private static List<PermissionNode> getPermissionsFromClasses() {
-        List<PermissionNode> nodes = new ArrayList<>();
-        for (Class<? extends PermissionNode> clazz : permissionClasses) {
-            nodes.addAll(Arrays.<PermissionNode>asList(clazz.getEnumConstants()));
-        }
-        return Collections.unmodifiableList(nodes);
-    }
-
-    /**
-     * Returns all permission entries from the plugin.yml file.
-     *
-     * @return map with the permission entries by permission node
-     */
-    private static Map<String, PermissionDefinition> getPermissionsFromPluginYmlFile() {
-        FileConfiguration pluginFile = YamlConfiguration.loadConfiguration(getJarFile("/plugin.yml"));
-        MemorySection permsList = (MemorySection) pluginFile.get("permissions");
-
-        Map<String, PermissionDefinition> permissions = new HashMap<>();
-        addChildren(permsList, permissions);
-        return ImmutableMap.copyOf(permissions);
-    }
-
-    /**
-     * Recursively visits every MemorySection and creates a {@link PermissionDefinition} when applicable.
-     *
-     * @param node the node to visit
-     * @param collection the collection to add constructed permission definitions to
-     */
-    private static void addChildren(MemorySection node, Map<String, PermissionDefinition> collection) {
-        // A MemorySection may have a permission entry, as well as MemorySection children
-        boolean hasPermissionEntry = false;
-        for (String key : node.getKeys(false)) {
-            if (node.get(key) instanceof MemorySection && !"children".equals(key)) {
-                addChildren((MemorySection) node.get(key), collection);
-            } else if (PERMISSION_FIELDS.contains(key)) {
-                hasPermissionEntry = true;
-            } else {
-                throw new IllegalStateException("Unexpected key '" + key + "'");
-            }
-        }
-        if (hasPermissionEntry) {
-            PermissionDefinition permDef = new PermissionDefinition(node);
-            collection.put(permDef.node, permDef);
-        }
-    }
-
-    /**
-     * Validates that the given permission definition's children, if present, are children of the wildcard permission.
-     *
-     * @param definition the permission definition to process
-     * @param errorList list of errors to add an entry to in case of unsuccessful check
-     */
-    private static void validateChildren(PermissionDefinition definition, List<String> errorList) {
-        // Replace ending .* in path if present, e.g. authme.player.* -> authme.player
-        // Add ending '.' since we want all children to be children, i.e. authme.playertest would not be OK
-        String root = definition.node.replaceAll("\\.\\*$", "") + ".";
-        Set<String> expectedChildren = permissionNodes.stream().map(PermissionNode::getNode)
-            .filter(n -> n.startsWith(root)).collect(Collectors.toSet());
-        Set<String> missingChildren = Sets.difference(expectedChildren, definition.children);
-        Set<String> unexpectedChildren = Sets.difference(definition.children, expectedChildren);
-
-        if (!missingChildren.isEmpty()) {
-            errorList.add("Node '" + definition.node + "' has missing children: " + missingChildren);
-        }
-        if (!unexpectedChildren.isEmpty()) {
-            errorList.add("Node '" + definition.node + "' has unexpected children: " + unexpectedChildren);
-        }
-    }
-
-    /**
-     * Represents a permission entry in plugin.yml.
-     */
-    private static final class PermissionDefinition {
-
-        private final String node;
-        private final Set<String> children;
-        private final DefaultPermission expectedDefault;
-
-        PermissionDefinition(MemorySection memorySection) {
-            this.node = removePermissionsPrefix(memorySection.getCurrentPath());
-            this.expectedDefault = mapToDefaultPermission(memorySection.getString("default"));
-
-            if (memorySection.get("children") instanceof MemorySection) {
-                List<String> children = new ArrayList<>();
-                collectChildren((MemorySection) memorySection.get("children"), children);
-                this.children = removeStart(memorySection.getCurrentPath() + ".children.", children);
-            } else {
-                this.children = Collections.emptySet();
-            }
-        }
-
-        /**
-         * Returns the {@link DefaultPermission} corresponding to the {@code default} value in plugin.yml.
-         *
-         * @param defaultValue the value of the default
-         * @return the according DefaultPermission object, or null
-         */
-        private static DefaultPermission mapToDefaultPermission(String defaultValue) {
-            if ("true".equals(defaultValue)) {
-                return DefaultPermission.ALLOWED;
-            } else if ("op".equals(defaultValue)) {
-                return DefaultPermission.OP_ONLY;
-            } else if ("false".equals(defaultValue)) {
-                return DefaultPermission.NOT_ALLOWED;
-            } else if (defaultValue == null) {
-                // Return null: comparison with the default of the PermissionNode will fail
-                // -> force to set default in plugin.yml
-                return null;
-            }
-            throw new IllegalStateException("Unknown default description '" + defaultValue + "'");
-        }
-
-        /**
-         * Removes the starting "permission." node in the path.
-         *
-         * @param path the path to truncate
-         * @return the shortened path
-         */
-        private static String removePermissionsPrefix(String path) {
-            if (path.startsWith("permissions.")) {
-                return path.substring("permissions.".length());
-            }
-            throw new IllegalStateException("Unexpected path '" + path + "': does not begin with 'permissions.'");
-        }
-
-        /**
-         * Recursively walks through the given memory section to gather all keys.
-         * Assumes that the ending value is a boolean and throws an exception otherwise.
-         *
-         * @param parentSection the memory section to traverse
-         * @param children list to add all results to
-         */
-        private static void collectChildren(MemorySection parentSection, List<String> children) {
-            for (Map.Entry<String, Object> entry : parentSection.getValues(false).entrySet()) {
-                if (entry.getValue() instanceof MemorySection) {
-                    collectChildren((MemorySection) entry.getValue(), children);
-                } else if (entry.getValue() instanceof Boolean) {
-                    if (!Boolean.TRUE.equals(entry.getValue())) {
-                        throw new IllegalStateException("Child entry '" + entry.getKey()
-                            + "' has unexpected value '" + entry.getValue() + "'");
-                    }
-                    children.add(parentSection.getCurrentPath() + "." + entry.getKey());
-                } else {
-                    throw new IllegalStateException("Found child entry at '" + entry.getKey() + "' with value "
-                        + "of unexpected type: '" + parentSection.getCurrentPath() + "." + entry.getValue() + "'");
-                }
-            }
-        }
-
-        /**
-         * Removes the given start from all entries in the list.
-         *
-         * @param start the start to remove
-         * @param list the entries to modify
-         * @return list with shortened entries
-         */
-        private static Set<String> removeStart(String start, List<String> list) {
-            Set<String> result = new HashSet<>(list.size());
-            for (String entry : list) {
-                result.add(entry.substring(start.length()));
-            }
-            return result;
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/permission/PermissionsManagerInitializationTest.java b/src/test/java/fr/xephi/authme/permission/PermissionsManagerInitializationTest.java
deleted file mode 100644
index bdd1c5e6..00000000
--- a/src/test/java/fr/xephi/authme/permission/PermissionsManagerInitializationTest.java
+++ /dev/null
@@ -1,190 +0,0 @@
-package fr.xephi.authme.permission;
-
-import com.google.common.collect.ImmutableMap;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.permission.handlers.LuckPermsHandler;
-import fr.xephi.authme.permission.handlers.PermissionHandler;
-import fr.xephi.authme.permission.handlers.PermissionsExHandler;
-import fr.xephi.authme.permission.handlers.VaultHandler;
-import fr.xephi.authme.permission.handlers.ZPermissionsHandler;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import net.luckperms.api.LuckPerms;
-import net.luckperms.api.LuckPermsProvider;
-import net.milkbowl.vault.permission.Permission;
-import org.bukkit.Bukkit;
-import org.bukkit.Server;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.ServicesManager;
-import org.junit.AssumptionViolatedException;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.tyrannyofheaven.bukkit.zPermissions.ZPermissionsService;
-
-import java.util.Collection;
-import java.util.Map;
-import java.util.stream.Collectors;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static fr.xephi.authme.permission.PermissionsSystemType.LUCK_PERMS;
-import static fr.xephi.authme.permission.PermissionsSystemType.PERMISSIONS_EX;
-import static fr.xephi.authme.permission.PermissionsSystemType.VAULT;
-import static fr.xephi.authme.permission.PermissionsSystemType.Z_PERMISSIONS;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-
-/**
- * Tests the initialization of {@link PermissionHandler} in {@link PermissionsManager}.
- */
-@RunWith(Parameterized.class)
-public class PermissionsManagerInitializationTest {
-
-    @Parameterized.Parameter(0)
-    public PermissionsSystemType permissionsSystemType;
-    @Parameterized.Parameter(1)
-    public Class<?> expectedHandlerType;
-
-    private Settings settings = mock(Settings.class);
-    private ServicesManager servicesManager = mock(ServicesManager.class);
-    private Server server = mock(Server.class);
-    private PluginManager pluginManager = mock(PluginManager.class);
-    private PermissionsManager permissionsManager = new PermissionsManager(server, pluginManager, settings);
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Before
-    public void setUp() {
-        ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
-        given(server.getServicesManager()).willReturn(servicesManager);
-    }
-
-    @Test
-    public void shouldInitializeHandler() {
-        // given
-        setUpForPermissionSystemTest();
-        given(settings.getProperty(PluginSettings.FORCE_VAULT_HOOK)).willReturn(false);
-        Plugin plugin = mock(Plugin.class);
-        given(plugin.isEnabled()).willReturn(true);
-        given(pluginManager.getPlugin(permissionsSystemType.getPluginName())).willReturn(plugin);
-
-        // when
-        permissionsManager.setup();
-
-        // then
-        PermissionHandler handler = getHandlerFieldValue();
-        assertThat(handler, instanceOf(expectedHandlerType));
-        assertThat(handler.getPermissionSystem(), equalTo(permissionsSystemType));
-    }
-
-    @Test
-    public void shouldInitializeToVaultIfSoConfigured() {
-        // given
-        setUpForVault();
-        given(settings.getProperty(PluginSettings.FORCE_VAULT_HOOK)).willReturn(true);
-        Plugin plugin = mock(Plugin.class);
-        given(plugin.isEnabled()).willReturn(true);
-        given(pluginManager.getPlugin(VAULT.getPluginName())).willReturn(plugin);
-
-        // when
-        permissionsManager.setup();
-
-        // then
-        PermissionHandler handler = getHandlerFieldValue();
-        assertThat(handler, instanceOf(VaultHandler.class));
-        verify(pluginManager, only()).getPlugin(VAULT.getPluginName());
-    }
-
-    @Test
-    public void shouldNotHookIntoDisabledPlugin() {
-        // given
-        given(settings.getProperty(PluginSettings.FORCE_VAULT_HOOK)).willReturn(false);
-        Plugin plugin = mock(Plugin.class);
-        given(plugin.isEnabled()).willReturn(false);
-        given(pluginManager.getPlugin(permissionsSystemType.getPluginName())).willReturn(plugin);
-
-        // when
-        permissionsManager.setup();
-
-        // then
-        assertThat(getHandlerFieldValue(), nullValue());
-    }
-
-    @Test
-    public void shouldCatchInitializationException() {
-        // given
-        given(settings.getProperty(PluginSettings.FORCE_VAULT_HOOK)).willReturn(false);
-        Plugin plugin = mock(Plugin.class);
-        // Typically we'd expect a PermissionHandler exception further down the line but we can test it easily like this
-        given(plugin.isEnabled()).willThrow(new IllegalStateException("Some exception occurred"));
-        given(pluginManager.getPlugin(permissionsSystemType.getPluginName())).willReturn(plugin);
-
-        // when
-        permissionsManager.setup();
-
-        // then
-        assertThat(getHandlerFieldValue(), nullValue());
-    }
-
-    @Parameterized.Parameters(name = "{0}")
-    public static Collection<Object[]> createParameters() {
-        Map<PermissionsSystemType, Class<?>> handlersByPermissionSystemType = ImmutableMap.of(
-            LUCK_PERMS, LuckPermsHandler.class,
-            PERMISSIONS_EX, PermissionsExHandler.class,
-            Z_PERMISSIONS, ZPermissionsHandler.class,
-            VAULT, VaultHandler.class);
-
-        // Verify that all handlers are present -> reminder to add any new entry here as well
-        if (!handlersByPermissionSystemType.keySet().equals(newHashSet(PermissionsSystemType.values()))) {
-            throw new IllegalStateException("Test is not set up with all "
-                + PermissionsSystemType.class.getSimpleName() + " entries");
-        }
-
-        // Wrap the above map in a Collection<Object[]> to satisfy JUnit
-        return handlersByPermissionSystemType.entrySet().stream()
-            .map(e -> new Object[]{ e.getKey(), e.getValue() })
-            .collect(Collectors.toList());
-    }
-
-    private void setUpForPermissionSystemTest() {
-        if (permissionsSystemType == LUCK_PERMS) {
-            LuckPerms api = mock(LuckPerms.class);
-            ReflectionTestUtils.setField(LuckPermsProvider.class, null, "instance", api);
-        } else if (permissionsSystemType == PERMISSIONS_EX) {
-            throw new AssumptionViolatedException(
-                "PermissionsEx instance cannot be mocked because of missing dependencies -- skipping");
-        } else if (permissionsSystemType == Z_PERMISSIONS) {
-            ZPermissionsService zPermissionsService = mock(ZPermissionsService.class);
-            given(servicesManager.load(ZPermissionsService.class)).willReturn(zPermissionsService);
-        } else if (permissionsSystemType == VAULT) {
-            setUpForVault();
-        } else {
-            throw new IllegalStateException("Unhandled permission systems type: " + permissionsSystemType);
-        }
-    }
-
-    private void setUpForVault() {
-        RegisteredServiceProvider<Permission> registeredServiceProvider = mock(RegisteredServiceProvider.class);
-        given(servicesManager.getRegistration(Permission.class)).willReturn(registeredServiceProvider);
-        Permission permission = mock(Permission.class);
-        given(registeredServiceProvider.getProvider()).willReturn(permission);
-    }
-
-    private PermissionHandler getHandlerFieldValue() {
-        return ReflectionTestUtils.getFieldValue(PermissionsManager.class, permissionsManager, "handler");
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/permission/PermissionsManagerTest.java b/src/test/java/fr/xephi/authme/permission/PermissionsManagerTest.java
deleted file mode 100644
index 6c7efb45..00000000
--- a/src/test/java/fr/xephi/authme/permission/PermissionsManagerTest.java
+++ /dev/null
@@ -1,151 +0,0 @@
-package fr.xephi.authme.permission;
-
-import org.bukkit.Server;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.PluginManager;
-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.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link PermissionsManager}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PermissionsManagerTest {
-
-    @InjectMocks
-    private PermissionsManager permissionsManager;
-
-    @Mock
-    private Server server;
-
-    @Mock
-    private PluginManager pluginManager;
-
-    @Test
-    public void shouldUseDefaultPermissionForCommandSender() {
-        // given
-        PermissionNode node = TestPermissions.LOGIN;
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        boolean result = permissionsManager.hasPermission(sender, node);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldGrantToOpCommandSender() {
-        // given
-        PermissionNode node = TestPermissions.DELETE_USER;
-        CommandSender sender = mock(CommandSender.class);
-        given(sender.isOp()).willReturn(true);
-
-        // when
-        boolean result = permissionsManager.hasPermission(sender, node);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldDenyPermissionEvenForOpCommandSender() {
-        // given
-        PermissionNode node = TestPermissions.WORLD_DOMINATION;
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        boolean result = permissionsManager.hasPermission(sender, node);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldAllowForNonOpPlayer() {
-        // given
-        PermissionNode node = TestPermissions.LOGIN;
-        Player player = mock(Player.class);
-
-        // when
-        boolean result = permissionsManager.hasPermission(player, node);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldDenyForNonOpPlayer() {
-        // given
-        PermissionNode node = TestPermissions.DELETE_USER;
-        Player player = mock(Player.class);
-
-        // when
-        boolean result = permissionsManager.hasPermission(player, node);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldAllowForOpPlayer() {
-        // given
-        PermissionNode node = TestPermissions.DELETE_USER;
-        Player player = mock(Player.class);
-        given(player.isOp()).willReturn(true);
-
-        // when
-        boolean result = permissionsManager.hasPermission(player, node);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldDenyEvenForOpPlayer() {
-        // given
-        PermissionNode node = TestPermissions.WORLD_DOMINATION;
-        Player player = mock(Player.class);
-
-        // when
-        boolean result = permissionsManager.hasPermission(player, node);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldHandleNullPermissionForCommandSender() {
-        // given
-        PermissionNode node = null;
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        boolean result = permissionsManager.hasPermission(sender, node);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldHandleNullPermissionForPlayer() {
-        // given
-        PermissionNode node = null;
-        Player player = mock(Player.class);
-
-        // when
-        boolean result = permissionsManager.hasPermission(player, node);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/permission/PermissionsSystemTypeTest.java b/src/test/java/fr/xephi/authme/permission/PermissionsSystemTypeTest.java
deleted file mode 100644
index 79b513a1..00000000
--- a/src/test/java/fr/xephi/authme/permission/PermissionsSystemTypeTest.java
+++ /dev/null
@@ -1,45 +0,0 @@
-package fr.xephi.authme.permission;
-
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasItem;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link PermissionsSystemType}.
- */
-public class PermissionsSystemTypeTest {
-
-    @Test
-    public void shouldHaveDefinedAndUniqueNames() {
-        // given / when / then
-        List<String> names = new ArrayList<>(PermissionsSystemType.values().length);
-        List<String> pluginNames = new ArrayList<>(PermissionsSystemType.values().length);
-
-        for (PermissionsSystemType system : PermissionsSystemType.values()) {
-            assertThat("Display name for enum entry '" + system + "' is not null",
-                system.getDisplayName(), not(nullValue()));
-            assertThat("Plugin name for enum entry '" + system + "' is not null",
-                system.getPluginName(), not(nullValue()));
-            assertThat("Only one enum entry has display name '" + system.getDisplayName() + "'",
-                names, not(hasItem(system.getDisplayName())));
-            assertThat("Only one enum entry has plugin name '" + system.getPluginName() + "'",
-                pluginNames, not(hasItem(system.getPluginName())));
-            names.add(system.getDisplayName());
-            pluginNames.add(system.getPluginName());
-        }
-    }
-
-    @Test
-    public void shouldRecognizePermissionSystemType() {
-        assertThat(PermissionsSystemType.isPermissionSystem("bogus"), equalTo(false));
-        assertThat(PermissionsSystemType.isPermissionSystem("PermissionsEx"), equalTo(true));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/permission/PlayerPermissionTest.java b/src/test/java/fr/xephi/authme/permission/PlayerPermissionTest.java
deleted file mode 100644
index 32a45b98..00000000
--- a/src/test/java/fr/xephi/authme/permission/PlayerPermissionTest.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package fr.xephi.authme.permission;
-
-/**
- * Test for {@link PlayerPermission}.
- */
-public class PlayerPermissionTest extends AbstractPermissionsEnumTest {
-
-    @Override
-    protected PermissionNode[] getPermissionNodes() {
-        return PlayerPermission.values();
-    }
-
-    @Override
-    protected String getRequiredPrefix() {
-        return "authme.player.";
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/permission/PlayerStatePermissionTest.java b/src/test/java/fr/xephi/authme/permission/PlayerStatePermissionTest.java
deleted file mode 100644
index 56e5e1ce..00000000
--- a/src/test/java/fr/xephi/authme/permission/PlayerStatePermissionTest.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package fr.xephi.authme.permission;
-
-import org.junit.Test;
-
-import java.util.Collection;
-import java.util.Set;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link PlayerStatePermission}.
- */
-public class PlayerStatePermissionTest extends AbstractPermissionsEnumTest {
-
-    @Test
-    public void shouldNotStartWithOtherPrefixes() {
-        // given
-        Set<String> forbiddenPrefixes = newHashSet("authme.player", "authme.admin", "authme.debug");
-
-        // when/then
-        for (PlayerStatePermission permission : PlayerStatePermission.values()) {
-            if (startsWithAny(permission.getNode(), forbiddenPrefixes)) {
-                fail("The permission '" + permission + "' should not start with any of " + forbiddenPrefixes);
-            }
-        }
-    }
-
-    @Override
-    protected PermissionNode[] getPermissionNodes() {
-        return PlayerStatePermission.values();
-    }
-
-    @Override
-    protected String getRequiredPrefix() {
-        return "authme.";
-    }
-
-    private static boolean startsWithAny(String node, Collection<String> prefixes) {
-        for (String prefix : prefixes) {
-            if (node.startsWith(prefix)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/permission/TestPermissions.java b/src/test/java/fr/xephi/authme/permission/TestPermissions.java
deleted file mode 100644
index 89460771..00000000
--- a/src/test/java/fr/xephi/authme/permission/TestPermissions.java
+++ /dev/null
@@ -1,33 +0,0 @@
-package fr.xephi.authme.permission;
-
-/**
- * Sample permission nodes for testing.
- */
-public enum TestPermissions implements PermissionNode {
-
-    LOGIN("authme.login", DefaultPermission.ALLOWED),
-
-    DELETE_USER("authme.admin.delete", DefaultPermission.OP_ONLY),
-
-    WORLD_DOMINATION("global.own", DefaultPermission.NOT_ALLOWED);
-
-
-    private final String node;
-    private final DefaultPermission defaultPermission;
-
-    TestPermissions(String node, DefaultPermission defaultPermission) {
-        this.node = node;
-        this.defaultPermission = defaultPermission;
-    }
-
-    @Override
-    public String getNode() {
-        return node;
-    }
-
-    @Override
-    public DefaultPermission getDefaultPermission() {
-        return defaultPermission;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/permission/handlers/VaultHandlerTest.java b/src/test/java/fr/xephi/authme/permission/handlers/VaultHandlerTest.java
deleted file mode 100644
index 852dcaef..00000000
--- a/src/test/java/fr/xephi/authme/permission/handlers/VaultHandlerTest.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package fr.xephi.authme.permission.handlers;
-
-import fr.xephi.authme.data.limbo.UserGroup;
-import net.milkbowl.vault.permission.Permission;
-import org.bukkit.Server;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static java.util.stream.Collectors.toList;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.empty;
-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 VaultHandler}.
- */
-public class VaultHandlerTest {
-
-    private VaultHandlerTestImpl vaultHandlerTest = VaultHandlerTestImpl.create();
-
-    @Test
-    public void shouldReturnGroups() {
-        // given
-        Permission permissionMock = vaultHandlerTest.permissionMock;
-        Player player = mock(Player.class);
-        given(permissionMock.getPlayerGroups(null, player)).willReturn(new String[]{"abc", "test"});
-
-        // when
-        List<UserGroup> result = vaultHandlerTest.getGroups(player);
-
-        // then
-        List<String> groupNames = result.stream().map(UserGroup::getGroupName).collect(toList());
-        assertThat(groupNames, contains("abc", "test"));
-        verify(permissionMock).getPlayerGroups(null, player);
-    }
-
-    /**
-     * Bug #1702: VaultHandler may return null for groups list.
-     */
-    @Test
-    public void shouldHandleNullAsGroups() {
-        // given
-        Permission permissionMock = vaultHandlerTest.permissionMock;
-        Player player = mock(Player.class);
-        given(permissionMock.getPlayerGroups(null, player)).willReturn(null);
-
-        // when
-        List<UserGroup> result = vaultHandlerTest.getGroups(player);
-
-        // then
-        assertThat(result, empty());
-        verify(permissionMock).getPlayerGroups(null, player);
-    }
-
-    /** Test implementation using a mock Vault Permission instance. */
-    private static final class VaultHandlerTestImpl extends VaultHandler {
-
-        private Permission permissionMock;
-
-        VaultHandlerTestImpl() throws PermissionHandlerException {
-            super(null);
-        }
-
-        static VaultHandlerTestImpl create() {
-            try {
-                return new VaultHandlerTestImpl();
-            } catch (PermissionHandlerException e) {
-                throw new IllegalStateException(e);
-            }
-        }
-
-        @Override
-        Permission getVaultPermission(Server server) {
-            permissionMock = mock(Permission.class);
-            return permissionMock;
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/process/changepassword/AsyncChangePasswordTest.java b/src/test/java/fr/xephi/authme/process/changepassword/AsyncChangePasswordTest.java
deleted file mode 100644
index b0dd97bb..00000000
--- a/src/test/java/fr/xephi/authme/process/changepassword/AsyncChangePasswordTest.java
+++ /dev/null
@@ -1,130 +0,0 @@
-package fr.xephi.authme.process.changepassword;
-
-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.security.PasswordSecurity;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.bungeecord.BungeeSender;
-import org.bukkit.command.CommandSender;
-import org.junit.Before;
-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;
-
-/**
- * Test for {@link AsyncChangePassword}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AsyncChangePasswordTest {
-
-    @InjectMocks
-    private AsyncChangePassword asyncChangePassword;
-
-    @Mock
-    private CommonService commonService;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private PasswordSecurity passwordSecurity;
-    @Mock
-    private BungeeSender bungeeSender;
-
-    @Before
-    public void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldRejectCommandForUnknownUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "player";
-        String password = "password";
-        given(playerCache.isAuthenticated(player)).willReturn(false);
-        given(dataSource.isAuthAvailable(player)).willReturn(false);
-
-        // when
-        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
-
-        // then
-        verify(commonService).send(sender, MessageKey.UNKNOWN_USER);
-        verify(dataSource, only()).isAuthAvailable(player);
-    }
-
-    @Test
-    public void shouldUpdatePasswordOfLoggedInUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "my_user12";
-        String password = "passPass";
-        given(playerCache.isAuthenticated(player)).willReturn(true);
-
-        HashedPassword hashedPassword = mock(HashedPassword.class);
-        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
-        given(dataSource.updatePassword(player, hashedPassword)).willReturn(true);
-
-        // when
-        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
-
-        // then
-        verify(commonService).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
-        verify(passwordSecurity).computeHash(password, player);
-        verify(dataSource).updatePassword(player, hashedPassword);
-    }
-
-    @Test
-    public void shouldUpdatePasswordOfOfflineUser() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "my_user12";
-        String password = "passPass";
-        given(playerCache.isAuthenticated(player)).willReturn(false);
-        given(dataSource.isAuthAvailable(player)).willReturn(true);
-
-        HashedPassword hashedPassword = mock(HashedPassword.class);
-        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
-        given(dataSource.updatePassword(player, hashedPassword)).willReturn(true);
-
-        // when
-        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
-
-        // then
-        verify(commonService).send(sender, MessageKey.PASSWORD_CHANGED_SUCCESS);
-        verify(passwordSecurity).computeHash(password, player);
-        verify(dataSource).updatePassword(player, hashedPassword);
-    }
-
-    @Test
-    public void shouldReportWhenSaveFailed() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String player = "my_user12";
-        String password = "passPass";
-        given(playerCache.isAuthenticated(player)).willReturn(true);
-
-        HashedPassword hashedPassword = mock(HashedPassword.class);
-        given(passwordSecurity.computeHash(password, player)).willReturn(hashedPassword);
-        given(dataSource.updatePassword(player, hashedPassword)).willReturn(false);
-
-        // when
-        asyncChangePassword.changePasswordAsAdmin(sender, player, password);
-
-        // then
-        verify(commonService).send(sender, MessageKey.ERROR);
-        verify(passwordSecurity).computeHash(password, player);
-        verify(dataSource).updatePassword(player, hashedPassword);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java b/src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java
deleted file mode 100644
index 6d2fdd22..00000000
--- a/src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java
+++ /dev/null
@@ -1,221 +0,0 @@
-package fr.xephi.authme.process.email;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.events.EmailChangedEvent;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.service.bungeecord.BungeeSender;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-import java.util.function.Function;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link AsyncAddEmail}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AsyncAddEmailTest {
-
-    @InjectMocks
-    private AsyncAddEmail asyncAddEmail;
-
-    @Mock
-    private Player player;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private CommonService service;
-
-    @Mock
-    private ValidationService validationService;
-
-    @Mock
-    private BungeeSender bungeeSender;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @BeforeClass
-    public static void setUp() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldAddEmail() {
-        // given
-        String email = "my.mail@example.org";
-        given(player.getName()).willReturn("testEr");
-        given(playerCache.isAuthenticated("tester")).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getEmail()).willReturn(null);
-        given(playerCache.getAuth("tester")).willReturn(auth);
-        given(dataSource.updateEmail(any(PlayerAuth.class))).willReturn(true);
-        given(validationService.validateEmail(email)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(email, player)).willReturn(true);
-        EmailChangedEvent event = spy(new EmailChangedEvent(player, null, email, false));
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-
-        // when
-        asyncAddEmail.addEmail(player, email);
-
-        // then
-        verify(dataSource).updateEmail(auth);
-        verify(service).send(player, MessageKey.EMAIL_ADDED_SUCCESS);
-        verify(auth).setEmail(email);
-        verify(playerCache).updatePlayer(auth);
-    }
-
-    @Test
-    public void shouldReturnErrorWhenMailCannotBeSaved() {
-        // given
-        String email = "my.mail@example.org";
-        given(player.getName()).willReturn("testEr");
-        given(playerCache.isAuthenticated("tester")).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getEmail()).willReturn(null);
-        given(playerCache.getAuth("tester")).willReturn(auth);
-        given(dataSource.updateEmail(any(PlayerAuth.class))).willReturn(false);
-        given(validationService.validateEmail(email)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(email, player)).willReturn(true);
-        EmailChangedEvent event = spy(new EmailChangedEvent(player, null, email, false));
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-
-        // when
-        asyncAddEmail.addEmail(player, email);
-
-        // then
-        verify(dataSource).updateEmail(auth);
-        verify(service).send(player, MessageKey.ERROR);
-    }
-
-    @Test
-    public void shouldNotAddMailIfPlayerAlreadyHasEmail() {
-        // given
-        given(player.getName()).willReturn("my_Player");
-        given(playerCache.isAuthenticated("my_player")).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getEmail()).willReturn("another@mail.tld");
-        given(playerCache.getAuth("my_player")).willReturn(auth);
-
-        // when
-        asyncAddEmail.addEmail(player, "some.mail@example.org");
-
-        // then
-        verify(service).send(player, MessageKey.USAGE_CHANGE_EMAIL);
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-    }
-
-    @Test
-    public void shouldNotAddMailIfItIsInvalid() {
-        // given
-        String email = "invalid_mail";
-        given(player.getName()).willReturn("my_Player");
-        given(playerCache.isAuthenticated("my_player")).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getEmail()).willReturn(null);
-        given(playerCache.getAuth("my_player")).willReturn(auth);
-        given(validationService.validateEmail(email)).willReturn(false);
-
-        // when
-        asyncAddEmail.addEmail(player, email);
-
-        // then
-        verify(service).send(player, MessageKey.INVALID_EMAIL);
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-    }
-
-    @Test
-    public void shouldNotAddMailIfAlreadyUsed() {
-        // given
-        String email = "player@mail.tld";
-        given(player.getName()).willReturn("TestName");
-        given(playerCache.isAuthenticated("testname")).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getEmail()).willReturn(null);
-        given(playerCache.getAuth("testname")).willReturn(auth);
-        given(validationService.validateEmail(email)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(email, player)).willReturn(false);
-
-        // when
-        asyncAddEmail.addEmail(player, email);
-
-        // then
-        verify(service).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-    }
-
-    @Test
-    public void shouldShowLoginMessage() {
-        // given
-        given(player.getName()).willReturn("Username12");
-        given(playerCache.isAuthenticated("username12")).willReturn(false);
-        given(dataSource.isAuthAvailable("Username12")).willReturn(true);
-
-        // when
-        asyncAddEmail.addEmail(player, "test@mail.com");
-
-        // then
-        verify(service).send(player, MessageKey.LOGIN_MESSAGE);
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-    }
-
-    @Test
-    public void shouldShowRegisterMessage() {
-        // given
-        given(player.getName()).willReturn("user");
-        given(playerCache.isAuthenticated("user")).willReturn(false);
-        given(dataSource.isAuthAvailable("user")).willReturn(false);
-
-        // when
-        asyncAddEmail.addEmail(player, "test@mail.com");
-
-        // then
-        verify(service).send(player, MessageKey.REGISTER_MESSAGE);
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-    }
-
-    @Test
-    public void shouldNotAddOnCancelledEvent() {
-        // given
-        String email = "player@mail.tld";
-        given(player.getName()).willReturn("TestName");
-        given(playerCache.isAuthenticated("testname")).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(auth.getEmail()).willReturn(null);
-        given(playerCache.getAuth("testname")).willReturn(auth);
-        given(validationService.validateEmail(email)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(email, player)).willReturn(true);
-        EmailChangedEvent event = spy(new EmailChangedEvent(player, null, email, false));
-        event.setCancelled(true);
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-
-        // when
-        asyncAddEmail.addEmail(player, email);
-
-        // then
-        verify(service).send(player, MessageKey.EMAIL_ADD_NOT_ALLOWED);
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java b/src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java
deleted file mode 100644
index b0f3e971..00000000
--- a/src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java
+++ /dev/null
@@ -1,273 +0,0 @@
-package fr.xephi.authme.process.email;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.events.EmailChangedEvent;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.ValidationService;
-import fr.xephi.authme.service.bungeecord.BungeeSender;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.function.Function;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-/**
- * Test for {@link AsyncChangeEmail}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AsyncChangeEmailTest {
-
-    @InjectMocks
-    private AsyncChangeEmail process;
-
-    @Mock
-    private Player player;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private CommonService service;
-
-    @Mock
-    private ValidationService validationService;
-
-    @Mock
-    private BungeeSender bungeeSender;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @BeforeClass
-    public static void setUp() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldChangeEmail() {
-        // given
-        String newEmail = "new@mail.tld";
-        given(player.getName()).willReturn("Bobby");
-        given(playerCache.isAuthenticated("bobby")).willReturn(true);
-        PlayerAuth auth = authWithMail("old@mail.tld");
-        given(playerCache.getAuth("bobby")).willReturn(auth);
-        given(dataSource.updateEmail(auth)).willReturn(true);
-        given(validationService.validateEmail(newEmail)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(newEmail, player)).willReturn(true);
-        EmailChangedEvent event = spy(new EmailChangedEvent(player, "old@mail.tld", newEmail, false));
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-        
-        // when
-        process.changeEmail(player, "old@mail.tld", newEmail);
-
-        // then
-        verify(dataSource).updateEmail(auth);
-        verify(playerCache).updatePlayer(auth);
-        verify(service).send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
-    }
-
-    @Test
-    public void shouldNotBeCaseSensitiveWhenComparingEmails() {
-        // given
-        String newEmail = "newmail@example.com";
-        given(player.getName()).willReturn("Debra");
-        given(playerCache.isAuthenticated("debra")).willReturn(true);
-        String oldEmail = "OLD-mail@example.org";
-        PlayerAuth auth = authWithMail(oldEmail);
-        given(playerCache.getAuth("debra")).willReturn(auth);
-        given(dataSource.updateEmail(auth)).willReturn(true);
-        given(validationService.validateEmail(newEmail)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(newEmail, player)).willReturn(true);
-        EmailChangedEvent event = spy(new EmailChangedEvent(player, oldEmail, newEmail, false));
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-
-        // when
-        process.changeEmail(player, "old-mail@example.org", newEmail);
-
-        // then
-        verify(dataSource).updateEmail(auth);
-        verify(playerCache).updatePlayer(auth);
-        verify(service).send(player, MessageKey.EMAIL_CHANGED_SUCCESS);
-    }
-
-    @Test
-    public void shouldShowErrorIfSaveFails() {
-        // given
-        String newEmail = "new@mail.tld";
-        given(player.getName()).willReturn("Bobby");
-        given(playerCache.isAuthenticated("bobby")).willReturn(true);
-        PlayerAuth auth = authWithMail("old@mail.tld");
-        given(playerCache.getAuth("bobby")).willReturn(auth);
-        given(dataSource.updateEmail(auth)).willReturn(false);
-        given(validationService.validateEmail(newEmail)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(newEmail, player)).willReturn(true);
-        EmailChangedEvent event = spy(new EmailChangedEvent(player, "old@mail.tld", newEmail, false));
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-
-        // when
-        process.changeEmail(player, "old@mail.tld", newEmail);
-
-        // then
-        verify(dataSource).updateEmail(auth);
-        verify(playerCache, never()).updatePlayer(auth);
-        verify(service).send(player, MessageKey.ERROR);
-    }
-
-    @Test
-    public void shouldShowAddEmailUsage() {
-        // given
-        given(player.getName()).willReturn("Bobby");
-        given(playerCache.isAuthenticated("bobby")).willReturn(true);
-        PlayerAuth auth = authWithMail(null);
-        given(playerCache.getAuth("bobby")).willReturn(auth);
-
-        // when
-        process.changeEmail(player, "old@mail.tld", "new@mailt.tld");
-
-        // then
-        verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(service).send(player, MessageKey.USAGE_ADD_EMAIL);
-    }
-
-    @Test
-    public void shouldRejectInvalidNewMail() {
-        // given
-        String newEmail = "bogus";
-        given(player.getName()).willReturn("Bobby");
-        given(playerCache.isAuthenticated("bobby")).willReturn(true);
-        PlayerAuth auth = authWithMail("old@mail.tld");
-        given(playerCache.getAuth("bobby")).willReturn(auth);
-        given(validationService.validateEmail(newEmail)).willReturn(false);
-
-        // when
-        process.changeEmail(player, "old@mail.tld", newEmail);
-
-        // then
-        verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(service).send(player, MessageKey.INVALID_NEW_EMAIL);
-    }
-
-    @Test
-    public void shouldRejectInvalidOldEmail() {
-        // given
-        String newEmail = "new@mail.tld";
-        given(player.getName()).willReturn("Bobby");
-        given(playerCache.isAuthenticated("bobby")).willReturn(true);
-        PlayerAuth auth = authWithMail("other@address.email");
-        given(playerCache.getAuth("bobby")).willReturn(auth);
-        given(validationService.validateEmail(newEmail)).willReturn(true);
-
-        // when
-        process.changeEmail(player, "old@mail.tld", newEmail);
-
-        // then
-        verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(service).send(player, MessageKey.INVALID_OLD_EMAIL);
-    }
-
-    @Test
-    public void shouldRejectAlreadyUsedEmail() {
-        // given
-        String newEmail = "new@example.com";
-        given(player.getName()).willReturn("Username");
-        given(playerCache.isAuthenticated("username")).willReturn(true);
-        PlayerAuth auth = authWithMail("old@example.com");
-        given(playerCache.getAuth("username")).willReturn(auth);
-        given(validationService.validateEmail(newEmail)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(newEmail, player)).willReturn(false);
-
-        // when
-        process.changeEmail(player, "old@example.com", newEmail);
-
-        // then
-        verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(service).send(player, MessageKey.EMAIL_ALREADY_USED_ERROR);
-    }
-
-    @Test
-    public void shouldSendLoginMessage() {
-        // given
-        given(player.getName()).willReturn("Bobby");
-        given(playerCache.isAuthenticated("bobby")).willReturn(false);
-        given(dataSource.isAuthAvailable("Bobby")).willReturn(true);
-
-        // when
-        process.changeEmail(player, "old@mail.tld", "new@mail.tld");
-
-        // then
-        verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(service).send(player, MessageKey.LOGIN_MESSAGE);
-    }
-
-    @Test
-    public void shouldShowRegistrationMessage() {
-        // given
-        given(player.getName()).willReturn("Bobby");
-        given(playerCache.isAuthenticated("bobby")).willReturn(false);
-        given(dataSource.isAuthAvailable("Bobby")).willReturn(false);
-
-        // when
-        process.changeEmail(player, "old@mail.tld", "new@mail.tld");
-
-        // then
-        verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(service).send(player, MessageKey.REGISTER_MESSAGE);
-    }
-
-    @Test
-    public void shouldNotChangeOnCancelledEvent() {
-        // given
-        String newEmail = "new@example.com";
-        String oldEmail = "old@example.com";
-        given(player.getName()).willReturn("Username");
-        given(playerCache.isAuthenticated("username")).willReturn(true);
-        PlayerAuth auth = authWithMail(oldEmail);
-        given(playerCache.getAuth("username")).willReturn(auth);
-        given(validationService.validateEmail(newEmail)).willReturn(true);
-        given(validationService.isEmailFreeForRegistration(newEmail, player)).willReturn(true);
-        EmailChangedEvent event = spy(new EmailChangedEvent(player, oldEmail, newEmail, false));
-        event.setCancelled(true);
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-
-        // when
-        process.changeEmail(player, oldEmail, newEmail);
-
-        // then
-        verify(dataSource, never()).updateEmail(any(PlayerAuth.class));
-        verify(playerCache, never()).updatePlayer(any(PlayerAuth.class));
-        verify(service).send(player, MessageKey.EMAIL_CHANGE_NOT_ALLOWED);
-    }
-
-    private static PlayerAuth authWithMail(String email) {
-        PlayerAuth auth = mock(PlayerAuth.class);
-        when(auth.getEmail()).thenReturn(email);
-        return auth;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/process/login/AsynchronousLoginTest.java b/src/test/java/fr/xephi/authme/process/login/AsynchronousLoginTest.java
deleted file mode 100644
index 673282a4..00000000
--- a/src/test/java/fr/xephi/authme/process/login/AsynchronousLoginTest.java
+++ /dev/null
@@ -1,271 +0,0 @@
-package fr.xephi.authme.process.login;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.data.limbo.LimboService;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.events.AuthMeAsyncPreLoginEvent;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.permission.PlayerStatePermission;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.settings.properties.DatabaseSettings;
-import fr.xephi.authme.settings.properties.HooksSettings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.Spy;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.internal.verification.VerificationModeFactory.only;
-
-/**
- * Test for {@link AsynchronousLogin}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AsynchronousLoginTest {
-
-    @InjectMocks
-    @Spy
-    private AsynchronousLogin asynchronousLogin;
-
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private CommonService commonService;
-    @Mock
-    private LimboService limboService;
-    @Mock
-    private BukkitService bukkitService;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldNotForceLoginAlreadyLoggedInPlayer() {
-        // given
-        String name = "bobby";
-        Player player = mockPlayer(name);
-        given(playerCache.isAuthenticated(name)).willReturn(true);
-
-        // when
-        asynchronousLogin.forceLogin(player);
-
-        // then
-        verify(playerCache, only()).isAuthenticated(name);
-        verify(commonService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldNotForceLoginNonExistentUser() {
-        // given
-        String name = "oscar";
-        Player player = mockPlayer(name);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        given(dataSource.getAuth(name)).willReturn(null);
-
-        // when
-        asynchronousLogin.forceLogin(player);
-
-        // then
-        verify(playerCache, only()).isAuthenticated(name);
-        verify(commonService).send(player, MessageKey.UNKNOWN_USER);
-        verify(dataSource, only()).getAuth(name);
-    }
-
-    @Test
-    public void shouldNotForceLoginInactiveUser() {
-        // given
-        String name = "oscar";
-        Player player = mockPlayer(name);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        int groupId = 13;
-        PlayerAuth auth = PlayerAuth.builder().name(name).groupId(groupId).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-        given(commonService.getProperty(DatabaseSettings.MYSQL_COL_GROUP)).willReturn("group");
-        given(commonService.getProperty(HooksSettings.NON_ACTIVATED_USERS_GROUP)).willReturn(groupId);
-
-        // when
-        asynchronousLogin.forceLogin(player);
-
-        // then
-        verify(playerCache, only()).isAuthenticated(name);
-        verify(commonService).send(player, MessageKey.ACCOUNT_NOT_ACTIVATED);
-        verify(dataSource, only()).getAuth(name);
-    }
-
-    @Test
-    public void shouldNotForceLoginUserWithAlreadyOnlineIp() {
-        // given
-        String name = "oscar";
-        String ip = "1.1.1.245";
-        Player player = mockPlayer(name);
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        PlayerAuth auth = PlayerAuth.builder().name(name).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-        given(commonService.getProperty(DatabaseSettings.MYSQL_COL_GROUP)).willReturn("");
-        doReturn(true).when(asynchronousLogin).hasReachedMaxLoggedInPlayersForIp(any(Player.class), anyString());
-
-        // when
-        asynchronousLogin.forceLogin(player);
-
-        // then
-        verify(playerCache, only()).isAuthenticated(name);
-        verify(commonService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
-        verify(dataSource, only()).getAuth(name);
-        verify(asynchronousLogin).hasReachedMaxLoggedInPlayersForIp(player, ip);
-    }
-
-    @Test
-    public void shouldNotForceLoginForCanceledEvent() {
-        // given
-        String name = "oscar";
-        String ip = "1.1.1.245";
-        Player player = mockPlayer(name);
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        PlayerAuth auth = PlayerAuth.builder().name(name).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-        given(commonService.getProperty(DatabaseSettings.MYSQL_COL_GROUP)).willReturn("");
-        given(commonService.getProperty(PluginSettings.USE_ASYNC_TASKS)).willReturn(true);
-        doReturn(false).when(asynchronousLogin).hasReachedMaxLoggedInPlayersForIp(any(Player.class), anyString());
-        doAnswer((Answer<Void>) invocation -> {
-            ((AuthMeAsyncPreLoginEvent) invocation.getArgument(0)).setCanLogin(false);
-            return null;
-        }).when(bukkitService).callEvent(any(AuthMeAsyncPreLoginEvent.class));
-
-        // when
-        asynchronousLogin.forceLogin(player);
-
-        // then
-        verify(playerCache, only()).isAuthenticated(name);
-        verify(dataSource, only()).getAuth(name);
-        verify(asynchronousLogin).hasReachedMaxLoggedInPlayersForIp(player, ip);
-    }
-
-
-    @Test
-    public void shouldPassMaxLoginPerIpCheck() {
-        // given
-        Player player = mockPlayer("Carl");
-        given(commonService.getProperty(RestrictionSettings.MAX_LOGIN_PER_IP)).willReturn(2);
-        given(commonService.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(false);
-        mockOnlinePlayersInBukkitService();
-
-        // when
-        boolean result = asynchronousLogin.hasReachedMaxLoggedInPlayersForIp(player, "1.1.1.1");
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
-        verify(bukkitService).getOnlinePlayers();
-    }
-
-    @Test
-    public void shouldSkipIpCheckForZeroThreshold() {
-        // given
-        Player player = mockPlayer("Fiona");
-        given(commonService.getProperty(RestrictionSettings.MAX_LOGIN_PER_IP)).willReturn(0);
-
-        // when
-        boolean result = asynchronousLogin.hasReachedMaxLoggedInPlayersForIp(player, "2.2.2.2");
-
-        // then
-        assertThat(result, equalTo(false));
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldSkipIpCheckForPlayerWithMultipleAccountsPermission() {
-        // given
-        Player player = mockPlayer("Frank");
-        given(commonService.getProperty(RestrictionSettings.MAX_LOGIN_PER_IP)).willReturn(1);
-        given(commonService.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(true);
-
-        // when
-        boolean result = asynchronousLogin.hasReachedMaxLoggedInPlayersForIp(player, "1.1.1.1");
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldFailIpCheckForIpWithTooManyPlayersOnline() {
-        // given
-        Player player = mockPlayer("Ian");
-        given(commonService.getProperty(RestrictionSettings.MAX_LOGIN_PER_IP)).willReturn(2);
-        given(commonService.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(false);
-        mockOnlinePlayersInBukkitService();
-
-        // when
-        boolean result = asynchronousLogin.hasReachedMaxLoggedInPlayersForIp(player, "2.2.2.2");
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(commonService).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
-        verify(bukkitService).getOnlinePlayers();
-    }
-
-    private static Player mockPlayer(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-
-    private void mockOnlinePlayersInBukkitService() {
-        // 1.1.1.1: albania (online), brazil (offline)
-        Player playerA = mockPlayer("albania");
-        TestHelper.mockIpAddressToPlayer(playerA, "1.1.1.1");
-        given(dataSource.isLogged(playerA.getName())).willReturn(true);
-        Player playerB = mockPlayer("brazil");
-        TestHelper.mockIpAddressToPlayer(playerB, "1.1.1.1");
-        given(dataSource.isLogged(playerB.getName())).willReturn(false);
-
-        // 2.2.2.2: congo (online), denmark (offline), ecuador (online)
-        Player playerC = mockPlayer("congo");
-        TestHelper.mockIpAddressToPlayer(playerC, "2.2.2.2");
-        given(dataSource.isLogged(playerC.getName())).willReturn(true);
-        Player playerD = mockPlayer("denmark");
-        TestHelper.mockIpAddressToPlayer(playerD, "2.2.2.2");
-        given(dataSource.isLogged(playerD.getName())).willReturn(false);
-        Player playerE = mockPlayer("ecuador");
-        TestHelper.mockIpAddressToPlayer(playerE, "2.2.2.2");
-        given(dataSource.isLogged(playerE.getName())).willReturn(true);
-
-        // 3.3.3.3: france (offline)
-        Player playerF = mockPlayer("france");
-        TestHelper.mockIpAddressToPlayer(playerF, "3.3.3.3");
-
-        List<Player> onlinePlayers = Arrays.asList(playerA, playerB, playerC, playerD, playerE, playerF);
-        given(bukkitService.getOnlinePlayers()).willReturn(onlinePlayers);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/process/register/AsyncRegisterTest.java b/src/test/java/fr/xephi/authme/process/register/AsyncRegisterTest.java
deleted file mode 100644
index 00e8be24..00000000
--- a/src/test/java/fr/xephi/authme/process/register/AsyncRegisterTest.java
+++ /dev/null
@@ -1,171 +0,0 @@
-package fr.xephi.authme.process.register;
-
-import ch.jalu.injector.factory.SingletonStore;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.events.AuthMeAsyncPreRegisterEvent;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.process.register.executors.PasswordRegisterParams;
-import fr.xephi.authme.process.register.executors.RegistrationExecutor;
-import fr.xephi.authme.process.register.executors.RegistrationMethod;
-import fr.xephi.authme.process.register.executors.TwoFactorRegisterParams;
-import fr.xephi.authme.service.BukkitService;
-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 java.util.function.Function;
-
-import static org.mockito.ArgumentMatchers.any;
-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.verifyNoInteractions;
-
-/**
- * Test for {@link AsyncRegister}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AsyncRegisterTest {
-
-    @InjectMocks
-    private AsyncRegister asyncRegister;
-
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private CommonService commonService;
-    @Mock
-    private BukkitService bukkitService;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private SingletonStore<RegistrationExecutor> registrationExecutorStore;
-
-    @Test
-    public void shouldDetectAlreadyLoggedInPlayer() {
-        // given
-        String name = "robert";
-        Player player = mockPlayerWithName(name);
-        given(playerCache.isAuthenticated(name)).willReturn(true);
-        RegistrationExecutor executor = mock(RegistrationExecutor.class);
-        singletonStoreWillReturn(registrationExecutorStore, executor);
-
-        // when
-        asyncRegister.register(RegistrationMethod.PASSWORD_REGISTRATION, PasswordRegisterParams.of(player, "abc", null));
-
-        // then
-        verify(commonService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
-        verifyNoInteractions(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);
-        singletonStoreWillReturn(registrationExecutorStore, executor);
-
-        // when
-        asyncRegister.register(RegistrationMethod.TWO_FACTOR_REGISTRATION, TwoFactorRegisterParams.of(player));
-
-        // then
-        verify(commonService).send(player, MessageKey.REGISTRATION_DISABLED);
-        verifyNoInteractions(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);
-        singletonStoreWillReturn(registrationExecutorStore, executor);
-
-        // when
-        asyncRegister.register(RegistrationMethod.TWO_FACTOR_REGISTRATION, TwoFactorRegisterParams.of(player));
-
-        // then
-        verify(commonService).send(player, MessageKey.NAME_ALREADY_REGISTERED);
-        verify(dataSource, only()).isAuthAvailable(name);
-        verifyNoInteractions(executor);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldStopForCanceledEvent() {
-        // given
-        String name = "edbert";
-        Player player = mockPlayerWithName(name);
-        TestHelper.mockIpAddressToPlayer(player, "33.44.55.66");
-        given(playerCache.isAuthenticated(name)).willReturn(false);
-        given(commonService.getProperty(RegistrationSettings.IS_ENABLED)).willReturn(true);
-        given(dataSource.isAuthAvailable(name)).willReturn(false);
-        RegistrationExecutor executor = mock(RegistrationExecutor.class);
-        TwoFactorRegisterParams params = TwoFactorRegisterParams.of(player);
-        singletonStoreWillReturn(registrationExecutorStore, executor);
-
-        AuthMeAsyncPreRegisterEvent canceledEvent = new AuthMeAsyncPreRegisterEvent(player, true);
-        canceledEvent.setCanRegister(false);
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(canceledEvent);
-
-        // when
-        asyncRegister.register(RegistrationMethod.TWO_FACTOR_REGISTRATION, params);
-
-        // then
-        verify(dataSource, only()).isAuthAvailable(name);
-    }
-
-    @Test
-    @SuppressWarnings("unchecked")
-    public void shouldStopForFailedExecutorCheck() {
-        // given
-        String name = "edbert";
-        Player player = mockPlayerWithName(name);
-        TestHelper.mockIpAddressToPlayer(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);
-        TwoFactorRegisterParams params = TwoFactorRegisterParams.of(player);
-        given(executor.isRegistrationAdmitted(params)).willReturn(false);
-        singletonStoreWillReturn(registrationExecutorStore, executor);
-
-        given(bukkitService.createAndCallEvent(any(Function.class)))
-            .willReturn(new AuthMeAsyncPreRegisterEvent(player, false));
-
-        // when
-        asyncRegister.register(RegistrationMethod.TWO_FACTOR_REGISTRATION, params);
-
-        // then
-        verify(dataSource, only()).isAuthAvailable(name);
-        verify(executor, only()).isRegistrationAdmitted(params);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-
-    @SuppressWarnings("unchecked")
-    private static void singletonStoreWillReturn(SingletonStore<RegistrationExecutor> store,
-                                                 RegistrationExecutor mock) {
-        given(store.getSingleton(any(Class.class))).willReturn(mock);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorTest.java b/src/test/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorTest.java
deleted file mode 100644
index a52b0075..00000000
--- a/src/test/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorTest.java
+++ /dev/null
@@ -1,167 +0,0 @@
-package fr.xephi.authme.process.register.executors;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.mail.EmailService;
-import fr.xephi.authme.message.MessageKey;
-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.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.stringWithLength;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.not;
-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.verifyNoInteractions;
-
-/**
- * Test for {@link EmailRegisterExecutor}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class EmailRegisterExecutorTest {
-
-    @InjectMocks
-    private EmailRegisterExecutor executor;
-
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private CommonService commonService;
-    @Mock
-    private EmailService emailService;
-    @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);
-        EmailRegisterParams params = EmailRegisterParams.of(player, email);
-
-        // when
-        boolean result = executor.isRegistrationAdmitted(params);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(dataSource).countAuthsByEmail(email);
-        verify(commonService).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(commonService.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(true);
-        EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
-
-        // when
-        boolean result = executor.isRegistrationAdmitted(params);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(commonService).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);
-        EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
-
-        // when
-        boolean result = executor.isRegistrationAdmitted(params);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(commonService).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.mockIpAddressToPlayer(player, "123.45.67.89");
-        given(player.getName()).willReturn("Veronica");
-        EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
-
-        // when
-        PlayerAuth auth = executor.buildPlayerAuth(params);
-
-        // then
-        assertThat(auth, hasAuthBasicData("veronica", "Veronica", "test@example.com", null));
-        assertThat(auth.getRegistrationIp(), equalTo("123.45.67.89"));
-        assertIsCloseTo(auth.getRegistrationDate(), System.currentTimeMillis(), 1000);
-        assertThat(auth.getPassword().getHash(), stringWithLength(12));
-    }
-
-    @Test
-    public void shouldPerformActionAfterDataSourceSave() {
-        // given
-        given(emailService.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("Laleh");
-        EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
-        String password = "A892C#@";
-        params.setPassword(password);
-
-        // when
-        executor.executePostPersistAction(params);
-
-        // then
-        verify(emailService).sendPasswordMail("Laleh", "test@example.com", password);
-        verify(syncProcessManager).processSyncEmailRegister(player);
-    }
-
-    @Test
-    public void shouldHandleEmailSendingFailure() {
-        // given
-        given(emailService.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(false);
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("Laleh");
-        EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
-        String password = "A892C#@";
-        params.setPassword(password);
-
-        // when
-        executor.executePostPersistAction(params);
-
-        // then
-        verify(emailService).sendPasswordMail("Laleh", "test@example.com", password);
-        verify(commonService).send(player, MessageKey.EMAIL_SEND_FAILURE);
-        verifyNoInteractions(syncProcessManager);
-    }
-
-    private static void assertIsCloseTo(long value1, long value2, long tolerance) {
-        assertThat(Math.abs(value1 - value2), not(greaterThan(tolerance)));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutorTest.java b/src/test/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutorTest.java
deleted file mode 100644
index 7e2e5fd0..00000000
--- a/src/test/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutorTest.java
+++ /dev/null
@@ -1,154 +0,0 @@
-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.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.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncDelayedTaskWithDelay;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.not;
-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.verifyNoInteractions;
-
-/**
- * Test for {@link PasswordRegisterExecutor}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PasswordRegisterExecutorTest {
-
-    @InjectMocks
-    private PasswordRegisterExecutor executor;
-
-    @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);
-        PasswordRegisterParams params = PasswordRegisterParams.of(player, password, null);
-
-        // when
-        boolean result = executor.isRegistrationAdmitted(params);
-
-        // 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);
-        PasswordRegisterParams params = PasswordRegisterParams.of(player, password, null);
-
-        // when
-        boolean result = executor.isRegistrationAdmitted(params);
-
-        // 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.mockIpAddressToPlayer(player, "123.45.67.89");
-        PasswordRegisterParams params = PasswordRegisterParams.of(player, "pass", "mail@example.org");
-
-        // when
-        PlayerAuth auth = executor.buildPlayerAuth(params);
-
-        // then
-        assertThat(auth, hasAuthBasicData("s1m0n", "S1m0N", "mail@example.org", null));
-        assertThat(auth.getRegistrationIp(), equalTo("123.45.67.89"));
-        assertIsCloseTo(auth.getRegistrationDate(), System.currentTimeMillis(), 500);
-        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);
-        PasswordRegisterParams params = PasswordRegisterParams.of(player, "pass", "mail@example.org");
-        setBukkitServiceToScheduleSyncDelayedTaskWithDelay(bukkitService);
-
-        // when
-        executor.executePostPersistAction(params);
-
-        // then
-        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);
-        PasswordRegisterParams params = PasswordRegisterParams.of(player, "pass", "mail@example.org");
-
-        // when
-        executor.executePostPersistAction(params);
-
-        // then
-        verifyNoInteractions(bukkitService, asynchronousLogin);
-        verify(syncProcessManager).processSyncPasswordRegister(player);
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-
-    private static void assertIsCloseTo(long value1, long value2, long tolerance) {
-        assertThat(Math.abs(value1 - value2), not(greaterThan(tolerance)));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/process/register/executors/PlayerAuthBuilderHelperTest.java b/src/test/java/fr/xephi/authme/process/register/executors/PlayerAuthBuilderHelperTest.java
deleted file mode 100644
index cbe460df..00000000
--- a/src/test/java/fr/xephi/authme/process/register/executors/PlayerAuthBuilderHelperTest.java
+++ /dev/null
@@ -1,41 +0,0 @@
-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.entity.Player;
-import org.junit.Test;
-
-import static fr.xephi.authme.AuthMeMatchers.equalToHash;
-import static fr.xephi.authme.AuthMeMatchers.hasAuthBasicData;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.lessThan;
-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.mockIpAddressToPlayer(player, ip);
-        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, null));
-        assertThat(auth.getRegistrationIp(), equalTo("192.168.34.47"));
-        assertThat(Math.abs(auth.getRegistrationDate() - System.currentTimeMillis()), lessThan(1000L));
-        assertThat(auth.getPassword(), equalToHash("myHash0001"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/process/unregister/AsynchronousUnregisterTest.java b/src/test/java/fr/xephi/authme/process/unregister/AsynchronousUnregisterTest.java
deleted file mode 100644
index 99d736dd..00000000
--- a/src/test/java/fr/xephi/authme/process/unregister/AsynchronousUnregisterTest.java
+++ /dev/null
@@ -1,310 +0,0 @@
-package fr.xephi.authme.process.unregister;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.data.limbo.LimboService;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.events.AbstractUnregisterEvent;
-import fr.xephi.authme.message.MessageKey;
-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.TeleportationService;
-import fr.xephi.authme.service.bungeecord.BungeeSender;
-import fr.xephi.authme.settings.commandconfig.CommandManager;
-import fr.xephi.authme.settings.properties.RegistrationSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.function.Function;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link AsynchronousUnregister}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class AsynchronousUnregisterTest {
-
-    @InjectMocks
-    private AsynchronousUnregister asynchronousUnregister;
-
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private CommonService service;
-    @Mock
-    private PasswordSecurity passwordSecurity;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private BukkitService bukkitService;
-    @Mock
-    private LimboService limboService;
-    @Mock
-    private TeleportationService teleportationService;
-    @Mock
-    private CommandManager commandManager;
-    @Mock
-    private BungeeSender bungeeSender;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldRejectWrongPassword() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Bobby";
-        given(player.getName()).willReturn(name);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(playerCache.getAuth(name)).willReturn(auth);
-        HashedPassword password = new HashedPassword("password", "in_auth_obj");
-        given(auth.getPassword()).willReturn(password);
-        String userPassword = "pass";
-        given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(false);
-
-        // when
-        asynchronousUnregister.unregister(player, userPassword);
-
-        // then
-        verify(service).send(player, MessageKey.WRONG_PASSWORD);
-        verify(passwordSecurity).comparePassword(userPassword, password, name);
-        verifyNoInteractions(dataSource, limboService, teleportationService, bukkitService, bungeeSender);
-        verify(player, only()).getName();
-    }
-
-    @Test
-    public void shouldPerformUnregister() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Frank21";
-        given(player.getName()).willReturn(name);
-        given(player.isOnline()).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(playerCache.getAuth(name)).willReturn(auth);
-        HashedPassword password = new HashedPassword("password", "in_auth_obj");
-        given(auth.getPassword()).willReturn(password);
-        String userPassword = "pass";
-        given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(true);
-        given(dataSource.removeAuth(name)).willReturn(true);
-        given(service.getProperty(RegistrationSettings.FORCE)).willReturn(true);
-        given(service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)).willReturn(true);
-        given(service.getProperty(RestrictionSettings.TIMEOUT)).willReturn(21);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        asynchronousUnregister.unregister(player, userPassword);
-
-        // then
-        verify(service).send(player, MessageKey.UNREGISTERED_SUCCESS);
-        verify(passwordSecurity).comparePassword(userPassword, password, name);
-        verify(dataSource).removeAuth(name);
-        verify(playerCache).removePlayer(name);
-        verify(teleportationService).teleportOnJoin(player);
-        verifyCalledUnregisterEventFor(player);
-        verify(commandManager).runCommandsOnUnregister(player);
-        verify(player).addPotionEffect(new PotionEffect(PotionEffectType.BLINDNESS, 21 * 20, 2));
-    }
-
-    @Test
-    public void shouldPerformUnregisterAndNotApplyBlindEffect() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Frank21";
-        given(player.getName()).willReturn(name);
-        given(player.isOnline()).willReturn(true);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(playerCache.getAuth(name)).willReturn(auth);
-        HashedPassword password = new HashedPassword("password", "in_auth_obj");
-        given(auth.getPassword()).willReturn(password);
-        String userPassword = "pass";
-        given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(true);
-        given(dataSource.removeAuth(name)).willReturn(true);
-        given(service.getProperty(RegistrationSettings.FORCE)).willReturn(true);
-        given(service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)).willReturn(false);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        asynchronousUnregister.unregister(player, userPassword);
-
-        // then
-        verify(service).send(player, MessageKey.UNREGISTERED_SUCCESS);
-        verify(passwordSecurity).comparePassword(userPassword, password, name);
-        verify(dataSource).removeAuth(name);
-        verify(playerCache).removePlayer(name);
-        verify(teleportationService).teleportOnJoin(player);
-        verifyCalledUnregisterEventFor(player);
-        verify(commandManager).runCommandsOnUnregister(player);
-        verify(player, never()).addPotionEffect(any(PotionEffect.class));
-    }
-
-    @Test
-    public void shouldNotApplyUnregisteredEffectsForNotForcedRegistration() {
-        // given
-        Player player = mock(Player.class);
-        String name = "__FranK";
-        given(player.getName()).willReturn(name);
-        given(player.isOnline()).willReturn(true);
-        String userPassword = "141$$5ad";
-        HashedPassword password = new HashedPassword("ttt123");
-        PlayerAuth auth = PlayerAuth.builder().name(name).password(password).build();
-        given(playerCache.getAuth(name)).willReturn(auth);
-        given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(true);
-        given(dataSource.removeAuth(name)).willReturn(true);
-        given(service.getProperty(RegistrationSettings.FORCE)).willReturn(false);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        asynchronousUnregister.unregister(player, userPassword);
-
-        // then
-        verify(service).send(player, MessageKey.UNREGISTERED_SUCCESS);
-        verify(passwordSecurity).comparePassword(userPassword, password, name);
-        verify(dataSource).removeAuth(name);
-        verify(playerCache).removePlayer(name);
-        verifyNoInteractions(teleportationService, limboService);
-        verifyCalledUnregisterEventFor(player);
-        verify(commandManager).runCommandsOnUnregister(player);
-    }
-
-    @Test
-    public void shouldHandleDatabaseError() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Frank21";
-        given(player.getName()).willReturn(name);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(playerCache.getAuth(name)).willReturn(auth);
-        HashedPassword password = new HashedPassword("password", "in_auth_obj");
-        given(auth.getPassword()).willReturn(password);
-        String userPassword = "pass";
-        given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(true);
-        given(dataSource.removeAuth(name)).willReturn(false);
-
-        // when
-        asynchronousUnregister.unregister(player, userPassword);
-
-        // then
-        verify(passwordSecurity).comparePassword(userPassword, password, name);
-        verify(dataSource).removeAuth(name);
-        verify(service).send(player, MessageKey.ERROR);
-        verifyNoInteractions(teleportationService, bukkitService, bungeeSender);
-    }
-
-    @Test
-    public void shouldNotTeleportOfflinePlayer() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Frank21";
-        given(player.getName()).willReturn(name);
-        given(player.isOnline()).willReturn(false);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        given(playerCache.getAuth(name)).willReturn(auth);
-        HashedPassword password = new HashedPassword("password", "in_auth_obj");
-        given(auth.getPassword()).willReturn(password);
-        String userPassword = "pass";
-        given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(true);
-        given(dataSource.removeAuth(name)).willReturn(true);
-
-        // when
-        asynchronousUnregister.unregister(player, userPassword);
-
-        // then
-        verify(passwordSecurity).comparePassword(userPassword, password, name);
-        verify(dataSource).removeAuth(name);
-        verify(playerCache).removePlayer(name);
-        verifyNoInteractions(teleportationService);
-        verifyCalledUnregisterEventFor(player);
-    }
-
-    // Initiator known and Player object available
-    @Test
-    public void shouldPerformAdminUnregister() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Frank21";
-        given(player.isOnline()).willReturn(true);
-        given(dataSource.removeAuth(name)).willReturn(true);
-        given(service.getProperty(RegistrationSettings.FORCE)).willReturn(true);
-        given(service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)).willReturn(false);
-        CommandSender initiator = mock(CommandSender.class);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        asynchronousUnregister.adminUnregister(initiator, name, player);
-
-        // then
-        verify(service).send(player, MessageKey.UNREGISTERED_SUCCESS);
-        verify(service).send(initiator, MessageKey.UNREGISTERED_SUCCESS);
-        verify(dataSource).removeAuth(name);
-        verify(playerCache).removePlayer(name);
-        verify(teleportationService).teleportOnJoin(player);
-        verifyCalledUnregisterEventFor(player);
-        verify(commandManager).runCommandsOnUnregister(player);
-    }
-
-    @Test
-    public void shouldPerformAdminUnregisterWithoutInitiatorOrPlayer() {
-        // given
-        String name = "billy";
-        given(dataSource.removeAuth(name)).willReturn(true);
-
-        // when
-        asynchronousUnregister.adminUnregister(null, name, null);
-
-        // then
-        verify(dataSource).removeAuth(name);
-        verify(playerCache).removePlayer(name);
-        verifyNoInteractions(teleportationService);
-        verifyCalledUnregisterEventFor(null);
-    }
-
-    @Test
-    public void shouldHandleDatabaseErrorForAdminUnregister() {
-        // given
-        String name = "TtOoLl";
-        CommandSender initiator = mock(CommandSender.class);
-        given(dataSource.removeAuth(name)).willReturn(false);
-
-        // when
-        asynchronousUnregister.adminUnregister(initiator, name, null);
-
-        // then
-        verify(dataSource).removeAuth(name);
-        verify(service).send(initiator, MessageKey.ERROR);
-        verifyNoInteractions(playerCache, teleportationService, bukkitService, bungeeSender);
-    }
-
-    @SuppressWarnings("unchecked")
-    private void verifyCalledUnregisterEventFor(Player player) {
-        ArgumentCaptor<Function<Boolean, AbstractUnregisterEvent>> eventFunctionCaptor =
-            ArgumentCaptor.forClass(Function.class);
-        verify(bukkitService).createAndCallEvent(eventFunctionCaptor.capture());
-        AbstractUnregisterEvent event = eventFunctionCaptor.getValue().apply(true);
-        assertThat(event.getPlayer(), equalTo(player));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/HashAlgorithmIntegrationTest.java b/src/test/java/fr/xephi/authme/security/HashAlgorithmIntegrationTest.java
deleted file mode 100644
index 8ebcbda1..00000000
--- a/src/test/java/fr/xephi/authme/security/HashAlgorithmIntegrationTest.java
+++ /dev/null
@@ -1,109 +0,0 @@
-package fr.xephi.authme.security;
-
-import ch.jalu.injector.Injector;
-import ch.jalu.injector.InjectorBuilder;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.security.crypts.Argon2;
-import fr.xephi.authme.security.crypts.EncryptionMethod;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.security.crypts.description.Recommendation;
-import fr.xephi.authme.security.crypts.description.Usage;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.HooksSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import fr.xephi.authme.util.StringUtils;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Integration test for {@link HashAlgorithm}.
- */
-public class HashAlgorithmIntegrationTest {
-
-    private static Injector injector;
-
-    @BeforeClass
-    public static void setUpConfigAndInjector() {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(HooksSettings.BCRYPT_LOG2_ROUND)).willReturn(8);
-        given(settings.getProperty(SecuritySettings.DOUBLE_MD5_SALT_LENGTH)).willReturn(16);
-        given(settings.getProperty(SecuritySettings.PBKDF2_NUMBER_OF_ROUNDS)).willReturn(10_000);
-        injector = new InjectorBuilder().addDefaultHandlers("fr.xephi.authme").create();
-        injector.register(Settings.class, settings);
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldHaveUniqueClassForEntries() {
-        // given
-        Set<Class<? extends EncryptionMethod>> classes = new HashSet<>();
-
-        // when / then
-        for (HashAlgorithm algorithm : HashAlgorithm.values()) {
-            if (!HashAlgorithm.CUSTOM.equals(algorithm)) {
-                if (!classes.add(algorithm.getClazz())) {
-                    fail("Found class '" + algorithm.getClazz() + "' twice!");
-                }
-            }
-        }
-    }
-
-    @Test
-    public void shouldBeAbleToInstantiateEncryptionAlgorithms() {
-        // given / when / then
-        for (HashAlgorithm algorithm : HashAlgorithm.values()) {
-            if (!HashAlgorithm.CUSTOM.equals(algorithm) && !HashAlgorithm.PLAINTEXT.equals(algorithm)) {
-                if (HashAlgorithm.ARGON2.equals(algorithm) && !Argon2.isLibraryLoaded()) {
-                    System.out.println("[WARNING] Cannot find argon2 library, skipping integration test");
-                    continue;
-                }
-                EncryptionMethod method = injector.createIfHasDependencies(algorithm.getClazz());
-                if (method == null) {
-                    fail("Could not create '" + algorithm.getClazz() + "' - forgot to provide some class?");
-                }
-                HashedPassword hashedPassword = method.computeHash("pwd", "name");
-                assertThat("Salt should not be null if method.hasSeparateSalt(), and vice versa. Method: '"
-                    + method + "'", StringUtils.isBlank(hashedPassword.getSalt()), equalTo(!method.hasSeparateSalt()));
-                assertThat("Hash should not be empty for method '" + method + "'",
-                    StringUtils.isBlank(hashedPassword.getHash()), equalTo(false));
-            }
-        }
-    }
-
-    @Test
-    public void shouldBeDeprecatedIfEncryptionClassIsDeprecated() throws NoSuchFieldException {
-        // given
-        List<String> failedEntries = new LinkedList<>();
-
-        // when
-        for (HashAlgorithm hashAlgorithm : HashAlgorithm.values()) {
-            if (hashAlgorithm != HashAlgorithm.CUSTOM && hashAlgorithm != HashAlgorithm.PLAINTEXT) {
-                boolean isEnumDeprecated = HashAlgorithm.class.getDeclaredField(hashAlgorithm.name())
-                    .isAnnotationPresent(Deprecated.class);
-                boolean isDeprecatedClass = hashAlgorithm.getClazz().isAnnotationPresent(Deprecated.class);
-                Recommendation recommendation = hashAlgorithm.getClazz().getAnnotation(Recommendation.class);
-                boolean hasDeprecatedUsage = recommendation != null && recommendation.value() == Usage.DEPRECATED;
-                if (isEnumDeprecated != isDeprecatedClass || isEnumDeprecated != hasDeprecatedUsage) {
-                    failedEntries.add(hashAlgorithm + ": enum @Deprecated = " + isEnumDeprecated
-                        + ", @Deprecated class = " + isDeprecatedClass + ", usage Deprecated = " + hasDeprecatedUsage);
-                }
-            }
-        }
-
-        // then
-        if (!failedEntries.isEmpty()) {
-            fail("Found inconsistencies:\n" + String.join("\n", failedEntries));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/HashUtilsTest.java b/src/test/java/fr/xephi/authme/security/HashUtilsTest.java
deleted file mode 100644
index 16cba704..00000000
--- a/src/test/java/fr/xephi/authme/security/HashUtilsTest.java
+++ /dev/null
@@ -1,136 +0,0 @@
-package fr.xephi.authme.security;
-
-import org.junit.Test;
-
-import java.security.MessageDigest;
-import java.util.ArrayList;
-import java.util.List;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link HashUtils}.
- */
-public class HashUtilsTest {
-
-    /**
-     * List of passwords whose hash is provided to the class to test against.
-     */
-    private static final String[] GIVEN_PASSWORDS = {"", "password", "PassWord1", "&^%te$t?Pw@_"};
-
-    @Test
-    public void shouldHashMd5() {
-        // given
-        String[] correctHashes =  {
-            "d41d8cd98f00b204e9800998ecf8427e", // empty string
-            "5f4dcc3b5aa765d61d8327deb882cf99", // password
-            "f2126d405f46ed603ff5b2950f062c96", // PassWord1
-            "0833dcd2bc741f90c46bbac5498fd08f"  // &^%te$t?Pw@_
-        };
-
-        // when
-        List<String> result = new ArrayList<>();
-        for (String password : GIVEN_PASSWORDS) {
-            result.add(HashUtils.md5(password));
-        }
-
-        // then
-        assertThat(result, contains(correctHashes));
-    }
-
-    @Test
-    public void shouldHashSha1() {
-        // given
-        String[] correctHashes =  {
-            "da39a3ee5e6b4b0d3255bfef95601890afd80709", // empty string
-            "5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8", // password
-            "285d0c707f9644b75e1a87a62f25d0efb56800f0", // PassWord1
-            "a42ef8e61e890af80461ca5dcded25cbfcf407a4"  // &^%te$t?Pw@_
-        };
-
-        // when
-        List<String> result = new ArrayList<>();
-        for (String password : GIVEN_PASSWORDS) {
-            result.add(HashUtils.sha1(password));
-        }
-
-        // then
-        assertThat(result, contains(correctHashes));
-    }
-
-    @Test
-    public void shouldHashSha256() {
-        // given
-        String[] correctHashes =  {
-            "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", // empty string
-            "5e884898da28047151d0e56f8dc6292773603d0d6aabbdd62a11ef721d1542d8", // password
-            "c04265d72b749debd67451c083785aa572742e3222e86884de16485fa14b55e7", // PassWord1
-            "005e3d7439d3e9a60a9d74aa1c763b36bfebec8e434ab6c5efab3df37eb2dae6"  // &^%te$t?Pw@_
-        };
-
-        // when
-        List<String> result = new ArrayList<>();
-        for (String password : GIVEN_PASSWORDS) {
-            result.add(HashUtils.sha256(password));
-        }
-
-        // then
-        assertThat(result, contains(correctHashes));
-    }
-
-
-    @Test
-    public void shouldHashSha512() {
-        // given
-        String[] correctHashes =  {
-            "cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e", // empty string
-            "b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86", // password
-            "ae9942149995a8171391625b36da134d5e288c721650d7c8d2d464fb49a49f3f551e4916ab1e097d9dd1201b01d69b1dccdefa3d2524a66092fb61b3df6e7e71", // PassWord1
-            "8c4f3df78db191142d819a72c16058b9e1ea41ae9b1649e1184eb89e30344c51c9c71039c483cf2f1b76b51480d8459d7eb3cfbaa24b07f2041d1551af4ead75"  // &^%te$t?Pw@_
-        };
-
-        // when
-        List<String> result = new ArrayList<>();
-        for (String password : GIVEN_PASSWORDS) {
-            result.add(HashUtils.sha512(password));
-        }
-
-        // then
-        assertThat(result, contains(correctHashes));
-    }
-
-    @Test
-    public void shouldRetrieveMd5Instance() {
-        // given
-        MessageDigestAlgorithm algorithm = MessageDigestAlgorithm.MD5;
-
-        // when
-        MessageDigest digest = HashUtils.getDigest(algorithm);
-
-        // then
-        assertThat(digest.getAlgorithm(), equalTo("MD5"));
-    }
-
-    @Test
-    public void shouldCheckForValidBcryptHashStart() {
-        // given / when / then
-        assertThat(HashUtils.isValidBcryptHash(""), equalTo(false));
-        assertThat(HashUtils.isValidBcryptHash("$2"), equalTo(false));
-        assertThat(HashUtils.isValidBcryptHash("#2ae5fc78"), equalTo(false));
-        assertThat(HashUtils.isValidBcryptHash("$2afsdaf"), equalTo(false));
-        assertThat(HashUtils.isValidBcryptHash("$fdfasdfasdfasdfasdfasdfasdfasdfasdfasdfsadfasdfasdfasdfasdf"), equalTo(false));
-        assertThat(HashUtils.isValidBcryptHash("$2y$asdfasdfasdfasdfasdfasdfasdfasdfasdfsadfasdfasdfasdfasdf"), equalTo(true));
-    }
-
-    @Test
-    public void shouldCompareStrings() {
-        // given / when / then
-        assertThat(HashUtils.isEqual("test", "test"), equalTo(true));
-        assertThat(HashUtils.isEqual("test", "Test"), equalTo(false));
-        assertThat(HashUtils.isEqual("1234", "1234."), equalTo(false));
-        assertThat(HashUtils.isEqual("ພາສາຫວຽດນາມ", "ພາສາຫວຽດນາມ"), equalTo(true));
-        assertThat(HashUtils.isEqual("test", "tëst"), equalTo(false));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/PasswordSecurityTest.java b/src/test/java/fr/xephi/authme/security/PasswordSecurityTest.java
deleted file mode 100644
index aa3165e7..00000000
--- a/src/test/java/fr/xephi/authme/security/PasswordSecurityTest.java
+++ /dev/null
@@ -1,289 +0,0 @@
-package fr.xephi.authme.security;
-
-import ch.jalu.injector.Injector;
-import ch.jalu.injector.InjectorBuilder;
-import ch.jalu.injector.factory.Factory;
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.events.PasswordEncryptionEvent;
-import fr.xephi.authme.security.crypts.EncryptionMethod;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.security.crypts.Joomla;
-import fr.xephi.authme.security.crypts.Md5;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.HooksSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.bukkit.event.Event;
-import org.bukkit.plugin.PluginManager;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-import java.util.Collections;
-import java.util.Locale;
-import java.util.Set;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.equalToIgnoringCase;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PasswordSecurity}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class PasswordSecurityTest {
-
-    @InjectDelayed
-    private PasswordSecurity passwordSecurity;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private PluginManager pluginManager;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private Factory<HashAlgorithm> hashAlgorithmFactory;
-
-    @Mock
-    private EncryptionMethod method;
-
-    private Class<?> caughtClassInEvent;
-
-    @BeforeClass
-    public static void setUpTest() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    public void setUpMocks() {
-        caughtClassInEvent = null;
-
-        // When the password encryption event is emitted, replace the encryption method with our mock.
-        doAnswer(new Answer<Void>() {
-            @Override
-            public Void answer(InvocationOnMock invocation) throws Throwable {
-                Object[] arguments = invocation.getArguments();
-                if (arguments[0] instanceof PasswordEncryptionEvent) {
-                    PasswordEncryptionEvent event = (PasswordEncryptionEvent) arguments[0];
-                    caughtClassInEvent = event.getMethod() == null ? null : event.getMethod().getClass();
-                    event.setMethod(method);
-                }
-                return null;
-            }
-        }).when(pluginManager).callEvent(any(Event.class));
-
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.BCRYPT);
-        given(settings.getProperty(SecuritySettings.LEGACY_HASHES)).willReturn(Collections.emptySet());
-        given(settings.getProperty(HooksSettings.BCRYPT_LOG2_ROUND)).willReturn(8);
-
-        Injector injector = new InjectorBuilder()
-            .addDefaultHandlers("fr.xephi.authme.security.crypts")
-            .create();
-        injector.register(Settings.class, settings);
-
-        given(hashAlgorithmFactory.newInstance(any(Class.class))).willAnswer(invocation -> {
-                Object o = injector.createIfHasDependencies(invocation.getArgument(0));
-                if (o == null) {
-                    throw new IllegalArgumentException("Cannot create object of class '" + invocation.getArgument(0)
-                        + "': missing class that needs to be provided?");
-                }
-                return o;
-        });
-    }
-
-    @Test
-    public void shouldReturnPasswordMatch() {
-        // given
-        HashedPassword password = new HashedPassword("$TEST$10$SOME_HASH", null);
-        String playerName = "Tester";
-        // Calls to EncryptionMethod are always with the lower-case version of the name
-        String playerLowerCase = playerName.toLowerCase(Locale.ROOT);
-        String clearTextPass = "myPassTest";
-
-        given(dataSource.getPassword(playerName)).willReturn(password);
-        given(method.comparePassword(clearTextPass, password, playerLowerCase)).willReturn(true);
-
-        // when
-        boolean result = passwordSecurity.comparePassword(clearTextPass, playerName);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(dataSource).getPassword(playerName);
-        verify(pluginManager).callEvent(any(PasswordEncryptionEvent.class));
-        verify(method).comparePassword(clearTextPass, password, playerLowerCase);
-    }
-
-    @Test
-    public void shouldReturnPasswordMismatch() {
-        // given
-        HashedPassword password = new HashedPassword("$TEST$10$SOME_HASH", null);
-        String playerName = "My_PLayer";
-        String playerLowerCase = playerName.toLowerCase(Locale.ROOT);
-        String clearTextPass = "passw0Rd1";
-
-        given(dataSource.getPassword(playerName)).willReturn(password);
-        given(method.comparePassword(clearTextPass, password, playerLowerCase)).willReturn(false);
-
-        // when
-        boolean result = passwordSecurity.comparePassword(clearTextPass, playerName);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(dataSource).getPassword(playerName);
-        verify(pluginManager).callEvent(any(PasswordEncryptionEvent.class));
-        verify(method).comparePassword(clearTextPass, password, playerLowerCase);
-    }
-
-    @Test
-    public void shouldReturnFalseIfPlayerDoesNotExist() {
-        // given
-        String playerName = "bobby";
-        String clearTextPass = "tables";
-        given(dataSource.getPassword(playerName)).willReturn(null);
-
-        // when
-        boolean result = passwordSecurity.comparePassword(clearTextPass, playerName);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(dataSource).getPassword(playerName);
-        verify(method, never()).comparePassword(anyString(), any(HashedPassword.class), anyString());
-    }
-
-    @Test
-    public void shouldTryOtherMethodsForFailedPassword() {
-        // given
-        // BCRYPT hash for "Test"
-        HashedPassword password =
-            new HashedPassword("$2y$10$2e6d2193f43501c926e25elvWlPmWczmrfrnbZV0dUZGITjYjnkkW");
-        String playerName = "somePlayer";
-        String playerLowerCase = playerName.toLowerCase(Locale.ROOT);
-        String clearTextPass = "Test";
-        // MD5 hash for "Test"
-        HashedPassword newPassword = new HashedPassword("0cbc6611f5540bd0809a388dc95a615b");
-
-        given(dataSource.getPassword(argThat(equalToIgnoringCase(playerName)))).willReturn(password);
-        given(method.comparePassword(clearTextPass, password, playerLowerCase)).willReturn(false);
-        given(method.computeHash(clearTextPass, playerLowerCase)).willReturn(newPassword);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.MD5);
-        given(settings.getProperty(SecuritySettings.LEGACY_HASHES)).willReturn(newHashSet(HashAlgorithm.BCRYPT));
-        passwordSecurity.reload();
-
-        // when
-        boolean result = passwordSecurity.comparePassword(clearTextPass, playerName);
-
-        // then
-        assertThat(result, equalTo(true));
-        // Note ljacqu 20151230: We need to check the player name in a case-insensitive way because the methods within
-        // PasswordSecurity may convert the name into all lower-case. This is desired because EncryptionMethod methods
-        // should only be invoked with all lower-case names. Data source is case-insensitive itself, so this is fine.
-        verify(dataSource).getPassword(argThat(equalToIgnoringCase(playerName)));
-        verify(pluginManager, times(2)).callEvent(any(PasswordEncryptionEvent.class));
-        verify(method).comparePassword(clearTextPass, password, playerLowerCase);
-        verify(dataSource).updatePassword(playerLowerCase, newPassword);
-    }
-
-    @Test
-    public void shouldTryLegacyMethodsAndFail() {
-        // given
-        HashedPassword password = new HashedPassword("hashNotMatchingAnyMethod", "someBogusSalt");
-        String playerName = "asfd";
-        String clearTextPass = "someInvalidPassword";
-        given(dataSource.getPassword(playerName)).willReturn(password);
-        given(method.comparePassword(clearTextPass, password, playerName)).willReturn(false);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.MD5);
-        given(settings.getProperty(SecuritySettings.LEGACY_HASHES)).willReturn(
-            newHashSet(HashAlgorithm.DOUBLEMD5, HashAlgorithm.JOOMLA, HashAlgorithm.SMF, HashAlgorithm.SHA256));
-        passwordSecurity.reload();
-
-        // when
-        boolean result = passwordSecurity.comparePassword(clearTextPass, playerName);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(dataSource, never()).updatePassword(anyString(), any(HashedPassword.class));
-    }
-
-    @Test
-    public void shouldHashPassword() {
-        // given
-        String password = "MyP@ssword";
-        String username = "theUserInTest";
-        String usernameLowerCase = username.toLowerCase(Locale.ROOT);
-        HashedPassword hashedPassword = new HashedPassword("$T$est#Hash", "__someSalt__");
-        given(method.computeHash(password, usernameLowerCase)).willReturn(hashedPassword);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.JOOMLA);
-        passwordSecurity.reload();
-
-        // when
-        HashedPassword result = passwordSecurity.computeHash(password, username);
-
-        // then
-        assertThat(result, equalTo(hashedPassword));
-        // Check that an event was fired twice: once on test setup, and once because we called reload()
-        verify(pluginManager, times(2)).callEvent(any(PasswordEncryptionEvent.class));
-        assertThat(Joomla.class.equals(caughtClassInEvent), equalTo(true));
-    }
-
-    @Test
-    public void shouldSkipCheckIfMandatorySaltIsUnavailable() {
-        // given
-        String password = "?topSecretPass\\";
-        String username = "someone12";
-        HashedPassword hashedPassword = new HashedPassword("~T!est#Hash");
-        given(method.hasSeparateSalt()).willReturn(true);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.XAUTH);
-        passwordSecurity.reload();
-
-        // when
-        boolean result = passwordSecurity.comparePassword(password, hashedPassword, username);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(dataSource, never()).getAuth(anyString());
-        // Check that an event was fired twice: once on test setup, and once because we called reload()
-        verify(pluginManager, times(2)).callEvent(any(PasswordEncryptionEvent.class));
-        verify(method, never()).comparePassword(anyString(), any(HashedPassword.class), anyString());
-    }
-
-    @Test
-    public void shouldReloadSettings() {
-        // given
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.MD5);
-        given(settings.getProperty(SecuritySettings.LEGACY_HASHES))
-            .willReturn(newHashSet(HashAlgorithm.CUSTOM, HashAlgorithm.BCRYPT));
-        reset(pluginManager); // reset behavior when the event is emitted to check that we create an instance of Md5.java
-
-        // when
-        passwordSecurity.reload();
-
-        // then
-        assertThat(ReflectionTestUtils.getFieldValue(PasswordSecurity.class, passwordSecurity, "encryptionMethod"),
-            instanceOf(Md5.class));
-        Set<HashAlgorithm> legacyHashesSet = newHashSet(HashAlgorithm.CUSTOM, HashAlgorithm.BCRYPT);
-        assertThat(ReflectionTestUtils.getFieldValue(PasswordSecurity.class, passwordSecurity, "legacyAlgorithms"),
-            equalTo(legacyHashesSet));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/AbstractEncryptionMethodTest.java b/src/test/java/fr/xephi/authme/security/crypts/AbstractEncryptionMethodTest.java
deleted file mode 100644
index 6a96425f..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/AbstractEncryptionMethodTest.java
+++ /dev/null
@@ -1,239 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.security.crypts.description.AsciiRestricted;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeThat;
-
-/**
- * Test for implementations of {@link EncryptionMethod}.
- */
-public abstract class AbstractEncryptionMethodTest {
-
-    /** The username used to query {@link EncryptionMethod#comparePassword}. */
-    private static final String USERNAME = "Test_Player00";
-    /**
-     * List of passwords whose hash is provided to the class to test against; this verifies that previously constructed
-     * hashes remain valid.
-     */
-    private static final String[] GIVEN_PASSWORDS = {"password", "PassWord1", "&^%te$t?Pw@_", "âË_3(íù*"};
-    /**
-     * List of passwords that are hashed at runtime and then tested against; this verifies that newly generated hashes
-     * are valid.
-     */
-    private static final List<String> INTERNAL_PASSWORDS =
-        ImmutableList.of("test1234", "Ab_C73", "(!#&$~`_-Aa0", "Ûïé1&?+A");
-
-    private static final String[] BOGUS_HASHES = {"", "test", "$t$test$", "$SHA$Test$$$$", "$$$$$",
-        "asdfg:hjkl", "::test", "~#$#~~~#$#~", "d41d8cd98f00b204e9800998ecf427e",
-        "$2y$7a$da641e404b982ed" };
-
-    /**
-     * Certain hash algorithms are slow by design, which has a considerable effect on these unit tests.
-     * Setting the property below to "true" will reduce the checks in these unit tests as to offer fast,
-     * partial tests during development.
-     */
-    private static final boolean SKIP_LONG_TESTS =
-        "true".equals(System.getProperty("project.skipExtendedHashTests"));
-
-    /** The encryption method to test. */
-    private EncryptionMethod method;
-    /** Map with the hashes against which the entries in GIVEN_PASSWORDS are tested. */
-    private Map<String, HashedPassword> hashes;
-
-    /**
-     * Creates a new test for the given encryption method. This is for encryption methods that do not have
-     * a separate salt.
-     *
-     * @param method the encryption method to test
-     * @param hash0 the pre-generated hash for the first entry in {@link #GIVEN_PASSWORDS}
-     * @param hash1 hash for second given password
-     * @param hash2 hash for third given password
-     * @param hash3 hash for fourth given password
-     */
-    public AbstractEncryptionMethodTest(EncryptionMethod method, String hash0,
-                                        String hash1, String hash2, String hash3) {
-        verifyCorrectConstructorIsUsed(method, false);
-        this.method = method;
-
-        hashes = ImmutableMap.of(
-            GIVEN_PASSWORDS[0], new HashedPassword(hash0),
-            GIVEN_PASSWORDS[1], new HashedPassword(hash1),
-            GIVEN_PASSWORDS[2], new HashedPassword(hash2),
-            GIVEN_PASSWORDS[3], new HashedPassword(hash3));
-    }
-
-    /**
-     * Creates a new test for the given encryption method. This is for encryption methods that use
-     * a separate salt.
-     *
-     * @param method the encryption method to test
-     * @param result0 the pre-generated hash for the first entry in {@link #GIVEN_PASSWORDS}
-     * @param result1 hash for second given password
-     * @param result2 hash for third given password
-     * @param result3 hash for fourth given password
-     */
-    public AbstractEncryptionMethodTest(EncryptionMethod method, HashedPassword result0, HashedPassword result1,
-                                        HashedPassword result2, HashedPassword result3) {
-        verifyCorrectConstructorIsUsed(method, true);
-        this.method = method;
-
-        hashes = ImmutableMap.of(
-            GIVEN_PASSWORDS[0], result0,
-            GIVEN_PASSWORDS[1], result1,
-            GIVEN_PASSWORDS[2], result2,
-            GIVEN_PASSWORDS[3], result3);
-    }
-
-    @BeforeClass
-    public static void setupLogger() {
-        TestHelper.setupLogger();
-    }
-
-    protected void verifyCorrectConstructorIsUsed(EncryptionMethod method, boolean isConstructorWithSalt) {
-        if (isConstructorWithSalt && !method.hasSeparateSalt()) {
-            throw new UnsupportedOperationException("Salt is not stored separately, so test should be initialized"
-                + " with the password hashes only. Use the other constructor");
-        } else if (!isConstructorWithSalt && method.hasSeparateSalt()) {
-            throw new UnsupportedOperationException("Test must be initialized with HashedPassword objects if "
-                + "the salt is stored separately. Use the other constructor");
-        }
-    }
-
-    @Test
-    public void testGivenPasswords() {
-        // Start with the 2nd to last password if we skip long tests
-        int start = SKIP_LONG_TESTS ? GIVEN_PASSWORDS.length - 2 : 0;
-        // Test entries in GIVEN_PASSWORDS except the last one
-        for (int i = start; i < GIVEN_PASSWORDS.length - 1; ++i) {
-            String password = GIVEN_PASSWORDS[i];
-            assertTrue("Hash for password '" + password + "' should match",
-                doesGivenHashMatch(password, method));
-        }
-
-        // Note #375: Windows console seems to use its own character encoding (Windows-1252?) and it seems impossible to
-        // force it to use UTF-8, so passwords with non-ASCII characters will fail. Since we do not recommend to use
-        // such characters in passwords (something outside of our control, e.g. a database system, might also cause
-        // problems), we will check the last password in GIVEN_PASSWORDS in a non-failing way; if the hash doesn't match
-        // we'll just issue a message to System.err
-        String lastPassword = GIVEN_PASSWORDS[GIVEN_PASSWORDS.length - 1];
-        if (!doesGivenHashMatch(lastPassword, method)) {
-            System.err.println("Note: Hash for password '" + lastPassword + "' does not match for method " + method);
-        }
-    }
-
-    @Test
-    public void testPasswordEquality() {
-        List<String> internalPasswords = method.getClass().isAnnotationPresent(AsciiRestricted.class)
-            ? INTERNAL_PASSWORDS.subList(0, INTERNAL_PASSWORDS.size() - 1)
-            : INTERNAL_PASSWORDS;
-
-        for (String password : internalPasswords) {
-            final String salt = method.generateSalt();
-            final String hash = method.computeHash(password, salt, USERNAME);
-            HashedPassword hashedPassword = new HashedPassword(hash, salt);
-
-            // Check that the computeHash(password, salt, name) method has the same output for the returned salt
-            if (testHashEqualityForSameSalt()) {
-                assertThat("Computing a hash with the same salt will generate the same hash",
-                    hash, equalTo(method.computeHash(password, salt, USERNAME)));
-            }
-
-            assertTrue("Generated hash for '" + password + "' should match password (hash = '" + hash + "')",
-                method.comparePassword(password, hashedPassword, USERNAME));
-            assumeThat(SKIP_LONG_TESTS, equalTo(false));
-
-            if (!password.equals(password.toLowerCase(Locale.ROOT))) {
-                assertFalse("Lower-case of '" + password + "' should not match generated hash '" + hash + "'",
-                    method.comparePassword(password.toLowerCase(Locale.ROOT), hashedPassword, USERNAME));
-            }
-            if (!password.equals(password.toUpperCase(Locale.ROOT))) {
-                assertFalse("Upper-case of '" + password + "' should not match generated hash '" + hash + "'",
-                    method.comparePassword(password.toUpperCase(Locale.ROOT), hashedPassword, USERNAME));
-            }
-        }
-    }
-
-    /** Tests various strings to ensure that encryption methods don't rely on the hash's format too much. */
-    @Test
-    public void testMalformedHashes() {
-        assumeThat(SKIP_LONG_TESTS, equalTo(false));
-        String salt = method.hasSeparateSalt() ? "testSalt" : null;
-        for (String bogusHash : BOGUS_HASHES) {
-            HashedPassword hashedPwd = new HashedPassword(bogusHash, salt);
-            assertFalse("Passing bogus hash '" + bogusHash + "' does not result in an error",
-                method.comparePassword("Password", hashedPwd, "player"));
-        }
-    }
-
-    private boolean doesGivenHashMatch(String password, EncryptionMethod method) {
-        return method.comparePassword(password, hashes.get(password), USERNAME);
-    }
-
-    /**
-     * Generates a test class for a given encryption method. Simply create a test class and run the following code,
-     * replacing {@code XXX} with the actual class:
-     * <p>
-     * <code>@org.junit.Test public void generate() { AbstractEncryptionMethodTest.generateTest(new XXX()); }</code>
-     * <p>
-     * The output is the entire test class.
-     *
-     * @param method The method to create a test class for
-     */
-    protected static void generateTest(EncryptionMethod method) {
-        String className = method.getClass().getSimpleName();
-        // Create javadoc and "public class extends" and the constructor call "super(new Class(),"
-        System.out.println("/**\n * Test for {@link " + className + "}.\n */");
-        System.out.println("public class " + className + "Test extends AbstractEncryptionMethodTest {");
-        System.out.println("\n\tpublic " + className + "Test() {");
-        System.out.println("\t\tsuper(new " + className + "(),");
-
-        // Iterate through the GIVEN_PASSWORDS and generate a hash so we can always check it later
-        String delim = ",  ";
-        for (String password : GIVEN_PASSWORDS) {
-            if (password.equals(GIVEN_PASSWORDS[GIVEN_PASSWORDS.length - 1])) {
-                delim = "); ";
-            }
-
-            // Encr. method uses separate salt, so we need to call the constructor that takes HashedPassword instances
-            if (method.hasSeparateSalt()) {
-                HashedPassword hashedPassword = method.computeHash(password, USERNAME);
-                System.out.println(String.format("\t\tnew HashedPassword(\"%s\", \"%s\")%s// %s",
-                    hashedPassword.getHash(), hashedPassword.getSalt(), delim, password));
-            } else {
-                // Encryption method doesn't have separate salt, so simply pass the generated hash to the constructor
-                System.out.println("\t\t\"" + method.computeHash(password, USERNAME).getHash()
-                    + "\"" + delim + "// " + password);
-            }
-        }
-
-        // Close the constructor and class declarations
-        System.out.println("\t}");
-        System.out.println("\n}");
-    }
-
-    /**
-     * Return whether an encryption algorithm should be tested that it generates the same
-     * hash for the same salt. If {@code true}, we call {@link EncryptionMethod#computeHash(String, String)}
-     * and verify that {@link EncryptionMethod#computeHash(String, String, String)} generates
-     * the same hash for the salt returned in the first call.
-     *
-     * @return Whether or not to test that the hash is the same for the same salt
-     */
-    protected boolean testHashEqualityForSameSalt() {
-        return true;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Argon2Test.java b/src/test/java/fr/xephi/authme/security/crypts/Argon2Test.java
deleted file mode 100644
index 46b315d5..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Argon2Test.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assume.assumeThat;
-
-/**
- * Test for {@link Argon2}.
- */
-public class Argon2Test extends AbstractEncryptionMethodTest {
-
-    private static final boolean IS_LIBRARY_LOADED = Argon2.isLibraryLoaded();
-
-    public Argon2Test() {
-        super(new Argon2(),
-            "$argon2i$v=19$m=65536,t=2,p=1$dOP8NiXsPTcMgzI4Z8Rbew$ShdowtoTEWTL5UTFz1UgQOigb9JOlm4ZxWPA6WbIeUw",  // password
-            "$argon2i$v=19$m=65536,t=2,p=1$amZHbPfgc5peKd/4w1AI1g$Q2PUiOVw47TACijP57U0xf7QfiZ00HV4eFzMDA6yKRE",  // PassWord1
-            "$argon2i$v=19$m=65536,t=2,p=1$58v7dWNn9/bpD00QLzSebw$7cMC7p0qceE3Mgf2yQp4X7c+UkO9oyJwQ7S6XTBubNs",  // &^%te$t?Pw@_
-            "$argon2i$v=19$m=65536,t=2,p=1$93OSU71DgBOzpmhti7+6rQ$sSSI6QQQdoG9DlGwLjYz576kTek89nwr9CyNpy6bsL0"); // âË_3(íù*
-
-        assumeThat("Argon2 library is not loaded - skipping test",
-            IS_LIBRARY_LOADED, equalTo(true));
-    }
-
-    @Override
-    protected boolean testHashEqualityForSameSalt() {
-        // Argon2 has a salt but it is handled internally
-        return false;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/BCrypt2yTest.java b/src/test/java/fr/xephi/authme/security/crypts/BCrypt2yTest.java
deleted file mode 100644
index f34bac62..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/BCrypt2yTest.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.nullValue;
-import static org.hamcrest.Matchers.startsWith;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link BCrypt2y}.
- */
-public class BCrypt2yTest extends AbstractEncryptionMethodTest {
-
-    public BCrypt2yTest() {
-        super(new BCrypt2y(),
-            "$2y$10$da641e404b982edf1c7c0uTU9BcKzfA2vWKV05q6r.dCvm/93wqVK",  // password
-            "$2y$10$e52c48a76f5b86f5da899uiK/HYocyPsfQXESNbP278rIz08LKEP2",  // PassWord1
-            "$2y$10$be6f11548dc5fb4088410ONdC0dXnJ04y1RHcJh5fVF3XK5d.qgqK",  // &^%te$t?Pw@_
-            "$2y$10$a8097db1fa4423b93f1b2eF6rMAGFkSX178fpROf/OvCFtrDebp6K"); // âË_3(íù*
-    }
-
-    @Test
-    public void shouldGenerateWith2yPrefixAndCostFactor10() {
-        // given
-        BCrypt2y bCrypt2y = new BCrypt2y();
-
-        // when
-        HashedPassword result = bCrypt2y.computeHash("test", null);
-
-        // then
-        assertThat(result.getHash(), startsWith("$2y$10$"));
-        assertThat(result.getSalt(), nullValue());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/BCryptTest.java b/src/test/java/fr/xephi/authme/security/crypts/BCryptTest.java
deleted file mode 100644
index 9c3946f1..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/BCryptTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.HooksSettings;
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.startsWith;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link BCrypt}.
- */
-public class BCryptTest extends AbstractEncryptionMethodTest {
-
-    public BCryptTest() {
-        super(new BCrypt(mockSettings()),
-            "$2a$10$6iATmYgwJVc3YONhVcZFve3Cfb5GnwvKhJ20r.hMjmcNkIT9.Uh9K", // password
-            "$2a$10$LOhUxhEcS0vgDPv/jkXvCurNb7LjP9xUlEolJGk.Uhgikqc6FtIOi", // PassWord1
-            "$2a$10$j9da7SGiaakWhzIms9BtwemLUeIhSEphGUQ3XSlvYgpYsGnGCKRBa", // &^%te$t?Pw@_
-            "$2a$10$mkmO3SNzQT/SA5fG/8P8PePz/DI/kKpIH8vd1Owf/fQfFu6F0QyWO"  // âË_3(íù*
-        );
-    }
-
-    @Test
-    public void shouldGenerateWith2aPrefix() {
-        // given
-        BCrypt bCrypt = new BCrypt(mockSettings());
-
-        // when
-        HashedPassword result = bCrypt.computeHash("test", null);
-
-        // then
-        assertThat(result.getHash(), startsWith("$2a$08$"));
-    }
-
-    private static Settings mockSettings() {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(HooksSettings.BCRYPT_LOG2_ROUND)).willReturn(8);
-        return settings;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/CmwCryptTest.java b/src/test/java/fr/xephi/authme/security/crypts/CmwCryptTest.java
deleted file mode 100644
index 7c6652db..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/CmwCryptTest.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link CmwCrypt}.
- */
-public class CmwCryptTest extends AbstractEncryptionMethodTest {
-
-    public CmwCryptTest() {
-        super(new CmwCrypt(),
-            "1619d7adc23f4f633f11014d2f22b7d8",  // password
-            "c651798d2d9da38f86654107ae60c86a",  // PassWord1
-            "1fff869a744700cdb623a403c46e93ea",  // &^%te$t?Pw@_
-            "6436230e0effff37af79302147319dda"); // âË_3(íù*
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/CrazyCrypt1Test.java b/src/test/java/fr/xephi/authme/security/crypts/CrazyCrypt1Test.java
deleted file mode 100644
index f98ece5a..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/CrazyCrypt1Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link CrazyCrypt1}.
- */
-public class CrazyCrypt1Test extends AbstractEncryptionMethodTest {
-
-    public CrazyCrypt1Test() {
-        super(new CrazyCrypt1(),
-            "d5c76eb36417d4e97ec62609619e40a9e549a2598d0dab5a7194fd997a9305af78de2b93f958e150d19dd1e7f821043379ddf5f9c7f352bf27df91ae4913f3e8",  // password
-            "49c63f827c88196871e344e589bd46cc4fa6db3c27801bbad5374c0d216381977627c1d76f2114667d5dd117e046f7493eb06e4f461f4f848aa08f6f40a3e934",  // PassWord1
-            "6fefb0233bab6e6efb9c16f82cb0d8f569488905e2dae0e7c9dde700e7363da67213d37c44bc15f4a05854c9c21e5688389d416413c7309398aa96cb1f341d08",  // &^%te$t?Pw@_
-            "46f51cde7657fdec9848bad0fd8e7fb97783cf5335f94dbb5260899ab0b04022a52d651b1c45345328850178e7165308c8c213040b0864de66018a0b769d37cb"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/DoubleMd5Test.java b/src/test/java/fr/xephi/authme/security/crypts/DoubleMd5Test.java
deleted file mode 100644
index cc12df9e..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/DoubleMd5Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link DoubleMd5}.
- */
-public class DoubleMd5Test extends AbstractEncryptionMethodTest {
-
-    public DoubleMd5Test() {
-        super(new DoubleMd5(),
-            "696d29e0940a4957748fe3fc9efd22a3",  // password
-            "c77aa2024d9fb7233a2872452d601aba",  // PassWord1
-            "fbd5790af706ec19f8a7ef161878758b",  // &^%te$t?Pw@_
-            "cf3b0b6c6c7a4da95019634fb732aaf0"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Ipb3Test.java b/src/test/java/fr/xephi/authme/security/crypts/Ipb3Test.java
deleted file mode 100644
index 984f3d21..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Ipb3Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Ipb3}.
- */
-public class Ipb3Test extends AbstractEncryptionMethodTest {
-
-    public Ipb3Test() {
-        super(new Ipb3(),
-            new HashedPassword("f8ecea1ce42b5babef369ff7692dbe3f", "1715b"),  //password
-            new HashedPassword("40a93731a931352e0619cdf09b975040", "ba91c"),  //PassWord1
-            new HashedPassword("a77ca982373946d5800430bd2947ba11", "a7725"),  //&^%te$t?Pw@_
-            new HashedPassword("383d7b9e2b707d6e894ec7b30e3032c3", "fa9fd")); //âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Ipb4Test.java b/src/test/java/fr/xephi/authme/security/crypts/Ipb4Test.java
deleted file mode 100644
index d019f3d7..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Ipb4Test.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import org.junit.Test;
-
-import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.startsWith;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link Ipb4}.
- */
-public class Ipb4Test extends AbstractEncryptionMethodTest {
-
-    public Ipb4Test() {
-        super(new Ipb4(),
-            new HashedPassword("$2a$13$leEvXu77OIwPwNvtZIJvaeAx8EItGHuR3nIlq8416g0gXeJaQdrr2", "leEvXu77OIwPwNvtZIJval"),  //password
-            new HashedPassword("$2a$13$xyTTP9zhQQtRRKIJPv5AuuOGJ6Ni9FLbDhcuIAcPjt3XzCxIWe3Uu", "xyTTP9zhQQtRRKIJPv5Au3"),  //PassWord1
-            new HashedPassword("$2a$13$rGBrqErm9DZyzbxIGHlgf.xfA15/4d5Ay/TK.3y9lG3AljcoG9Lsi", "rGBrqErm9DZyzbxIGHlgfN"),  //&^%te$t?Pw@_
-            new HashedPassword("$2a$13$18dKXZLoGpeHHL81edM9HuipiUcMjn5VDJHlxwRUMRXfJ1b.ZQrJ.", "18dKXZLoGpeHHL81edM9H6")); //âË_3(íù*
-    }
-
-    @Test
-    public void shouldCreateHashesWith2aAndCostFactor13() {
-        // given
-        Ipb4 hashMethod = new Ipb4();
-
-        // when
-        HashedPassword result = hashMethod.computeHash("test", "name");
-
-        // then
-        assertThat(result.getHash(), startsWith("$2a$13$"));
-        assertThat(result.getSalt(), stringWithLength(22));
-    }
-
-    @Test
-    public void shouldThrowForInvalidSalt() {
-        // given
-        Ipb4 hashMethod = new Ipb4();
-
-        // when
-        try {
-            hashMethod.computeHash("pass", "invalid salt", "name");
-
-            // then
-            fail("Expected exception to be thrown");
-        } catch (IllegalStateException e) {
-            assertThat(e.getMessage(), containsString("Cannot parse hash with salt"));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/JoomlaTest.java b/src/test/java/fr/xephi/authme/security/crypts/JoomlaTest.java
deleted file mode 100644
index d2673b34..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/JoomlaTest.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Joomla}.
- */
-public class JoomlaTest extends AbstractEncryptionMethodTest {
-
-    public JoomlaTest() {
-        super(new Joomla(),
-            "b18c99813cd96df3a706652f47177490:377c4aaf92c5ed57711306909e6065ca", // password
-            "c5af71da91a8841d95937ba24a5b7fdb:07068e5850930b794526a614438cafc7", // PassWord1
-            "f5fccd5166af7080833d7c7a6a531295:7cb6eeabcfac67ffe1341ec43375a9e6", // &^%te$t?Pw@_
-            "dce946c6864d2223caeed9d80f356bcc:0c55fa3eca8c42557a989700ac1c4b8e"  // âË_3(íù*
-        );
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Md5Test.java b/src/test/java/fr/xephi/authme/security/crypts/Md5Test.java
deleted file mode 100644
index c0791837..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Md5Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Md5}.
- */
-public class Md5Test extends AbstractEncryptionMethodTest {
-
-    public Md5Test() {
-        super(new Md5(),
-            "5f4dcc3b5aa765d61d8327deb882cf99",  // password
-            "f2126d405f46ed603ff5b2950f062c96",  // PassWord1
-            "0833dcd2bc741f90c46bbac5498fd08f",  // &^%te$t?Pw@_
-            "d1accd961cb7b688c87278191c1dfed3"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Md5vBTest.java b/src/test/java/fr/xephi/authme/security/crypts/Md5vBTest.java
deleted file mode 100644
index eac20fcd..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Md5vBTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Md5vB}.
- */
-public class Md5vBTest extends AbstractEncryptionMethodTest {
-
-    public Md5vBTest() {
-        super(new Md5vB(),
-            "$MD5vb$bd9832fffa287321$5006d371fcb813f2347987f902a024ad",  // password
-            "$MD5vb$5e492c1166b5a828$c954fa5ee561700a097826971653b57f",  // PassWord1
-            "$MD5vb$3ec43cd46a61d70b$59687c0976f2e327b1245c8063f7008c",  // &^%te$t?Pw@_
-            "$MD5vb$2fb6bf22929e3127$a7155b88e2899561fe16b14ccdb0d935"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/MyBBTest.java b/src/test/java/fr/xephi/authme/security/crypts/MyBBTest.java
deleted file mode 100644
index fabd9f35..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/MyBBTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link MyBB}.
- */
-public class MyBBTest extends AbstractEncryptionMethodTest {
-
-    public MyBBTest() {
-        super(new MyBB(),
-            new HashedPassword("57c7a16d860833db5030738f5a465d2b", "acdc14e6"),  //password
-            new HashedPassword("08fbdf721f2c42d9780b7d66df0ba830", "792fd7fb"),  //PassWord1
-            new HashedPassword("d602f38fb59ad9e185d5604f5d4ddb36", "4b5534a4"),  //&^%te$t?Pw@_
-            new HashedPassword("b3c39410d0ab8ae2a65c257820797fad", "e5a6cb14")); //âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Pbkdf2DjangoTest.java b/src/test/java/fr/xephi/authme/security/crypts/Pbkdf2DjangoTest.java
deleted file mode 100644
index a5a1af61..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Pbkdf2DjangoTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Pbkdf2Django}.
- */
-public class Pbkdf2DjangoTest extends AbstractEncryptionMethodTest {
-
-    public Pbkdf2DjangoTest() {
-        super(new Pbkdf2Django(),
-            "pbkdf2_sha256$15000$50a7ff2d7e00$t7Qx2CfzMhGEbyCa3Wk5nJvNjj3N+FdxhpwJDerl4Fs=",  // password
-            "pbkdf2_sha256$15000$f9d8a58f3fe2$oMqmMGuJetdubW0cpubmT8CltQLjHT+L2GuwKsaWLx8=",  // PassWord1
-            "pbkdf2_sha256$15000$1170bc7a31f5$Ex/2aQsXm4kogLIYARpUPn04ccK5LYYjyVPpl32ALjE=",  // &^%te$t?Pw@_
-            "pbkdf2_sha256$15000$c029bd67eea4$Hfw992SL2WtYQ6g2WLdxA09hbmMDwjrr/Z+uUggbxwo="); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Pbkdf2Test.java b/src/test/java/fr/xephi/authme/security/crypts/Pbkdf2Test.java
deleted file mode 100644
index 8296e56e..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Pbkdf2Test.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link Pbkdf2}.
- */
-public class Pbkdf2Test extends AbstractEncryptionMethodTest {
-
-    public Pbkdf2Test() {
-        super(new Pbkdf2(mockSettings()),
-            "pbkdf2_sha256$10000$b25801311edf$093E38B16DFF13FCE5CD64D5D888EE6E0376A3E572FE5DA6749515EA0F384413223A21C464B0BE899E64084D1FFEFD44F2AC768453C87F41B42CC6954C416900",  // password
-            "pbkdf2_sha256$10000$fe705da06c57$A41527BD58FED9C9E6F452FC1BA8B0C4C4224ECC63E37F71EB1A0865D2AB81BBFEBCA9B7B6A6E8AEF4717B43F8EB6FB4EDEFFBB399D9D991EF7E23013595BAF0",  // PassWord1
-            "pbkdf2_sha256$10000$05603593cdda$1D30D1D90D826C866755969F06C312E21CC3E8DA0B777E2C764700E4E1FD890B731FAF44753D68F3FC025D3EAA709E800FBF2AF61DB23464311FCE7D35353A30",  // &^%te$t?Pw@_
-            "pbkdf2_sha256$10000$fb944d66d754$F7E3BF8CB07CE3B3C8C5C534F803252F7B4FD58832E33BA62BA46CA06F23BAE12BE03A9CB5874BCFD4469E42972406F920E59F002247B23C22A8CF3D0E7BFFE0"); // âË_3(íù*
-    }
-
-    @Test
-    public void shouldDetectMatchForHashWithOtherRoundNumber() {
-        // given
-        Pbkdf2 pbkdf2 = new Pbkdf2(mockSettings());
-        String hash = "pbkdf2_sha256$4128$3469b0d48b702046$DC8A54351008C6054E12FB19E0BF8A4EA6D4165E0EDC97A1ECD15231037C382DE5BF85D07D5BC9D1ADF9BBFE4CE257C6059FB1B9FF65DB69D8B205F064BE0DA9";
-        String clearText = "PassWord1";
-
-        // when
-        boolean isMatch = pbkdf2.comparePassword(clearText, new HashedPassword(hash), "");
-
-        // then
-        assertThat(isMatch, equalTo(true));
-    }
-
-    private static Settings mockSettings() {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(SecuritySettings.PBKDF2_NUMBER_OF_ROUNDS)).willReturn(4128);
-        return settings;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/PhpBBTest.java b/src/test/java/fr/xephi/authme/security/crypts/PhpBBTest.java
deleted file mode 100644
index 743a7b46..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/PhpBBTest.java
+++ /dev/null
@@ -1,59 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import com.google.common.collect.ImmutableMap;
-import org.junit.Test;
-
-import java.util.Map;
-
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link PhpBB}.
- */
-public class PhpBBTest extends AbstractEncryptionMethodTest {
-
-    public PhpBBTest() {
-        super(new PhpBB(),
-            "$2a$10$1rnuna3GBduBy1NQuOpnWODqBfl8CZHeULuBThNfAvkOYDRRQR1Zi",  // password
-            "$2a$10$F6LVgXa8.t95H0Fikr6nG.aEMgIQRXlFpzMvAjbO7ag3fny9GGS3i",  // PassWord1
-            "$2a$10$ex57hkfuMLwYsdG8ru/4teh48kHCSv0HPLPjhhHsEB3NqXiOi7RQS",  // &^%te$t?Pw@_
-            "$2a$10$2B/HAJ3MeoxGQgqLM6GDlOBqd.2uzLPi1VznXlrXcayLixSaRIWqC"); // âË_3(íù*
-    }
-
-    @Test
-    public void shouldMatchPhpassSaltedMd5Hashes() {
-        // given
-        Map<String, String> givenHashes = ImmutableMap.of(
-            "password", "$H$7MaSGQb0xe3Fp/a.Q.Ewpw.UKfCv.t0",
-            "PassWord1", "$H$7ESfAVjzqajC7fJFcZKZIhyds41MuW.",
-            "&^%te$t?Pw@_", "$H$7G65SXRPbR69jLg.qZTjtqsw36Ciw7.",
-            "âË_3(íù*", "$H$7Brcg8zO9amr2SHVgz.pFxprDu40v4/");
-        PhpBB phpBB = new PhpBB();
-
-        // when / then
-        for (Map.Entry<String, String> hashEntry : givenHashes.entrySet()) {
-            if (!phpBB.comparePassword(hashEntry.getKey(), new HashedPassword(hashEntry.getValue()), null)) {
-                fail("Hash comparison for '" + hashEntry.getKey() + "' failed");
-            }
-        }
-    }
-
-    @Test
-    public void shouldMatchUnsaltedMd5Hashes() {
-        // given
-        Map<String, String> givenHashes = ImmutableMap.of(
-            "password", "5f4dcc3b5aa765d61d8327deb882cf99",
-            "PassWord1", "f2126d405f46ed603ff5b2950f062c96",
-            "&^%te$t?Pw@_", "0833dcd2bc741f90c46bbac5498fd08f",
-            "âË_3(íù*", "e7412bf1a9d312dc2901c3101a097abe");
-        PhpBB phpBB = new PhpBB();
-
-        // when / then
-        for (Map.Entry<String, String> hashEntry : givenHashes.entrySet()) {
-            if (!phpBB.comparePassword(hashEntry.getKey(), new HashedPassword(hashEntry.getValue()), null)) {
-                fail("Hash comparison for '" + hashEntry.getKey() + "' failed");
-            }
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/PhpFusionTest.java b/src/test/java/fr/xephi/authme/security/crypts/PhpFusionTest.java
deleted file mode 100644
index a08a6ad8..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/PhpFusionTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link PhpFusion}.
- */
-public class PhpFusionTest extends AbstractEncryptionMethodTest {
-
-    public PhpFusionTest() {
-        super(new PhpFusion(),
-            new HashedPassword("f7a606c4eb3fcfbc382906476e05b06f21234a77d1a4eacc0f93f503deb69e70", "6cd1c97c55cb"),  // password
-            new HashedPassword("8a9b7bb706a3347e5f684a7cb905bfb26b9a0d099358064139ab3ed1a66aeb2b", "d6012370b73f"),  // PassWord1
-            new HashedPassword("43f2f23f44c8f89e2dbf06050bc8c77dbcdf71a7b5d28c87ec657d474e63d62d", "f75400a209a4"),  // &^%te$t?Pw@_
-            new HashedPassword("4e7f4eb7e3653d7460f1cf590def4153c6fcdf8b8e16fb95538fdf9e54a95245", "d552e0f5b23a")); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/RoyalAuthTest.java b/src/test/java/fr/xephi/authme/security/crypts/RoyalAuthTest.java
deleted file mode 100644
index 7734dc03..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/RoyalAuthTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link RoyalAuth}.
- */
-public class RoyalAuthTest extends AbstractEncryptionMethodTest {
-
-    public RoyalAuthTest() {
-        super(new RoyalAuth(),
-            "5d21ef9236896bc4ac508e524e2da8a0def555dac1cdfc7259d62900d1d3f553826210c369870673ae2cf1c41abcf4f92670d76af1db044d33559324f5c2a339",  // password
-            "ecc685f4328bc54093c086ced66c5c11855e117ea22940632d5c0f55fff84d94bfdcc74e05f5d95bbdd052823a7057910748bc1c7a07af96b3e86731a4f11794",  // PassWord1
-            "2c0b4674f7c2c266db13ae4382cbeee3083167a774f6e73793a6268a0b8b2c3c6b324a99596f4a7958e58c5311c77e25975a3b517ce17adfc4eaece821e3dd19",  // &^%te$t?Pw@_
-            "f7bdc87552f7f7d19b68de5e6be6e48f4a6f277d9a5b00f470958062ab3a82b6c62ab8df86ef38636a632e10ef7bf8e3b5cafe8af53bb628919a84676ee0b4b7"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Salted2Md5Test.java b/src/test/java/fr/xephi/authme/security/crypts/Salted2Md5Test.java
deleted file mode 100644
index fc34a13f..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Salted2Md5Test.java
+++ /dev/null
@@ -1,28 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link Salted2Md5}.
- */
-public class Salted2Md5Test extends AbstractEncryptionMethodTest {
-
-    public Salted2Md5Test() {
-        super(new Salted2Md5(mockSettings()),
-            new HashedPassword("9f3d13dc01a6fe61fd669954174399f3", "9b5f5749"),  // password
-            new HashedPassword("b28c32f624a4eb161d6adc9acb5bfc5b", "f750ba32"),  // PassWord1
-            new HashedPassword("38dcb83cc68424afe3cda012700c2bb1", "eb2c3394"),  // &^%te$t?Pw@_
-            new HashedPassword("ad25606eae5b760c8a2469d65578ac39", "04eee598")); // âË_3(íù*)
-    }
-
-    private static Settings mockSettings() {
-        Settings settings = mock(Settings.class);
-        given(settings.getProperty(SecuritySettings.DOUBLE_MD5_SALT_LENGTH)).willReturn(8);
-        return settings;
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/SaltedSha512Test.java b/src/test/java/fr/xephi/authme/security/crypts/SaltedSha512Test.java
deleted file mode 100644
index 98ab0615..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/SaltedSha512Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link SaltedSha512}.
- */
-public class SaltedSha512Test extends AbstractEncryptionMethodTest {
-
-    public SaltedSha512Test() {
-        super(new SaltedSha512(),
-            new HashedPassword("dea7a37cecf5384ae8e347fd1411efb51364b6ba1b328695de3b354612c1d7010807e8b7051c40f740e498490e1f133e2c2408327d13fbdd68e1b1f6d548e624", "29f8a3c52147f987fee7ba3e0fb311bd"),  // password
-            new HashedPassword("7c06225aac574d2dc7c81a2ed306637adf025715f52083e05bdab014faaa234e24a97d0e69ea0108dfa77cc9228e58be319ee677e679b5d1ad168d40e50a42f6", "8ea37b85d020b98f60c0fe9b8ec9296c"),  // PassWord1
-            new HashedPassword("55711adbe03c9616f3505f0d57077fdd528c32243eb6f9840c1a6ff9e553940d6b89790750ebd52ebda63ca793fbe9980d54057af40836820c648750fe22d49c", "9f58079631ef21d32b4710694f1f461b"),  // &^%te$t?Pw@_
-            new HashedPassword("29dc5be8702975ea4563ed3de5b145e2d2f1c37ae661bbe0d3e94d964402cf09d539d65f3b90ff6921ea3d40727f76fb38fb34d1e5c2d62238c4e0203efc372f", "048bb76168265d906f1fd1f81d0616a9")); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Sha1Test.java b/src/test/java/fr/xephi/authme/security/crypts/Sha1Test.java
deleted file mode 100644
index 2bd5543f..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Sha1Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Sha1}.
- */
-public class Sha1Test extends AbstractEncryptionMethodTest {
-
-    public Sha1Test() {
-        super(new Sha1(),
-            "5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8",  // password
-            "285d0c707f9644b75e1a87a62f25d0efb56800f0",  // PassWord1
-            "a42ef8e61e890af80461ca5dcded25cbfcf407a4",  // &^%te$t?Pw@_
-            "64a8fb6e043105ba6cf3f2d63d59ca24d80aabbb"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Sha256Test.java b/src/test/java/fr/xephi/authme/security/crypts/Sha256Test.java
deleted file mode 100644
index b9f75165..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Sha256Test.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Sha256}.
- */
-public class Sha256Test extends AbstractEncryptionMethodTest {
-
-    public Sha256Test() {
-        super(new Sha256(),
-            "$SHA$11aa0706173d7272$dbba96681c2ae4e0bfdf226d70fbbc5e4ee3d8071faa613bc533fe8a64817d10", // password
-            "$SHA$3c72a18a29b08d40$8e50a7a4f69a80f4893dc921eac84bd74b3f9ebfa22908302c9965eac3aa45e5", // PassWord1
-            "$SHA$584cea1cfab90030$adc006330e73d81e463fe02a4fe9b17bdbbcc05955bff72fb27cf2089f0b3859", // &^%te$t?Pw@_
-            "$SHA$0b503d90dd9949d4$ba70c330242e0daa9a154ec9f4cce7f01dd05aff489d37c653e36a507c74d84f"  // âË_3(íù*
-        );
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Sha512Test.java b/src/test/java/fr/xephi/authme/security/crypts/Sha512Test.java
deleted file mode 100644
index 2871cd3a..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Sha512Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Sha512}.
- */
-public class Sha512Test extends AbstractEncryptionMethodTest {
-
-    public Sha512Test() {
-        super(new Sha512(),
-            "b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86",  // password
-            "ae9942149995a8171391625b36da134d5e288c721650d7c8d2d464fb49a49f3f551e4916ab1e097d9dd1201b01d69b1dccdefa3d2524a66092fb61b3df6e7e71",  // PassWord1
-            "8c4f3df78db191142d819a72c16058b9e1ea41ae9b1649e1184eb89e30344c51c9c71039c483cf2f1b76b51480d8459d7eb3cfbaa24b07f2041d1551af4ead75",  // &^%te$t?Pw@_
-            "9db561d04daa6086538444181f1a2ed180bbc5191df2a50c5c1be0c62b510e1dc32936c259e7138d4aa544ce5b60820fa4ead0362aeef730f86d360dc325d824"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/SmfTest.java b/src/test/java/fr/xephi/authme/security/crypts/SmfTest.java
deleted file mode 100644
index 442d5194..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/SmfTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import org.junit.Test;
-
-import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link Smf}.
- */
-public class SmfTest extends AbstractEncryptionMethodTest {
-
-    public SmfTest() {
-        super(new Smf(),
-            "9b361c66977bb059d460a20d3c21fb3394772df5",  // password
-            "31a560bdd095a837945d46add1605108ba87b268",  // PassWord1
-            "8d4b84544e0891be8c183fe9b1003cfac18c51a1",  // &^%te$t?Pw@_
-            "03cca5af1eb0a93be47777651b2e7be4fd5d537d"); // âË_3(íù*
-    }
-
-    @Override
-    protected void verifyCorrectConstructorIsUsed(EncryptionMethod method, boolean isSaltConstructor) {
-        // Smf declares to use a separate salt, but it's not used in the actual hashing mechanism, see Smf class Javadoc
-        assertThat(method.hasSeparateSalt(), equalTo(true));
-        assertThat(isSaltConstructor, equalTo(false));
-    }
-
-    @Test
-    public void shouldGenerateFourCharSalt() {
-        // given
-        EncryptionMethod method = new Smf();
-
-        // when / then
-        assertThat(method.hasSeparateSalt(), equalTo(true));
-        for (int i = 0; i < 3; ++i) {
-            HashedPassword hash = method.computeHash("pw", "name");
-            String salt = hash.getSalt();
-            assertThat(salt, stringWithLength(4));
-            assertThat(salt.matches("[a-z0-9]{4}"), equalTo(true));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/TwoFactorTest.java b/src/test/java/fr/xephi/authme/security/crypts/TwoFactorTest.java
deleted file mode 100644
index cdc25267..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/TwoFactorTest.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import fr.xephi.authme.TestHelper;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link TwoFactor}.
- */
-public class TwoFactorTest {
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldGenerateBarcodeUrl() {
-        // given
-        String user = "tester";
-        String host = "192.168.0.4";
-        String secret = "3AK6Y4KWGRLJMEQW";
-
-        // when
-        String url = TwoFactor.getQrBarcodeUrl(user, host, secret);
-
-        // then
-        String expected = "https://www.google.com/chart?chs=130x130&chld=M%7C0&cht=qr"
-            + "&chl=otpauth://totp/tester@192.168.0.4%3Fsecret%3D3AK6Y4KWGRLJMEQW";
-        assertThat(url, equalTo(expected));
-    }
-
-    @Test
-    public void shouldHandleInvalidHash() {
-        // given
-        HashedPassword password = new HashedPassword("!@&#@!(*&@");
-        String inputPassword = "12345";
-        TwoFactor twoFactor = new TwoFactor();
-
-        // when
-        boolean result = twoFactor.comparePassword(inputPassword, password, "name");
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldHandleInvalidInput() {
-        // given
-        HashedPassword password = new HashedPassword("3AK6Y4KWGRLJMEQW");
-        String inputPassword = "notA_number!";
-        TwoFactor twoFactor = new TwoFactor();
-
-        // when
-        boolean result = twoFactor.comparePassword(inputPassword, password, "name");
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Wbb3Test.java b/src/test/java/fr/xephi/authme/security/crypts/Wbb3Test.java
deleted file mode 100644
index 7443253f..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Wbb3Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Wbb3}.
- */
-public class Wbb3Test extends AbstractEncryptionMethodTest {
-
-    public Wbb3Test() {
-        super(new Wbb3(),
-            new HashedPassword("8df818ef7d56075ab2744f74b98ad68a375ccac4", "b7415b355492ea60314f259a35733a3092c03e3f"),  // password
-            new HashedPassword("106da5cf5df92cb845e12cf62cbdb5235b6dc693", "6110f19b2b52910dccf592a19c59126873f42e69"),  // PassWord1
-            new HashedPassword("940a9fb7acec0178c6691e8b3c14bd7d789078b1", "f9dd501ff3d1bf74904f9e89649e378429af56e7"),  // &^%te$t?Pw@_
-            new HashedPassword("0fa12e8d96c9e95f73aa91f3b76f8cdc815ec8a5", "736be8669f6159ddb2d5b47a3e6428cdb8b324de")); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/Wbb4Test.java b/src/test/java/fr/xephi/authme/security/crypts/Wbb4Test.java
deleted file mode 100644
index 6c5459f6..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/Wbb4Test.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Wbb4}.
- */
-public class Wbb4Test extends AbstractEncryptionMethodTest {
-
-    public Wbb4Test() {
-        super(new Wbb4(),
-            "$2a$08$7DGr.wROqEPe0Z3XJS7n5.k.QWehovLHbpI.UkdfRb4ns268WsR6C",  // password
-            "$2a$08$yWWVUA4PB4mqW.0wyIvV3OdoH492HuLk5L3iaqUrpRK2.2zn08d/K",  // PassWord1
-            "$2a$08$EHXUFt7bTT9Fnsu22KWvF.QDssiosV8YzH8CyWqulB/ckOA7qioJG",  // &^%te$t?Pw@_
-            "$2a$08$ZZu5YH4zwpk0cr2dOYZpF.CkTKMvCBOAtTbAH7AwnOiL.n0mWkgDC"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/WhirlpoolTest.java b/src/test/java/fr/xephi/authme/security/crypts/WhirlpoolTest.java
deleted file mode 100644
index 76cef4b0..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/WhirlpoolTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Whirlpool}.
- */
-public class WhirlpoolTest extends AbstractEncryptionMethodTest {
-
-    public WhirlpoolTest() {
-        super(new Whirlpool(),
-            "74DFC2B27ACFA364DA55F93A5CAEE29CCAD3557247EDA238831B3E9BD931B01D77FE994E4F12B9D4CFA92A124461D2065197D8CF7F33FC88566DA2DB2A4D6EAE",  // password
-            "819B4CBD26508E39EA76BFE102DCF2ACC87A446747CAB0BD88522B0822A724583E81B6A4BD2CE255DB694E530B659F47D434EEB50344A02F50B64414C9671583",  // PassWord1
-            "71ECB0E5AEAB006F5336348076AA6A8E46075AEC9E010C7055BA1334B57746F2A9D8A8799BDD9B7EB4AB7544A59D25F469C8BCA2067508ACBA62A929260A1E17",  // &^%te$t?Pw@_
-            "CBFEFB3DD7FC6D7F88E006955CFFE07758C74216A825A355D67AE352DA99D8F17FA00CB5CB6875A90BAB4992121E786F57E7B3602232002752925E4DC545C414"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/WordpressTest.java b/src/test/java/fr/xephi/authme/security/crypts/WordpressTest.java
deleted file mode 100644
index 0c444c2f..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/WordpressTest.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link Wordpress}.
- */
-public class WordpressTest extends AbstractEncryptionMethodTest {
-
-    public WordpressTest() {
-        super(new Wordpress(),
-            "$P$B9wyjxuU4yrfjnnHNGSzH9ti9CC0Os1",  // password
-            "$P$BjzPjjzPjjkRzvGGRTyYu0sNqcz6Ci0",  // PassWord1
-            "$P$BjzPjjzPjrAOyB1V0WFdpisgCTFx.N/",  // &^%te$t?Pw@_
-            "$P$BjzPjxxyjp2QdKcab/oTW8l/W0AgE21"); // âË_3(íù*
-    }
-
-    @Override
-    protected boolean testHashEqualityForSameSalt() {
-        // We need to skip the test because Wordpress uses an "internal salt" that is not exposed to the outside
-        return false;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/XAuthTest.java b/src/test/java/fr/xephi/authme/security/crypts/XAuthTest.java
deleted file mode 100644
index 877a81ee..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/XAuthTest.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-/**
- * Test for {@link XAuth}.
- */
-public class XAuthTest extends AbstractEncryptionMethodTest {
-
-    public XAuthTest() {
-        super(new XAuth(),
-            "e54d4916577410d26d2f6e9362445463dab9ffdff9a67ed3b74d3f2312bc8fab84f653fcb88ad8338793ef8a6d0a1162105e46ec24f0dcb52355c634e3e6439f45444b09c715",  // password
-            "d54489a4fd4732ee03d56810ab92944096e3d49335266adeecfbc12567abb3ff744761b33a1fcc4d04739e377775c788e4baace3caf35c7b9176b82b1fe3472e4cbdc5a43214",  // PassWord1
-            "ce6404c1092fb5abf0a72f9c4327bfe8f4cdc4b8dc90ee6ca35c42b8ae9481b89c2559bb60b99ff2b57a102cfced40b8e2f5ef481400c9e6f79445017fc763b1cc27f4c2df36",  // &^%te$t?Pw@_
-            "73074fe3f5503677ab9c5a1885b46a8b6fb249453317da08d86312c20e7b326e84f615e1b594c71129d2d1020400a89838e44653dc02d1799886e522a2789fbe1df6e70b7ffb"); // âË_3(íù*
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/security/crypts/XfBCryptTest.java b/src/test/java/fr/xephi/authme/security/crypts/XfBCryptTest.java
deleted file mode 100644
index 982f5d48..00000000
--- a/src/test/java/fr/xephi/authme/security/crypts/XfBCryptTest.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package fr.xephi.authme.security.crypts;
-
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.nullValue;
-import static org.hamcrest.Matchers.startsWith;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link XfBCrypt}.
- */
-public class XfBCryptTest extends AbstractEncryptionMethodTest {
-
-    public XfBCryptTest() {
-        super(new XfBCrypt(),
-            "$2a$10$UtuON/ZG.x8EWG/zQbryB.BHfQVrfxk3H7qykzP.UJQ8YiLjZyfqq",  // password
-            "$2a$10$Q.ocUo.YtHTdI4nu3pcpKun6BILcmWHm541ANULucmuU/ps1QKY4K",  // PassWord1
-            "$2a$10$yHjm02.K4HP5iFU1F..yLeTeo7PWZVbKAr/QGex5jU4.J3mdq/uuO",  // &^%te$t?Pw@_
-            "$2a$10$joIayhGStExKWxNbiqMMPOYFSpQ76HVNjpOB7.QwTmG5q.TiJJ.0e"); // âË_3(íù*
-    }
-
-    @Test
-    public void shouldGenerateWith2aPrefixAndCostFactor10() {
-        // given
-        XfBCrypt xfBCrypt = new XfBCrypt();
-
-        // when
-        HashedPassword result = xfBCrypt.computeHash("test", null);
-
-        // then
-        assertThat(result.getHash(), startsWith("$2a$10$"));
-        assertThat(result.getSalt(), nullValue());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/totp/GenerateTotpServiceTest.java b/src/test/java/fr/xephi/authme/security/totp/GenerateTotpServiceTest.java
deleted file mode 100644
index 3778cc10..00000000
--- a/src/test/java/fr/xephi/authme/security/totp/GenerateTotpServiceTest.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package fr.xephi.authme.security.totp;
-
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.security.totp.TotpAuthenticator.TotpGenerationResult;
-import fr.xephi.authme.util.expiring.ExpiringMap;
-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 java.util.concurrent.TimeUnit;
-
-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;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link GenerateTotpService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class GenerateTotpServiceTest {
-
-    @InjectMocks
-    private GenerateTotpService generateTotpService;
-
-    @Mock
-    private TotpAuthenticator totpAuthenticator;
-
-    @Test
-    public void shouldGenerateTotpKey() {
-        // given
-        TotpGenerationResult givenGenerationResult = new TotpGenerationResult("1234", "http://example.com/link/to/chart");
-        Player player = mockPlayerWithName("Spencer");
-        given(totpAuthenticator.generateTotpKey(player)).willReturn(givenGenerationResult);
-
-        // when
-        TotpGenerationResult result = generateTotpService.generateTotpKey(player);
-
-        // then
-        assertThat(result, equalTo(givenGenerationResult));
-        assertThat(generateTotpService.getGeneratedTotpKey(player), equalTo(givenGenerationResult));
-    }
-
-    @Test
-    public void shouldRemoveGeneratedTotpKey() {
-        // given
-        TotpGenerationResult givenGenerationResult = new TotpGenerationResult("1234", "http://example.com/link/to/chart");
-        Player player = mockPlayerWithName("Hanna");
-        given(totpAuthenticator.generateTotpKey(player)).willReturn(givenGenerationResult);
-        generateTotpService.generateTotpKey(player);
-
-        // when
-        generateTotpService.removeGenerateTotpKey(player);
-
-        // then
-        assertThat(generateTotpService.getGeneratedTotpKey(player), nullValue());
-    }
-
-    @Test
-    public void shouldCheckGeneratedTotpKey() {
-        // given
-        String generatedKey = "ASLO43KDF2J";
-        TotpGenerationResult givenGenerationResult = new TotpGenerationResult(generatedKey, "url");
-        Player player = mockPlayerWithName("Aria");
-        given(totpAuthenticator.generateTotpKey(player)).willReturn(givenGenerationResult);
-        generateTotpService.generateTotpKey(player);
-        String validCode = "928374";
-        given(totpAuthenticator.checkCode("Aria", generatedKey, validCode)).willReturn(true);
-
-        // when
-        boolean invalidCodeResult = generateTotpService.isTotpCodeCorrectForGeneratedTotpKey(player, "000000");
-        boolean validCodeResult = generateTotpService.isTotpCodeCorrectForGeneratedTotpKey(player, validCode);
-        boolean unknownPlayerResult = generateTotpService.isTotpCodeCorrectForGeneratedTotpKey(mockPlayerWithName("other"), "299874");
-
-        // then
-        assertThat(invalidCodeResult, equalTo(false));
-        assertThat(validCodeResult, equalTo(true));
-        assertThat(unknownPlayerResult, equalTo(false));
-        verify(totpAuthenticator).checkCode("Aria", generatedKey, "000000");
-        verify(totpAuthenticator).checkCode("Aria", generatedKey, validCode);
-    }
-
-    @Test
-    public void shouldRemoveExpiredEntries() throws InterruptedException {
-        // given
-        TotpGenerationResult generationResult = new TotpGenerationResult("key", "url");
-        ExpiringMap<String, TotpGenerationResult> generatedKeys =
-            ReflectionTestUtils.getFieldValue(GenerateTotpService.class, generateTotpService, "totpKeys");
-        generatedKeys.setExpiration(1, TimeUnit.MILLISECONDS);
-        generatedKeys.put("ghost", generationResult);
-        generatedKeys.setExpiration(5, TimeUnit.MINUTES);
-        generatedKeys.put("ezra", generationResult);
-
-        // when
-        Thread.sleep(2L);
-        generateTotpService.performCleanup();
-
-        // then
-        assertThat(generateTotpService.getGeneratedTotpKey(mockPlayerWithName("Ezra")), equalTo(generationResult));
-        assertThat(generateTotpService.getGeneratedTotpKey(mockPlayerWithName("ghost")), nullValue());
-    }
-
-    private static Player mockPlayerWithName(String name) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/security/totp/TotpAuthenticatorTest.java b/src/test/java/fr/xephi/authme/security/totp/TotpAuthenticatorTest.java
deleted file mode 100644
index 8df99408..00000000
--- a/src/test/java/fr/xephi/authme/security/totp/TotpAuthenticatorTest.java
+++ /dev/null
@@ -1,145 +0,0 @@
-package fr.xephi.authme.security.totp;
-
-import com.google.common.collect.Table;
-import com.warrenstrange.googleauth.IGoogleAuthenticator;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.security.totp.TotpAuthenticator.TotpGenerationResult;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.util.Utils;
-import org.bukkit.entity.Player;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.startsWith;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link TotpAuthenticator}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class TotpAuthenticatorTest {
-
-    private TotpAuthenticator totpAuthenticator;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private IGoogleAuthenticator googleAuthenticator;
-
-    @Before
-    public void initializeTotpAuthenticator() {
-        totpAuthenticator = new TotpAuthenticatorTestImpl(settings);
-    }
-
-    @Test
-    public void shouldGenerateTotpKey() {
-        // given
-        // Use the GoogleAuthenticator instance the TotpAuthenticator normally creates to test its parameters
-        totpAuthenticator = new TotpAuthenticator(settings);
-
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("Bobby");
-        given(settings.getProperty(PluginSettings.SERVER_NAME)).willReturn("MCtopia");
-
-        // when
-        TotpGenerationResult key1 = totpAuthenticator.generateTotpKey(player);
-        TotpGenerationResult key2 = totpAuthenticator.generateTotpKey(player);
-
-        // then
-        assertThat(key1.getTotpKey(), stringWithLength(32));
-        assertThat(key2.getTotpKey(), stringWithLength(32));
-        assertThat(key1.getAuthenticatorQrCodeUrl(), startsWith("https://api.qrserver.com/v1/create-qr-code/?data="));
-        assertThat(key1.getAuthenticatorQrCodeUrl(), containsString("MCtopia"));
-        assertThat(key2.getAuthenticatorQrCodeUrl(), startsWith("https://api.qrserver.com/v1/create-qr-code/?data="));
-        assertThat(key1.getTotpKey(), not(equalTo(key2.getTotpKey())));
-    }
-
-    @Test
-    public void shouldCheckCodeAndDeclareItValidOnlyOnce() {
-        // given
-        String secret = "the_secret";
-        int code = 21398;
-        given(googleAuthenticator.authorize(secret, code)).willReturn(true);
-
-        // when
-        boolean result1 = totpAuthenticator.checkCode("pl", secret, Integer.toString(code));
-        boolean result2 = totpAuthenticator.checkCode("pl", secret, Integer.toString(code));
-
-        // then
-        assertThat(result1, equalTo(true));
-        assertThat(result2, equalTo(false));
-        verify(googleAuthenticator).authorize(secret, code);
-    }
-
-    @Test
-    public void shouldHandleInvalidNumberInput() {
-        // given / when
-        boolean result = totpAuthenticator.checkCode("foo", "Some_Secret", "123ZZ");
-
-        // then
-        assertThat(result, equalTo(false));
-        verifyNoInteractions(googleAuthenticator);
-    }
-
-    @Test
-    public void shouldVerifyCode() {
-        // given
-        String totpKey = "ASLO43KDF2J";
-        PlayerAuth auth = PlayerAuth.builder()
-            .name("Maya")
-            .totpKey(totpKey)
-            .build();
-        String inputCode = "408435";
-        given(totpAuthenticator.checkCode("Maya", totpKey, inputCode)).willReturn(true);
-
-        // when
-        boolean result = totpAuthenticator.checkCode(auth, inputCode);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(googleAuthenticator).authorize(totpKey, 408435);
-    }
-
-    @Test
-    public void shouldRemoveOldEntries() {
-        // given
-        Table<String, Integer, Long> usedCodes = ReflectionTestUtils.getFieldValue(
-            TotpAuthenticator.class, totpAuthenticator, "usedCodes");
-        usedCodes.put("bobby", 414213, System.currentTimeMillis());
-        usedCodes.put("charlie", 732050, System.currentTimeMillis() - 6 * Utils.MILLIS_PER_MINUTE);
-        usedCodes.put("bobby", 236067, System.currentTimeMillis() - 9 * Utils.MILLIS_PER_MINUTE);
-
-        // when
-        totpAuthenticator.performCleanup();
-
-        // then
-        assertThat(usedCodes.size(), equalTo(1));
-        assertThat(usedCodes.contains("bobby", 414213), equalTo(true));
-    }
-
-    private final class TotpAuthenticatorTestImpl extends TotpAuthenticator {
-
-        TotpAuthenticatorTestImpl(Settings settings) {
-            super(settings);
-        }
-
-        @Override
-        protected IGoogleAuthenticator createGoogleAuthenticator() {
-            return googleAuthenticator;
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/AntiBotServiceTest.java b/src/test/java/fr/xephi/authme/service/AntiBotServiceTest.java
deleted file mode 100644
index 64379254..00000000
--- a/src/test/java/fr/xephi/authme/service/AntiBotServiceTest.java
+++ /dev/null
@@ -1,188 +0,0 @@
-package fr.xephi.authme.service;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.permission.AdminPermission;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.ProtectionSettings;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitTask;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncDelayedTaskWithDelay;
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link AntiBotService}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class AntiBotServiceTest {
-
-    @InjectDelayed
-    private AntiBotService antiBotService;
-
-    @Mock
-    private Settings settings;
-    @Mock
-    private Messages messages;
-    @Mock
-    private PermissionsManager permissionsManager;
-    @Mock
-    private BukkitService bukkitService;
-
-    @BeforeInjecting
-    public void initSettings() {
-        given(settings.getProperty(ProtectionSettings.ANTIBOT_DURATION)).willReturn(10);
-        given(settings.getProperty(ProtectionSettings.ANTIBOT_INTERVAL)).willReturn(5);
-        given(settings.getProperty(ProtectionSettings.ANTIBOT_SENSIBILITY)).willReturn(5);
-        given(settings.getProperty(ProtectionSettings.ENABLE_ANTIBOT)).willReturn(true);
-        given(settings.getProperty(ProtectionSettings.ANTIBOT_DELAY)).willReturn(8);
-        setBukkitServiceToScheduleSyncDelayedTaskWithDelay(bukkitService);
-    }
-
-    @Test
-    public void shouldStartListenerOnStartup() {
-        // given / when / then
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.LISTENING));
-    }
-
-    @Test
-    public void shouldNotListenForDisabledSetting() {
-        // given
-        reset(bukkitService);
-        given(settings.getProperty(ProtectionSettings.ENABLE_ANTIBOT)).willReturn(false);
-
-        // when
-        AntiBotService antiBotService = new AntiBotService(settings, messages, permissionsManager, bukkitService);
-
-        // then
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.DISABLED));
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldActivateAntibot() {
-        // given - listening antibot
-        BukkitTask task = mock(BukkitTask.class);
-        given(bukkitService.runTaskLater(any(Runnable.class), anyLong())).willReturn(task);
-
-        // when
-        antiBotService.overrideAntiBotStatus(true);
-
-        // then
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.ACTIVE));
-        // Check that a task is scheduled to disable again
-        ArgumentCaptor<Runnable> runnableCaptor = ArgumentCaptor.forClass(Runnable.class);
-        verify(bukkitService).runTaskLater(runnableCaptor.capture(), anyLong());
-        runnableCaptor.getValue().run();
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.LISTENING));
-    }
-
-    @Test
-    public void shouldNotActivateAntibotForDisabledSetting() {
-        // given - disabled antibot
-        given(settings.getProperty(ProtectionSettings.ENABLE_ANTIBOT)).willReturn(false);
-        AntiBotService antiBotService = new AntiBotService(settings, messages, permissionsManager, bukkitService);
-
-        // when
-        antiBotService.overrideAntiBotStatus(true);
-
-        // then
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.DISABLED));
-    }
-
-    @Test
-    public void shouldKeepTrackOfKickedPlayers() {
-        // given
-        String name = "eratic";
-        antiBotService.addPlayerKick(name);
-
-        // when
-        boolean result1 = antiBotService.wasPlayerKicked(name);
-        boolean result2 = antiBotService.wasPlayerKicked("other");
-
-        // then
-        assertThat(result1, equalTo(true));
-        assertThat(result2, equalTo(false));
-    }
-
-    @Test
-    public void shouldAcceptPlayerToJoin() {
-        // given / when
-        boolean result = antiBotService.shouldKick();
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldActivateAntibotAfterThreshold() {
-        // given
-        int sensitivity = 10;
-        given(settings.getProperty(ProtectionSettings.ANTIBOT_SENSIBILITY)).willReturn(sensitivity);
-        AntiBotService antiBotService = new AntiBotService(settings, messages, permissionsManager, bukkitService);
-
-        for (int i = 0; i < sensitivity; ++i) {
-            antiBotService.shouldKick();
-        }
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.LISTENING));
-
-        // when
-        antiBotService.shouldKick();
-
-        // then
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.ACTIVE));
-    }
-
-    @Test
-    public void shouldInformPlayersOnActivation() {
-        // given - listening antibot
-        List<Player> players = Arrays.asList(mock(Player.class), mock(Player.class));
-        given(bukkitService.getOnlinePlayers()).willReturn(players);
-        given(permissionsManager.hasPermission(players.get(0), AdminPermission.ANTIBOT_MESSAGES)).willReturn(false);
-        given(permissionsManager.hasPermission(players.get(1), AdminPermission.ANTIBOT_MESSAGES)).willReturn(true);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        antiBotService.overrideAntiBotStatus(true);
-
-        // then
-        verify(permissionsManager).hasPermission(players.get(0), AdminPermission.ANTIBOT_MESSAGES);
-        verify(permissionsManager).hasPermission(players.get(1), AdminPermission.ANTIBOT_MESSAGES);
-        verify(messages, only()).send(players.get(1), MessageKey.ANTIBOT_AUTO_ENABLED_MESSAGE);
-    }
-
-    @Test
-    public void shouldImmediatelyStartAfterFirstStartup() {
-        // given - listening antibot
-        given(bukkitService.runTaskLater(any(Runnable.class), anyLong())).willReturn(mock(BukkitTask.class));
-        antiBotService.overrideAntiBotStatus(true);
-
-        // when
-        antiBotService.reload(settings);
-
-        // then
-        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.LISTENING));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/service/BukkitServiceTest.java b/src/test/java/fr/xephi/authme/service/BukkitServiceTest.java
deleted file mode 100644
index 2e6ee72c..00000000
--- a/src/test/java/fr/xephi/authme/service/BukkitServiceTest.java
+++ /dev/null
@@ -1,319 +0,0 @@
-package fr.xephi.authme.service;
-
-import fr.xephi.authme.AuthMe;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.events.FailedLoginEvent;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import org.bukkit.Bukkit;
-import org.bukkit.Server;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.scheduler.BukkitRunnable;
-import org.bukkit.scheduler.BukkitScheduler;
-import org.bukkit.scheduler.BukkitTask;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link BukkitService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class BukkitServiceTest {
-
-    private BukkitService bukkitService;
-
-    @Mock
-    private AuthMe authMe;
-    @Mock
-    private Settings settings;
-    @Mock
-    private Server server;
-    @Mock
-    private BukkitScheduler scheduler;
-    @Mock
-    private PluginManager pluginManager;
-
-    @Before
-    public void constructBukkitService() {
-        ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
-        given(server.getScheduler()).willReturn(scheduler);
-        given(server.getPluginManager()).willReturn(pluginManager);
-        given(settings.getProperty(PluginSettings.USE_ASYNC_TASKS)).willReturn(true);
-        bukkitService = new BukkitService(authMe, settings);
-    }
-
-    @Test
-    public void shouldDispatchCommand() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String command = "help test abc";
-
-        // when
-        bukkitService.dispatchCommand(sender, command);
-
-        // then
-        verify(server).dispatchCommand(sender, command);
-    }
-
-    @Test
-    public void shouldDispatchConsoleCommand() {
-        // given
-        ConsoleCommandSender consoleSender = mock(ConsoleCommandSender.class);
-        given(server.getConsoleSender()).willReturn(consoleSender);
-        String command = "my command";
-
-        // when
-        bukkitService.dispatchConsoleCommand(command);
-
-        // then
-        verify(server).dispatchCommand(consoleSender, command);
-    }
-
-    @Test
-    public void shouldScheduleSyncDelayedTask() {
-        // given
-        Runnable task = () -> {/* noop */};
-        given(scheduler.scheduleSyncDelayedTask(authMe, task)).willReturn(123);
-
-        // when
-        int taskId = bukkitService.scheduleSyncDelayedTask(task);
-
-        // then
-        verify(scheduler, only()).scheduleSyncDelayedTask(authMe, task);
-        assertThat(taskId, equalTo(123));
-    }
-
-    @Test
-    public void shouldScheduleSyncDelayedTaskWithDelay() {
-        // given
-        Runnable task = () -> {/* noop */};
-        int delay = 3;
-        given(scheduler.scheduleSyncDelayedTask(authMe, task, delay)).willReturn(44);
-
-        // when
-        int taskId = bukkitService.scheduleSyncDelayedTask(task, delay);
-
-        // then
-        verify(scheduler, only()).scheduleSyncDelayedTask(authMe, task, delay);
-        assertThat(taskId, equalTo(44));
-    }
-
-    @Test
-    public void shouldScheduleSyncTask() {
-        // given
-        BukkitService spy = Mockito.spy(bukkitService);
-        doReturn(1).when(spy).scheduleSyncDelayedTask(any(Runnable.class));
-        Runnable task = mock(Runnable.class);
-
-        // when
-        spy.scheduleSyncTaskFromOptionallyAsyncTask(task);
-
-        // then
-        verify(spy).scheduleSyncDelayedTask(task);
-        verifyNoInteractions(task);
-    }
-
-    @Test
-    public void shouldRunTaskDirectly() {
-        // given
-        given(server.isPrimaryThread()).willReturn(true);
-        bukkitService.reload(settings);
-        BukkitService spy = Mockito.spy(bukkitService);
-        Runnable task = mock(Runnable.class);
-
-        // when
-        spy.scheduleSyncTaskFromOptionallyAsyncTask(task);
-
-        // then
-        verify(task).run();
-        verify(spy, only()).scheduleSyncTaskFromOptionallyAsyncTask(task);
-    }
-
-    @Test
-    public void shouldRunTask() {
-        // given
-        Runnable task = () -> {/* noop */};
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(scheduler.runTask(authMe, task)).willReturn(bukkitTask);
-
-        // when
-        BukkitTask resultingTask = bukkitService.runTask(task);
-
-        // then
-        assertThat(resultingTask, equalTo(bukkitTask));
-        verify(scheduler, only()).runTask(authMe, task);
-    }
-
-    @Test
-    public void shouldRunTaskLater() {
-        // given
-        Runnable task = () -> {/* noop */};
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        long delay = 400;
-        given(scheduler.runTaskLater(authMe, task, delay)).willReturn(bukkitTask);
-
-        // when
-        BukkitTask resultingTask = bukkitService.runTaskLater(task, delay);
-
-        // then
-        assertThat(resultingTask, equalTo(bukkitTask));
-        verify(scheduler, only()).runTaskLater(authMe, task, delay);
-    }
-
-    @Test
-    public void shouldRunTaskInAsync() {
-        // given
-        Runnable task = mock(Runnable.class);
-        BukkitService spy = Mockito.spy(bukkitService);
-        doReturn(null).when(spy).runTaskAsynchronously(task);
-
-        // when
-        spy.runTaskOptionallyAsync(task);
-
-        // then
-        verifyNoInteractions(task);
-        verify(spy).runTaskAsynchronously(task);
-    }
-
-    @Test
-    public void shouldRunTaskDirectlyIfConfigured() {
-        // given
-        given(settings.getProperty(PluginSettings.USE_ASYNC_TASKS)).willReturn(false);
-        bukkitService.reload(settings);
-        BukkitService spy = Mockito.spy(bukkitService);
-        Runnable task = mock(Runnable.class);
-
-        // when
-        spy.runTaskOptionallyAsync(task);
-
-        // then
-        verify(task).run();
-        verify(spy, only()).runTaskOptionallyAsync(task);
-    }
-
-    @Test
-    public void shouldRunTaskAsynchronously() {
-        // given
-        Runnable task = () -> {/* noop */};
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(scheduler.runTaskAsynchronously(authMe, task)).willReturn(bukkitTask);
-
-        // when
-        BukkitTask resultingTask = bukkitService.runTaskAsynchronously(task);
-
-        // then
-        assertThat(resultingTask, equalTo(bukkitTask));
-        verify(scheduler, only()).runTaskAsynchronously(authMe, task);
-    }
-
-    @Test
-    public void shouldRunTaskTimerAsynchronously() {
-        // given
-        BukkitRunnable task = new BukkitRunnable() {
-            @Override
-            public void run() {
-            }
-        };
-        long delay = 20L;
-        long period = 4000L;
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(task.runTaskTimerAsynchronously(authMe, delay, period)).willReturn(bukkitTask);
-
-        // when
-        BukkitTask resultingTask = bukkitService.runTaskTimerAsynchronously(task, delay, period);
-
-        // then
-        assertThat(resultingTask, equalTo(bukkitTask));
-    }
-
-    @Test
-    public void shouldRunTaskTimer() {
-        // given
-        BukkitRunnable bukkitRunnable = mock(BukkitRunnable.class);
-        long delay = 20;
-        long period = 80;
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(bukkitRunnable.runTaskTimer(authMe, delay, period)).willReturn(bukkitTask);
-
-        // when
-        BukkitTask result = bukkitService.runTaskTimer(bukkitRunnable, delay, period);
-
-        // then
-        assertThat(result, equalTo(bukkitTask));
-        verify(bukkitRunnable).runTaskTimer(authMe, delay, period);
-    }
-
-    @Test
-    public void shouldBroadcastMessage() {
-        // given
-        String message = "Important message to all";
-        given(server.broadcastMessage(message)).willReturn(24);
-
-        // when
-        int result = bukkitService.broadcastMessage(message);
-
-        // then
-        assertThat(result, equalTo(24));
-        verify(server).broadcastMessage(message);
-    }
-
-    @Test
-    public void shouldCreateAndEmitSyncEvent() {
-        // given
-        given(settings.getProperty(PluginSettings.USE_ASYNC_TASKS)).willReturn(false);
-        bukkitService.reload(settings);
-        Player player = mock(Player.class);
-
-        // when
-        FailedLoginEvent event = bukkitService.createAndCallEvent(isAsync -> new FailedLoginEvent(player, isAsync));
-
-        // then
-        verify(pluginManager).callEvent(event);
-        assertThat(event.isAsynchronous(), equalTo(false));
-        assertThat(event.getPlayer(), equalTo(player));
-    }
-
-    @Test
-    public void shouldCreateAndEmitAsyncEvent() {
-        // given
-        Player player = mock(Player.class);
-
-        // when
-        FailedLoginEvent event = bukkitService.createAndCallEvent(isAsync -> new FailedLoginEvent(player, isAsync));
-
-        // then
-        verify(pluginManager).callEvent(event);
-        assertThat(event.isAsynchronous(), equalTo(true));
-        assertThat(event.getPlayer(), equalTo(player));
-    }
-
-    @Test
-    public void shouldReturnServerIp() {
-        // given
-        String ip = "99.99.99.99";
-        given(server.getIp()).willReturn(ip);
-
-        // when
-        String result = bukkitService.getIp();
-
-        // then
-        assertThat(result, equalTo(ip));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/BukkitServiceTestHelper.java b/src/test/java/fr/xephi/authme/service/BukkitServiceTestHelper.java
deleted file mode 100644
index 9807e4f5..00000000
--- a/src/test/java/fr/xephi/authme/service/BukkitServiceTestHelper.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package fr.xephi.authme.service;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.Mockito.doAnswer;
-
-/**
- * Offers utility methods for testing involving a {@link BukkitService} mock.
- */
-public final class BukkitServiceTestHelper {
-
-    private BukkitServiceTestHelper() {
-    }
-
-    /**
-     * Sets a BukkitService mock to run any Runnable it is passed to its method
-     * {@link BukkitService#scheduleSyncTaskFromOptionallyAsyncTask}.
-     *
-     * @param bukkitService the mock to set behavior on
-     */
-    public static void setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(BukkitService bukkitService) {
-        doAnswer(invocation -> {
-            Runnable runnable = invocation.getArgument(0);
-            runnable.run();
-            return null;
-        }).when(bukkitService).scheduleSyncTaskFromOptionallyAsyncTask(any(Runnable.class));
-    }
-
-    /**
-     * Sets a BukkitService mock to run any Runnable it is passed to its method
-     * {@link BukkitService#runTaskAsynchronously}.
-     *
-     * @param bukkitService the mock to set behavior on
-     */
-    public static void setBukkitServiceToRunTaskAsynchronously(BukkitService bukkitService) {
-        doAnswer(invocation -> {
-            Runnable runnable = invocation.getArgument(0);
-            runnable.run();
-            return null;
-        }).when(bukkitService).runTaskAsynchronously(any(Runnable.class));
-    }
-
-    /**
-     * Sets a BukkitService mock to run any Runnable it is passed to its method
-     * {@link BukkitService#runTaskOptionallyAsync}.
-     *
-     * @param bukkitService the mock to set behavior on
-     */
-    public static void setBukkitServiceToRunTaskOptionallyAsync(BukkitService bukkitService) {
-        doAnswer(invocation -> {
-            Runnable runnable = invocation.getArgument(0);
-            runnable.run();
-            return null;
-        }).when(bukkitService).runTaskOptionallyAsync(any(Runnable.class));
-    }
-
-    /**
-     * Sets a BukkitService mock to run any Runnable it is passed to its method
-     * {@link BukkitService#scheduleSyncDelayedTask(Runnable)}.
-     *
-     * @param bukkitService the mock to set behavior on
-     */
-    public static void setBukkitServiceToScheduleSyncDelayedTask(BukkitService bukkitService) {
-        doAnswer(invocation -> {
-            Runnable runnable = invocation.getArgument(0);
-            runnable.run();
-            return null;
-        }).when(bukkitService).scheduleSyncDelayedTask(any(Runnable.class));
-    }
-
-    /**
-     * Sets a BukkitService mock to run any Runnable it is passed to its method
-     * {@link BukkitService#scheduleSyncDelayedTask(Runnable, long)}.
-     *
-     * @param bukkitService the mock to set behavior on
-     */
-    public static void setBukkitServiceToScheduleSyncDelayedTaskWithDelay(BukkitService bukkitService) {
-        doAnswer(invocation -> {
-            Runnable runnable = invocation.getArgument(0);
-            runnable.run();
-            return null;
-        }).when(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), anyLong());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/CommonServiceTest.java b/src/test/java/fr/xephi/authme/service/CommonServiceTest.java
deleted file mode 100644
index b74762dc..00000000
--- a/src/test/java/fr/xephi/authme/service/CommonServiceTest.java
+++ /dev/null
@@ -1,112 +0,0 @@
-package fr.xephi.authme.service;
-
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.permission.PermissionNode;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerPermission;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.bukkit.command.CommandSender;
-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.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 CommonService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class CommonServiceTest {
-
-    @InjectMocks
-    private CommonService commonService;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private Messages messages;
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Test
-    public void shouldGetProperty() {
-        // given
-        given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(8);
-
-        // when
-        int result = commonService.getProperty(SecuritySettings.CAPTCHA_LENGTH);
-
-        // then
-        verify(settings).getProperty(SecuritySettings.CAPTCHA_LENGTH);
-        assertThat(result, equalTo(8));
-    }
-
-    @Test
-    public void shouldSendMessageToPlayer() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
-
-        // when
-        commonService.send(sender, key);
-
-        // then
-        verify(messages).send(sender, key);
-    }
-
-    @Test
-    public void shouldSendMessageWithReplacements() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
-        String[] replacements = new String[]{"test", "toast"};
-
-        // when
-        commonService.send(sender, key, replacements);
-
-        // then
-        verify(messages).send(sender, key, replacements);
-    }
-
-    @Test
-    public void shouldRetrieveSingleMessage() {
-        // given
-        MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
-        Player player = mock(Player.class);
-        String text = "Test text";
-        given(messages.retrieveSingle(player, key)).willReturn(text);
-
-        // when
-        String result = commonService.retrieveSingleMessage(player, key);
-
-        // then
-        assertThat(result, equalTo(text));
-        verify(messages).retrieveSingle(player, key);
-    }
-
-    @Test
-    public void shouldCheckPermission() {
-        // given
-        Player player = mock(Player.class);
-        PermissionNode permission = PlayerPermission.CHANGE_PASSWORD;
-        given(permissionsManager.hasPermission(player, permission)).willReturn(true);
-
-        // when
-        boolean result = commonService.hasPermission(player, permission);
-
-        // then
-        verify(permissionsManager).hasPermission(player, permission);
-        assertThat(result, equalTo(true));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/GeoIpServiceTest.java b/src/test/java/fr/xephi/authme/service/GeoIpServiceTest.java
deleted file mode 100644
index 8654ec8b..00000000
--- a/src/test/java/fr/xephi/authme/service/GeoIpServiceTest.java
+++ /dev/null
@@ -1,123 +0,0 @@
-package fr.xephi.authme.service;
-
-import com.maxmind.db.GeoIp2Provider;
-import com.maxmind.db.model.Country;
-import com.maxmind.db.model.CountryResponse;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.InetAddress;
-
-import fr.xephi.authme.settings.Settings;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link GeoIpService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class GeoIpServiceTest {
-
-    private GeoIpService geoIpService;
-    private File dataFolder;
-
-    @Mock
-    private GeoIp2Provider lookupService;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private Settings settings;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @Before
-    public void initializeGeoLiteApi() throws IOException {
-        dataFolder = temporaryFolder.newFolder();
-        geoIpService = new GeoIpService(dataFolder, bukkitService, settings, lookupService);
-    }
-
-    @Test
-    public void shouldGetCountry() throws Exception {
-        // given
-        InetAddress ip = InetAddress.getByName("123.45.67.89");
-        String countryCode = "XX";
-
-        Country country = mock(Country.class);
-        given(country.getIsoCode()).willReturn(countryCode);
-
-        CountryResponse response = mock(CountryResponse.class);
-        given(response.getCountry()).willReturn(country);
-        given(lookupService.getCountry(ip)).willReturn(response);
-
-        // when
-        String result = geoIpService.getCountryCode(ip.getHostAddress());
-
-        // then
-        assertThat(result, equalTo(countryCode));
-        verify(lookupService).getCountry(ip);
-    }
-
-    @Test
-    public void shouldNotLookUpCountryForLocalhostIp() throws Exception  {
-        // given
-        String ip = "127.0.0.1";
-
-        // when
-        String result = geoIpService.getCountryCode(ip);
-
-        // then
-        assertThat(result, equalTo("LOCALHOST"));
-        verify(lookupService, never()).getCountry(any());
-    }
-
-    @Test
-    public void shouldLookUpCountryName() throws Exception {
-        // given
-        InetAddress ip = InetAddress.getByName("24.45.167.89");
-        String countryName = "Ecuador";
-
-        Country country = mock(Country.class);
-        given(country.getName()).willReturn(countryName);
-
-        CountryResponse response = mock(CountryResponse.class);
-        given(response.getCountry()).willReturn(country);
-        given(lookupService.getCountry(ip)).willReturn(response);
-
-        // when
-        String result = geoIpService.getCountryName(ip.getHostAddress());
-
-        // then
-        assertThat(result, equalTo(countryName));
-        verify(lookupService).getCountry(ip);
-    }
-
-    @Test
-    public void shouldNotLookUpCountryNameForLocalhostIp() throws Exception {
-        // given
-        InetAddress ip = InetAddress.getByName("127.0.0.1");
-
-        // when
-        String result = geoIpService.getCountryName(ip.getHostAddress());
-
-        // then
-        assertThat(result, equalTo("LocalHost"));
-        verify(lookupService, never()).getCountry(ip);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/HelpTranslationGeneratorIntegrationTest.java b/src/test/java/fr/xephi/authme/service/HelpTranslationGeneratorIntegrationTest.java
deleted file mode 100644
index 3e094cc2..00000000
--- a/src/test/java/fr/xephi/authme/service/HelpTranslationGeneratorIntegrationTest.java
+++ /dev/null
@@ -1,186 +0,0 @@
-package fr.xephi.authme.service;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.command.CommandInitializer;
-import fr.xephi.authme.command.help.HelpMessage;
-import fr.xephi.authme.command.help.HelpMessagesService;
-import fr.xephi.authme.command.help.HelpSection;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.message.HelpMessagesFileHandler;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import org.bukkit.configuration.MemorySection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.io.IOException;
-
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-import static org.mockito.BDDMockito.given;
-
-/**
- * Integration test for {@link HelpTranslationGenerator}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class HelpTranslationGeneratorIntegrationTest {
-
-    @InjectDelayed
-    private HelpTranslationGenerator helpTranslationGenerator;
-    @InjectDelayed
-    private HelpMessagesService helpMessagesService;
-    @InjectDelayed
-    private HelpMessagesFileHandler helpMessagesFileHandler;
-    @InjectDelayed
-    private CommandInitializer commandInitializer;
-
-    @DataFolder
-    private File dataFolder;
-    private File helpMessagesFile;
-
-    @Mock
-    private Settings settings;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    public void setUpClasses() throws IOException {
-        dataFolder = temporaryFolder.newFolder();
-        File messagesFolder = new File(dataFolder, "messages");
-        messagesFolder.mkdir();
-        helpMessagesFile = new File(messagesFolder, "help_test.yml");
-        Files.copy(TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "message/help_test.yml"), helpMessagesFile);
-        given(settings.getProperty(PluginSettings.MESSAGES_LANGUAGE)).willReturn("test");
-    }
-
-    @Test
-    public void shouldUpdateCurrentHelpFile() throws IOException {
-        // given / when
-        helpTranslationGenerator.updateHelpFile();
-
-        // then
-        FileConfiguration configuration = YamlConfiguration.loadConfiguration(helpMessagesFile);
-        checkCommonEntries(configuration);
-        checkSections(configuration);
-        checkCommands(configuration);
-    }
-
-    private void checkCommonEntries(FileConfiguration configuration) {
-        // Entries that were already present
-        assertThat(configuration.getString(HelpMessage.HEADER.getKey()), equalTo("My custom help header"));
-        assertThat(configuration.getString(HelpMessage.OPTIONAL.getKey()), equalTo("t-opt"));
-        assertThat(configuration.getString("common.defaultPermissions.notAllowed"), equalTo("t-noperm"));
-        assertThat(configuration.getString("common.defaultPermissions.allowed"), equalTo("t-allperm"));
-
-        // Entries that were added from the default
-        assertThat(configuration.getString(HelpMessage.DEFAULT.getKey()), equalTo("Default"));
-        assertThat(configuration.getString("common.defaultPermissions.opOnly"), equalTo("OP's only"));
-    }
-
-    private void checkSections(FileConfiguration configuration) {
-        // Entries that were already present
-        assertThat(configuration.getString(HelpSection.COMMAND.getKey()), equalTo("my command translation"));
-        assertThat(configuration.getString(HelpSection.SHORT_DESCRIPTION.getKey()), equalTo(""));
-        assertThat(configuration.getString(HelpSection.CHILDREN.getKey()), equalTo(""));
-
-        // Entries that were added from the default
-        assertThat(configuration.getString(HelpSection.DETAILED_DESCRIPTION.getKey()), equalTo("Detailed description"));
-        assertThat(configuration.getString(HelpSection.ARGUMENTS.getKey()), equalTo("Arguments"));
-        assertThat(configuration.getString(HelpSection.COMMAND.getKey()), equalTo("my command translation"));
-    }
-
-    private void checkCommands(FileConfiguration configuration) {
-        // Check /authme and /authme register entries: full text was available
-        checkDescription(configuration.get("commands.authme"), "test auth desc", "test auth long desc");
-        checkDescription(configuration.get("commands.authme.register"), "test reg desc", "test reg long desc");
-        checkArgs(configuration.get("commands.authme.register"),
-            arg("test reg arg1", "test reg arg1 text"), arg("test reg arg2", "test reg arg2 text"));
-
-        // Check /unregister: only had detailed description
-        checkDescription(configuration.get("commands.authme.unregister"), "Unregister a player", "Detailed description for unregister.");
-
-        // Check /email add
-        checkDescription(configuration.get("commands.email.add"), "email add desc", "email add long desc");
-        checkArgs(configuration.get("commands.email.add"),
-            arg("add arg1", "add arg1 text"), arg("add arg2", "add arg2 text"));
-
-        // Check /login
-        checkDescription(configuration.get("commands.login"), "Login command", "/login detailed desc.");
-        checkArgs(configuration.get("commands.login"), arg("loginArg", "Login password"));
-
-        // Check /unregister
-        checkDescription(configuration.get("commands.unregister"), "unreg_desc", "unreg_detail_desc");
-        checkArgs(configuration.get("commands.unregister"), arg("unreg_arg_label", "unreg_arg_desc"));
-
-        // Check /changepassword: had tons of invalid stuff, just expect it to be taken from defaults
-        checkDescription(configuration.get("commands.changepassword"), "[a list, instead of text]", "1337");
-        assertThat(configuration.get("commands.changepassword.arg1.label"), equalTo("true"));
-        assertThat(configuration.get("commands.changepassword.arg1.description"), equalTo("[]"));
-        // We have a whole object as arg2.label, for which the toString() is generated. Not very useful, so just test a portion...
-        assertThat((String) configuration.get("commands.changepassword.arg2.label"), containsString("MemorySection"));
-        assertThat(configuration.get("commands.changepassword.arg2.description"), equalTo("New password"));
-        assertThat(configuration.get("commands.changepassword.arg3"), nullValue());
-
-        // Check /captcha, with empty arg text
-        checkArgs(configuration.get("commands.captcha"), arg("", ""));
-    }
-
-    private static void checkDescription(Object memorySection, String description, String detailedDescription) {
-        if (memorySection instanceof MemorySection) {
-            MemorySection memSection = (MemorySection) memorySection;
-            assertThat(memSection.getString("description"), equalTo(description));
-            assertThat(memSection.getString("detailedDescription"), equalTo(detailedDescription));
-        } else {
-            fail("Expected MemorySection, got '" + memorySection + "'");
-        }
-    }
-
-    private static void checkArgs(Object memorySection, Argument... arguments) {
-        if (memorySection instanceof MemorySection) {
-            MemorySection memSection = (MemorySection) memorySection;
-            int i = 1;
-            for (Argument arg : arguments) {
-                assertThat(memSection.getString("arg" + i + ".label"), equalTo(arg.label));
-                assertThat(memSection.getString("arg" + i + ".description"), equalTo(arg.description));
-                ++i;
-            }
-            assertThat(memSection.get("arg" + i), nullValue());
-        } else {
-            fail("Expected MemorySection, got '" + memorySection + "'");
-        }
-    }
-
-    private static Argument arg(String label, String description) {
-        return new Argument(label, description);
-    }
-
-    private static final class Argument {
-        final String label;
-        final String description;
-
-        Argument(String label, String description) {
-            this.label = label;
-            this.description = description;
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/MigrationServiceTest.java b/src/test/java/fr/xephi/authme/service/MigrationServiceTest.java
deleted file mode 100644
index ec989a04..00000000
--- a/src/test/java/fr/xephi/authme/service/MigrationServiceTest.java
+++ /dev/null
@@ -1,125 +0,0 @@
-package fr.xephi.authme.service;
-
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.security.HashAlgorithm;
-import fr.xephi.authme.security.crypts.HashedPassword;
-import fr.xephi.authme.security.crypts.Sha256;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Locale;
-
-import static fr.xephi.authme.AuthMeMatchers.equalToHash;
-import static org.hamcrest.Matchers.equalToIgnoringCase;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link MigrationService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class MigrationServiceTest {
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private Sha256 sha256;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldMigratePlaintextHashes() {
-        // given
-        PlayerAuth auth1 = authWithNickAndHash("bobby", "test");
-        PlayerAuth auth2 = authWithNickAndHash("user", "myPassword");
-        PlayerAuth auth3 = authWithNickAndHash("Tester12", "$tester12_pw");
-        given(dataSource.getAllAuths()).willReturn(Arrays.asList(auth1, auth2, auth3));
-        setSha256MockToUppercase(sha256);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.PLAINTEXT);
-
-        // when
-        MigrationService.changePlainTextToSha256(settings, dataSource, sha256);
-
-        // then
-        verify(sha256, times(3)).computeHash(anyString(), anyString());
-        verify(dataSource).getAllAuths(); // need to verify this because we use verifyNoMoreInteractions() after
-        verify(dataSource).updatePassword(auth1);
-        assertThat(auth1.getPassword(), equalToHash("TEST"));
-        verify(dataSource).updatePassword(auth2);
-        assertThat(auth2.getPassword(), equalToHash("MYPASSWORD"));
-        verify(dataSource).updatePassword(auth3);
-        assertThat(auth3.getPassword(), equalToHash("$TESTER12_PW"));
-        verifyNoMoreInteractions(dataSource);
-        verify(settings).setProperty(SecuritySettings.PASSWORD_HASH, HashAlgorithm.SHA256);
-    }
-
-    @Test
-    public void shouldNotMigrateShaHashes() {
-        // given
-        PlayerAuth auth1 = authWithNickAndHash("testUser", "abc1234");
-        PlayerAuth auth2 = authWithNickAndHash("minecraft", "$SHA$f28930ae09823eba4cd98a3");
-        given(dataSource.getAllAuths()).willReturn(Arrays.asList(auth1, auth2));
-        setSha256MockToUppercase(sha256);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.PLAINTEXT);
-
-        // when
-        MigrationService.changePlainTextToSha256(settings, dataSource, sha256);
-
-        // then
-        verify(sha256).computeHash(eq("abc1234"), argThat(equalToIgnoringCase("testUser")));
-        verifyNoMoreInteractions(sha256);
-        verify(dataSource).getAllAuths(); // need to verify this because we use verifyNoMoreInteractions() after
-        verify(dataSource).updatePassword(auth1);
-        assertThat(auth1.getPassword(), equalToHash("ABC1234"));
-        verifyNoMoreInteractions(dataSource);
-        verify(settings).setProperty(SecuritySettings.PASSWORD_HASH, HashAlgorithm.SHA256);
-    }
-
-    @Test
-    public void shouldNotMigrateForHashOtherThanPlaintext() {
-        // given
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.BCRYPT);
-
-        // when
-        MigrationService.changePlainTextToSha256(settings, dataSource, sha256);
-
-        // then
-        verify(settings).getProperty(SecuritySettings.PASSWORD_HASH);
-        verifyNoMoreInteractions(settings, dataSource, sha256);
-    }
-
-    private static PlayerAuth authWithNickAndHash(String nick, String hash) {
-        return PlayerAuth.builder()
-            .name(nick)
-            .password(hash, null)
-            .build();
-    }
-
-    private static void setSha256MockToUppercase(Sha256 sha256) {
-        given(sha256.computeHash(anyString(), anyString())).willAnswer(invocation -> {
-            String plainPassword = invocation.getArgument(0);
-            return new HashedPassword(plainPassword.toUpperCase(Locale.ROOT), null);
-        });
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/PasswordRecoveryServiceTest.java b/src/test/java/fr/xephi/authme/service/PasswordRecoveryServiceTest.java
deleted file mode 100644
index bf3dd083..00000000
--- a/src/test/java/fr/xephi/authme/service/PasswordRecoveryServiceTest.java
+++ /dev/null
@@ -1,122 +0,0 @@
-package fr.xephi.authme.service;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.mail.EmailService;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.Messages;
-import fr.xephi.authme.security.PasswordSecurity;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-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;
-
-/**
- * Tests for {@link PasswordRecoveryService}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class PasswordRecoveryServiceTest {
-
-    @InjectDelayed
-    private PasswordRecoveryService recoveryService;
-
-    @Mock
-    private CommonService commonService;
-
-    @Mock
-    private RecoveryCodeService codeService;
-
-    @Mock
-    private DataSource dataSource;
-
-    @Mock
-    private EmailService emailService;
-
-    @Mock
-    private PasswordSecurity passwordSecurity;
-
-    @Mock
-    private Messages messages;
-
-    @BeforeInjecting
-    public void initSettings() {
-        given(commonService.getProperty(SecuritySettings.EMAIL_RECOVERY_COOLDOWN_SECONDS)).willReturn(40);
-        given(commonService.getProperty(SecuritySettings.PASSWORD_CHANGE_TIMEOUT)).willReturn(2);
-    }
-
-    @Test
-    public void shouldSendRecoveryCode() {
-        // given
-        Player player = mock(Player.class);
-        String name = "Carl";
-        given(player.getName()).willReturn(name);
-        String email = "test@example.com";
-        String code = "qwerty";
-        given(codeService.generateCode(name)).willReturn(code);
-        given(emailService.sendRecoveryCode(player.getName(), email, code)).willReturn(true);
-
-        // when
-        recoveryService.createAndSendRecoveryCode(player, email);
-
-        // then
-        verify(codeService).generateCode(name);
-        verify(emailService).sendRecoveryCode(name, email, code);
-        verify(commonService).send(player, MessageKey.RECOVERY_CODE_SENT);
-    }
-
-    @Test
-    public void shouldKeepTrackOfSuccessfulRecoversByIp() {
-        // given
-        Player bobby = mock(Player.class);
-        TestHelper.mockIpAddressToPlayer(bobby, "192.168.8.8");
-        given(bobby.getName()).willReturn("bobby");
-
-        Player bobby2 = mock(Player.class);
-        TestHelper.mockIpAddressToPlayer(bobby2, "127.0.0.1");
-        given(bobby2.getName()).willReturn("bobby");
-
-        Player other = mock(Player.class);
-        TestHelper.mockIpAddressToPlayer(other, "192.168.8.8");
-        given(other.getName()).willReturn("other");
-
-        // when
-        recoveryService.addSuccessfulRecovery(bobby);
-
-        // then
-        assertThat(recoveryService.canChangePassword(bobby), equalTo(true));
-        assertThat(recoveryService.canChangePassword(bobby2), equalTo(false));
-        assertThat(recoveryService.canChangePassword(other), equalTo(false));
-    }
-
-    @Test
-    public void shouldRemovePlayerFromSuccessfulRecovers() {
-        // given
-        Player bobby = mock(Player.class);
-        TestHelper.mockIpAddressToPlayer(bobby, "192.168.8.8");
-        given(bobby.getName()).willReturn("bobby");
-        recoveryService.addSuccessfulRecovery(bobby);
-
-        Player other = mock(Player.class);
-        TestHelper.mockIpAddressToPlayer(other, "8.8.8.8");
-        given(other.getName()).willReturn("other");
-        recoveryService.addSuccessfulRecovery(other);
-
-        // when
-        recoveryService.removeFromSuccessfulRecovery(other);
-
-
-        // then
-        assertThat(recoveryService.canChangePassword(bobby), equalTo(true));
-        assertThat(recoveryService.canChangePassword(other), equalTo(false));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/PluginHookServiceTest.java b/src/test/java/fr/xephi/authme/service/PluginHookServiceTest.java
deleted file mode 100644
index d949db7d..00000000
--- a/src/test/java/fr/xephi/authme/service/PluginHookServiceTest.java
+++ /dev/null
@@ -1,271 +0,0 @@
-package fr.xephi.authme.service;
-
-import com.earth2me.essentials.Essentials;
-import com.earth2me.essentials.User;
-import com.onarandombox.MultiverseCore.MultiverseCore;
-import com.onarandombox.MultiverseCore.api.MVWorldManager;
-import com.onarandombox.MultiverseCore.api.MultiverseWorld;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.io.File;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doThrow;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link PluginHookService}.
- */
-public class PluginHookServiceTest {
-
-    /** The plugin name of Essentials. */
-    private static final String ESSENTIALS = "Essentials";
-    /** The plugin name of CMI. */
-    private static final String CMI = "CMI";
-    /** The plugin name of Multiverse-Core. */
-    private static final String MULTIVERSE = "Multiverse-Core";
-
-    @BeforeClass
-    public static void setLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldHookIntoEssentials() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-        setPluginAvailable(pluginManager, ESSENTIALS, Essentials.class);
-        assertThat(pluginHookService.isEssentialsAvailable(), equalTo(false));
-
-        // when
-        pluginHookService.tryHookToEssentials();
-
-        // then
-        assertThat(pluginHookService.isEssentialsAvailable(), equalTo(true));
-    }
-
-    @Test
-    public void shouldHookIntoEssentialsAtInitialization() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        setPluginAvailable(pluginManager, ESSENTIALS, Essentials.class);
-
-        // when
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // then
-        assertThat(pluginHookService.isEssentialsAvailable(), equalTo(true));
-    }
-
-    @Test
-    public void shouldHookIntoCmiAtInitialization() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        setPluginAvailable(pluginManager, CMI, Plugin.class);
-
-        // when
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // then
-        assertThat(pluginHookService.isCmiAvailable(), equalTo(true));
-    }
-
-    @Test
-    public void shouldHookIntoMultiverseAtInitialization() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        setPluginAvailable(pluginManager, MULTIVERSE, MultiverseCore.class);
-
-        // when
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // then
-        assertThat(pluginHookService.isMultiverseAvailable(), equalTo(true));
-    }
-
-    @Test
-    public void shouldReturnEssentialsDataFolder() {
-        // given
-        Essentials ess = mock(Essentials.class);
-        File essDataFolder = new File("test/data-folder");
-        // Need to set the data folder with reflections because getDataFolder() is declared final
-        ReflectionTestUtils.setField(JavaPlugin.class, ess, "dataFolder", essDataFolder);
-
-        PluginManager pluginManager = mock(PluginManager.class);
-        setPluginAvailable(pluginManager, ESSENTIALS, ess);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // when
-        File dataFolder = pluginHookService.getEssentialsDataFolder();
-
-        // then
-        assertThat(dataFolder, equalTo(essDataFolder));
-    }
-
-    @Test
-    public void shouldReturnNullForUnhookedEssentials() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // when
-        File result = pluginHookService.getEssentialsDataFolder();
-
-        // then
-        assertThat(result, nullValue());
-    }
-
-    @Test
-    public void shouldSetSocialSpyStatus() {
-        // given
-        Player player = mock(Player.class);
-
-        Essentials ess = mock(Essentials.class);
-        User user = mock(User.class);
-        given(ess.getUser(player)).willReturn(user);
-
-        PluginManager pluginManager = mock(PluginManager.class);
-        setPluginAvailable(pluginManager, ESSENTIALS, ess);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // when
-        pluginHookService.setEssentialsSocialSpyStatus(player, true);
-
-        // then
-        verify(ess).getUser(player);
-        verify(user).setSocialSpyEnabled(true);
-    }
-
-    @Test
-    public void shouldNotDoAnythingForUnhookedEssentials() {
-        // given
-        PluginHookService pluginHookService = new PluginHookService(mock(PluginManager.class));
-
-        // when/then
-        pluginHookService.setEssentialsSocialSpyStatus(mock(Player.class), false);
-    }
-
-    @Test
-    public void shouldUnhookEssentialsAndMultiverse() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        setPluginAvailable(pluginManager, ESSENTIALS, Essentials.class);
-        setPluginAvailable(pluginManager, MULTIVERSE, MultiverseCore.class);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // when
-        pluginHookService.unhookEssentials();
-        pluginHookService.unhookMultiverse();
-
-        // then
-        assertThat(pluginHookService.isEssentialsAvailable(), equalTo(false));
-        assertThat(pluginHookService.isMultiverseAvailable(), equalTo(false));
-    }
-
-    @Test
-    public void shouldHandlePluginRetrievalError() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        given(pluginManager.isPluginEnabled(anyString())).willReturn(true);
-        doThrow(IllegalStateException.class).when(pluginManager).getPlugin(anyString());
-
-        // when
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // then
-        assertThat(pluginHookService.isEssentialsAvailable(), equalTo(false));
-        assertThat(pluginHookService.isCmiAvailable(), equalTo(false));
-        assertThat(pluginHookService.isMultiverseAvailable(), equalTo(false));
-    }
-
-    @Test
-    public void shouldReturnNullForUnavailableMultiverse() {
-        // given
-        PluginManager pluginManager = mock(PluginManager.class);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-        World world = mock(World.class);
-
-        // when
-        Location result = pluginHookService.getMultiverseSpawn(world);
-
-        // then
-        assertThat(result, nullValue());
-    }
-
-    @Test
-    public void shouldGetMultiverseSpawn() {
-        // given
-        Location location = mock(Location.class);
-        MultiverseWorld multiverseWorld = mock(MultiverseWorld.class);
-        given(multiverseWorld.getSpawnLocation()).willReturn(location);
-
-        World world = mock(World.class);
-        MVWorldManager mvWorldManager = mock(MVWorldManager.class);
-        given(mvWorldManager.isMVWorld(world)).willReturn(true);
-        given(mvWorldManager.getMVWorld(world)).willReturn(multiverseWorld);
-        MultiverseCore multiverse = mock(MultiverseCore.class);
-        given(multiverse.getMVWorldManager()).willReturn(mvWorldManager);
-
-        PluginManager pluginManager = mock(PluginManager.class);
-        setPluginAvailable(pluginManager, MULTIVERSE, multiverse);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // when
-        Location spawn = pluginHookService.getMultiverseSpawn(world);
-
-        // then
-        assertThat(spawn, equalTo(location));
-        verify(mvWorldManager).isMVWorld(world);
-        verify(mvWorldManager).getMVWorld(world);
-        verify(multiverseWorld).getSpawnLocation();
-    }
-
-    @Test
-    public void shouldReturnNullForNonMvWorld() {
-        // given
-        World world = mock(World.class);
-        MVWorldManager mvWorldManager = mock(MVWorldManager.class);
-        given(mvWorldManager.isMVWorld(world)).willReturn(false);
-
-        PluginManager pluginManager = mock(PluginManager.class);
-        MultiverseCore multiverse = mock(MultiverseCore.class);
-        setPluginAvailable(pluginManager, MULTIVERSE, multiverse);
-        given(multiverse.getMVWorldManager()).willReturn(mvWorldManager);
-        PluginHookService pluginHookService = new PluginHookService(pluginManager);
-
-        // when
-        Location spawn = pluginHookService.getMultiverseSpawn(world);
-
-        // then
-        assertThat(spawn, nullValue());
-        verify(mvWorldManager).isMVWorld(world);
-        verify(mvWorldManager, never()).getMVWorld(world);
-    }
-
-    private static void setPluginAvailable(PluginManager managerMock, String pluginName,
-                                           Class<? extends Plugin> pluginClass) {
-        setPluginAvailable(managerMock, pluginName, mock(pluginClass));
-    }
-
-    private static <T extends Plugin> void setPluginAvailable(PluginManager managerMock, String pluginName, T plugin) {
-        given(managerMock.isPluginEnabled(pluginName)).willReturn(true);
-        given(managerMock.getPlugin(pluginName)).willReturn(plugin);
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/service/RecoveryCodeServiceTest.java b/src/test/java/fr/xephi/authme/service/RecoveryCodeServiceTest.java
deleted file mode 100644
index 9641db9a..00000000
--- a/src/test/java/fr/xephi/authme/service/RecoveryCodeServiceTest.java
+++ /dev/null
@@ -1,131 +0,0 @@
-package fr.xephi.authme.service;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import fr.xephi.authme.util.expiring.ExpiringMap;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-
-/**
- * Test for {@link RecoveryCodeService}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class RecoveryCodeServiceTest {
-
-    @InjectDelayed
-    private RecoveryCodeService recoveryCodeService;
-
-    @Mock
-    private Settings settings;
-
-    @BeforeInjecting
-    public void initSettings() {
-        given(settings.getProperty(SecuritySettings.RECOVERY_CODE_HOURS_VALID)).willReturn(4);
-        given(settings.getProperty(SecuritySettings.RECOVERY_CODE_LENGTH)).willReturn(5);
-        given(settings.getProperty(SecuritySettings.RECOVERY_CODE_MAX_TRIES)).willReturn(3);
-    }
-
-    @Test
-    public void shouldBeDisabledForNonPositiveLength() {
-        assertThat(recoveryCodeService.isRecoveryCodeNeeded(), equalTo(true));
-
-        // given
-        given(settings.getProperty(SecuritySettings.RECOVERY_CODE_LENGTH)).willReturn(0);
-
-        // when
-        recoveryCodeService.reload(settings);
-
-        // then
-        assertThat(recoveryCodeService.isRecoveryCodeNeeded(), equalTo(false));
-    }
-
-    @Test
-    public void shouldGenerateAndStoreCode() {
-        // given
-        String name = "Bobbers";
-
-        // when
-        recoveryCodeService.generateCode(name);
-
-        // then
-        String code = getCodeMap().get(name);
-        assertThat(code, stringWithLength(5));
-    }
-
-    @Test
-    public void playerHasTriesLeft() {
-        // given
-        String player = "Dusty";
-        recoveryCodeService.generateCode(player);
-
-        // when
-        boolean result = recoveryCodeService.hasTriesLeft(player);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void playerHasNoTriesLeft() {
-        // given
-        String player = "Dusty";
-        recoveryCodeService.generateCode(player);
-        recoveryCodeService.isCodeValid(player, "1st try");
-        recoveryCodeService.isCodeValid(player, "2nd try");
-        recoveryCodeService.isCodeValid(player, "3rd try");
-
-        // when
-        boolean result = recoveryCodeService.hasTriesLeft(player);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldRecognizeCorrectCode() {
-        // given
-        String player = "dragon";
-        String code = recoveryCodeService.generateCode(player);
-
-        // when
-        boolean result = recoveryCodeService.isCodeValid(player, code);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldRemoveCode() {
-        // given
-        String player = "Tester";
-        String code = recoveryCodeService.generateCode(player);
-
-        // when
-        recoveryCodeService.removeCode(player);
-
-        // then
-        assertThat(recoveryCodeService.isCodeValid(player, code), equalTo(false));
-        assertThat(getCodeMap().get(player), nullValue());
-        assertThat(getTriesCounter().get(player), equalTo(0));
-    }
-
-
-    private ExpiringMap<String, String> getCodeMap() {
-        return ReflectionTestUtils.getFieldValue(RecoveryCodeService.class, recoveryCodeService, "recoveryCodes");
-    }
-
-    private ExpiringMap<String, Integer> getTriesCounter() {
-        return ReflectionTestUtils.getFieldValue(RecoveryCodeService.class, recoveryCodeService, "playerTries");
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/SessionServiceTest.java b/src/test/java/fr/xephi/authme/service/SessionServiceTest.java
deleted file mode 100644
index 7153f149..00000000
--- a/src/test/java/fr/xephi/authme/service/SessionServiceTest.java
+++ /dev/null
@@ -1,246 +0,0 @@
-package fr.xephi.authme.service;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.events.RestoreSessionEvent;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.util.function.Function;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link SessionService}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class SessionServiceTest {
-
-    @InjectDelayed
-    private SessionService sessionService;
-
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private CommonService commonService;
-    @Mock
-    private BukkitService bukkitService;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @BeforeInjecting
-    public void setUpEnabledProperty() {
-        given(commonService.getProperty(PluginSettings.SESSIONS_ENABLED)).willReturn(true);
-    }
-
-    @Test
-    public void shouldCheckSessionsEnabledSetting() {
-        // given
-        Player player = mock(Player.class);
-        given(commonService.getProperty(PluginSettings.SESSIONS_ENABLED)).willReturn(false);
-        sessionService.reload();
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verifyNoInteractions(dataSource);
-    }
-
-    @Test
-    public void shouldCheckIfUserHasSession() {
-        // given
-        String name = "Bobby";
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        given(dataSource.hasSession(name)).willReturn(false);
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService, only()).getProperty(PluginSettings.SESSIONS_ENABLED);
-        verify(dataSource, only()).hasSession(name);
-    }
-
-    @Test
-    public void shouldCheckLastLoginDate() {
-        // given
-        String name = "Bobby";
-        String ip = "127.3.12.15";
-        Player player = mockPlayerWithNameAndIp(name, ip);
-        given(commonService.getProperty(PluginSettings.SESSIONS_TIMEOUT)).willReturn(8);
-        given(dataSource.hasSession(name)).willReturn(true);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name(name)
-            .lastLogin(System.currentTimeMillis() - 10 * 60 * 1000)
-            .lastIp(ip).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService).getProperty(PluginSettings.SESSIONS_ENABLED);
-        verify(dataSource).hasSession(name);
-        verify(dataSource).setUnlogged(name);
-        verify(dataSource).revokeSession(name);
-    }
-
-    @Test
-    public void shouldRefuseSessionForAuthWithNullLastLoginTimestamp() {
-        // given
-        String name = "Bobby";
-        String ip = "127.3.12.15";
-        Player player = mockPlayerWithNameAndIp(name, ip);
-        given(commonService.getProperty(PluginSettings.SESSIONS_TIMEOUT)).willReturn(8);
-        given(dataSource.hasSession(name)).willReturn(true);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name(name)
-            .lastLogin(null)
-            .lastIp(ip).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService).getProperty(PluginSettings.SESSIONS_ENABLED);
-        verify(dataSource).hasSession(name);
-        verify(dataSource).setUnlogged(name);
-        verify(dataSource).revokeSession(name);
-    }
-
-    @Test
-    public void shouldCheckLastLoginIp() {
-        // given
-        String name = "Bobby";
-        String ip = "127.3.12.15";
-        Player player = mockPlayerWithNameAndIp(name, ip);
-        given(dataSource.hasSession(name)).willReturn(true);
-        given(commonService.getProperty(PluginSettings.SESSIONS_TIMEOUT)).willReturn(8);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name(name)
-            .lastLogin(System.currentTimeMillis() - 7 * 60 * 1000)
-            .lastIp("8.8.8.8").build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService).getProperty(PluginSettings.SESSIONS_ENABLED);
-        verify(commonService).send(player, MessageKey.SESSION_EXPIRED);
-        verify(dataSource).hasSession(name);
-        verify(dataSource).setUnlogged(name);
-        verify(dataSource).revokeSession(name);
-    }
-
-    @Test
-    public void shouldEmitEventForValidSession() {
-        // given
-        String name = "Bobby";
-        String ip = "127.3.12.15";
-        Player player = mockPlayerWithNameAndIp(name, ip);
-        given(commonService.getProperty(PluginSettings.SESSIONS_TIMEOUT)).willReturn(8);
-        given(dataSource.hasSession(name)).willReturn(true);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name(name)
-            .lastLogin(System.currentTimeMillis() - 7 * 60 * 1000)
-            .lastIp(ip).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-        RestoreSessionEvent event = spy(new RestoreSessionEvent(player, false));
-        given(bukkitService.createAndCallEvent(any(Function.class))).willReturn(event);
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(commonService).getProperty(PluginSettings.SESSIONS_ENABLED);
-        verify(commonService).getProperty(PluginSettings.SESSIONS_TIMEOUT);
-        verifyNoMoreInteractions(commonService);
-        verify(dataSource).hasSession(name);
-        verify(dataSource).setUnlogged(name);
-        verify(dataSource).revokeSession(name);
-        verify(event).isCancelled();
-    }
-
-    @Test
-    public void shouldHandleNullPlayerAuth() {
-        // given
-        String name = "Bobby";
-        Player player = mockPlayerWithNameAndIp(name, "127.3.12.15");
-        given(dataSource.hasSession(name)).willReturn(true);
-        given(dataSource.getAuth(name)).willReturn(null);
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService).getProperty(PluginSettings.SESSIONS_ENABLED);
-        verify(dataSource).hasSession(name);
-        verify(dataSource).setUnlogged(name);
-        verify(dataSource).revokeSession(name);
-        verify(dataSource).getAuth(name);
-    }
-
-    @Test
-    public void shouldHandlePlayerAuthWithNullLastIp() {
-        // given
-        String name = "Charles";
-        Player player = mockPlayerWithNameAndIp(name, "144.117.118.145");
-        given(dataSource.hasSession(name)).willReturn(true);
-        given(commonService.getProperty(PluginSettings.SESSIONS_TIMEOUT)).willReturn(8);
-        PlayerAuth auth = PlayerAuth.builder()
-            .name(name)
-            .lastIp(null)
-            .lastLogin(System.currentTimeMillis()).build();
-        given(dataSource.getAuth(name)).willReturn(auth);
-
-        // when
-        boolean result = sessionService.canResumeSession(player);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(commonService).getProperty(PluginSettings.SESSIONS_ENABLED);
-        verify(dataSource).hasSession(name);
-        verify(dataSource).setUnlogged(name);
-        verify(dataSource).revokeSession(name);
-        verify(dataSource).getAuth(name);
-    }
-
-    private static Player mockPlayerWithNameAndIp(String name, String ip) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/TeleportationServiceTest.java b/src/test/java/fr/xephi/authme/service/TeleportationServiceTest.java
deleted file mode 100644
index 46db5e05..00000000
--- a/src/test/java/fr/xephi/authme/service/TeleportationServiceTest.java
+++ /dev/null
@@ -1,415 +0,0 @@
-package fr.xephi.authme.service;
-
-import fr.xephi.authme.data.auth.PlayerAuth;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.data.limbo.LimboPlayer;
-import fr.xephi.authme.events.FirstSpawnTeleportEvent;
-import fr.xephi.authme.events.SpawnTeleportEvent;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.SpawnLoader;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-
-import static fr.xephi.authme.service.BukkitServiceTestHelper.setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link TeleportationService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class TeleportationServiceTest {
-
-    @InjectMocks
-    private TeleportationService teleportationService;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Mock
-    private SpawnLoader spawnLoader;
-
-    @Mock
-    private PlayerCache playerCache;
-
-    @Before
-    public void setUpForcedWorlds() {
-        given(settings.getProperty(RestrictionSettings.FORCE_SPAWN_ON_WORLDS))
-            .willReturn(Arrays.asList("forced1", "OtherForced"));
-        teleportationService.reload();
-
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-    }
-
-    // -----------
-    // JOINING
-    // -----------
-    @Test
-    public void shouldNotTeleportPlayerOnJoin() {
-        // given
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(true);
-        Player player = mock(Player.class);
-
-        // when
-        teleportationService.teleportOnJoin(player);
-
-        // then
-        verifyNoInteractions(player);
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldTeleportPlayerToFirstSpawn() {
-        // given
-        Player player = mock(Player.class);
-        given(player.hasPlayedBefore()).willReturn(false);
-        given(player.isOnline()).willReturn(true);
-        Location firstSpawn = mockLocation();
-        given(spawnLoader.getFirstSpawn()).willReturn(firstSpawn);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportNewPlayerToFirstSpawn(player);
-
-        // then
-        verify(player).teleport(firstSpawn);
-        verify(bukkitService).callEvent(any(FirstSpawnTeleportEvent.class));
-        verify(spawnLoader).getFirstSpawn();
-        verify(spawnLoader, never()).getSpawnLocation(any(Player.class));
-    }
-
-    @Test
-    public void shouldTeleportPlayerToSpawn() {
-        // given
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-        Player player = mock(Player.class);
-        given(player.isOnline()).willReturn(true);
-        Location spawn = mockLocation();
-        given(spawnLoader.getSpawnLocation(player)).willReturn(spawn);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnJoin(player);
-
-        // then
-        verify(player).teleport(spawn);
-        verify(bukkitService).callEvent(any(SpawnTeleportEvent.class));
-        verify(spawnLoader).getSpawnLocation(player);
-    }
-
-    @Test
-    // No first spawn defined, no teleport settings enabled
-    public void shouldNotTeleportNewPlayer() {
-        // given
-        Player player = mock(Player.class);
-        given(spawnLoader.getFirstSpawn()).willReturn(null);
-
-        // when
-        teleportationService.teleportNewPlayerToFirstSpawn(player);
-
-        // then
-        verify(player, never()).teleport(any(Location.class));
-        verify(spawnLoader).getFirstSpawn();
-        verify(spawnLoader, never()).getSpawnLocation(any(Player.class));
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldNotTeleportPlayerToFirstSpawnIfNoTeleportEnabled() {
-        // given
-        Player player = mock(Player.class);
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(true);
-
-        // when
-        teleportationService.teleportNewPlayerToFirstSpawn(player);
-
-        // then
-        verify(player, never()).teleport(any(Location.class));
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldNotTeleportNotNewPlayerToFirstSpawn() {
-        // given
-        Player player = mock(Player.class);
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(false);
-
-        // when
-        teleportationService.teleportNewPlayerToFirstSpawn(player);
-
-        // then
-        verify(player, never()).teleport(any(Location.class));
-        verifyNoInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldNotTeleportPlayerForRemovedLocationInEvent() {
-        // given
-        final Player player = mock(Player.class);
-        Location spawn = mockLocation();
-        given(spawnLoader.getSpawnLocation(player)).willReturn(spawn);
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-        doAnswer(invocation -> {
-            SpawnTeleportEvent event = (SpawnTeleportEvent) invocation.getArguments()[0];
-            assertThat(event.getPlayer(), equalTo(player));
-            event.setTo(null);
-            return null;
-        }).when(bukkitService).callEvent(any(SpawnTeleportEvent.class));
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnJoin(player);
-
-        // then
-        verify(bukkitService).callEvent(any(SpawnTeleportEvent.class));
-        verify(player, never()).teleport(any(Location.class));
-    }
-
-    @Test
-    public void shouldNotTeleportPlayerForCanceledEvent() {
-        // given
-        final Player player = mock(Player.class);
-        Location spawn = mockLocation();
-        given(spawnLoader.getSpawnLocation(player)).willReturn(spawn);
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-        doAnswer(invocation -> {
-            SpawnTeleportEvent event = (SpawnTeleportEvent) invocation.getArguments()[0];
-            assertThat(event.getPlayer(), equalTo(player));
-            event.setCancelled(true);
-            return null;
-        }).when(bukkitService).callEvent(any(SpawnTeleportEvent.class));
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnJoin(player);
-
-        // then
-        verify(bukkitService).callEvent(any(SpawnTeleportEvent.class));
-        verify(player, never()).teleport(any(Location.class));
-    }
-
-    // ---------
-    // LOGIN
-    // ---------
-    @Test
-    public void shouldNotTeleportUponLogin() {
-        // given
-        given(settings.getProperty(RestrictionSettings.NO_TELEPORT)).willReturn(true);
-        Player player = mock(Player.class);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        verifyNoInteractions(player, auth, limbo, bukkitService, spawnLoader);
-    }
-
-    @Test
-    public void shouldTeleportPlayerToSpawnAfterLogin() {
-        // given
-        given(settings.getProperty(RestrictionSettings.FORCE_SPAWN_LOCATION_AFTER_LOGIN)).willReturn(true);
-        Player player = mock(Player.class);
-        given(player.isOnline()).willReturn(true);
-        Location spawn = mockLocation();
-        given(spawnLoader.getSpawnLocation(player)).willReturn(spawn);
-        PlayerAuth auth = mock(PlayerAuth.class);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        Location limboLocation = mockLocation();
-        given(limboLocation.getWorld().getName()).willReturn("forced1");
-        given(limbo.getLocation()).willReturn(limboLocation);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        verify(player).teleport(spawn);
-    }
-
-    @Test
-    // Check that the worlds for "force spawn loc after login" are case-sensitive
-    public void shouldNotTeleportToSpawnForOtherCaseInWorld() {
-        // given
-        given(settings.getProperty(RestrictionSettings.FORCE_SPAWN_LOCATION_AFTER_LOGIN)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(false);
-        Player player = mock(Player.class);
-        Location spawn = mockLocation();
-        PlayerAuth auth = mock(PlayerAuth.class);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        Location limboLocation = mockLocation();
-        given(limboLocation.getWorld().getName()).willReturn("Forced1"); // different case
-        given(limbo.getLocation()).willReturn(limboLocation);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        verify(player, never()).teleport(spawn);
-        verifyNoInteractions(bukkitService, spawnLoader);
-    }
-
-    @Test
-    public void shouldTeleportBackToPlayerAuthLocation() {
-        // given
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.SAVE_QUIT_LOCATION)).willReturn(true);
-
-        PlayerAuth auth = createAuthWithLocation();
-        auth.setWorld("myWorld");
-        World world = mock(World.class);
-        given(bukkitService.getWorld("myWorld")).willReturn(world);
-
-        Player player = mock(Player.class);
-        given(player.isOnline()).willReturn(true);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        Location limboLocation = mockLocation();
-        given(limbo.getLocation()).willReturn(limboLocation);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        ArgumentCaptor<Location> locationCaptor = ArgumentCaptor.forClass(Location.class);
-        verify(player).teleport(locationCaptor.capture());
-        assertCorrectLocation(locationCaptor.getValue(), auth, world);
-    }
-
-    @Test
-    public void shouldTeleportAccordingToPlayerAuthAndPlayerWorldAsFallback() {
-        // given
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.SAVE_QUIT_LOCATION)).willReturn(true);
-
-        PlayerAuth auth = createAuthWithLocation();
-        auth.setWorld("myWorld");
-        given(bukkitService.getWorld("myWorld")).willReturn(null);
-
-        Player player = mock(Player.class);
-        given(player.isOnline()).willReturn(true);
-        World world = mock(World.class);
-        given(player.getWorld()).willReturn(world);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        Location limboLocation = mockLocation();
-        given(limbo.getLocation()).willReturn(limboLocation);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        ArgumentCaptor<Location> locationCaptor = ArgumentCaptor.forClass(Location.class);
-        verify(player).teleport(locationCaptor.capture());
-        assertCorrectLocation(locationCaptor.getValue(), auth, world);
-    }
-
-    @Test
-    public void shouldTeleportWithLimboPlayerIfAuthYCoordIsNotSet() {
-        // given
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.SAVE_QUIT_LOCATION)).willReturn(true);
-
-        PlayerAuth auth = createAuthWithLocation();
-        auth.setQuitLocY(0.0);
-        auth.setWorld("authWorld");
-        Player player = mock(Player.class);
-        given(player.isOnline()).willReturn(true);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        Location location = mockLocation();
-        given(limbo.getLocation()).willReturn(location);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        verify(player).teleport(location);
-        verify(bukkitService, never()).getWorld(anyString());
-    }
-
-    @Test
-    public void shouldTeleportWithLimboPlayerIfSaveQuitLocIsDisabled() {
-        // given
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.SAVE_QUIT_LOCATION)).willReturn(false);
-
-        PlayerAuth auth = createAuthWithLocation();
-        Player player = mock(Player.class);
-        given(player.isOnline()).willReturn(true);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-        Location location = mockLocation();
-        given(limbo.getLocation()).willReturn(location);
-        setBukkitServiceToScheduleSyncTaskFromOptionallyAsyncTask(bukkitService);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        verify(player).teleport(location);
-    }
-
-    @Test
-    public void shouldNotTeleportForNullLocationInLimboPlayer() {
-        // given
-        given(settings.getProperty(RestrictionSettings.SAVE_QUIT_LOCATION)).willReturn(false);
-        given(settings.getProperty(RestrictionSettings.TELEPORT_UNAUTHED_TO_SPAWN)).willReturn(true);
-
-        PlayerAuth auth = PlayerAuth.builder().name("bobby").build();
-        Player player = mock(Player.class);
-        LimboPlayer limbo = mock(LimboPlayer.class);
-
-        // when
-        teleportationService.teleportOnLogin(player, auth, limbo);
-
-        // then
-        verifyNoInteractions(player);
-        verify(limbo, times(2)).getLocation();
-    }
-
-    private static void assertCorrectLocation(Location location, PlayerAuth auth, World world) {
-        assertThat(location.getX(), equalTo(auth.getQuitLocX()));
-        assertThat(location.getY(), equalTo(auth.getQuitLocY()));
-        assertThat(location.getZ(), equalTo(auth.getQuitLocZ()));
-        assertThat(location.getWorld(), equalTo(world));
-    }
-
-    // We check that the World in Location is set, this method creates a mock World in Location for us
-    private static Location mockLocation() {
-        Location location = mock(Location.class);
-        given(location.getWorld()).willReturn(mock(World.class));
-        return location;
-    }
-
-    private static PlayerAuth createAuthWithLocation() {
-        return PlayerAuth.builder()
-            .name("bobby")
-            .locX(123.45).locY(23.4).locZ(-4.567)
-            .build();
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/service/ValidationServiceTest.java b/src/test/java/fr/xephi/authme/service/ValidationServiceTest.java
deleted file mode 100644
index da8f1632..00000000
--- a/src/test/java/fr/xephi/authme/service/ValidationServiceTest.java
+++ /dev/null
@@ -1,423 +0,0 @@
-package fr.xephi.authme.service;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import com.google.common.base.Strings;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerStatePermission;
-import fr.xephi.authme.service.ValidationService.ValidationResult;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.EmailSettings;
-import fr.xephi.authme.settings.properties.ProtectionSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Mock;
-import org.mockito.Mockito;
-
-import java.net.InetSocketAddress;
-import java.util.Collections;
-import java.util.logging.Logger;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static java.util.Arrays.asList;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.BDDMockito.willReturn;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link ValidationService}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class ValidationServiceTest {
-
-    @InjectDelayed
-    private ValidationService validationService;
-    @Mock
-    private Settings settings;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private PermissionsManager permissionsManager;
-    @Mock
-    private GeoIpService geoIpService;
-
-    @BeforeInjecting
-    public void createService() {
-        given(settings.getProperty(RestrictionSettings.ALLOWED_PASSWORD_REGEX)).willReturn("[a-zA-Z]+");
-        given(settings.getProperty(SecuritySettings.MIN_PASSWORD_LENGTH)).willReturn(3);
-        given(settings.getProperty(SecuritySettings.MAX_PASSWORD_LENGTH)).willReturn(20);
-        given(settings.getProperty(SecuritySettings.UNSAFE_PASSWORDS)).willReturn(newHashSet("unsafe", "other-unsafe"));
-        given(settings.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(3);
-        given(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES)).willReturn(newHashSet("name01", "npc"));
-        given(settings.getProperty(RestrictionSettings.ENABLE_RESTRICTED_USERS)).willReturn(false);
-    }
-
-    @Test
-    public void shouldRejectPasswordSameAsUsername() {
-        // given/when
-        ValidationResult error = validationService.validatePassword("bobby", "Bobby");
-
-        // then
-        assertErrorEquals(error, MessageKey.PASSWORD_IS_USERNAME_ERROR);
-    }
-
-    @Test
-    public void shouldRejectPasswordNotMatchingPattern() {
-        // given/when
-        // service mock returns pattern a-zA-Z -> numbers should not be accepted
-        ValidationResult error = validationService.validatePassword("invalid1234", "myPlayer");
-
-        // then
-        assertErrorEquals(error, MessageKey.PASSWORD_CHARACTERS_ERROR, "[a-zA-Z]+");
-    }
-
-    @Test
-    public void shouldRejectTooShortPassword() {
-        // given/when
-        ValidationResult error = validationService.validatePassword("ab", "tester");
-
-        // then
-        assertErrorEquals(error, MessageKey.INVALID_PASSWORD_LENGTH);
-    }
-
-    @Test
-    public void shouldRejectTooLongPassword() {
-        // given/when
-        ValidationResult error = validationService.validatePassword(Strings.repeat("a", 30), "player");
-
-        // then
-        assertErrorEquals(error, MessageKey.INVALID_PASSWORD_LENGTH);
-    }
-
-    @Test
-    public void shouldRejectUnsafePassword() {
-        // given/when
-        ValidationResult error = validationService.validatePassword("unsafe", "playertest");
-
-        // then
-        assertErrorEquals(error, MessageKey.PASSWORD_UNSAFE_ERROR);
-    }
-
-    @Test
-    public void shouldAcceptValidPassword() {
-        // given/when
-        ValidationResult error = validationService.validatePassword("safePass", "some_user");
-
-        // then
-        assertThat(error.hasError(), equalTo(false));
-    }
-
-    @Test
-    public void shouldAcceptEmailWithEmptyLists() {
-        // given
-        given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.emptyList());
-        given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.emptyList());
-
-        // when
-        boolean result = validationService.validateEmail("test@example.org");
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldAcceptEmailWithWhitelist() {
-        // given
-        given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
-            .willReturn(asList("domain.tld", "example.com"));
-        given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.emptyList());
-
-        // when
-        boolean result = validationService.validateEmail("TesT@Example.com");
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldRejectEmailNotInWhitelist() {
-        // given
-        given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
-            .willReturn(asList("domain.tld", "example.com"));
-        given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.emptyList());
-
-        // when
-        boolean result = validationService.validateEmail("email@other-domain.abc");
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldAcceptEmailNotInBlacklist() {
-        // given
-        given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.emptyList());
-        given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
-            .willReturn(asList("Example.org", "a-test-name.tld"));
-
-        // when
-        boolean result = validationService.validateEmail("sample@valid-name.tld");
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldRejectEmailInBlacklist() {
-        // given
-        given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.emptyList());
-        given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
-            .willReturn(asList("Example.org", "a-test-name.tld"));
-
-        // when
-        boolean result = validationService.validateEmail("sample@a-Test-name.tld");
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldRejectInvalidEmail() {
-        // given/when/then
-        assertThat(validationService.validateEmail("invalidinput"), equalTo(false));
-    }
-
-    @Test
-    public void shouldRejectInvalidEmailWithoutDomain() {
-        // given/when/then
-        assertThat(validationService.validateEmail("invalidinput@"), equalTo(false));
-    }
-
-    @Test
-    public void shouldRejectDefaultEmail() {
-        // given/when/then
-        assertThat(validationService.validateEmail("your@email.com"), equalTo(false));
-    }
-
-    @Test
-    public void shouldAllowRegistration() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String email = "my.address@example.org";
-        given(permissionsManager.hasPermission(sender, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS))
-            .willReturn(false);
-        given(dataSource.countAuthsByEmail(email)).willReturn(2);
-
-        // when
-        boolean result = validationService.isEmailFreeForRegistration(email, sender);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldRejectEmailWithTooManyAccounts() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String email = "mail@example.org";
-        given(permissionsManager.hasPermission(sender, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS))
-            .willReturn(false);
-        given(dataSource.countAuthsByEmail(email)).willReturn(5);
-
-        // when
-        boolean result = validationService.isEmailFreeForRegistration(email, sender);
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldAllowBypassForPresentPermission() {
-        // given
-        CommandSender sender = mock(CommandSender.class);
-        String email = "mail-address@example.com";
-        given(permissionsManager.hasPermission(sender, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS))
-            .willReturn(true);
-        given(dataSource.countAuthsByEmail(email)).willReturn(7);
-
-        // when
-        boolean result = validationService.isEmailFreeForRegistration(email, sender);
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldRecognizeUnrestrictedNames() {
-        assertThat(validationService.isUnrestricted("npc"), equalTo(true));
-        assertThat(validationService.isUnrestricted("someplayer"), equalTo(false));
-        assertThat(validationService.isUnrestricted("NAME01"), equalTo(true));
-
-        // Check reloading
-        given(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES)).willReturn(newHashSet("new", "names"));
-        validationService.reload();
-        assertThat(validationService.isUnrestricted("npc"), equalTo(false));
-        assertThat(validationService.isUnrestricted("New"), equalTo(true));
-    }
-
-    @Test
-    public void shouldNotInvokeGeoLiteApiIfCountryListsAreEmpty() {
-        // given
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(Collections.emptyList());
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.emptyList());
-
-        // when
-        boolean result = validationService.isCountryAdmitted("addr");
-
-        // then
-        assertThat(result, equalTo(true));
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldAcceptCountryInWhitelist() {
-        // given
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(asList("ch", "it"));
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.emptyList());
-        String ip = "127.0.0.1";
-        given(geoIpService.getCountryCode(ip)).willReturn("CH");
-
-        // when
-        boolean result = validationService.isCountryAdmitted(ip);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(geoIpService).getCountryCode(ip);
-    }
-
-    @Test
-    public void shouldRejectCountryMissingFromWhitelist() {
-        // given
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(asList("ch", "it"));
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.emptyList());
-        String ip = "123.45.67.89";
-        given(geoIpService.getCountryCode(ip)).willReturn("BR");
-
-        // when
-        boolean result = validationService.isCountryAdmitted(ip);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(geoIpService).getCountryCode(ip);
-    }
-
-    @Test
-    public void shouldAcceptCountryAbsentFromBlacklist() {
-        // given
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(Collections.emptyList());
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(asList("ch", "it"));
-        String ip = "127.0.0.1";
-        given(geoIpService.getCountryCode(ip)).willReturn("BR");
-
-        // when
-        boolean result = validationService.isCountryAdmitted(ip);
-
-        // then
-        assertThat(result, equalTo(true));
-        verify(geoIpService).getCountryCode(ip);
-    }
-
-    @Test
-    public void shouldRejectCountryInBlacklist() {
-        // given
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(Collections.emptyList());
-        given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(asList("ch", "it"));
-        String ip = "123.45.67.89";
-        given(geoIpService.getCountryCode(ip)).willReturn("IT");
-
-        // when
-        boolean result = validationService.isCountryAdmitted(ip);
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(geoIpService).getCountryCode(ip);
-    }
-
-    @Test
-    public void shouldCheckNameRestrictions() {
-        // given
-        given(settings.getProperty(RestrictionSettings.ENABLE_RESTRICTED_USERS)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.RESTRICTED_USERS))
-            .willReturn(newHashSet("Bobby;127.0.0.4", "Tamara;32.24.16.8", "Gabriel;regex:93\\.23\\.44\\..*", "emanuel;94.65.24.*", "imyourisp;*.yourisp.net"));
-        validationService.reload();
-
-        Player bobby = mockPlayer("bobby", "127.0.0.4");
-        Player tamara = mockPlayer("taMARA", "8.8.8.8");
-        Player gabriel = mockPlayer("Gabriel", "93.23.44.65");
-        Player gabriel2 = mockPlayer("Gabriel", "93.23.33.34");
-        Player emanuel = mockPlayer("emanuel", "94.65.24.10");
-        Player emanuel2 = mockPlayer("emanuel", "94.65.60.10");
-        Player imYourIsp = mockPlayer("imyourisp", "65.65.65.65");
-        Player notRestricted = mockPlayer("notRestricted", "0.0.0.0");
-
-        ValidationService validationServiceSpy = Mockito.spy(validationService);
-        willReturn("bogus.tld").given(validationServiceSpy).getHostName(any(InetSocketAddress.class));
-        InetSocketAddress imYourIspSocketAddr = imYourIsp.getAddress();
-        willReturn("bazinga.yourisp.net").given(validationServiceSpy).getHostName(imYourIspSocketAddr);
-
-        // when
-        boolean isBobbyAdmitted = validationServiceSpy.fulfillsNameRestrictions(bobby);
-        boolean isTamaraAdmitted = validationServiceSpy.fulfillsNameRestrictions(tamara);
-        boolean isGabrielAdmitted = validationServiceSpy.fulfillsNameRestrictions(gabriel);
-        boolean isGabriel2Admitted = validationServiceSpy.fulfillsNameRestrictions(gabriel2);
-        boolean isEmanuelAdmitted = validationServiceSpy.fulfillsNameRestrictions(emanuel);
-        boolean isEmanuel2Admitted = validationServiceSpy.fulfillsNameRestrictions(emanuel2);
-        boolean isImYourIspAdmitted = validationServiceSpy.fulfillsNameRestrictions(imYourIsp);
-        boolean isNotRestrictedAdmitted = validationServiceSpy.fulfillsNameRestrictions(notRestricted);
-
-        // then
-        assertThat(isBobbyAdmitted, equalTo(true));
-        assertThat(isTamaraAdmitted, equalTo(false));
-        assertThat(isGabrielAdmitted, equalTo(true));
-        assertThat(isGabriel2Admitted, equalTo(false));
-        assertThat(isEmanuelAdmitted, equalTo(true));
-        assertThat(isEmanuel2Admitted, equalTo(false));
-        assertThat(isImYourIspAdmitted, equalTo(true));
-        assertThat(isNotRestrictedAdmitted, equalTo(true));
-    }
-
-    @Test
-    public void shouldLogWarningForInvalidRestrictionRule() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        given(settings.getProperty(RestrictionSettings.ENABLE_RESTRICTED_USERS)).willReturn(true);
-        given(settings.getProperty(RestrictionSettings.RESTRICTED_USERS))
-            .willReturn(newHashSet("Bobby;127.0.0.4", "Tamara;"));
-
-        // when
-        validationService.reload();
-
-        // then
-        ArgumentCaptor<String> stringCaptor = ArgumentCaptor.forClass(String.class);
-        verify(logger).warning(stringCaptor.capture());
-        assertThat(stringCaptor.getValue(), containsString("Tamara;"));
-    }
-
-    private static Player mockPlayer(String name, String ip) {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn(name);
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        return player;
-    }
-
-    private static void assertErrorEquals(ValidationResult validationResult, MessageKey messageKey, String... args) {
-        assertThat(validationResult.hasError(), equalTo(true));
-        assertThat(validationResult.getMessageKey(), equalTo(messageKey));
-        assertThat(validationResult.getArgs(), equalTo(args));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/service/yaml/YamlFileResourceProviderTest.java b/src/test/java/fr/xephi/authme/service/yaml/YamlFileResourceProviderTest.java
deleted file mode 100644
index 3b6bbddb..00000000
--- a/src/test/java/fr/xephi/authme/service/yaml/YamlFileResourceProviderTest.java
+++ /dev/null
@@ -1,48 +0,0 @@
-package fr.xephi.authme.service.yaml;
-
-import ch.jalu.configme.resource.YamlFileResource;
-import fr.xephi.authme.TestHelper;
-import org.junit.Test;
-import org.yaml.snakeyaml.parser.ParserException;
-
-import java.io.File;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link YamlFileResourceProvider}.
- */
-public class YamlFileResourceProviderTest {
-
-    @Test
-    public void shouldLoadValidFile() {
-        // given
-        File yamlFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "service/yaml/validYaml.yml");
-
-        // when
-        YamlFileResource resource = YamlFileResourceProvider.loadFromFile(yamlFile);
-
-        // then
-        assertThat(resource.createReader().getString("test.jkl"), equalTo("Test test"));
-    }
-
-    @Test
-    public void shouldThrowForInvalidFile() {
-        // given
-        File yamlFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "service/yaml/invalidYaml.yml");
-
-        // when
-        try {
-            YamlFileResourceProvider.loadFromFile(yamlFile).createReader();
-
-            // then
-            fail("Expected exception to be thrown");
-        } catch (YamlParseException e) {
-            assertThat(e.getFile(), equalTo(yamlFile.getPath()));
-            assertThat(e.getCause(), instanceOf(ParserException.class));
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java b/src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java
deleted file mode 100644
index f589e6c3..00000000
--- a/src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java
+++ /dev/null
@@ -1,140 +0,0 @@
-package fr.xephi.authme.settings;
-
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.properties.EnumProperty;
-import ch.jalu.configme.properties.Property;
-import com.google.common.collect.ImmutableSet;
-import fr.xephi.authme.settings.properties.AuthMeSettingsRetriever;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static fr.xephi.authme.ReflectionTestUtils.getFieldValue;
-import static org.junit.Assert.fail;
-
-/**
- * Tests the consistency of the settings configuration.
- */
-public class SettingsConsistencyTest {
-
-    /**
-     * Maximum characters one comment line may have (prevents horizontal scrolling).
-     */
-    private static final int MAX_COMMENT_LENGTH = 90;
-
-    /**
-     * Properties to exclude from the enum check.
-     */
-    private static final Set<Property<?>> EXCLUDED_ENUM_PROPERTIES =
-        ImmutableSet.of(SecuritySettings.PASSWORD_HASH, SecuritySettings.LEGACY_HASHES);
-
-    private static ConfigurationData configurationData;
-
-    @BeforeClass
-    public static void buildConfigurationData() {
-        configurationData = AuthMeSettingsRetriever.buildConfigurationData();
-    }
-
-    @Test
-    public void shouldHaveCommentOnEachProperty() {
-        // given
-        List<Property<?>> properties = configurationData.getProperties();
-
-        // when / then
-        for (Property<?> property : properties) {
-            if (configurationData.getCommentsForSection(property.getPath()).isEmpty()) {
-                fail("No comment defined for " + property);
-            }
-        }
-    }
-
-    @Test
-    public void shouldNotHaveVeryLongCommentLines() {
-        // given
-        Map<String, List<String>> commentEntries = configurationData.getAllComments();
-        List<String> badPaths = new ArrayList<>(0);
-
-        // when
-        for (Map.Entry<String, List<String>> commentEntry : commentEntries.entrySet()) {
-            for (String comment : commentEntry.getValue()) {
-                if (comment.length() > MAX_COMMENT_LENGTH) {
-                    badPaths.add(commentEntry.getKey());
-                    break;
-                }
-            }
-        }
-
-        // then
-        if (!badPaths.isEmpty()) {
-            fail("Comment lines should not be longer than " + MAX_COMMENT_LENGTH + " chars, "
-                + "but found too long comments for paths:\n- "
-                + String.join("\n- ", badPaths));
-        }
-    }
-
-
-    /**
-     * Checks that enum properties have all possible enum values listed in their comment
-     * so the user knows which values are available.
-     */
-    @Test
-    public void shouldMentionAllEnumValues() {
-        // given
-        Map<Property<?>, Enum<?>> invalidEnumProperties = new HashMap<>();
-
-        for (Property<?> property : configurationData.getProperties()) {
-            // when
-            Class<? extends Enum<?>> enumClass = getEnumClass(property);
-            if (enumClass != null && !EXCLUDED_ENUM_PROPERTIES.contains(property)) {
-                String comments = String.join("\n", configurationData.getCommentsForSection(property.getPath()));
-                Arrays.stream(enumClass.getEnumConstants())
-                    .filter(e -> !comments.contains(e.name()) && !isDeprecated(e))
-                    .findFirst()
-                    .ifPresent(e -> invalidEnumProperties.put(property, e));
-            }
-        }
-
-        // then
-        if (!invalidEnumProperties.isEmpty()) {
-            String invalidEnums = invalidEnumProperties.entrySet().stream()
-                .map(e -> e.getKey() + " does not mention " + e.getValue() + " and possibly others")
-                .collect(Collectors.joining("\n- "));
-
-            fail("Found enum properties that do not list all entries in the comments:\n- " + invalidEnums);
-        }
-    }
-
-    /**
-     * Returns the enum class the property holds values for, if applicable.
-     *
-     * @param property the property to get the enum class from
-     * @return the enum class, or null if not available
-     */
-    private static Class<? extends Enum<?>> getEnumClass(Property<?> property) {
-        if (property instanceof EnumProperty<?>) {
-            Class clazz = property.getDefaultValue().getClass();
-            // Check if is anonymous class in case enum implements methods, e.g. AllowFlightRestoreType
-            return clazz.isAnonymousClass() ? clazz.getEnclosingClass() : clazz;
-        } else if (property instanceof EnumSetProperty<?>) {
-            return getFieldValue(EnumSetProperty.class, (EnumSetProperty<?>) property, "enumClass");
-        }
-        return null;
-    }
-
-    private static boolean isDeprecated(Enum<?> enumValue) {
-        try {
-            return enumValue.getDeclaringClass().getField(enumValue.name()).isAnnotationPresent(Deprecated.class);
-        } catch (NoSuchFieldException e) {
-            throw new IllegalStateException("Could not fetch field for enum '" + enumValue
-                + "' in " + enumValue.getDeclaringClass());
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/SettingsIntegrationTest.java b/src/test/java/fr/xephi/authme/settings/SettingsIntegrationTest.java
deleted file mode 100644
index e9a58c67..00000000
--- a/src/test/java/fr/xephi/authme/settings/SettingsIntegrationTest.java
+++ /dev/null
@@ -1,146 +0,0 @@
-package fr.xephi.authme.settings;
-
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
-import ch.jalu.configme.migration.PlainMigrationService;
-import ch.jalu.configme.properties.Property;
-import ch.jalu.configme.resource.PropertyResource;
-import ch.jalu.configme.resource.YamlFileResource;
-import com.google.common.collect.ImmutableMap;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.properties.TestConfiguration;
-import fr.xephi.authme.settings.properties.TestEnum;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Map;
-
-import static fr.xephi.authme.TestHelper.getJarFile;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Integration test for {@link Settings} (ConfigMe integration).
- */
-public class SettingsIntegrationTest {
-
-    /** File name of the sample config including all {@link TestConfiguration} values. */
-    private static final String COMPLETE_FILE = TestHelper.PROJECT_ROOT + "settings/config-sample-values.yml";
-    /** File name of the sample config missing certain {@link TestConfiguration} values. */
-    private static final String INCOMPLETE_FILE = TestHelper.PROJECT_ROOT + "settings/config-incomplete-sample.yml";
-
-    private static ConfigurationData CONFIG_DATA =
-        ConfigurationDataBuilder.createConfiguration(TestConfiguration.class);
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    private File testPluginFolder;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Before
-    public void setUpTestPluginFolder() throws IOException {
-        testPluginFolder = temporaryFolder.newFolder();
-    }
-
-    @Test
-    public void shouldLoadAndReadAllProperties() throws IOException {
-        // given
-        PropertyResource resource = new YamlFileResource(copyFileFromResources(COMPLETE_FILE));
-        // Pass another, non-existent file to check if the settings had to be rewritten
-        File newFile = temporaryFolder.newFile();
-
-        // when / then
-        Settings settings = new Settings(testPluginFolder, resource,
-            new PlainMigrationService(), CONFIG_DATA);
-        Map<Property<?>, Object> expectedValues = ImmutableMap.<Property<?>, Object>builder()
-            .put(TestConfiguration.DURATION_IN_SECONDS, 22)
-            .put(TestConfiguration.SYSTEM_NAME, "Custom sys name")
-            .put(TestConfiguration.RATIO_ORDER, TestEnum.FIRST)
-            .put(TestConfiguration.RATIO_FIELDS, Arrays.asList("Australia", "Burundi", "Colombia"))
-            .put(TestConfiguration.VERSION_NUMBER, 2492)
-            .put(TestConfiguration.SKIP_BORING_FEATURES, false)
-            .put(TestConfiguration.BORING_COLORS, Arrays.asList("beige", "gray"))
-            .put(TestConfiguration.DUST_LEVEL, 2)
-            .put(TestConfiguration.USE_COOL_FEATURES, true)
-            .put(TestConfiguration.COOL_OPTIONS, Arrays.asList("Dinosaurs", "Explosions", "Big trucks"))
-            .build();
-        for (Map.Entry<Property<?>, Object> entry : expectedValues.entrySet()) {
-            assertThat("Property '" + entry.getKey().getPath() + "' has expected value",
-                settings.getProperty(entry.getKey()), equalTo(entry.getValue()));
-        }
-        assertThat(newFile.length(), equalTo(0L));
-    }
-
-    @Test
-    public void shouldWriteMissingProperties() {
-        // given/when
-        File file = copyFileFromResources(INCOMPLETE_FILE);
-        PropertyResource resource = new YamlFileResource(file);
-        // Expectation: File is rewritten to since it does not have all configurations
-        new Settings(testPluginFolder, resource, new PlainMigrationService(), CONFIG_DATA);
-
-        // Load the settings again -> checks that what we wrote can be loaded again
-        resource = new YamlFileResource(file);
-
-        // then
-        Settings settings = new Settings(testPluginFolder, resource,
-            new PlainMigrationService(), CONFIG_DATA);
-        Map<Property<?>, Object> expectedValues = ImmutableMap.<Property<?>, Object>builder()
-            .put(TestConfiguration.DURATION_IN_SECONDS, 22)
-            .put(TestConfiguration.SYSTEM_NAME, "[TestDefaultValue]")
-            .put(TestConfiguration.RATIO_ORDER, TestEnum.SECOND)
-            .put(TestConfiguration.RATIO_FIELDS, Arrays.asList("Australia", "Burundi", "Colombia"))
-            .put(TestConfiguration.VERSION_NUMBER, 32046)
-            .put(TestConfiguration.SKIP_BORING_FEATURES, false)
-            .put(TestConfiguration.BORING_COLORS, Collections.EMPTY_LIST)
-            .put(TestConfiguration.DUST_LEVEL, -1)
-            .put(TestConfiguration.USE_COOL_FEATURES, false)
-            .put(TestConfiguration.COOL_OPTIONS, Arrays.asList("Dinosaurs", "Explosions", "Big trucks"))
-            .build();
-        for (Map.Entry<Property<?>, Object> entry : expectedValues.entrySet()) {
-            assertThat("Property '" + entry.getKey().getPath() + "' has expected value",
-                settings.getProperty(entry.getKey()), equalTo(entry.getValue()));
-        }
-    }
-
-    @Test
-    public void shouldReloadSettings() throws IOException {
-        // given
-        File configFile = temporaryFolder.newFile();
-        PropertyResource resource = new YamlFileResource(configFile);
-        Settings settings = new Settings(testPluginFolder, resource, null, CONFIG_DATA);
-
-        // when
-        assertThat(settings.getProperty(TestConfiguration.RATIO_ORDER), equalTo(TestEnum.SECOND)); // default value
-        Files.copy(getJarFile(COMPLETE_FILE), configFile);
-        settings.reload();
-
-        // then
-        assertThat(settings.getProperty(TestConfiguration.RATIO_ORDER), equalTo(TestEnum.FIRST));
-    }
-
-    private File copyFileFromResources(String path) {
-        try {
-            File source = getJarFile(path);
-            File destination = temporaryFolder.newFile();
-            Files.copy(source, destination);
-            return destination;
-        } catch (IOException e) {
-            throw new IllegalStateException("Could not copy test file", e);
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java b/src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java
deleted file mode 100644
index 021bfb93..00000000
--- a/src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java
+++ /dev/null
@@ -1,155 +0,0 @@
-package fr.xephi.authme.settings;
-
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.PropertyResource;
-import ch.jalu.configme.resource.YamlFileResource;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-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.security.HashAlgorithm;
-import fr.xephi.authme.settings.properties.AuthMeSettingsRetriever;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.util.ArrayList;
-import java.util.List;
-
-import static fr.xephi.authme.TestHelper.getJarFile;
-import static fr.xephi.authme.settings.properties.DatabaseSettings.MYSQL_COL_SALT;
-import static fr.xephi.authme.settings.properties.PluginSettings.ENABLE_PERMISSION_CHECK;
-import static fr.xephi.authme.settings.properties.PluginSettings.LOG_LEVEL;
-import static fr.xephi.authme.settings.properties.PluginSettings.REGISTERED_GROUP;
-import static fr.xephi.authme.settings.properties.PluginSettings.UNREGISTERED_GROUP;
-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;
-import static fr.xephi.authme.settings.properties.RestrictionSettings.FORCE_SPAWN_ON_WORLDS;
-import static fr.xephi.authme.settings.properties.SecuritySettings.LEGACY_HASHES;
-import static fr.xephi.authme.settings.properties.SecuritySettings.PASSWORD_HASH;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link SettingsMigrationService}.
- */
-public class SettingsMigrationServiceTest {
-
-    private static final String OLD_CONFIG_FILE = TestHelper.PROJECT_ROOT + "settings/config-old.yml";
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    /* When settings are loaded, test that migrations are applied and immediately available in memory. */
-    @Test
-    public void shouldPerformMigrationsInMemory() throws IOException {
-        // given
-        File dataFolder = temporaryFolder.newFolder();
-        File configFile = new File(dataFolder, "config.yml");
-        Files.copy(getJarFile(OLD_CONFIG_FILE), configFile);
-        PropertyResource resource = new YamlFileResource(configFile);
-        SettingsMigrationService migrationService = new SettingsMigrationService(dataFolder);
-
-        // when
-        Settings settings = new Settings(
-            dataFolder, resource, migrationService, AuthMeSettingsRetriever.buildConfigurationData());
-
-        // then
-        verifyHasUpToDateSettings(settings, dataFolder);
-    }
-
-    /*
-     * When settings are loaded, test that migrations are applied and persisted to disk,
-     * i.e. when the settings are loaded again from the file, no migrations should be necessary.
-     */
-    @Test
-    public void shouldPerformMigrationsAndPersistToDisk() throws IOException {
-        // given
-        File dataFolder = temporaryFolder.newFolder();
-        File configFile = new File(dataFolder, "config.yml");
-        Files.copy(getJarFile(OLD_CONFIG_FILE), configFile);
-        PropertyResource resource = new YamlFileResource(configFile);
-        TestMigrationServiceExtension migrationService = new TestMigrationServiceExtension(dataFolder);
-        ConfigurationData configurationData = AuthMeSettingsRetriever.buildConfigurationData();
-
-        // when
-        new Settings(dataFolder, resource, migrationService, configurationData);
-        resource = new YamlFileResource(configFile);
-        Settings settings = new Settings(dataFolder, resource, migrationService, configurationData);
-
-        // then
-        verifyHasUpToDateSettings(settings, dataFolder);
-        assertThat(migrationService.returnedValues, contains(true, false));
-    }
-
-    @Test
-    public void shouldKeepOldOtherAccountsSettings() throws IOException {
-        // given
-        File dataFolder = temporaryFolder.newFolder();
-        File configFile = new File(dataFolder, "config.yml");
-        Files.copy(getJarFile(OLD_CONFIG_FILE), configFile);
-        PropertyResource resource = new YamlFileResource(configFile);
-        SettingsMigrationService migrationService = new SettingsMigrationService(dataFolder);
-
-        // when
-        migrationService.performMigrations(resource.createReader(), AuthMeSettingsRetriever.buildConfigurationData());
-
-        // then
-        assertThat(migrationService.hasOldOtherAccountsCommand(), equalTo(true));
-        assertThat(migrationService.getOldOtherAccountsCommand(), equalTo("msg admin %playername% has a lot of accounts!"));
-        assertThat(migrationService.getOldOtherAccountsCommandThreshold(), equalTo(5));
-    }
-
-    private void verifyHasUpToDateSettings(Settings settings, File dataFolder) throws IOException {
-        assertThat(settings.getProperty(ALLOWED_NICKNAME_CHARACTERS), equalTo(ALLOWED_NICKNAME_CHARACTERS.getDefaultValue()));
-        assertThat(settings.getProperty(DELAY_JOIN_MESSAGE), equalTo(true));
-        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(RegistrationType.EMAIL));
-        assertThat(settings.getProperty(REGISTER_SECOND_ARGUMENT), equalTo(RegisterSecondaryArgument.CONFIRMATION));
-        assertThat(settings.getProperty(ENABLE_PERMISSION_CHECK), equalTo(true));
-        assertThat(settings.getProperty(REGISTERED_GROUP), equalTo("unLoggedinGroup"));
-        assertThat(settings.getProperty(UNREGISTERED_GROUP), equalTo(""));
-        assertThat(settings.getProperty(PASSWORD_HASH), equalTo(HashAlgorithm.SHA256));
-        assertThat(settings.getProperty(LEGACY_HASHES), contains(HashAlgorithm.PBKDF2, HashAlgorithm.WORDPRESS, HashAlgorithm.SHA512));
-        assertThat(settings.getProperty(MYSQL_COL_SALT), equalTo("salt_col_name"));
-
-        // Check migration of old setting to email.html
-        assertThat(Files.readLines(new File(dataFolder, "email.html"), StandardCharsets.UTF_8),
-            contains("Dear <playername />, <br /><br /> This is your new AuthMe password for the server "
-                + "<br /><br /> <servername /> : <br /><br /> <generatedpass /><br /><image /><br />Do not forget to "
-                + "change password after login! <br /> /changepassword <generatedpass /> newPassword"));
-    }
-
-    private static class TestMigrationServiceExtension extends SettingsMigrationService {
-        private List<Boolean> returnedValues = new ArrayList<>();
-
-        TestMigrationServiceExtension(@DataFolder File pluginFolder) {
-            super(pluginFolder);
-        }
-
-        @Override
-        protected boolean performMigrations(PropertyReader reader, ConfigurationData configurationData) {
-            boolean result = super.performMigrations(reader, configurationData);
-            returnedValues.add(result);
-            return result;
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/SettingsTest.java b/src/test/java/fr/xephi/authme/settings/SettingsTest.java
deleted file mode 100644
index 73d3cc8d..00000000
--- a/src/test/java/fr/xephi/authme/settings/SettingsTest.java
+++ /dev/null
@@ -1,120 +0,0 @@
-package fr.xephi.authme.settings;
-
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.PropertyResource;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.properties.TestConfiguration;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.util.Collections;
-
-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.RETURNS_DEEP_STUBS;
-import static org.mockito.Mockito.mock;
-
-/**
- * Unit tests for {@link Settings}.
- */
-public class SettingsTest {
-    
-    private static final ConfigurationData CONFIG_DATA =
-        ConfigurationDataBuilder.createConfiguration(TestConfiguration.class);
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-    private File testPluginFolder;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Before
-    public void setUpTestPluginFolder() throws IOException {
-        testPluginFolder = temporaryFolder.newFolder();
-    }
-
-    @Test
-    public void shouldLoadEmailMessage() throws IOException {
-        // given
-        String emailMessage = "Sample email message\nThat's all!";
-        File emailFile = new File(testPluginFolder, "email.html");
-        createFile(emailFile);
-        Files.write(emailFile.toPath(), emailMessage.getBytes());
-
-        PropertyResource resource = mockPropertyResourceAndReader();
-        Settings settings = new Settings(testPluginFolder, resource, null, CONFIG_DATA);
-
-        // when
-        String result = settings.getPasswordEmailMessage();
-
-        // then
-        assertThat(result, equalTo(emailMessage));
-    }
-
-    @Test
-    public void shouldLoadRecoveryCodeMessage() throws IOException {
-        // given
-        String emailMessage = "Your recovery code is %code.";
-        File emailFile = new File(testPluginFolder, "recovery_code_email.html");
-        createFile(emailFile);
-        Files.write(emailFile.toPath(), emailMessage.getBytes());
-
-        PropertyResource resource = mockPropertyResourceAndReader();
-        Settings settings = new Settings(testPluginFolder, resource, null, CONFIG_DATA);
-
-        // when
-        String result = settings.getRecoveryCodeEmailMessage();
-
-        // then
-        assertThat(result, equalTo(emailMessage));
-    }
-
-    @Test
-    public void shouldLoadVerificationMessage() throws IOException {
-        // given
-        String emailMessage = "Please verify your identity with <recoverycode />.";
-        File emailFile = new File(testPluginFolder, "verification_code_email.html");
-        createFile(emailFile);
-        Files.write(emailFile.toPath(), emailMessage.getBytes());
-
-        PropertyResource resource = mockPropertyResourceAndReader();
-        Settings settings = new Settings(testPluginFolder, resource, null, CONFIG_DATA);
-
-        // when
-        String result = settings.getVerificationEmailMessage();
-
-        // then
-        assertThat(result, equalTo(emailMessage));
-    }
-
-    private static PropertyResource mockPropertyResourceAndReader() {
-        PropertyReader reader = mock(PropertyReader.class, RETURNS_DEEP_STUBS);
-        given(reader.getList(anyString())).willReturn(Collections.emptyList());
-        PropertyResource resource = mock(PropertyResource.class);
-        given(resource.createReader()).willReturn(reader);
-        return resource;
-    }
-
-    private static void createFile(File file) {
-        try {
-            file.getParentFile().mkdirs();
-            file.createNewFile();
-        } catch (IOException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/settings/SettingsWarnerTest.java b/src/test/java/fr/xephi/authme/settings/SettingsWarnerTest.java
deleted file mode 100644
index fbea9f9a..00000000
--- a/src/test/java/fr/xephi/authme/settings/SettingsWarnerTest.java
+++ /dev/null
@@ -1,99 +0,0 @@
-package fr.xephi.authme.settings;
-
-import fr.xephi.authme.AuthMe;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.security.HashAlgorithm;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.settings.properties.EmailSettings;
-import fr.xephi.authme.settings.properties.HooksSettings;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import fr.xephi.authme.settings.properties.SecuritySettings;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Optional;
-import java.util.logging.Logger;
-
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.internal.verification.VerificationModeFactory.times;
-
-/**
- * Test for {@link SettingsWarner}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class SettingsWarnerTest {
-
-    @InjectMocks
-    private SettingsWarner settingsWarner;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private BukkitService bukkitService;
-
-    @Test
-    public void shouldLogWarnings() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(false);
-        given(settings.getProperty(EmailSettings.SMTP_PORT)).willReturn(44);
-        given(settings.getProperty(EmailSettings.PORT25_USE_TLS)).willReturn(false);
-        given(settings.getProperty(PluginSettings.SESSIONS_ENABLED)).willReturn(true);
-        given(settings.getProperty(PluginSettings.SESSIONS_TIMEOUT)).willReturn(-5);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.BCRYPT);
-        given(settings.getProperty(HooksSettings.BUNGEECORD)).willReturn(false);
-        given(bukkitService.isBungeeCordConfiguredForSpigot()).willReturn(Optional.of(true));
-
-        // when
-        settingsWarner.logWarningsForMisconfigurations();
-
-        // then
-        verify(logger, times(4)).warning(anyString());
-    }
-
-    @Test
-    public void shouldWarnBungeeWithoutSpigot() {
-        Logger logger = TestHelper.setupLogger();
-
-        // this cannot be covered above, because it's conflicting with the other settings
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(true);
-        given(settings.getProperty(EmailSettings.SMTP_PORT)).willReturn(25);
-        given(settings.getProperty(EmailSettings.PORT25_USE_TLS)).willReturn(false);
-        given(settings.getProperty(PluginSettings.SESSIONS_ENABLED)).willReturn(false);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.MD5);
-        given(settings.getProperty(HooksSettings.BUNGEECORD)).willReturn(true);
-        given(bukkitService.isBungeeCordConfiguredForSpigot()).willReturn(Optional.of(false));
-
-        // when
-        settingsWarner.logWarningsForMisconfigurations();
-
-        // then
-        verify(logger, times(1)).warning(anyString());
-    }
-
-    @Test
-    public void shouldNotLogAnyWarning() {
-        Logger logger = TestHelper.setupLogger();
-        given(settings.getProperty(RestrictionSettings.FORCE_SINGLE_SESSION)).willReturn(true);
-        given(settings.getProperty(EmailSettings.SMTP_PORT)).willReturn(25);
-        given(settings.getProperty(EmailSettings.PORT25_USE_TLS)).willReturn(false);
-        given(settings.getProperty(PluginSettings.SESSIONS_ENABLED)).willReturn(false);
-        given(settings.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.MD5);
-        given(settings.getProperty(HooksSettings.BUNGEECORD)).willReturn(false);
-        given(bukkitService.isBungeeCordConfiguredForSpigot()).willReturn(Optional.empty());
-
-        // when
-        settingsWarner.logWarningsForMisconfigurations();
-
-        // then
-        verifyNoInteractions(logger);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/SpawnLoaderTest.java b/src/test/java/fr/xephi/authme/settings/SpawnLoaderTest.java
deleted file mode 100644
index edd56192..00000000
--- a/src/test/java/fr/xephi/authme/settings/SpawnLoaderTest.java
+++ /dev/null
@@ -1,81 +0,0 @@
-package fr.xephi.authme.settings;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.service.PluginHookService;
-import fr.xephi.authme.settings.properties.RestrictionSettings;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.io.IOException;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link SpawnLoader}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class SpawnLoaderTest {
-
-    @InjectDelayed
-    private SpawnLoader spawnLoader;
-
-    @Mock
-    private Settings settings;
-
-    @Mock
-    private PluginHookService pluginHookService;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @DataFolder
-    private File testFolder;
-
-    @BeforeInjecting
-    public void setup() throws IOException {
-        // Copy test config into a new temporary folder
-        testFolder = temporaryFolder.newFolder();
-        File source = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "settings/spawn-firstspawn.yml");
-        File destination = new File(testFolder, "spawn.yml");
-        Files.copy(source, destination);
-
-        // Create a settings mock with default values
-        given(settings.getProperty(RestrictionSettings.SPAWN_PRIORITY))
-            .willReturn("authme, essentials, multiverse, default");
-    }
-
-    @Test
-    public void shouldSetSpawn() {
-        // given
-        World world = mock(World.class);
-        given(world.getName()).willReturn("new_world");
-        Location newSpawn = new Location(world, 123, 45.0, -67.89);
-
-        // when
-        boolean result = spawnLoader.setSpawn(newSpawn);
-
-        // then
-        assertThat(result, equalTo(true));
-        YamlConfiguration configuration = YamlConfiguration.loadConfiguration(new File(testFolder, "spawn.yml"));
-        assertThat(configuration.getDouble("spawn.x"), equalTo(123.0));
-        assertThat(configuration.getDouble("spawn.y"), equalTo(45.0));
-        assertThat(configuration.getDouble("spawn.z"), equalTo(-67.89));
-        assertThat(configuration.getString("spawn.world"), equalTo("new_world"));
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/settings/WelcomeMessageConfigurationTest.java b/src/test/java/fr/xephi/authme/settings/WelcomeMessageConfigurationTest.java
deleted file mode 100644
index 3415a950..00000000
--- a/src/test/java/fr/xephi/authme/settings/WelcomeMessageConfigurationTest.java
+++ /dev/null
@@ -1,144 +0,0 @@
-package fr.xephi.authme.settings;
-
-import ch.jalu.injector.testing.BeforeInjecting;
-import ch.jalu.injector.testing.DelayedInjectionRunner;
-import ch.jalu.injector.testing.InjectDelayed;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.data.auth.PlayerCache;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.CommonService;
-import fr.xephi.authme.service.GeoIpService;
-import fr.xephi.authme.settings.properties.PluginSettings;
-import fr.xephi.authme.settings.properties.RegistrationSettings;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link WelcomeMessageConfiguration}.
- */
-@RunWith(DelayedInjectionRunner.class)
-public class WelcomeMessageConfigurationTest {
-
-    @InjectDelayed
-    private WelcomeMessageConfiguration welcomeMessageConfiguration;
-    @Mock
-    private Server server;
-    @Mock
-    private BukkitService bukkitService;
-    @Mock
-    private GeoIpService geoIpService;
-    @Mock
-    private PlayerCache playerCache;
-    @Mock
-    private CommonService service;
-    @DataFolder
-    private File testPluginFolder;
-
-    private File welcomeFile;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @BeforeInjecting
-    public void createPluginFolder() throws IOException {
-        testPluginFolder = temporaryFolder.newFolder();
-        welcomeFile = new File(testPluginFolder, "welcome.txt");
-        welcomeFile.createNewFile();
-        given(service.getProperty(RegistrationSettings.USE_WELCOME_MESSAGE)).willReturn(true);
-    }
-
-    @Test
-    public void shouldLoadWelcomeMessage() {
-        // given
-        String welcomeMessage = "This is my welcome message for testing\nBye!";
-        setWelcomeMessageAndReload(welcomeMessage);
-        Player player = mock(Player.class);
-
-        // when
-        List<String> result = welcomeMessageConfiguration.getWelcomeMessage(player);
-
-        // then
-        assertThat(result, hasSize(2));
-        assertThat(result, contains(welcomeMessage.split("\\n")));
-        verifyNoInteractions(player, playerCache, geoIpService, bukkitService, server);
-    }
-
-    @Test
-    public void shouldReplaceNameAndIpAndCountry() {
-        // given
-        String welcomeMessage = "Hello {PLAYER}, your IP is {IP}\nYour country is {COUNTRY}.\nWelcome to {SERVER}!";
-        setWelcomeMessageAndReload(welcomeMessage);
-
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("Bobby");
-        TestHelper.mockIpAddressToPlayer(player, "123.45.66.77");
-        given(geoIpService.getCountryName("123.45.66.77")).willReturn("Syldavia");
-        given(service.getProperty(PluginSettings.SERVER_NAME)).willReturn("CrazyServer");
-
-        // when
-        List<String> result = welcomeMessageConfiguration.getWelcomeMessage(player);
-
-        // then
-        assertThat(result, hasSize(3));
-        assertThat(result.get(0), equalTo("Hello Bobby, your IP is 123.45.66.77"));
-        assertThat(result.get(1), equalTo("Your country is Syldavia."));
-        assertThat(result.get(2), equalTo("Welcome to CrazyServer!"));
-        verifyNoInteractions(server, playerCache);
-    }
-
-    @Test
-    public void shouldApplyOtherReplacements() {
-        // given
-        String welcomeMessage = "{ONLINE}/{MAXPLAYERS} online\n{LOGINS} logged in\nYour world is {WORLD}\nServer: {VERSION}";
-        setWelcomeMessageAndReload(welcomeMessage);
-        given(bukkitService.getOnlinePlayers()).willReturn(Arrays.asList(mock(Player.class), mock(Player.class)));
-        given(server.getMaxPlayers()).willReturn(20);
-        given(playerCache.getLogged()).willReturn(1);
-        given(server.getBukkitVersion()).willReturn("Bukkit-456.77.8");
-
-        World world = mock(World.class);
-        given(world.getName()).willReturn("Hub");
-        Player player = mock(Player.class);
-        given(player.getWorld()).willReturn(world);
-
-        // when
-        List<String> result = welcomeMessageConfiguration.getWelcomeMessage(player);
-
-        // then
-        assertThat(result, hasSize(4));
-        assertThat(result.get(0), equalTo("2/20 online"));
-        assertThat(result.get(1), equalTo("1 logged in"));
-        assertThat(result.get(2), equalTo("Your world is Hub"));
-        assertThat(result.get(3), equalTo("Server: Bukkit-456.77.8"));
-    }
-
-    private void setWelcomeMessageAndReload(String welcomeMessage) {
-        try {
-            Files.write(welcomeFile.toPath(), welcomeMessage.getBytes());
-        } catch (IOException e) {
-            throw new IllegalStateException("Could not write to '" + welcomeFile + "'", e);
-        }
-        welcomeMessageConfiguration.reload();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/commandconfig/CommandManagerTest.java b/src/test/java/fr/xephi/authme/settings/commandconfig/CommandManagerTest.java
deleted file mode 100644
index 2a586c57..00000000
--- a/src/test/java/fr/xephi/authme/settings/commandconfig/CommandManagerTest.java
+++ /dev/null
@@ -1,320 +0,0 @@
-package fr.xephi.authme.settings.commandconfig;
-
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.service.BukkitServiceTestHelper;
-import fr.xephi.authme.service.GeoIpService;
-import fr.xephi.authme.settings.SettingsMigrationService;
-import org.bukkit.entity.Player;
-import org.junit.Before;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Collections;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.only;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-
-/**
- * Test for {@link CommandManager}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class CommandManagerTest {
-
-    private static final String TEST_FILES_FOLDER = "/fr/xephi/authme/settings/commandconfig/";
-
-    private CommandManager manager;
-    private Player player;
-
-    @InjectMocks
-    private CommandMigrationService commandMigrationService;
-
-    @Mock
-    private BukkitService bukkitService;
-    @Mock
-    private GeoIpService geoIpService;
-    @Mock
-    private SettingsMigrationService settingsMigrationService;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    private File testFolder;
-
-    @Before
-    public void setup() throws IOException {
-        testFolder = temporaryFolder.newFolder();
-        player = mockPlayer();
-        BukkitServiceTestHelper.setBukkitServiceToScheduleSyncDelayedTaskWithDelay(bukkitService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnLogin() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnLogin(player, Collections.emptyList());
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
-        verify(bukkitService).dispatchCommand(any(Player.class), eq("motd"));
-        verify(bukkitService).dispatchCommand(any(Player.class), eq("list"));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(60L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(120L));
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnLoginWithTwoAlts() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnLogin(player, Arrays.asList("willy", "nilly", "billy", "silly"));
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
-        verify(bukkitService).dispatchCommand(player, "motd");
-        verify(bukkitService).dispatchCommand(player, "list");
-        verify(bukkitService).dispatchConsoleCommand("helpop Player Bobby has more than 1 account");
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(60L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(120L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(180L));
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnLoginWithFifteenAlts() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnLogin(player, Collections.nCopies(15, "swag"));
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
-        verify(bukkitService).dispatchCommand(player, "motd");
-        verify(bukkitService).dispatchCommand(player, "list");
-        verify(bukkitService).dispatchConsoleCommand("helpop Player Bobby has more than 1 account");
-        verify(bukkitService).dispatchConsoleCommand("log Bobby 127.0.0.3 many accounts");
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(60L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(120L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(180L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(240L));
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnLoginWithTwentyFiveAlts() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnLogin(player, Collections.nCopies(25, "yolo"));
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
-        verify(bukkitService).dispatchCommand(player, "motd");
-        verify(bukkitService).dispatchCommand(player, "list");
-        verify(bukkitService).dispatchConsoleCommand("helpop Player Bobby has more than 1 account");
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(60L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(120L));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(180L));
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnLoginWithIncompleteConfig() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.incomplete.yml");
-        initManager();
-        BukkitServiceTestHelper.setBukkitServiceToScheduleSyncDelayedTaskWithDelay(bukkitService);
-
-        // when
-        manager.runCommandsOnLogin(player, Collections.emptyList());
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back, bob");
-        verify(bukkitService).dispatchCommand(any(Player.class), eq("list"));
-        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(100L));
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnSessionLogin() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnSessionLogin(player);
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("msg Bobby Session login!");
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnFirstLogin() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnFirstLogin(player, Collections.emptyList());
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("pay Bobby 30");
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldNotExecuteFirstLoginCommandWhoseThresholdIsNotMet() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnFirstLogin(player, Arrays.asList("u", "wot", "m8"));
-
-        // then
-        verifyNoInteractions(bukkitService, geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnJoin() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnJoin(player);
-
-        // then
-        verify(bukkitService, only()).dispatchConsoleCommand("broadcast bob has joined");
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnJoinWithIncompleteConfig() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.incomplete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnJoin(player);
-
-        // then
-        verify(bukkitService, only()).dispatchConsoleCommand("broadcast Bobby has joined");
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnRegister() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnRegister(player);
-
-        // then
-        verify(bukkitService).dispatchCommand(any(Player.class), eq("me I just registered"));
-        verify(bukkitService).dispatchConsoleCommand("log Bobby (127.0.0.3, Syldavia) registered");
-        verify(bukkitService, times(2)).scheduleSyncDelayedTask(any(Runnable.class), eq(100L));
-        verifyNoMoreInteractions(bukkitService);
-    }
-
-    @Test
-    public void shouldExecuteCommandOnLogout() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnLogout(player);
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("broadcast Bobby (127.0.0.3) logged out");
-        verifyNoMoreInteractions(bukkitService);
-        verifyNoInteractions(geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandsOnRegisterWithIncompleteConfig() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.incomplete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnRegister(player);
-
-        // then
-        verifyNoInteractions(bukkitService, geoIpService);
-    }
-
-    @Test
-    public void shouldExecuteCommandOnUnregister() {
-        // given
-        copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.incomplete.yml");
-        initManager();
-
-        // when
-        manager.runCommandsOnUnregister(player);
-
-        // then
-        verify(bukkitService).dispatchConsoleCommand("msg Bobby sad to see you go!");
-    }
-
-    private void initManager() {
-        manager = new CommandManager(testFolder, bukkitService, geoIpService, commandMigrationService);
-    }
-
-    private void copyJarFileAsCommandsYml(String path) {
-        File source = TestHelper.getJarFile(path);
-        File destination = new File(testFolder, "commands.yml");
-        try {
-            Files.copy(source, destination);
-        } catch (IOException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-
-    private Player mockPlayer() {
-        Player player = mock(Player.class);
-        given(player.getName()).willReturn("Bobby");
-        given(player.getDisplayName()).willReturn("bob");
-        String ip = "127.0.0.3";
-        TestHelper.mockIpAddressToPlayer(player, ip);
-        given(geoIpService.getCountryName(ip)).willReturn("Syldavia");
-        return player;
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/commandconfig/CommandMigrationServiceTest.java b/src/test/java/fr/xephi/authme/settings/commandconfig/CommandMigrationServiceTest.java
deleted file mode 100644
index 800bcc05..00000000
--- a/src/test/java/fr/xephi/authme/settings/commandconfig/CommandMigrationServiceTest.java
+++ /dev/null
@@ -1,146 +0,0 @@
-package fr.xephi.authme.settings.commandconfig;
-
-import ch.jalu.configme.beanmapper.propertydescription.BeanDescriptionFactoryImpl;
-import ch.jalu.configme.beanmapper.propertydescription.BeanPropertyDescription;
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
-import ch.jalu.configme.resource.PropertyResource;
-import ch.jalu.configme.resource.YamlFileResource;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.SettingsMigrationService;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.io.File;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static org.hamcrest.Matchers.aMapWithSize;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-
-/**
- * Test for {@link CommandMigrationService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class CommandMigrationServiceTest {
-
-    @InjectMocks
-    private CommandMigrationService commandMigrationService;
-
-    @Mock
-    private SettingsMigrationService settingsMigrationService;
-
-    @BeforeClass
-    public static void setUpLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldRewriteForEmptyFile() {
-        // given
-        File commandFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "settings/commandconfig/commands.empty.yml");
-        PropertyResource resource = new YamlFileResource(commandFile);
-
-        // when
-        boolean result = commandMigrationService.checkAndMigrate(
-            resource.createReader(), ConfigurationDataBuilder.createConfiguration(CommandSettingsHolder.class));
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldRewriteIncompleteFile() {
-        // given
-        File commandFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "settings/commandconfig/commands.incomplete.yml");
-        PropertyResource resource = new YamlFileResource(commandFile);
-
-        // when
-        boolean result = commandMigrationService.checkAndMigrate(
-            resource.createReader(), ConfigurationDataBuilder.createConfiguration(CommandSettingsHolder.class));
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldNotChangeCompleteFile() {
-        // given
-        File commandFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "settings/commandconfig/commands.complete.yml");
-        PropertyResource resource = new YamlFileResource(commandFile);
-
-        // when
-        boolean result = commandMigrationService.checkAndMigrate(
-            resource.createReader(), ConfigurationDataBuilder.createConfiguration(CommandSettingsHolder.class));
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    /**
-     * Checks that {@link CommandMigrationService#COMMAND_CONFIG_PROPERTIES} contains all properties defined in the
-     * {@link CommandConfig} class. It is used to ensure that the commands.yml file is complete.
-     */
-    @Test
-    public void shouldHaveAllPropertiesFromCommandConfig() {
-        // given
-        String[] properties = new BeanDescriptionFactoryImpl()
-            .getAllProperties(CommandConfig.class)
-            .stream()
-            .map(BeanPropertyDescription::getName)
-            .toArray(String[]::new);
-
-        // when / then
-        assertThat(CommandMigrationService.COMMAND_CONFIG_PROPERTIES, containsInAnyOrder(properties));
-    }
-
-    @Test
-    public void shouldMigrateOldOtherAccountsCommand() {
-        // given
-        given(settingsMigrationService.hasOldOtherAccountsCommand()).willReturn(true);
-        given(settingsMigrationService.getOldOtherAccountsCommand())
-            .willReturn("helpop %playername% (%playerip%) has other accounts!");
-        given(settingsMigrationService.getOldOtherAccountsCommandThreshold()).willReturn(3);
-        File commandFile = TestHelper.getJarFile(TestHelper.PROJECT_ROOT + "settings/commandconfig/commands.complete.yml");
-        PropertyResource resource = new YamlFileResource(commandFile);
-        ConfigurationData configurationData = ConfigurationDataBuilder.createConfiguration(CommandSettingsHolder.class);
-
-        // when
-        commandMigrationService.checkAndMigrate(
-            resource.createReader(), configurationData);
-
-        // then
-        Map<String, OnLoginCommand> onLoginCommands = configurationData.getValue(CommandSettingsHolder.COMMANDS).getOnLogin();
-        assertThat(onLoginCommands, aMapWithSize(6)); // 5 in the file + the newly migrated on
-        OnLoginCommand newCommand = getUnknownOnLoginCommand(onLoginCommands);
-        assertThat(newCommand.getCommand(), equalTo("helpop %p (%ip) has other accounts!"));
-        assertThat(newCommand.getExecutor(), equalTo(Executor.CONSOLE));
-        assertThat(newCommand.getIfNumberOfAccountsAtLeast().get(), equalTo(3));
-        assertThat(newCommand.getIfNumberOfAccountsLessThan().isPresent(), equalTo(false));
-    }
-
-    /*
-     * Returns the command under onLogin from commands.complete.yml that isn't present in the beginning.
-     */
-    private static OnLoginCommand getUnknownOnLoginCommand(Map<String, OnLoginCommand> onLoginCommands) {
-        Set<String> knownKeys = newHashSet("welcome", "show_motd", "display_list", "warn_for_alts", "log_suspicious_user");
-        List<String> unknownKeys = onLoginCommands.keySet().stream()
-            .filter(key -> !knownKeys.contains(key))
-            .collect(Collectors.toList());
-        if (unknownKeys.size() == 1) {
-            return onLoginCommands.get(unknownKeys.get(0));
-        } else {
-            throw new IllegalStateException("Expected 1 unknown key but found " + unknownKeys.size() + ": " + unknownKeys);
-        }
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/commandconfig/CommandYmlConsistencyTest.java b/src/test/java/fr/xephi/authme/settings/commandconfig/CommandYmlConsistencyTest.java
deleted file mode 100644
index 99b4d615..00000000
--- a/src/test/java/fr/xephi/authme/settings/commandconfig/CommandYmlConsistencyTest.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package fr.xephi.authme.settings.commandconfig;
-
-import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
-import ch.jalu.configme.resource.PropertyResource;
-import ch.jalu.configme.resource.YamlFileResource;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.settings.SettingsMigrationService;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.io.File;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.verify;
-
-/**
- * Tests that commands.yml is well-formed.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class CommandYmlConsistencyTest {
-
-    @InjectMocks
-    private CommandMigrationService commandMigrationService;
-
-    @Mock
-    private SettingsMigrationService settingsMigrationService;
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @Test
-    public void shouldLoadWithNoMigrations() {
-        // given
-        File commandFile = TestHelper.getJarFile("/commands.yml");
-        PropertyResource resource = new YamlFileResource(commandFile);
-
-        // when
-        boolean result = commandMigrationService.checkAndMigrate(
-            resource.createReader(), ConfigurationDataBuilder.createConfiguration(CommandSettingsHolder.class));
-
-        // then
-        assertThat(result, equalTo(false));
-        verify(settingsMigrationService).hasOldOtherAccountsCommand();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/properties/AuthMeSettingsRetrieverTest.java b/src/test/java/fr/xephi/authme/settings/properties/AuthMeSettingsRetrieverTest.java
deleted file mode 100644
index 35ab9627..00000000
--- a/src/test/java/fr/xephi/authme/settings/properties/AuthMeSettingsRetrieverTest.java
+++ /dev/null
@@ -1,26 +0,0 @@
-package fr.xephi.authme.settings.properties;
-
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.closeTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link AuthMeSettingsRetriever}.
- */
-public class AuthMeSettingsRetrieverTest {
-
-    @Test
-    public void shouldReturnAllProperties() {
-        // given / when
-        ConfigurationData configurationData = AuthMeSettingsRetriever.buildConfigurationData();
-
-        // then
-        // Note ljacqu 20161123: Check that the number of properties returned corresponds to what we expect with
-        // an error margin of 10: this prevents us from having to adjust the test every time the config is changed.
-        // If this test fails, replace the first argument in closeTo() with the new number of properties
-        assertThat((double) configurationData.getProperties().size(),
-            closeTo(182, 10));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/properties/SettingsClassConsistencyTest.java b/src/test/java/fr/xephi/authme/settings/properties/SettingsClassConsistencyTest.java
deleted file mode 100644
index 178576bc..00000000
--- a/src/test/java/fr/xephi/authme/settings/properties/SettingsClassConsistencyTest.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package fr.xephi.authme.settings.properties;
-
-import ch.jalu.configme.SettingsHolder;
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.properties.Property;
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.lang.reflect.Field;
-import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.hasSize;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.fail;
-
-/**
- * Test for {@link SettingsHolder} implementations.
- */
-public class SettingsClassConsistencyTest {
-
-    private static final String SETTINGS_FOLDER = TestHelper.PROJECT_ROOT + "settings/properties";
-    private static List<Class<? extends SettingsHolder>> classes;
-
-    @BeforeClass
-    public static void scanForSettingsClasses() {
-        ClassCollector collector = new ClassCollector(TestHelper.SOURCES_FOLDER, SETTINGS_FOLDER);
-        classes = collector.collectClasses(SettingsHolder.class);
-
-        if (classes.isEmpty()) {
-            throw new IllegalStateException("Did not find any SettingsHolder classes. Is the folder correct?");
-        }
-        System.out.println("Found " + classes.size() + " SettingsHolder implementations");
-    }
-
-    /**
-     * Make sure that all {@link Property} instances we define are in public, static, final fields.
-     */
-    @Test
-    public void shouldHavePublicStaticFinalFields() {
-        for (Class<?> clazz : classes) {
-            Field[] fields = clazz.getDeclaredFields();
-            for (Field field : fields) {
-                if (Property.class.isAssignableFrom(field.getType())) {
-                    String fieldName = "Field " + clazz.getSimpleName() + "#" + field.getName();
-                    assertThat(fieldName + " should be public, static, and final",
-                        isValidConstantField(field), equalTo(true));
-                }
-            }
-        }
-    }
-
-    /**
-     * Make sure that no properties use the same path.
-     */
-    @Test
-    public void shouldHaveUniquePaths() {
-        Set<String> paths = new HashSet<>();
-        for (Class<?> clazz : classes) {
-            Field[] fields = clazz.getDeclaredFields();
-            for (Field field : fields) {
-                if (Property.class.isAssignableFrom(field.getType())) {
-                    Property<?> property =
-                        ReflectionTestUtils.getFieldValue(clazz, null, field.getName());
-                    if (!paths.add(property.getPath())) {
-                        fail("Path '" + property.getPath() + "' should be used by only one constant");
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Checks that {@link AuthMeSettingsRetriever} returns a ConfigurationData with all
-     * available SettingsHolder classes.
-     */
-    @Test
-    public void shouldHaveAllClassesInConfigurationData() {
-        // given
-        long totalProperties = classes.stream()
-            .map(Class::getDeclaredFields)
-            .flatMap(Arrays::stream)
-            .filter(field -> Property.class.isAssignableFrom(field.getType()))
-            .count();
-
-        // when
-        ConfigurationData configData = AuthMeSettingsRetriever.buildConfigurationData();
-
-        // then
-        assertThat("ConfigurationData should have " + totalProperties + " properties (as found manually)",
-            configData.getProperties(), hasSize((int) totalProperties));
-    }
-
-    private static boolean isValidConstantField(Field field) {
-        int modifiers = field.getModifiers();
-        return Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers) && Modifier.isFinal(modifiers);
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/properties/TestConfiguration.java b/src/test/java/fr/xephi/authme/settings/properties/TestConfiguration.java
deleted file mode 100644
index d964679a..00000000
--- a/src/test/java/fr/xephi/authme/settings/properties/TestConfiguration.java
+++ /dev/null
@@ -1,49 +0,0 @@
-package fr.xephi.authme.settings.properties;
-
-import ch.jalu.configme.SettingsHolder;
-import ch.jalu.configme.properties.Property;
-
-import java.util.List;
-
-import static ch.jalu.configme.properties.PropertyInitializer.newListProperty;
-import static ch.jalu.configme.properties.PropertyInitializer.newProperty;
-
-/**
- * Sample properties for testing purposes.
- */
-public final class TestConfiguration implements SettingsHolder {
-
-    public static final Property<Integer> DURATION_IN_SECONDS =
-        newProperty("test.duration", 4);
-
-    public static final Property<String> SYSTEM_NAME =
-        newProperty("test.systemName", "[TestDefaultValue]");
-
-    public static final Property<TestEnum> RATIO_ORDER =
-        newProperty(TestEnum.class, "sample.ratio.order", TestEnum.SECOND);
-
-    public static final Property<List<String>> RATIO_FIELDS =
-        newListProperty("sample.ratio.fields", "a", "b", "c");
-
-    public static final Property<Integer> VERSION_NUMBER =
-        newProperty("version", 32046);
-
-    public static final Property<Boolean> SKIP_BORING_FEATURES =
-        newProperty("features.boring.skip", false);
-
-    public static final Property<List<String>> BORING_COLORS =
-        newListProperty("features.boring.colors");
-
-    public static final Property<Integer> DUST_LEVEL =
-        newProperty("features.boring.dustLevel", -1);
-
-    public static final Property<Boolean> USE_COOL_FEATURES =
-        newProperty("features.cool.enabled", false);
-
-    public static final Property<List<String>> COOL_OPTIONS =
-        newListProperty("features.cool.options", "Sparks", "Sprinkles");
-
-
-    private TestConfiguration() {
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/settings/properties/TestEnum.java b/src/test/java/fr/xephi/authme/settings/properties/TestEnum.java
deleted file mode 100644
index e02d6825..00000000
--- a/src/test/java/fr/xephi/authme/settings/properties/TestEnum.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package fr.xephi.authme.settings.properties;
-
-/**
- * Test enum used in {@link TestConfiguration}.
- */
-public enum TestEnum {
-
-    FIRST,
-
-    SECOND,
-
-    THIRD,
-
-    FOURTH
-
-}
diff --git a/src/test/java/fr/xephi/authme/task/CleanupTaskTest.java b/src/test/java/fr/xephi/authme/task/CleanupTaskTest.java
deleted file mode 100644
index 4269f9bd..00000000
--- a/src/test/java/fr/xephi/authme/task/CleanupTaskTest.java
+++ /dev/null
@@ -1,44 +0,0 @@
-package fr.xephi.authme.task;
-
-import ch.jalu.injector.factory.SingletonStore;
-import fr.xephi.authme.initialization.HasCleanup;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.List;
-
-import static java.util.Arrays.asList;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-
-/**
- * Test for {@link CleanupTask}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class CleanupTaskTest {
-
-    @InjectMocks
-    private CleanupTask cleanupTask;
-
-    @Mock
-    private SingletonStore<HasCleanup> hasCleanupStore;
-
-    @Test
-    public void shouldPerformCleanup() {
-        // given
-        List<HasCleanup> services = asList(mock(HasCleanup.class), mock(HasCleanup.class), mock(HasCleanup.class));
-        given(hasCleanupStore.retrieveAllOfType()).willReturn(services);
-
-        // when
-        cleanupTask.run();
-
-        // then
-        verify(services.get(0)).performCleanup();
-        verify(services.get(1)).performCleanup();
-        verify(services.get(2)).performCleanup();
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/task/purge/PurgeServiceTest.java b/src/test/java/fr/xephi/authme/task/purge/PurgeServiceTest.java
deleted file mode 100644
index 8823f1aa..00000000
--- a/src/test/java/fr/xephi/authme/task/purge/PurgeServiceTest.java
+++ /dev/null
@@ -1,200 +0,0 @@
-package fr.xephi.authme.task.purge;
-
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.datasource.DataSource;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.service.BukkitService;
-import fr.xephi.authme.settings.Settings;
-import fr.xephi.authme.settings.properties.PurgeSettings;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.junit.MockitoJUnitRunner;
-
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.List;
-import java.util.Set;
-import java.util.UUID;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.not;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.anyCollection;
-import static org.mockito.ArgumentMatchers.anyLong;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PurgeService}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PurgeServiceTest {
-
-    @InjectMocks
-    private PurgeService purgeService;
-
-    @Mock
-    private BukkitService bukkitService;
-    @Mock
-    private DataSource dataSource;
-    @Mock
-    private Settings settings;
-    @Mock
-    private PermissionsManager permissionsManager;
-    @Mock
-    private PurgeExecutor executor;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldNotRunAutoPurge() {
-        // given
-        given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(false);
-        given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
-
-        // when
-        purgeService.runAutoPurge();
-
-        // then
-        verifyNoInteractions(bukkitService, dataSource);
-    }
-
-    @Test
-    public void shouldNotRunAutoPurgeForInvalidInterval() {
-        // given
-        given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(true);
-        given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(0);
-
-        // when
-        purgeService.runAutoPurge();
-
-        // then
-        verifyNoInteractions(bukkitService, dataSource);
-    }
-
-    @Test
-    public void shouldRunAutoPurge() {
-        // given
-        given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(true);
-        given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
-        Set<String> playerNames = newHashSet("alpha", "bravo", "charlie", "delta");
-        given(dataSource.getRecordsToPurge(anyLong())).willReturn(playerNames);
-
-        // when
-        purgeService.runAutoPurge();
-
-        // then
-        ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
-        verify(dataSource).getRecordsToPurge(captor.capture());
-        assertCorrectPurgeTimestamp(captor.getValue(), 60);
-        assertThat(Boolean.TRUE, equalTo(
-            ReflectionTestUtils.getFieldValue(PurgeService.class, purgeService, "isPurging")));
-        verifyScheduledPurgeTask(null, playerNames);
-    }
-
-    @Test
-    public void shouldRecognizeNoPlayersToPurge() {
-        // given
-        final long delay = 123012301L;
-        given(dataSource.getRecordsToPurge(delay)).willReturn(Collections.emptySet());
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        purgeService.runPurge(sender, delay);
-
-        // then
-        verify(dataSource).getRecordsToPurge(delay);
-        verify(dataSource, never()).purgeRecords(anyCollection());
-        verify(sender).sendMessage("No players to purge");
-        verifyNoInteractions(bukkitService, permissionsManager);
-    }
-
-    @Test
-    public void shouldRunPurge() {
-        // given
-        final long delay = 1809714L;
-        Set<String> playerNames = newHashSet("charlie", "delta", "echo", "foxtrot");
-        given(dataSource.getRecordsToPurge(delay)).willReturn(playerNames);
-        Player sender = mock(Player.class);
-        UUID uuid = UUID.randomUUID();
-        given(sender.getUniqueId()).willReturn(uuid);
-
-        // when
-        purgeService.runPurge(sender, delay);
-
-        // then
-        verify(dataSource).getRecordsToPurge(delay);
-        verifyScheduledPurgeTask(uuid, playerNames);
-    }
-
-    @Test
-    public void shouldNotRunPurgeIfProcessIsAlreadyRunning() {
-        // given
-        purgeService.setPurging(true);
-        CommandSender sender = mock(CommandSender.class);
-        OfflinePlayer[] offlinePlayers = new OfflinePlayer[]{mock(OfflinePlayer.class), mock(OfflinePlayer.class)};
-
-        // when
-        purgeService.purgePlayers(sender, newHashSet("test", "names"), offlinePlayers);
-
-        // then
-        verify(sender).sendMessage(argThat(containsString("Purge is already in progress")));
-        verifyNoInteractions(bukkitService, dataSource, permissionsManager);
-    }
-
-    @Test
-    public void shouldExecutePurgeActions() {
-        // given
-        List<String> names = Arrays.asList("alpha", "bravo", "foxtrot");
-        List<OfflinePlayer> offlinePlayers = Arrays.asList(
-            mock(OfflinePlayer.class), mock(OfflinePlayer.class), mock(OfflinePlayer.class));
-
-        // when
-        purgeService.executePurge(offlinePlayers, names);
-
-        // then
-        verify(executor).executePurge(offlinePlayers, names);
-    }
-
-    private void assertCorrectPurgeTimestamp(long timestamp, int configuredDays) {
-        final long toleranceMillis = 100L;
-        Calendar cal = Calendar.getInstance();
-        cal.add(Calendar.DATE, -configuredDays);
-        long expectedTimestamp = cal.getTimeInMillis();
-
-        assertThat("Timestamp is equal to now minus " + configuredDays + " days (within tolerance)",
-            Math.abs(timestamp - expectedTimestamp), not(greaterThan(toleranceMillis)));
-    }
-
-    private void verifyScheduledPurgeTask(UUID senderUuid, Set<String> names) {
-        ArgumentCaptor<PurgeTask> captor = ArgumentCaptor.forClass(PurgeTask.class);
-        verify(bukkitService).runTaskTimerAsynchronously(captor.capture(), eq(0L), eq(1L));
-        PurgeTask task = captor.getValue();
-
-        Object senderInTask = ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "sender");
-        Set<String> namesInTask = ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "toPurge");
-        assertThat(senderInTask, equalTo(senderUuid));
-        assertThat(namesInTask, containsInAnyOrder(names.toArray()));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/task/purge/PurgeTaskTest.java b/src/test/java/fr/xephi/authme/task/purge/PurgeTaskTest.java
deleted file mode 100644
index 2ecf6a13..00000000
--- a/src/test/java/fr/xephi/authme/task/purge/PurgeTaskTest.java
+++ /dev/null
@@ -1,247 +0,0 @@
-package fr.xephi.authme.task.purge;
-
-import fr.xephi.authme.ReflectionTestUtils;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.permission.PermissionNode;
-import fr.xephi.authme.permission.PermissionsManager;
-import fr.xephi.authme.permission.PlayerStatePermission;
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.Server;
-import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitRunnable;
-import org.bukkit.scheduler.BukkitScheduler;
-import org.bukkit.scheduler.BukkitTask;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.ArgumentCaptor;
-import org.mockito.Captor;
-import org.mockito.Mock;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.junit.MockitoJUnitRunner;
-import org.mockito.stubbing.Answer;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-import static com.google.common.collect.Sets.newHashSet;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.empty;
-import static org.junit.Assert.assertThat;
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.anyString;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.reset;
-import static org.mockito.Mockito.times;
-import static org.mockito.Mockito.verify;
-import static org.mockito.hamcrest.MockitoHamcrest.argThat;
-
-/**
- * Test for {@link PurgeTask}.
- */
-@RunWith(MockitoJUnitRunner.class)
-public class PurgeTaskTest {
-
-    private static final PermissionNode BYPASS_NODE = PlayerStatePermission.BYPASS_PURGE;
-
-    private Map<OfflinePlayer, Boolean> playerBypassAssignments = new HashMap<>();
-
-    @Mock
-    private PermissionsManager permissionsManager;
-
-    @Mock
-    private PurgeService purgeService;
-
-    @Captor
-    private ArgumentCaptor<Collection<OfflinePlayer>> playerCaptor;
-
-    @Captor
-    private ArgumentCaptor<Collection<String>> namesCaptor;
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldRunTask() {
-        // given
-        Set<String> names =
-            newHashSet("alpha", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel", "india");
-        // alpha and echo have bypass permission
-        // Foxtrot and india are not present as OfflinePlayer
-        // Additionally, BOGUS and 123456 are not present in the names list
-        OfflinePlayer[] players = asArray(
-            mockOfflinePlayer("Alpha", true),  mockOfflinePlayer("BOGUS", false),  mockOfflinePlayer("charlie", false),
-            mockOfflinePlayer("Delta", false), mockOfflinePlayer("BRAVO", false),  mockOfflinePlayer("Echo", true),
-            mockOfflinePlayer("Golf", false),  mockOfflinePlayer("123456", false), mockOfflinePlayer("HOTEL", false));
-        reset(purgeService, permissionsManager);
-        setPermissionsBehavior();
-        PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, players);
-
-        // when (1 - first run, 5 players per run)
-        task.run();
-
-        // then (1)
-        // In the first run, Alpha to BRAVO (see players list above) went through. One of those players is not present
-        // in the names list, so expect the permission manager to have been called four times
-        verify(permissionsManager, times(4)).hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE));
-        // Alpha has the bypass permission, so we expect charlie, Delta and BRAVO to be purged
-        assertRanPurgeWithPlayers(players[2], players[3], players[4]);
-
-        // when (2)
-        reset(purgeService, permissionsManager);
-        setPermissionsBehavior();
-        task.run();
-
-        // then (2)
-        // Echo, Golf, HOTEL
-        verify(permissionsManager, times(3)).hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE));
-        assertRanPurgeWithPlayers(players[6], players[8]);
-
-        // given (3)
-        // Third round: no more OfflinePlayer objects, but some names remain
-        reset(purgeService, permissionsManager);
-        given(permissionsManager.hasPermissionOffline("india", BYPASS_NODE)).willReturn(true);
-
-        // when (3)
-        task.run();
-
-        // then (3)
-        // We no longer have any OfflinePlayers, so lookup of permissions was done with the names
-        verify(permissionsManager, times(2)).hasPermissionOffline(anyString(), eq(BYPASS_NODE));
-        verify(permissionsManager, never()).hasPermissionOffline(any(OfflinePlayer.class), any(PermissionNode.class));
-        assertRanPurgeWithNames("foxtrot");
-    }
-
-    /**
-     * #1008: OfflinePlayer#getName may return null.
-     */
-    @Test
-    public void shouldHandleOfflinePlayerWithNullName() {
-        // given
-        Set<String> names = newHashSet("name1", "name2");
-        OfflinePlayer[] players = asArray(
-            mockOfflinePlayer(null, false),  mockOfflinePlayer("charlie", false),  mockOfflinePlayer("name1", false));
-        reset(purgeService, permissionsManager);
-        setPermissionsBehavior();
-
-        PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, players);
-
-        // when
-        task.run();
-
-        // then
-        assertRanPurgeWithPlayers(players[2]);
-    }
-
-    @Test
-    public void shouldStopTaskAndInformSenderUponCompletion() {
-        // given
-        Set<String> names = newHashSet("name1", "name2");
-        Player sender = mock(Player.class);
-        UUID uuid = UUID.randomUUID();
-        given(sender.getUniqueId()).willReturn(uuid);
-        PurgeTask task = new PurgeTask(purgeService, permissionsManager, sender, names, new OfflinePlayer[0]);
-
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(bukkitTask.getTaskId()).willReturn(10049);
-        ReflectionTestUtils.setField(BukkitRunnable.class, task, "task", bukkitTask);
-
-        Server server = mock(Server.class);
-        BukkitScheduler scheduler = mock(BukkitScheduler.class);
-        given(server.getScheduler()).willReturn(scheduler);
-        ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
-        given(server.getPlayer(uuid)).willReturn(sender);
-
-        task.run(); // Run for the first time -> results in empty names list
-
-        // when
-        task.run();
-
-        // then
-        verify(scheduler).cancelTask(task.getTaskId());
-        verify(sender).sendMessage(argThat(containsString("Database has been purged successfully")));
-    }
-
-    @Test
-    public void shouldStopTaskAndInformConsoleUser() {
-        // given
-        Set<String> names = newHashSet("name1", "name2");
-        PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, new OfflinePlayer[0]);
-
-        BukkitTask bukkitTask = mock(BukkitTask.class);
-        given(bukkitTask.getTaskId()).willReturn(10049);
-        ReflectionTestUtils.setField(BukkitRunnable.class, task, "task", bukkitTask);
-
-        Server server = mock(Server.class);
-        BukkitScheduler scheduler = mock(BukkitScheduler.class);
-        given(server.getScheduler()).willReturn(scheduler);
-        ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
-        ConsoleCommandSender consoleSender = mock(ConsoleCommandSender.class);
-        given(server.getConsoleSender()).willReturn(consoleSender);
-
-        task.run(); // Run for the first time -> results in empty names list
-
-        // when
-        task.run();
-
-        // then
-        verify(scheduler).cancelTask(task.getTaskId());
-        verify(consoleSender).sendMessage(argThat(containsString("Database has been purged successfully")));
-    }
-
-
-    private OfflinePlayer mockOfflinePlayer(String name, boolean hasBypassPermission) {
-        OfflinePlayer player = mock(OfflinePlayer.class);
-        given(player.getName()).willReturn(name);
-        playerBypassAssignments.put(player, hasBypassPermission);
-        return player;
-    }
-
-    private OfflinePlayer[] asArray(OfflinePlayer... players) {
-        return players;
-    }
-
-    private void setPermissionsBehavior() {
-        given(permissionsManager.hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE)))
-            .willAnswer((Answer<Boolean>) invocationOnMock -> {
-                OfflinePlayer player = invocationOnMock.getArgument(0);
-                Boolean hasPermission = playerBypassAssignments.get(player);
-                if (hasPermission == null) {
-                    throw new IllegalStateException("Unexpected check of '" + BYPASS_NODE
-                        + "' with player = " + player);
-                }
-                return hasPermission;
-            });
-        given(permissionsManager.loadUserData(any(OfflinePlayer.class))).willReturn(true);
-    }
-
-    private void assertRanPurgeWithPlayers(OfflinePlayer... players) {
-        List<String> names = new ArrayList<>(players.length);
-        for (OfflinePlayer player : players) {
-            names.add(player.getName());
-        }
-        verify(purgeService).executePurge(playerCaptor.capture(), namesCaptor.capture());
-        assertThat(namesCaptor.getValue(), containsInAnyOrder(names.toArray()));
-        assertThat(playerCaptor.getValue(), containsInAnyOrder(players));
-    }
-
-    private void assertRanPurgeWithNames(String... names) {
-        verify(purgeService).executePurge(playerCaptor.capture(), namesCaptor.capture());
-        assertThat(namesCaptor.getValue(), containsInAnyOrder(names));
-        assertThat(playerCaptor.getValue(), empty());
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/util/ExceptionUtilsTest.java b/src/test/java/fr/xephi/authme/util/ExceptionUtilsTest.java
deleted file mode 100644
index e6931b08..00000000
--- a/src/test/java/fr/xephi/authme/util/ExceptionUtilsTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package fr.xephi.authme.util;
-
-import fr.xephi.authme.ReflectionTestUtils;
-import org.junit.Test;
-
-import java.net.MalformedURLException;
-import java.util.ConcurrentModificationException;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.hamcrest.Matchers.sameInstance;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link ExceptionUtils}.
- */
-public class ExceptionUtilsTest {
-
-    @Test
-    public void shouldFindWantedThrowable() {
-        // given
-        ConcurrentModificationException initialCme = new ConcurrentModificationException();
-        Throwable th = new Throwable(initialCme);
-        ConcurrentModificationException cme = new ConcurrentModificationException(th);
-        IllegalStateException ise = new IllegalStateException(cme);
-        UnsupportedOperationException uoe = new UnsupportedOperationException(ise);
-        ReflectiveOperationException roe = new ReflectiveOperationException(uoe);
-
-        // when
-        IllegalStateException resultIse = ExceptionUtils.findThrowableInCause(IllegalStateException.class, roe);
-        ConcurrentModificationException resultCme = ExceptionUtils.findThrowableInCause(ConcurrentModificationException.class, cme);
-        StackOverflowError resultSoe = ExceptionUtils.findThrowableInCause(StackOverflowError.class, cme);
-
-        // then
-        assertThat(resultIse, sameInstance(ise));
-        assertThat(resultCme, sameInstance(cme));
-        assertThat(resultSoe, nullValue());
-    }
-
-    @Test
-    public void shouldHandleCircularCausesGracefully() {
-        // given
-        IllegalStateException ise = new IllegalStateException();
-        UnsupportedOperationException uoe = new UnsupportedOperationException(ise);
-        ReflectiveOperationException roe = new ReflectiveOperationException(uoe);
-        ReflectionTestUtils.setField(Throwable.class, ise, "cause", roe);
-
-        // when
-        NullPointerException resultNpe = ExceptionUtils.findThrowableInCause(NullPointerException.class, uoe);
-        UnsupportedOperationException resultUoe = ExceptionUtils.findThrowableInCause(UnsupportedOperationException.class, uoe);
-
-        // then
-        assertThat(resultNpe, nullValue());
-        assertThat(resultUoe, sameInstance(uoe));
-    }
-
-    @Test
-    public void shouldFormatException() {
-        // given
-        MalformedURLException ex = new MalformedURLException("Unrecognized URL format");
-
-        // when
-        String result = ExceptionUtils.formatException(ex);
-
-        // then
-        assertThat(result, equalTo("[MalformedURLException]: Unrecognized URL format"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/FileUtilsTest.java b/src/test/java/fr/xephi/authme/util/FileUtilsTest.java
deleted file mode 100644
index 36af6724..00000000
--- a/src/test/java/fr/xephi/authme/util/FileUtilsTest.java
+++ /dev/null
@@ -1,219 +0,0 @@
-package fr.xephi.authme.util;
-
-import com.google.common.io.Files;
-import fr.xephi.authme.TestHelper;
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.TemporaryFolder;
-
-import java.io.File;
-import java.io.IOException;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.matchesPattern;
-import static org.hamcrest.Matchers.not;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link FileUtils}.
- */
-public class FileUtilsTest {
-
-    /** Regex that matches timestamps such as 20180211_1048. */
-    private static final String BACKUP_TIMESTAMP_PATTERN = "20\\d{6}_\\d{4}";
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Rule
-    public TemporaryFolder temporaryFolder = new TemporaryFolder();
-
-    @Test
-    public void shouldNotCopyFile() throws IOException {
-        // given
-        File folder = temporaryFolder.newFolder();
-        File file = new File(folder, "config.yml");
-        // purposely don't copy config.yml to verify that config.yml isn't copied by the method
-        File emailJarFile = TestHelper.getJarFile("/email.html");
-        Files.copy(emailJarFile, file);
-
-        // when
-        boolean result = FileUtils.copyFileFromResource(file, "config.yml");
-
-        // then
-        assertThat(result, equalTo(true));
-        assertThat(file.length(), equalTo(emailJarFile.length()));
-    }
-
-    @Test
-    public void shouldCopyFileFromJar() throws IOException {
-        // given
-        File folder = temporaryFolder.newFolder();
-        File file = new File(folder, "some/folders/welcome.txt");
-
-        // when
-        boolean result = FileUtils.copyFileFromResource(file, "welcome.txt");
-
-        // then
-        assertThat(result, equalTo(true));
-        assertThat(file.exists(), equalTo(true));
-        File configJarFile = TestHelper.getJarFile("/welcome.txt");
-        assertThat(file.length(), equalTo(configJarFile.length()));
-    }
-
-    @Test
-    public void shouldReturnFalseForInvalidJarFile() throws IOException {
-        // given
-        File folder = temporaryFolder.newFolder();
-        File file = new File(folder, "bogus");
-
-        // when
-        boolean result = FileUtils.copyFileFromResource(file, "does-not-exist");
-
-        // then
-        assertThat(result, equalTo(false));
-        assertThat(file.exists(), equalTo(false));
-    }
-
-    @Test
-    public void shouldReturnFalseForParentInvalidParentFolders() throws IOException {
-        // given
-        File folder = temporaryFolder.newFolder();
-        new File(folder, "hello").createNewFile();
-        File fileToCreate = new File(folder, "hello/test");
-
-        // when
-        boolean result = FileUtils.copyFileFromResource(fileToCreate, "welcome.txt");
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldPurgeDirectory() throws IOException {
-        // given
-        File root = temporaryFolder.newFolder();
-        File file1 = new File(root, "a/b/c/test.html");
-        File file2 = new File(root, "a/b/f/toast.txt");
-        File file3 = new File(root, "a/g/rest.png");
-        File file4 = new File(root, "j/l/roast.tiff");
-        createFiles(file1, file2, file3, file4);
-
-        // when
-        FileUtils.purgeDirectory(new File(root, "a"));
-
-        // then
-        assertThat(file1.exists(), equalTo(false));
-        assertThat(file2.exists(), equalTo(false));
-        assertThat(file3.exists(), equalTo(false));
-        assertThat(file4.exists(), equalTo(true));
-        assertThat(new File(root, "a").exists(), equalTo(true));
-    }
-
-    @Test
-    public void shouldDeleteFile() throws IOException {
-        // given
-        File file = temporaryFolder.newFile();
-        assertThat(file.exists(), equalTo(true));
-
-        // when
-        FileUtils.delete(file);
-
-        // then
-        assertThat(file.exists(), equalTo(false));
-    }
-
-    @Test
-    public void shouldDoNothingForNullFile() {
-        // given
-        File file = null;
-
-        // when
-        FileUtils.delete(file);
-
-        // then
-        // Nothing happens
-    }
-
-    @Test
-    public void shouldGetResourceFromJar() {
-        // given / when / then
-        assertThat(FileUtils.getResourceFromJar("config.yml"), not(nullValue()));
-        assertThat(FileUtils.getResourceFromJar("does-not-exist"), nullValue());
-    }
-
-    @Test
-    public void shouldConstructPath() {
-        // given/when
-        String result = FileUtils.makePath("path", "to", "test-file.txt");
-
-        // then
-        assertThat(result, equalTo("path" + File.separator + "to" + File.separator + "test-file.txt"));
-    }
-
-    @Test
-    public void shouldCreateDirectory() throws IOException {
-        // given
-        File root = temporaryFolder.newFolder();
-        File dir = new File(root, "folder/folder2/myFolder");
-
-        // when
-        boolean result = FileUtils.createDirectory(dir);
-
-        // then
-        assertThat(result, equalTo(true));
-        assertThat(dir.exists(), equalTo(true));
-        assertThat(dir.isDirectory(), equalTo(true));
-    }
-
-    @Test
-    public void shouldReturnFalseOnDirectoryCreateFail() throws IOException {
-        // given
-        File root = temporaryFolder.newFolder();
-        File dirAsFile = new File(root, "file");
-        dirAsFile.createNewFile();
-
-        // when
-        boolean result = FileUtils.createDirectory(dirAsFile);
-
-        // then
-        assertThat(result, equalTo(false));
-        assertThat(dirAsFile.isFile(), equalTo(true));
-    }
-
-    @Test
-    public void shouldCreateCurrentTimestampString() {
-        // given / when
-        String currentTimeString = FileUtils.createCurrentTimeString();
-
-        // then
-        assertThat(currentTimeString, matchesPattern(BACKUP_TIMESTAMP_PATTERN));
-    }
-
-    @Test
-    public void shouldCreateBackupFile() {
-        // given
-        File file = new File("some/folders/config.yml");
-
-        // when
-        String backupFile = FileUtils.createBackupFilePath(file);
-
-        // then
-        String folders = String.join(File.separator,"some", "folders", "").replace("\\", "\\\\");
-        assertThat(backupFile, matchesPattern(folders + "backup_config_" + BACKUP_TIMESTAMP_PATTERN + "\\.yml"));
-    }
-
-    private static void createFiles(File... files) throws IOException {
-        for (File file : files) {
-            boolean result = file.getParentFile().mkdirs() & file.createNewFile();
-            if (!result) {
-                throw new IllegalStateException("Cannot create file '" + file + "'");
-            }
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/util/InternetProtocolUtilsTest.java b/src/test/java/fr/xephi/authme/util/InternetProtocolUtilsTest.java
deleted file mode 100644
index 54bc7dcb..00000000
--- a/src/test/java/fr/xephi/authme/util/InternetProtocolUtilsTest.java
+++ /dev/null
@@ -1,52 +0,0 @@
-package fr.xephi.authme.util;
-
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link InternetProtocolUtils}
- */
-public class InternetProtocolUtilsTest {
-
-    @Test
-    public void shouldCheckLocalAddress() {
-        // loopback
-        assertThat(InternetProtocolUtils.isLocalAddress("localhost"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("127.0.0.1"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("::1"), equalTo(true));
-
-        // site local
-        assertThat(InternetProtocolUtils.isLocalAddress("10.0.0.1"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("172.0.0.1"), equalTo(false));
-        assertThat(InternetProtocolUtils.isLocalAddress("172.16.0.1"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("192.168.0.1"), equalTo(true));
-
-        // deprecated site-local
-        // ref: https://en.wikipedia.org/wiki/IPv6_address#Default_address_selection
-        assertThat(InternetProtocolUtils.isLocalAddress("fec0::"), equalTo(true));
-
-        // unique site-local (not deprecated!)
-        // ref: https://en.wikipedia.org/wiki/Unique_local_address
-        assertThat(InternetProtocolUtils.isLocalAddress("fde4:8dba:82e1::"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("fc00::"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("fe00::"), equalTo(false));
-
-        // link local
-        assertThat(InternetProtocolUtils.isLocalAddress("169.254.0.64"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLocalAddress("FE80:0000:0000:0000:C800:0EFF:FE74:0008"), equalTo(true));
-
-        // public
-        assertThat(InternetProtocolUtils.isLocalAddress("94.32.34.5"), equalTo(false));
-    }
-
-    @Test
-    public void testIsLoopback() {
-        // loopback
-        assertThat(InternetProtocolUtils.isLoopbackAddress("localhost"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLoopbackAddress("127.0.0.1"), equalTo(true));
-        assertThat(InternetProtocolUtils.isLoopbackAddress("::1"), equalTo(true));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/PlayerUtilsTest.java b/src/test/java/fr/xephi/authme/util/PlayerUtilsTest.java
deleted file mode 100644
index 69d7b1f0..00000000
--- a/src/test/java/fr/xephi/authme/util/PlayerUtilsTest.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package fr.xephi.authme.util;
-
-import fr.xephi.authme.TestHelper;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.BDDMockito.given;
-import static org.mockito.Mockito.mock;
-
-/**
- * Test for {@link PlayerUtils}.
- */
-public class PlayerUtilsTest {
-
-    @BeforeClass
-    public static void setAuthmeInstance() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldGetPlayerIp() {
-        // given
-        Player player = mock(Player.class);
-        String ip = "124.86.248.62";
-        TestHelper.mockIpAddressToPlayer(player, ip);
-
-        // when
-        String result = PlayerUtils.getPlayerIp(player);
-
-        // then
-        assertThat(result, equalTo(ip));
-    }
-
-    @Test
-    public void shouldCheckIfIsNpc() {
-        // given
-        Player player1 = mock(Player.class);
-        given(player1.hasMetadata("NPC")).willReturn(false);
-        Player player2 = mock(Player.class);
-        given(player2.hasMetadata("NPC")).willReturn(true);
-
-        // when
-        boolean result1 = PlayerUtils.isNpc(player1);
-        boolean result2 = PlayerUtils.isNpc(player2);
-
-        // then
-        assertThat(result1, equalTo(false));
-        assertThat(result2, equalTo(true));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/RandomStringUtilsTest.java b/src/test/java/fr/xephi/authme/util/RandomStringUtilsTest.java
deleted file mode 100644
index a89b4922..00000000
--- a/src/test/java/fr/xephi/authme/util/RandomStringUtilsTest.java
+++ /dev/null
@@ -1,86 +0,0 @@
-package fr.xephi.authme.util;
-
-import org.junit.Test;
-
-import java.util.regex.Pattern;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link RandomStringUtils}.
- */
-public class RandomStringUtilsTest {
-
-    @Test
-    public void shouldGenerateRandomStrings() {
-        // given
-        int[] lengths = {0, 1, 19, 142, 1872};
-        Pattern badChars = Pattern.compile(".*[^0-9a-z].*");
-
-        // when / then
-        for (int length : lengths) {
-            String result = RandomStringUtils.generate(length);
-            assertThat("Result '" + result + "' should have length " + length,
-                result.length(), equalTo(length));
-            assertThat("Result '" + result + "' should only have characters a-z, 0-9",
-                badChars.matcher(result).matches(), equalTo(false));
-        }
-    }
-
-    @Test
-    public void shouldGenerateRandomHexString() {
-        // given
-        int[] lengths = {0, 1, 21, 160, 1784};
-        Pattern badChars = Pattern.compile(".*[^0-9a-f].*");
-
-        // when / then
-        for (int length : lengths) {
-            String result = RandomStringUtils.generateHex(length);
-            assertThat("Result '" + result + "' should have length " + length,
-                result.length(), equalTo(length));
-            assertThat("Result '" + result + "' should only have characters a-f, 0-9",
-                badChars.matcher(result).matches(), equalTo(false));
-        }
-    }
-
-    @Test
-    public void shouldGenerateRandomLowerUpperString() {
-        // given
-        int[] lengths = {0, 1, 17, 143, 1808};
-        Pattern badChars = Pattern.compile(".*[^0-9a-zA-Z].*");
-
-        // when / then
-        for (int length : lengths) {
-            String result = RandomStringUtils.generateLowerUpper(length);
-            assertThat("Result '" + result + "' should have length " + length,
-                result.length(), equalTo(length));
-            assertThat("Result '" + result + "' should only have characters a-z, A-Z, 0-9",
-                badChars.matcher(result).matches(), equalTo(false));
-        }
-    }
-
-    @Test
-    public void shouldGenerateRandomNumberString() {
-        // given
-        int[] lengths = {0, 1, 18, 147, 1833};
-        Pattern badChars = Pattern.compile(".*[^0-9].*");
-
-        // when / then
-        for (int length : lengths) {
-            String result = RandomStringUtils.generateNum(length);
-            assertThat("Result '" + result + "' should have length " + length,
-                result.length(), equalTo(length));
-            assertThat("Result '" + result + "' should only have characters 0-9",
-                badChars.matcher(result).matches(), equalTo(false));
-        }
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void shouldThrowForInvalidLength() {
-        // given/when
-        RandomStringUtils.generate(-3);
-
-        // then - throw exception
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/StringUtilsTest.java b/src/test/java/fr/xephi/authme/util/StringUtilsTest.java
deleted file mode 100644
index fcd000d9..00000000
--- a/src/test/java/fr/xephi/authme/util/StringUtilsTest.java
+++ /dev/null
@@ -1,88 +0,0 @@
-package fr.xephi.authme.util;
-
-import org.junit.Test;
-
-import static java.util.Arrays.asList;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
-
-/**
- * Test for {@link StringUtils}.
- */
-public class StringUtilsTest {
-
-    @Test
-    public void shouldFindContainedItem() {
-        // given
-        String text = "This is a test of containsAny()";
-        String piece = "test";
-
-        // when
-        boolean result = StringUtils.containsAny(text, asList("some", "words", "that", "do not", "exist", piece));
-
-        // then
-        assertThat(result, equalTo(true));
-    }
-
-    @Test
-    public void shouldReturnFalseIfNoneFound() {
-        // given
-        String text = "This is a test string";
-
-        // when
-        boolean result = StringUtils.containsAny(text, asList("some", "other", "words", null));
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldReturnFalseForNullString() {
-        // given/when
-        boolean result = StringUtils.containsAny(null, asList("some", "words", "to", "check"));
-
-        // then
-        assertThat(result, equalTo(false));
-    }
-
-    @Test
-    public void shouldCheckIfIsBlankString() {
-        // Should be true for null/empty/whitespace
-        assertTrue(StringUtils.isBlank(null));
-        assertTrue(StringUtils.isBlank(""));
-        assertTrue(StringUtils.isBlank(" \t"));
-
-        // Should be false if string has content
-        assertFalse(StringUtils.isBlank("P"));
-        assertFalse(StringUtils.isBlank(" test"));
-    }
-
-    @Test
-    public void shouldGetDifferenceWithNullString() {
-        // given/when/then
-        assertThat(StringUtils.getDifference(null, "test"), equalTo(1.0));
-        assertThat(StringUtils.getDifference("test", null), equalTo(1.0));
-        assertThat(StringUtils.getDifference(null, null), equalTo(1.0));
-    }
-
-    @Test
-    public void shouldGetDifferenceBetweenTwoString() {
-        // given/when/then
-        assertThat(StringUtils.getDifference("test", "taste"), equalTo(0.4));
-        assertThat(StringUtils.getDifference("test", "bear"), equalTo(0.75));
-        assertThat(StringUtils.getDifference("test", "something"), greaterThan(0.88));
-    }
-
-    @Test
-    public void shouldCheckIfHasNeedleInWord() {
-        // given/when/then
-        assertThat(StringUtils.isInsideString('@', "@hello"), equalTo(false));
-        assertThat(StringUtils.isInsideString('?', "absent"), equalTo(false));
-        assertThat(StringUtils.isInsideString('-', "abcd-"), equalTo(false));
-        assertThat(StringUtils.isInsideString('@', "hello@example"), equalTo(true));
-        assertThat(StringUtils.isInsideString('@', "D@Z"), equalTo(true));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/UtilsTest.java b/src/test/java/fr/xephi/authme/util/UtilsTest.java
deleted file mode 100644
index 37d52163..00000000
--- a/src/test/java/fr/xephi/authme/util/UtilsTest.java
+++ /dev/null
@@ -1,175 +0,0 @@
-package fr.xephi.authme.util;
-
-import fr.xephi.authme.TestHelper;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.entity.Player;
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.logging.Logger;
-import java.util.regex.Pattern;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoInteractions;
-
-/**
- * Test for {@link Utils}.
- */
-public class UtilsTest {
-
-    @BeforeClass
-    public static void initLogger() {
-        TestHelper.setupLogger();
-    }
-
-    @Test
-    public void shouldCompilePattern() {
-        // given
-        String pattern = "gr(a|e)ys?";
-
-        // when
-        Pattern result = Utils.safePatternCompile(pattern);
-
-        // then
-        assertThat(result.toString(), equalTo(pattern));
-    }
-
-    @Test
-    public void shouldDefaultToAllAllowedPattern() {
-        // given
-        String invalidPattern = "gr(a|eys?"; // missing closing ')'
-
-        // when
-        Pattern result = Utils.safePatternCompile(invalidPattern);
-
-        // then
-        assertThat(result.toString(), equalTo(".*?"));
-    }
-
-    @Test
-    public void shouldLogAndSendMessage() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        Player player = mock(Player.class);
-        String message = "Finished adding foo to the bar";
-
-        // when
-        Utils.logAndSendMessage(player, message);
-
-        // then
-        verify(logger).info(message);
-        verify(player).sendMessage(message);
-    }
-
-    @Test
-    public void shouldHandleNullAsCommandSender() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        String message = "Test test, test.";
-
-        // when
-        Utils.logAndSendMessage(null, message);
-
-        // then
-        verify(logger).info(message);
-    }
-
-    @Test
-    public void shouldNotSendToCommandSenderTwice() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        CommandSender sender = mock(ConsoleCommandSender.class);
-        String message = "Test test, test.";
-
-        // when
-        Utils.logAndSendMessage(sender, message);
-
-        // then
-        verify(logger).info(message);
-        verifyNoInteractions(sender);
-    }
-
-    @Test
-    public void shouldCheckIfCollectionIsEmpty() {
-        // given
-        List<String> emptyList = Collections.emptyList();
-        Collection<Integer> nonEmptyColl = Arrays.asList(3, 4, 5);
-
-        // when / then
-        assertThat(Utils.isCollectionEmpty(emptyList), equalTo(true));
-        assertThat(Utils.isCollectionEmpty(nonEmptyColl), equalTo(false));
-        assertThat(Utils.isCollectionEmpty(null), equalTo(true));
-    }
-
-    @Test
-    public void shouldLogAndSendWarning() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        String message = "Error while performing action";
-        CommandSender sender = mock(CommandSender.class);
-
-        // when
-        Utils.logAndSendWarning(sender, message);
-
-        // then
-        verify(logger).warning(message);
-        verify(sender).sendMessage(ChatColor.RED + message);
-    }
-
-    @Test
-    public void shouldLogWarningAndNotSendToConsoleSender() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        String message = "Error while performing action";
-        CommandSender sender = mock(ConsoleCommandSender.class);
-
-        // when
-        Utils.logAndSendWarning(sender, message);
-
-        // then
-        verify(logger).warning(message);
-        verifyNoInteractions(sender);
-    }
-
-    @Test
-    public void shouldLogWarningAndHandleNullCommandSender() {
-        // given
-        Logger logger = TestHelper.setupLogger();
-        String message = "Error while performing action";
-        CommandSender sender = null;
-
-        // when
-        Utils.logAndSendWarning(sender, message);
-
-        // then
-        verify(logger).warning(message);
-    }
-
-    @Test
-    public void shouldCheckIfClassIsLoaded() {
-        // given / when / then
-        assertThat(Utils.isClassLoaded("org.bukkit.event.player.PlayerFishEvent"), equalTo(true));
-        assertThat(Utils.isClassLoaded("com.someclass.doesnot.exist"), equalTo(false));
-    }
-
-    @Test
-    public void shouldDetectIfEmailIsEmpty() {
-        // given / when / then
-        assertThat(Utils.isEmailEmpty(""), equalTo(true));
-        assertThat(Utils.isEmailEmpty(null), equalTo(true));
-        assertThat(Utils.isEmailEmpty("your@email.com"), equalTo(true));
-        assertThat(Utils.isEmailEmpty("Your@Email.com"), equalTo(true));
-
-        assertThat(Utils.isEmailEmpty("my@example.org"), equalTo(false));
-        assertThat(Utils.isEmailEmpty("hey"), equalTo(false));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/UuidUtilsTest.java b/src/test/java/fr/xephi/authme/util/UuidUtilsTest.java
deleted file mode 100644
index b98bdba9..00000000
--- a/src/test/java/fr/xephi/authme/util/UuidUtilsTest.java
+++ /dev/null
@@ -1,29 +0,0 @@
-package fr.xephi.authme.util;
-
-import org.junit.Test;
-
-import java.util.UUID;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link UuidUtils}.
- */
-public class UuidUtilsTest {
-
-    @Test
-    public void shouldParseUuidSafely() {
-        // given
-        UUID correctUuid = UUID.fromString("8e0a9aaa-5eda-42ef-8daf-e6c6359f607e");
-
-        // when / then
-        assertThat(UuidUtils.parseUuidSafely("8e0a9aaa-5eda-42ef-8daf-e6c6359f607e"), equalTo(correctUuid));
-
-        assertThat(UuidUtils.parseUuidSafely(null), nullValue());
-        assertThat(UuidUtils.parseUuidSafely(""), nullValue());
-        assertThat(UuidUtils.parseUuidSafely("foo"), nullValue());
-        assertThat(UuidUtils.parseUuidSafely("8e0a9aaa-5eda-42ef-InvalidEnding"), nullValue());
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/expiring/DurationTest.java b/src/test/java/fr/xephi/authme/util/expiring/DurationTest.java
deleted file mode 100644
index 03a0f9d4..00000000
--- a/src/test/java/fr/xephi/authme/util/expiring/DurationTest.java
+++ /dev/null
@@ -1,43 +0,0 @@
-package fr.xephi.authme.util.expiring;
-
-import org.junit.Test;
-
-import java.util.concurrent.TimeUnit;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link Duration}.
- */
-public class DurationTest {
-
-    @Test
-    public void shouldConvertToAppropriateTimeUnit() {
-        check(Duration.createWithSuitableUnit(0, TimeUnit.HOURS),
-            0, TimeUnit.SECONDS);
-
-        check(Duration.createWithSuitableUnit(124, TimeUnit.MINUTES),
-            2, TimeUnit.HOURS);
-
-        check(Duration.createWithSuitableUnit(300, TimeUnit.HOURS),
-            12, TimeUnit.DAYS);
-
-        check(Duration.createWithSuitableUnit(60 * 24 * 50 + 8, TimeUnit.MINUTES),
-            50, TimeUnit.DAYS);
-
-        check(Duration.createWithSuitableUnit(1000L * 60 * 60 * 24 * 7 + 3000, TimeUnit.MILLISECONDS),
-            7, TimeUnit.DAYS);
-
-        check(Duration.createWithSuitableUnit(1000L * 60 * 60 * 3 + 1400, TimeUnit.MILLISECONDS),
-            3, TimeUnit.HOURS);
-
-        check(Duration.createWithSuitableUnit(248, TimeUnit.SECONDS),
-            4, TimeUnit.MINUTES);
-    }
-
-    private static void check(Duration duration, long expectedDuration, TimeUnit expectedUnit) {
-        assertThat(duration.getTimeUnit(), equalTo(expectedUnit));
-        assertThat(duration.getDuration(), equalTo(expectedDuration));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/expiring/ExpiringMapTest.java b/src/test/java/fr/xephi/authme/util/expiring/ExpiringMapTest.java
deleted file mode 100644
index ac9a5a71..00000000
--- a/src/test/java/fr/xephi/authme/util/expiring/ExpiringMapTest.java
+++ /dev/null
@@ -1,95 +0,0 @@
-package fr.xephi.authme.util.expiring;
-
-import org.junit.Test;
-
-import java.util.Map;
-import java.util.concurrent.TimeUnit;
-
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.nullValue;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link ExpiringMap}.
- */
-public class ExpiringMapTest {
-
-    @Test
-    public void shouldAddAndRetrieveEntries() {
-        // given
-        ExpiringMap<String, Double> map = new ExpiringMap<>(3, TimeUnit.MINUTES);
-
-        // when / then
-        map.put("three", 3.0);
-        map.put("treefiddy", 3.50);
-
-        assertThat(map.get("three"), equalTo(3.0));
-        assertThat(map.get("treefiddy"), equalTo(3.50));
-    }
-
-    @Test
-    public void shouldRemoveEntry() {
-        // given
-        ExpiringMap<String, Boolean> map = new ExpiringMap<>(1, TimeUnit.HOURS);
-        map.put("hi", true);
-        map.put("ha", false);
-
-        // when
-        map.remove("ha");
-
-        // then
-        assertThat(map.get("ha"), nullValue());
-        assertThat(map.get("hi"), equalTo(true));
-    }
-
-    @Test
-    public void shouldUpdateExpirationAndSupportNegativeValues() {
-        // given
-        ExpiringMap<Integer, Integer> map = new ExpiringMap<>(2, TimeUnit.DAYS);
-        map.put(2, 4);
-        map.put(3, 9);
-
-        // when
-        map.setExpiration(-100, TimeUnit.MILLISECONDS);
-
-        // then
-        map.put(5, 25);
-        assertThat(map.get(2), equalTo(4));
-        assertThat(map.get(3), equalTo(9));
-        assertThat(map.get(5), nullValue());
-    }
-
-    @Test
-    public void shouldCleanUpExpiredEntries() throws InterruptedException {
-        // given
-        ExpiringMap<Integer, Integer> map = new ExpiringMap<>(200, TimeUnit.MILLISECONDS);
-        map.put(144, 12);
-        map.put(121, 11);
-        map.put(81, 9);
-        map.setExpiration(900, TimeUnit.MILLISECONDS);
-        map.put(64, 8);
-        map.put(25, 5);
-
-        // when
-        Thread.sleep(300);
-        map.removeExpiredEntries();
-
-        // then
-        Map<Integer, ?> internalMap = map.getEntries();
-        assertThat(internalMap.keySet(), containsInAnyOrder(64, 25));
-    }
-
-    @Test
-    public void shouldReturnIfIsEmpty() {
-        // given
-        ExpiringMap<String, String> map = new ExpiringMap<>(-8, TimeUnit.SECONDS);
-
-        // when / then
-        assertThat(map.isEmpty(), equalTo(true));
-        map.put("hoi", "Welt");
-        assertThat(map.isEmpty(), equalTo(false));
-        map.removeExpiredEntries();
-        assertThat(map.isEmpty(), equalTo(true));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/expiring/ExpiringSetTest.java b/src/test/java/fr/xephi/authme/util/expiring/ExpiringSetTest.java
deleted file mode 100644
index 42180ab2..00000000
--- a/src/test/java/fr/xephi/authme/util/expiring/ExpiringSetTest.java
+++ /dev/null
@@ -1,143 +0,0 @@
-package fr.xephi.authme.util.expiring;
-
-import org.junit.Test;
-
-import java.util.concurrent.TimeUnit;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link ExpiringSet}.
- */
-public class ExpiringSetTest {
-
-    @Test
-    public void shouldAddEntry() {
-        // given
-        ExpiringSet<String> set = new ExpiringSet<>(10, TimeUnit.MINUTES);
-
-        // when
-        set.add("authme");
-
-        // then
-        assertThat(set.contains("authme"), equalTo(true));
-        assertThat(set.contains("other"), equalTo(false));
-    }
-
-    @Test
-    public void shouldRemoveEntries() {
-        // given
-        ExpiringSet<Integer> set = new ExpiringSet<>(20, TimeUnit.SECONDS);
-        set.add(20);
-        set.add(40);
-
-        // when
-        set.remove(40);
-        set.remove(60);
-
-        // then
-        assertThat(set.contains(20), equalTo(true));
-        assertThat(set.contains(40), equalTo(false));
-        assertThat(set.contains(60), equalTo(false));
-    }
-
-    @Test
-    public void shouldHandleNewExpirationAndSupportNegativeValues() {
-        // given
-        ExpiringSet<Character> set = new ExpiringSet<>(800, TimeUnit.MILLISECONDS);
-        set.add('A');
-
-        // when
-        set.setExpiration(-10, TimeUnit.SECONDS);
-        set.add('Y');
-
-        // then
-        assertThat(set.contains('A'), equalTo(true));
-        assertThat(set.contains('Y'), equalTo(false));
-    }
-
-    @Test
-    public void shouldClearAllValues() {
-        // given
-        ExpiringSet<String> set = new ExpiringSet<>(1, TimeUnit.MINUTES);
-        set.add("test");
-
-        // when / then
-        assertThat(set.isEmpty(), equalTo(false));
-        set.clear();
-        assertThat(set.isEmpty(), equalTo(true));
-        assertThat(set.contains("test"), equalTo(false));
-    }
-
-    @Test
-    public void shouldClearExpiredValues() {
-        // given
-        ExpiringSet<Integer> set = new ExpiringSet<>(2, TimeUnit.HOURS);
-        set.add(2);
-        set.setExpiration(-100, TimeUnit.SECONDS);
-        set.add(3);
-        set.setExpiration(20, TimeUnit.MINUTES);
-        set.add(6);
-
-        // when
-        set.removeExpiredEntries();
-
-        // then
-        assertThat(set.contains(2), equalTo(true));
-        assertThat(set.contains(3), equalTo(false));
-        assertThat(set.contains(6), equalTo(true));
-    }
-
-    @Test
-    public void shouldReturnExpiration() {
-        // given
-        ExpiringSet<String> set = new ExpiringSet<>(123, TimeUnit.MINUTES);
-        set.add("my entry");
-
-        // when
-        Duration expiration = set.getExpiration("my entry");
-        Duration unknownExpiration = set.getExpiration("bogus");
-
-        // then
-        assertIsDuration(expiration, 2, TimeUnit.HOURS);
-        assertIsDuration(unknownExpiration, -1, TimeUnit.SECONDS);
-    }
-
-    @Test
-    public void shouldReturnExpirationInSuitableUnits() {
-        // given
-        ExpiringSet<Integer> set = new ExpiringSet<>(601, TimeUnit.SECONDS);
-        set.add(12);
-        set.setExpiration(49, TimeUnit.HOURS);
-        set.add(23);
-
-        // when
-        Duration expiration12 = set.getExpiration(12);
-        Duration expiration23 = set.getExpiration(23);
-        Duration expectedUnknown = set.getExpiration(-100);
-
-        // then
-        assertIsDuration(expiration12, 10, TimeUnit.MINUTES);
-        assertIsDuration(expiration23, 2, TimeUnit.DAYS);
-        assertIsDuration(expectedUnknown, -1, TimeUnit.SECONDS);
-    }
-
-    @Test
-    public void shouldReturnMinusOneForExpiredEntry() {
-        // given
-        ExpiringSet<Integer> set = new ExpiringSet<>(-100, TimeUnit.SECONDS);
-        set.add(23);
-
-        // when
-        Duration expiration = set.getExpiration(23);
-
-        // then
-        assertIsDuration(expiration, -1, TimeUnit.SECONDS);
-    }
-
-    private static void assertIsDuration(Duration duration, long expectedDuration, TimeUnit expectedUnit) {
-        assertThat(duration.getTimeUnit(), equalTo(expectedUnit));
-        assertThat(duration.getDuration(), equalTo(expectedDuration));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/expiring/TimedCounterTest.java b/src/test/java/fr/xephi/authme/util/expiring/TimedCounterTest.java
deleted file mode 100644
index c2b65eed..00000000
--- a/src/test/java/fr/xephi/authme/util/expiring/TimedCounterTest.java
+++ /dev/null
@@ -1,70 +0,0 @@
-package fr.xephi.authme.util.expiring;
-
-import org.junit.Test;
-
-import java.util.concurrent.TimeUnit;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link TimedCounter}.
- */
-public class TimedCounterTest {
-
-    @Test
-    public void shouldReturnZeroForAnyKey() {
-        // given
-        TimedCounter<Double> counter = new TimedCounter<>(1, TimeUnit.DAYS);
-
-        // when / then
-        assertThat(counter.get(2.0), equalTo(0));
-        assertThat(counter.get(-3.14159), equalTo(0));
-    }
-
-    @Test
-    public void shouldIncrementCount() {
-        // given
-        TimedCounter<String> counter = new TimedCounter<>(10, TimeUnit.MINUTES);
-        counter.put("moto", 12);
-
-        // when
-        counter.increment("hello");
-        counter.increment("moto");
-
-        // then
-        assertThat(counter.get("hello"), equalTo(1));
-        assertThat(counter.get("moto"), equalTo(13));
-    }
-
-    @Test
-    public void shouldDecrementCount() {
-        // given
-        TimedCounter<String> counter = new TimedCounter<>(10, TimeUnit.MINUTES);
-        counter.put("moto", 12);
-
-        // when
-        counter.decrement("hello");
-        counter.decrement("moto");
-
-        // then
-        assertThat(counter.get("hello"), equalTo(0));
-        assertThat(counter.get("moto"), equalTo(11));
-    }
-
-    @Test
-    public void shouldSumUpEntries() {
-        // given
-        TimedCounter<String> counter = new TimedCounter<>(90, TimeUnit.SECONDS);
-        counter.getEntries().put("expired", new ExpiringMap.ExpiringEntry<>(800, 0));
-        counter.getEntries().put("expired2", new ExpiringMap.ExpiringEntry<>(24, System.currentTimeMillis() - 100));
-        counter.put("other", 10);
-        counter.put("Another", 4);
-
-        // when
-        int totals = counter.total();
-
-        // then
-        assertThat(totals, equalTo(14));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/lazytags/TagBuilderTest.java b/src/test/java/fr/xephi/authme/util/lazytags/TagBuilderTest.java
deleted file mode 100644
index 53362b5f..00000000
--- a/src/test/java/fr/xephi/authme/util/lazytags/TagBuilderTest.java
+++ /dev/null
@@ -1,42 +0,0 @@
-package fr.xephi.authme.util.lazytags;
-
-import org.junit.Test;
-
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link TagBuilder}.
- */
-public class TagBuilderTest {
-
-    @Test
-    public void shouldCreateNoArgsTag() {
-        // given
-        Supplier<String> supplier = () -> "hello";
-
-        // when
-        Tag<String> tag = TagBuilder.createTag("hey", supplier);
-
-        // then
-        assertThat(tag, instanceOf(SimpleTag.class));
-        assertThat(tag.getValue(null), equalTo("hello"));
-    }
-
-    @Test
-    public void shouldCreateDependentTag() {
-        // given
-        Function<Double, String> function = d -> Double.toString(d + d/10);
-
-        // when
-        Tag<Double> tag = TagBuilder.createTag("%test", function);
-
-        // then
-        assertThat(tag, instanceOf(DependentTag.class));
-        assertThat(tag.getValue(24d), equalTo("26.4"));
-    }
-}
diff --git a/src/test/java/fr/xephi/authme/util/lazytags/TagReplacerTest.java b/src/test/java/fr/xephi/authme/util/lazytags/TagReplacerTest.java
deleted file mode 100644
index 8c9a8187..00000000
--- a/src/test/java/fr/xephi/authme/util/lazytags/TagReplacerTest.java
+++ /dev/null
@@ -1,90 +0,0 @@
-package fr.xephi.authme.util.lazytags;
-
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static fr.xephi.authme.util.lazytags.TagBuilder.createTag;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link TagReplacer}.
- */
-public class TagReplacerTest {
-
-    @Test
-    public void shouldReplaceTags() {
-        // given
-        TestTagService tagService = new TestTagService();
-        List<Tag<Integer>> tags = tagService.getAvailableTags();
-        List<String> messages = Arrays.asList("pi = %PI", "for i = %self, i^2 = %square", "%self %self %PI");
-
-        // when
-        TagReplacer<Integer> tagReplacer = TagReplacer.newReplacer(tags, messages);
-        List<String> result = tagReplacer.getAdaptedMessages(3);
-
-        // then
-        assertThat(tagService.piCount, equalTo(1));
-        assertThat(tagService.selfCount, equalTo(1));
-        assertThat(tagService.doubleCount, equalTo(0));
-        assertThat(tagService.squareCount, equalTo(1));
-        assertThat(result, contains("pi = 3.14159", "for i = 3, i^2 = 9", "3 3 3.14159"));
-    }
-
-    @Test
-    public void shouldNotCallUnusedTags() {
-        // given
-        TestTagService tagService = new TestTagService();
-        List<Tag<Integer>> tags = tagService.getAvailableTags();
-        List<String> messages = Arrays.asList("pi = %PI", "double i = %double");
-
-        // when
-        TagReplacer<Integer> tagReplacer = TagReplacer.newReplacer(tags, messages);
-        List<String> result1 = tagReplacer.getAdaptedMessages(-4);
-        List<String> result2 = tagReplacer.getAdaptedMessages(0);
-
-        // then
-        assertThat(tagService.piCount, equalTo(2));
-        assertThat(tagService.selfCount, equalTo(0));
-        assertThat(tagService.doubleCount, equalTo(2));
-        assertThat(tagService.squareCount, equalTo(0));
-        assertThat(result1, contains("pi = 3.14159", "double i = -8"));
-        assertThat(result2, contains("pi = 3.14159", "double i = 0"));
-    }
-
-    static final class TestTagService {
-        int piCount, selfCount, doubleCount, squareCount;
-
-        String pi() {
-            ++piCount;
-            return "3.14159";
-        }
-
-        String self(int i) {
-            ++selfCount;
-            return Integer.toString(i);
-        }
-
-        String calcDouble(int i) {
-            ++doubleCount;
-            return Integer.toString(2 * i);
-        }
-
-        String calcSquare(int i) {
-            ++squareCount;
-            return Integer.toString(i * i);
-        }
-
-        List<Tag<Integer>> getAvailableTags() {
-            return Arrays.asList(
-                createTag("%PI", this::pi),
-                createTag("%self", this::self),
-                createTag("%double", this::calcDouble),
-                createTag("%square", this::calcSquare));
-        }
-    }
-
-}
diff --git a/src/test/java/fr/xephi/authme/util/lazytags/WrappedTagReplacerTest.java b/src/test/java/fr/xephi/authme/util/lazytags/WrappedTagReplacerTest.java
deleted file mode 100644
index 19915054..00000000
--- a/src/test/java/fr/xephi/authme/util/lazytags/WrappedTagReplacerTest.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package fr.xephi.authme.util.lazytags;
-
-import fr.xephi.authme.util.lazytags.TagReplacerTest.TestTagService;
-import org.hamcrest.Description;
-import org.hamcrest.Matcher;
-import org.hamcrest.TypeSafeMatcher;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.List;
-
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.equalTo;
-import static org.junit.Assert.assertThat;
-
-/**
- * Test for {@link WrappedTagReplacer}.
- */
-public class WrappedTagReplacerTest {
-
-    @Test
-    public void shouldApplyTags() {
-        // given
-        TestTagService tagService = new TestTagService();
-        List<Tag<Integer>> tags = tagService.getAvailableTags();
-        List<SampleClass> objects = Arrays.asList(
-            new SampleClass(3, "pi is %PI"),
-            new SampleClass(5, "no tags here"),
-            new SampleClass(7, "i+i = %double"));
-
-        // when
-        WrappedTagReplacer<SampleClass, Integer> replacer = new WrappedTagReplacer<>(
-            tags, objects, SampleClass::getDescription, (o, s) -> new SampleClass(o.number, s));
-        List<SampleClass> result1 = replacer.getAdaptedItems(8);
-        List<SampleClass> result2 = replacer.getAdaptedItems(1);
-
-        // then
-        assertThat(tagService.piCount, equalTo(2));
-        assertThat(tagService.selfCount, equalTo(0));
-        assertThat(tagService.doubleCount, equalTo(2));
-        assertThat(tagService.squareCount, equalTo(0));
-        assertThat(result1, contains(
-            sampleClass(3, "pi is 3.14159"), sampleClass(5, "no tags here"), sampleClass(7, "i+i = 16")));
-        assertThat(result2, contains(
-            sampleClass(3, "pi is 3.14159"), sampleClass(5, "no tags here"), sampleClass(7, "i+i = 2")));
-    }
-
-
-    private static Matcher<SampleClass> sampleClass(int number, String description) {
-        return new TypeSafeMatcher<SampleClass>() {
-            @Override
-            protected boolean matchesSafely(SampleClass item) {
-                return number == item.number && description.equals(item.description);
-            }
-
-            @Override
-            public void describeTo(Description description) {
-                description.appendText("SampleClass[number=" + number + ";description=" + description + "]");
-            }
-        };
-    }
-
-    private static final class SampleClass {
-        private final int number;
-        private final String description;
-
-        SampleClass(int number, String description) {
-            this.number = number;
-            this.description = description;
-        }
-
-        String getDescription() {
-            return description;
-        }
-    }
-}
diff --git a/src/test/java/tools/README.md b/src/test/java/tools/README.md
deleted file mode 100644
index 012405cf..00000000
--- a/src/test/java/tools/README.md
+++ /dev/null
@@ -1,6 +0,0 @@
-# About the _tools_ Folder
-
-This _tools_ folder provides helpers and extended tests useful during the development of AuthMe.
-This folder is not included during the build of AuthMe and does not contain unit tests.
-
-Run the `ToolsRunner` class to perform a task.
diff --git a/src/test/java/tools/ToolsRunner.java b/src/test/java/tools/ToolsRunner.java
deleted file mode 100644
index 3dfbd36b..00000000
--- a/src/test/java/tools/ToolsRunner.java
+++ /dev/null
@@ -1,76 +0,0 @@
-package tools;
-
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import tools.utils.AutoToolTask;
-import tools.utils.ToolTask;
-
-import java.util.Map;
-import java.util.Scanner;
-import java.util.TreeMap;
-
-/**
- * Runner for executing tool tasks.
- */
-public final class ToolsRunner {
-
-    private Map<String, ToolTask> tasks;
-
-    private ToolsRunner(Map<String, ToolTask> tasks) {
-        this.tasks = tasks;
-    }
-
-    /**
-     * Entry point of the runner.
-     *
-     * @param args .
-     */
-    public static void main(String... args) {
-        // Note ljacqu 20151212: If the tools folder becomes a lot bigger, it will make sense to restrict the depth
-        // of this recursive collector
-        ClassCollector collector = new ClassCollector(TestHelper.TEST_SOURCES_FOLDER, "tools");
-        Map<String, ToolTask> tasks = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
-        for (ToolTask task : collector.getInstancesOfType(ToolTask.class)) {
-            tasks.put(task.getTaskName(), task);
-        }
-
-        ToolsRunner runner = new ToolsRunner(tasks);
-        if (args == null || args.length == 0) {
-            runner.promptAndExecuteTask();
-        } else {
-            runner.executeAutomaticTasks(args);
-        }
-    }
-
-    private void promptAndExecuteTask() {
-        System.out.println("The following tasks are available:");
-        for (String key : tasks.keySet()) {
-            System.out.println("- " + key);
-        }
-
-        System.out.println("Please enter the task to run:");
-        Scanner scanner = new Scanner(System.in);
-        String inputTask = scanner.nextLine();
-
-        ToolTask task = tasks.get(inputTask);
-        if (task != null) {
-            task.execute(scanner);
-        } else {
-            System.out.println("Unknown task");
-        }
-        scanner.close();
-    }
-
-    private void executeAutomaticTasks(String... requests) {
-        for (String taskName : requests) {
-            ToolTask task = tasks.get(taskName);
-            if (task == null) {
-                System.out.format("Unknown task '%s'%n", taskName);
-            } else if (task instanceof AutoToolTask) {
-                ((AutoToolTask) task).executeDefault();
-            } else {
-                System.out.format("Task '%s' cannot be run on command line%n", taskName);
-            }
-        }
-    }
-}
diff --git a/src/test/java/tools/bathelpers/README.md b/src/test/java/tools/bathelpers/README.md
deleted file mode 100644
index ff119cd1..00000000
--- a/src/test/java/tools/bathelpers/README.md
+++ /dev/null
@@ -1,21 +0,0 @@
-## Bat Helpers
-Collection of .bat files to quickly perform some frequent development tasks.
-They allow you to quickly build the project and to move the generated JAR to
-the plugins folder of your test server.
-
-### Setup
-1. Copy the files into a new, convenient directory
-2. Open setvars.bat with a text editor and add the correct directories
-3. Open `cmd` and navigate to your _bathelpers_ folder (`cd C:\path\the\folder`)
-4. Type `list_files.bat` (Hint: Type `l` and hit Tab) to see the available tasks
-
-### Example use case
-1. After writing changes, `build_project` to build project
-2. `move_plugin` moves the JAR file to the plugin folder
-3. `run_server` to start the server with the fresh JAR
-4. Problem detected, stop the server
-5. Make a small change, use `quick_build` and `move_plugin` to update
-6. Verify the change again on the server: `run_server`
-
-All files start with a different letter, so you can conveniently type the
-first letter and then complete with Tab.
diff --git a/src/test/java/tools/bathelpers/build_project.bat b/src/test/java/tools/bathelpers/build_project.bat
deleted file mode 100644
index f30ea024..00000000
--- a/src/test/java/tools/bathelpers/build_project.bat
+++ /dev/null
@@ -1,6 +0,0 @@
-: Build the project normally
-if "%jarfile%" == "" (
-  call setvars.bat
-)
-
-mvn clean install -f "%pomfile%" -B
diff --git a/src/test/java/tools/bathelpers/freshen_jar.bat b/src/test/java/tools/bathelpers/freshen_jar.bat
deleted file mode 100644
index 3eba26db..00000000
--- a/src/test/java/tools/bathelpers/freshen_jar.bat
+++ /dev/null
@@ -1,5 +0,0 @@
-: Shortcut for quickbuild / move to plugins / run server
-
-call quick_build.bat
-call move_plugin.bat
-call run_server.bat
diff --git a/src/test/java/tools/bathelpers/list_files.bat b/src/test/java/tools/bathelpers/list_files.bat
deleted file mode 100644
index f0100fa8..00000000
--- a/src/test/java/tools/bathelpers/list_files.bat
+++ /dev/null
@@ -1,2 +0,0 @@
-: List all bat files in the directory
-dir /B *.bat
\ No newline at end of file
diff --git a/src/test/java/tools/bathelpers/move_plugin.bat b/src/test/java/tools/bathelpers/move_plugin.bat
deleted file mode 100644
index ac89c05f..00000000
--- a/src/test/java/tools/bathelpers/move_plugin.bat
+++ /dev/null
@@ -1,10 +0,0 @@
-: Moves the AuthMe JAR file to the plugins folder of the test server
-if "%jarfile%" == "" (
-  call setvars.bat
-)
-
-if exist %jarfile% (
-  xcopy %jarfile% %plugins% /y
-) else (
-  echo Target file not found: '%jarfile%'
-)
diff --git a/src/test/java/tools/bathelpers/quick_build.bat b/src/test/java/tools/bathelpers/quick_build.bat
deleted file mode 100644
index a3624fcd..00000000
--- a/src/test/java/tools/bathelpers/quick_build.bat
+++ /dev/null
@@ -1,6 +0,0 @@
-: Build quickly without cleaning or testing
-if "%jarfile%" == "" (
-  call setvars.bat
-)
-
-mvn install -o -f "%pomfile%" -Dmaven.test.skip -PskipJavadocGeneration
diff --git a/src/test/java/tools/bathelpers/run_server.bat b/src/test/java/tools/bathelpers/run_server.bat
deleted file mode 100644
index 7ab956fc..00000000
--- a/src/test/java/tools/bathelpers/run_server.bat
+++ /dev/null
@@ -1,9 +0,0 @@
-: Start the Minecraft server
-if "%jarfile%" == "" (
-  call setvars.bat
-)
-
-cd "%server%"
-call java -Xmx1024M -Xms1024M -jar spigot_server.jar
-cd "%batdir%"
-dir /B *.bat
\ No newline at end of file
diff --git a/src/test/java/tools/bathelpers/setvars.bat b/src/test/java/tools/bathelpers/setvars.bat
deleted file mode 100644
index e8ba9ba1..00000000
--- a/src/test/java/tools/bathelpers/setvars.bat
+++ /dev/null
@@ -1,14 +0,0 @@
-: The folder in which these .bat files are located
-SET batdir=C:\your\path\AUTHME_DEV\bathelpers\
-
-: The location of the generated JAR file
-SET jarfile=C:\Users\yourname\IdeaProjects\AuthMeReloaded\target\AuthMe-5.2-SNAPSHOT.jar
-
-: The location of the pom.xml file of the project
-SET pomfile=C:\Users\yourname\IdeaProjects\AuthMeReloaded\pom.xml
-
-: The folder in which the server is located
-SET server=C:\your\path\AUTHME_DEV\spigot-server\
-
-: The location of the plugins folder of the Minecraft server
-SET plugins=%server%\plugins
diff --git a/src/test/java/tools/checktestmocks/CheckTestMocks.java b/src/test/java/tools/checktestmocks/CheckTestMocks.java
deleted file mode 100644
index 9af3ae04..00000000
--- a/src/test/java/tools/checktestmocks/CheckTestMocks.java
+++ /dev/null
@@ -1,113 +0,0 @@
-package tools.checktestmocks;
-
-import com.google.common.collect.Sets;
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import org.mockito.Mock;
-import tools.utils.AutoToolTask;
-import tools.utils.InjectorUtils;
-
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-/**
- * Task checking if all tests' {@code @Mock} fields have a corresponding
- * {@code @Inject} field in the class they are testing.
- */
-public class CheckTestMocks implements AutoToolTask {
-
-    private List<String> errors = new ArrayList<>();
-
-    @Override
-    public String getTaskName() {
-        return "checkTestMocks";
-    }
-
-    @Override
-    public void executeDefault() {
-        ClassCollector collector = new ClassCollector(TestHelper.TEST_SOURCES_FOLDER, TestHelper.PROJECT_ROOT);
-        for (Class<?> clazz : collector.collectClasses(c -> isTestClassWithMocks(c))) {
-            checkClass(clazz);
-        }
-        System.out.println(String.join("\n", errors));
-    }
-
-    /**
-     * Checks the given test class' @Mock fields against the corresponding production class' @Inject fields.
-     *
-     * @param testClass the test class to verify
-     */
-    private void checkClass(Class<?> testClass) {
-        Class<?> realClass = returnRealClass(testClass);
-        if (realClass != null) {
-            Set<Class<?>> mockFields = getMocks(testClass);
-            Set<Class<?>> injectFields = InjectorUtils.getDependencies(realClass);
-            if (injectFields == null) {
-                addErrorEntry(testClass, "Could not find instantiation method");
-            } else if (!injectFields.containsAll(mockFields)) {
-                addErrorEntry(testClass, "Error - Found the following mocks absent as @Inject: "
-                    + formatClassList(Sets.difference(mockFields, injectFields)));
-            } else if (!mockFields.containsAll(injectFields)) {
-                addErrorEntry(testClass, "Info - Found @Inject fields which are not present as @Mock: "
-                    + formatClassList(Sets.difference(injectFields, mockFields)));
-            }
-        }
-    }
-
-    private void addErrorEntry(Class<?> clazz, String message) {
-        errors.add(clazz.getSimpleName() + ": " + message);
-    }
-
-    private static Set<Class<?>> getMocks(Class<?> clazz) {
-        Set<Class<?>> result = new HashSet<>();
-        for (Field field : clazz.getDeclaredFields()) {
-            if (field.isAnnotationPresent(Mock.class)) {
-                result.add(field.getType());
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Returns the production class ("real class") corresponding to the given test class.
-     * Returns null if the production class could not be mapped or loaded.
-     *
-     * @param testClass the test class to find the corresponding production class for
-     * @return production class, or null if not found
-     */
-    private static Class<?> returnRealClass(Class<?> testClass) {
-        String testClassName = testClass.getName();
-        String realClassName = testClassName.replaceAll("(Integration|Consistency)?Test$", "");
-        if (realClassName.equals(testClassName)) {
-            System.out.format("%s doesn't match typical test class naming pattern.%n", testClassName);
-            return null;
-        }
-        try {
-            return CheckTestMocks.class.getClassLoader().loadClass(realClassName);
-        } catch (ClassNotFoundException e) {
-            System.out.format("Real class '%s' not found for test class '%s'%n", realClassName, testClassName);
-            return null;
-        }
-    }
-
-    private static boolean isTestClassWithMocks(Class<?> clazz) {
-        for (Field field : clazz.getDeclaredFields()) {
-            if (field.isAnnotationPresent(Mock.class)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    private static String formatClassList(Collection<Class<?>> coll) {
-        return coll.stream()
-            .map(Class::getSimpleName)
-            .collect(Collectors.joining(", "));
-    }
-
-}
diff --git a/src/test/java/tools/dependencygraph/DrawDependency.java b/src/test/java/tools/dependencygraph/DrawDependency.java
deleted file mode 100644
index 40a3b6b2..00000000
--- a/src/test/java/tools/dependencygraph/DrawDependency.java
+++ /dev/null
@@ -1,213 +0,0 @@
-package tools.dependencygraph;
-
-import ch.jalu.injector.context.ObjectIdentifier;
-import ch.jalu.injector.factory.Factory;
-import ch.jalu.injector.factory.SingletonStore;
-import ch.jalu.injector.handlers.instantiation.Resolution;
-import ch.jalu.injector.handlers.instantiation.StandardInjectionProvider;
-import ch.jalu.injector.utils.ReflectionUtils;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Multimap;
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.command.ExecutableCommand;
-import fr.xephi.authme.command.executable.authme.debug.DebugCommand;
-import fr.xephi.authme.data.limbo.persistence.LimboPersistence;
-import fr.xephi.authme.datasource.converter.Converter;
-import fr.xephi.authme.initialization.DataFolder;
-import fr.xephi.authme.process.AsynchronousProcess;
-import fr.xephi.authme.process.SynchronousProcess;
-import fr.xephi.authme.process.register.executors.RegistrationExecutor;
-import fr.xephi.authme.security.crypts.EncryptionMethod;
-import org.bukkit.event.Listener;
-import tools.utils.InjectorUtils;
-import tools.utils.ToolTask;
-import tools.utils.ToolsConstants;
-
-import java.io.IOException;
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Scanner;
-
-/**
- * Creates a DOT file of the dependencies in AuthMe classes.
- */
-public class DrawDependency implements ToolTask {
-
-    private static final String DOT_FILE = ToolsConstants.TOOLS_SOURCE_ROOT + "dependencygraph/graph.dot";
-
-    private static final List<Class<?>> SUPER_TYPES = buildSuperTypesList();
-
-    /** Annotation types by which dependencies are identified. */
-    private static final List<Class<? extends Annotation>> ANNOTATION_TYPES = ImmutableList.of(DataFolder.class);
-
-    private boolean mapToSupertype;
-    // Map with the graph's nodes: value is one of the key's dependencies
-    private Multimap<Class<?>, String> foundDependencies = HashMultimap.create();
-
-    @Override
-    public String getTaskName() {
-        return "drawDependencyGraph";
-    }
-
-    @Override
-    public void execute(Scanner scanner) {
-        System.out.println("Summarize classes to their generic super type where applicable?");
-        mapToSupertype = "y".equalsIgnoreCase(scanner.nextLine());
-
-        // Gather all connections
-        ClassCollector collector = new ClassCollector(TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT);
-        for (Class<?> clazz : collector.collectClasses()) {
-            processClass(clazz);
-        }
-
-        // Prompt user for simplification of graph
-        System.out.println("Do you want to remove classes that are not used as dependency elsewhere?");
-        System.out.println("Specify the number of times to do this: [0=keep all]");
-        int stripVerticesCount;
-        try {
-            stripVerticesCount = Integer.valueOf(scanner.nextLine());
-        } catch (NumberFormatException e) {
-            stripVerticesCount = 0;
-        }
-
-        // Perform simplification as per user's wish
-        for (int i = 0; i < stripVerticesCount; ++i) {
-            stripNodesWithNoOutgoingEdges();
-        }
-
-        // Create dot file content
-        final String pattern = "\t\"%s\" -> \"%s\";";
-        String dotFile = "";
-        for (Map.Entry<Class<?>, String> entry : foundDependencies.entries()) {
-            dotFile += "\n" + String.format(pattern, entry.getValue(), entry.getKey().getSimpleName());
-        }
-
-        // Write dot file
-        try {
-            Files.write(Paths.get(DOT_FILE), ("digraph G {\n" + dotFile + "\n}").getBytes());
-        } catch (IOException e) {
-            throw new IllegalStateException(e);
-        }
-        System.out.println("Graph file written");
-        System.out.format("Run 'dot -Tpng %s -o graph.png' to generate image (requires GraphViz)%n", DOT_FILE);
-    }
-
-    private void processClass(Class<?> clazz) {
-        List<String> dependencies = getDependencies(clazz);
-        if (dependencies != null) {
-            foundDependencies.putAll(mapToSuper(clazz), dependencies);
-        }
-    }
-
-    private Class<?> mapToSuper(Class<?> clazz) {
-        if (!mapToSupertype || clazz == null) {
-            return clazz;
-        }
-        for (Class<?> parent : SUPER_TYPES) {
-            if (parent.isAssignableFrom(clazz)) {
-                return parent;
-            }
-        }
-        return clazz;
-    }
-
-    /**
-     * Returns the parameter of generic container classes, otherwise the input class.
-     * This is interesting so that a dependency in a class to {@code Factory<Foo>} is
-     * rendered as a dependency to {@code Foo}, not to {@code Factory}.
-     *
-     * @param genericType generic type of the dependency
-     * @return the class to use to render the dependency
-     */
-    private Class<?> unwrapGenericClass(Type genericType) {
-        if (genericType == Factory.class || genericType == SingletonStore.class) {
-            Class<?> parameterType = ReflectionUtils.getGenericType(genericType);
-            Objects.requireNonNull(parameterType,
-                "Parameter type for '" + genericType + "' should be a concrete class");
-            return parameterType;
-        }
-        return InjectorUtils.convertToClass(genericType);
-    }
-
-    private List<String> getDependencies(Class<?> clazz) {
-        Resolution<?> instantiation = new StandardInjectionProvider().safeGet(clazz);
-        return instantiation == null ? null : formatInjectionDependencies(instantiation);
-    }
-
-    /**
-     * Formats the dependencies returned by the given injection appropriately:
-     * if the dependency has an annotation, the annotation will be returned;
-     * otherwise the class name.
-     *
-     * @param injection the injection whose dependencies should be formatted
-     * @return list of dependencies in a friendly format
-     */
-    private List<String> formatInjectionDependencies(Resolution<?> injection) {
-        List<ObjectIdentifier> dependencies = injection.getDependencies();
-        List<String> result = new ArrayList<>(dependencies.size());
-        for (ObjectIdentifier dependency : dependencies) {
-            Class<?> annotation = getRelevantAnnotationClass(dependency.getAnnotations());
-            if (annotation != null) {
-                result.add("@" + annotation.getSimpleName());
-            } else {
-                Class<?> clazz = unwrapGenericClass(dependency.getType());
-                result.add(mapToSuper(clazz).getSimpleName());
-            }
-        }
-        return result;
-    }
-
-    private static Class<? extends Annotation> getRelevantAnnotationClass(List<Annotation> annotations) {
-        for (Annotation annotation : annotations) {
-            if (ANNOTATION_TYPES.contains(annotation.annotationType())) {
-                return annotation.annotationType();
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Removes all vertices in the graph that have no outgoing edges, i.e. all classes
-     * in the graph that only receive dependencies but are not used as a dependency anywhere.
-     * This process can be repeated multiple times.
-     */
-    private void stripNodesWithNoOutgoingEdges() {
-        Map<String, Boolean> dependencies = new HashMap<>();
-        for (Map.Entry<Class<?>, String> entry : foundDependencies.entries()) {
-            final String className = entry.getKey().getSimpleName();
-            dependencies.put(className, Boolean.FALSE);
-            dependencies.put(entry.getValue(), Boolean.TRUE);
-        }
-
-        foundDependencies.keys().removeIf(
-            clazz -> Boolean.FALSE.equals(dependencies.get(clazz.getSimpleName())));
-    }
-
-    /**
-     * @return list of classes in AuthMe which have multiple extensions
-     */
-    private static List<Class<?>> buildSuperTypesList() {
-        try {
-            // Get package-private classes
-            Class<?> debugSectionClass = Class.forName(
-                DebugCommand.class.getPackage().getName() + ".DebugSection");
-            Class<?> limboPersistenceClass = Class.forName(
-                LimboPersistence.class.getPackage().getName() + ".LimboPersistenceHandler");
-
-            return ImmutableList.of(ExecutableCommand.class, SynchronousProcess.class, AsynchronousProcess.class,
-                EncryptionMethod.class, Converter.class, Listener.class, RegistrationExecutor.class, debugSectionClass,
-                limboPersistenceClass);
-        } catch (ClassNotFoundException e) {
-            throw new IllegalStateException(e);
-        }
-    }
-}
diff --git a/src/test/java/tools/docs/UpdateDocsTask.java b/src/test/java/tools/docs/UpdateDocsTask.java
deleted file mode 100644
index 84f723c6..00000000
--- a/src/test/java/tools/docs/UpdateDocsTask.java
+++ /dev/null
@@ -1,51 +0,0 @@
-package tools.docs;
-
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.TestHelper;
-import tools.utils.AutoToolTask;
-import tools.utils.ToolTask;
-
-import java.util.List;
-import java.util.Scanner;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-
-/**
- * Task that runs all tasks which update files in the docs folder.
- */
-public class UpdateDocsTask implements AutoToolTask {
-
-    @Override
-    public String getTaskName() {
-        return "updateDocs";
-    }
-
-    @Override
-    public void execute(final Scanner scanner) {
-        executeTasks(task -> task.execute(scanner));
-    }
-
-    @Override
-    public void executeDefault() {
-        executeTasks(task -> {
-            if (task instanceof AutoToolTask) {
-                ((AutoToolTask) task).executeDefault();
-            }
-        });
-    }
-
-    private void executeTasks(Consumer<ToolTask> taskRunner) {
-        for (ToolTask task : getDocTasks()) {
-            System.out.println("\nRunning " + task.getTaskName() + "\n-------------------");
-            taskRunner.accept(task);
-        }
-    }
-
-    private List<ToolTask> getDocTasks() {
-        ClassCollector classCollector =
-            new ClassCollector(TestHelper.TEST_SOURCES_FOLDER, "tools/docs");
-        return classCollector.getInstancesOfType(ToolTask.class).stream()
-            .filter(task -> task.getClass() != getClass())
-            .collect(Collectors.toList());
-    }
-}
diff --git a/src/test/java/tools/docs/commands/CommandPageCreater.java b/src/test/java/tools/docs/commands/CommandPageCreater.java
deleted file mode 100644
index ff1500a7..00000000
--- a/src/test/java/tools/docs/commands/CommandPageCreater.java
+++ /dev/null
@@ -1,72 +0,0 @@
-package tools.docs.commands;
-
-import fr.xephi.authme.command.CommandArgumentDescription;
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.CommandInitializer;
-import fr.xephi.authme.command.CommandUtils;
-import fr.xephi.authme.permission.PermissionNode;
-import tools.utils.AutoToolTask;
-import tools.utils.FileIoUtils;
-import tools.utils.TagValue.NestedTagValue;
-import tools.utils.TagValueHolder;
-import tools.utils.ToolsConstants;
-
-import java.util.Collection;
-
-public class CommandPageCreater implements AutoToolTask {
-
-    private static final String OUTPUT_FILE = ToolsConstants.DOCS_FOLDER + "commands.md";
-
-    @Override
-    public String getTaskName() {
-        return "createCommandPage";
-    }
-
-    @Override
-    public void executeDefault() {
-        CommandInitializer commandInitializer = new CommandInitializer();
-        final Collection<CommandDescription> baseCommands = commandInitializer.getCommands();
-        NestedTagValue commandTags = new NestedTagValue();
-        addCommandsInfo(commandTags, baseCommands);
-
-        FileIoUtils.generateFileFromTemplate(
-            ToolsConstants.TOOLS_SOURCE_ROOT + "docs/commands/commands.tpl.md",
-            OUTPUT_FILE,
-            TagValueHolder.create().put("commands", commandTags));
-        System.out.println("Wrote to '" + OUTPUT_FILE + "' with " + baseCommands.size() + " base commands.");
-    }
-
-    private static void addCommandsInfo(NestedTagValue commandTags, Collection<CommandDescription> commands) {
-        for (CommandDescription command : commands) {
-            TagValueHolder tags = TagValueHolder.create()
-                .put("command", CommandUtils.constructCommandPath(command))
-                .put("description", command.getDetailedDescription())
-                .put("arguments", formatArguments(command.getArguments()))
-                .put("permissions", formatPermissions(command.getPermission()));
-            commandTags.add(tags);
-
-            if (!command.getChildren().isEmpty()) {
-                addCommandsInfo(commandTags, command.getChildren());
-            }
-        }
-    }
-
-    private static String formatPermissions(PermissionNode permission) {
-        if (permission == null) {
-            return "";
-        } else {
-            return permission.getNode();
-        }
-    }
-
-    private static String formatArguments(Iterable<CommandArgumentDescription> arguments) {
-        StringBuilder result = new StringBuilder();
-        for (CommandArgumentDescription argument : arguments) {
-            String argumentName = argument.isOptional()
-                ? "[" + argument.getName() + "]"
-                : "&lt;" + argument.getName() + ">";
-            result.append(" ").append(argumentName);
-        }
-        return result.toString();
-    }
-}
diff --git a/src/test/java/tools/docs/commands/commands.tpl.md b/src/test/java/tools/docs/commands/commands.tpl.md
deleted file mode 100644
index 61018634..00000000
--- a/src/test/java/tools/docs/commands/commands.tpl.md
+++ /dev/null
@@ -1,13 +0,0 @@
-<!-- {gen_warning} -->
-<!-- File auto-generated on {gen_date}. See docs/commands/commands.tpl.md -->
-
-## AuthMe Commands
-You can use the following commands to use the features of AuthMe. Mandatory arguments are marked with `< >`
-brackets; optional arguments are enclosed in square brackets (`[ ]`).
-
-[#commands]
-  - **{command}**{arguments}: {description}[permissions]
-  <br />Requires `{permissions}`[/permissions]
-[/#commands]
-
-{gen_footer}
diff --git a/src/test/java/tools/docs/config/UpdateConfigPageTask.java b/src/test/java/tools/docs/config/UpdateConfigPageTask.java
deleted file mode 100644
index d82cda19..00000000
--- a/src/test/java/tools/docs/config/UpdateConfigPageTask.java
+++ /dev/null
@@ -1,50 +0,0 @@
-package tools.docs.config;
-
-import ch.jalu.configme.SettingsManager;
-import ch.jalu.configme.SettingsManagerBuilder;
-import fr.xephi.authme.settings.properties.AuthMeSettingsRetriever;
-import fr.xephi.authme.util.FileUtils;
-import tools.utils.AutoToolTask;
-import tools.utils.FileIoUtils;
-import tools.utils.TagValueHolder;
-import tools.utils.ToolsConstants;
-
-import java.io.File;
-import java.io.IOException;
-
-/**
- * Task for updating the config docs page.
- */
-public class UpdateConfigPageTask implements AutoToolTask {
-
-    private static final String TEMPLATE_FILE = ToolsConstants.TOOLS_SOURCE_ROOT + "docs/config/config.tpl.md";
-    private static final String OUTPUT_FILE = ToolsConstants.DOCS_FOLDER + "config.md";
-
-    @Override
-    public String getTaskName() {
-        return "updateConfigPage";
-    }
-
-    @Override
-    public void executeDefault() {
-        File config = null;
-        try {
-            // Create empty temporary .yml file and save the config to it
-            config = File.createTempFile("authme-config-", ".yml");
-            SettingsManager settingsManager = SettingsManagerBuilder.withYamlFile(config)
-                .configurationData(AuthMeSettingsRetriever.buildConfigurationData())
-                .create();
-            settingsManager.save();
-
-            // Get the contents and generate template file
-            TagValueHolder tagValueHolder = TagValueHolder.create()
-                .put("config", FileIoUtils.readFromFile(config.toPath()));
-            FileIoUtils.generateFileFromTemplate(TEMPLATE_FILE, OUTPUT_FILE, tagValueHolder);
-            System.out.println("Wrote to '" + OUTPUT_FILE + "'");
-        } catch (IOException e) {
-            throw new IllegalStateException(e);
-        } finally {
-            FileUtils.delete(config);
-        }
-    }
-}
diff --git a/src/test/java/tools/docs/config/config.tpl.md b/src/test/java/tools/docs/config/config.tpl.md
deleted file mode 100644
index 1de5c99d..00000000
--- a/src/test/java/tools/docs/config/config.tpl.md
+++ /dev/null
@@ -1,16 +0,0 @@
-<!-- {gen_warning} -->
-<!-- File auto-generated on {gen_date}. See docs/config/config.tpl.md -->
-
-## AuthMe Configuration
-The first time you run AuthMe it will create a config.yml file in the plugins/AuthMe folder,
-with which you can configure various settings. The following is the initial contents of
-the generated config.yml file.
-
-```yml
-{config}
-```
-
-To change settings on a running server, save your changes to config.yml and use
-`/authme reload`.
-
-{gen_footer}
diff --git a/src/test/java/tools/docs/hashmethods/EncryptionMethodInfoGatherer.java b/src/test/java/tools/docs/hashmethods/EncryptionMethodInfoGatherer.java
deleted file mode 100644
index 5972ba74..00000000
--- a/src/test/java/tools/docs/hashmethods/EncryptionMethodInfoGatherer.java
+++ /dev/null
@@ -1,177 +0,0 @@
-package tools.docs.hashmethods;
-
-import ch.jalu.injector.Injector;
-import ch.jalu.injector.InjectorBuilder;
-import com.google.common.base.Strings;
-import com.google.common.collect.ImmutableSet;
-import fr.xephi.authme.ConsoleLogger;
-import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.security.HashAlgorithm;
-import fr.xephi.authme.security.crypts.Argon2;
-import fr.xephi.authme.security.crypts.EncryptionMethod;
-import fr.xephi.authme.security.crypts.HexSaltedMethod;
-import fr.xephi.authme.security.crypts.description.AsciiRestricted;
-import fr.xephi.authme.security.crypts.description.HasSalt;
-import fr.xephi.authme.security.crypts.description.Recommendation;
-import fr.xephi.authme.settings.Settings;
-
-import java.lang.annotation.Annotation;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.logging.Logger;
-
-import static org.mockito.Mockito.mock;
-
-/**
- * Gathers information on {@link EncryptionMethod} implementations based on
- * the annotations in {@link fr.xephi.authme.security.crypts.description}.
- */
-public class EncryptionMethodInfoGatherer {
-
-    private static final Set<Class<? extends Annotation>> RELEVANT_ANNOTATIONS =
-        ImmutableSet.of(HasSalt.class, Recommendation.class, AsciiRestricted.class);
-
-    private static Injector injector = createInitializer();
-
-    private Map<HashAlgorithm, MethodDescription> descriptions;
-
-    public EncryptionMethodInfoGatherer() {
-        ConsoleLogger.initialize(Logger.getAnonymousLogger(), null); // set logger because of Argon2.isLibraryLoaded()
-        descriptions = new LinkedHashMap<>();
-        constructDescriptions();
-    }
-
-    public Map<HashAlgorithm, MethodDescription> getDescriptions() {
-        return descriptions;
-    }
-
-    private void constructDescriptions() {
-        for (HashAlgorithm algorithm : HashAlgorithm.values()) {
-            if (algorithm.getClazz() != null && !algorithm.getClazz().isAnnotationPresent(Deprecated.class)) {
-                MethodDescription description = createDescription(algorithm);
-                descriptions.put(algorithm, description);
-            }
-        }
-    }
-
-    /**
-     * Creates a description of the given hash algorithm based on its annotations.
-     *
-     * @param algorithm the algorithm to describe
-     * @return description of the hash algorithm
-     */
-    private static MethodDescription createDescription(HashAlgorithm algorithm) {
-        Class<? extends EncryptionMethod> clazz = algorithm.getClazz();
-        EncryptionMethod method = createEncryptionMethod(clazz);
-        MethodDescription description = new MethodDescription(clazz);
-        description.setHashLength(method.computeHash("test", "user").getHash().length());
-        description.setHasSeparateSalt(method.hasSeparateSalt());
-
-        Map<Class<?>, Annotation> annotationMap = gatherAnnotations(clazz);
-        if (annotationMap.containsKey(HasSalt.class)) {
-            setSaltInformation(description, returnTyped(annotationMap, HasSalt.class), method);
-        }
-        if (annotationMap.containsKey(Recommendation.class)) {
-            description.setUsage(returnTyped(annotationMap, Recommendation.class).value());
-        }
-        if (annotationMap.containsKey(AsciiRestricted.class)) {
-            description.setAsciiRestricted(true);
-        }
-        return description;
-    }
-
-    private static EncryptionMethod createEncryptionMethod(Class<? extends EncryptionMethod> clazz) {
-        if (clazz == Argon2.class && !Argon2.isLibraryLoaded()) {
-            // The library for Argon2 isn't installed, so override the hash implementation to avoid using the library
-            return new Argon2DummyExtension();
-        }
-
-        EncryptionMethod method = injector.createIfHasDependencies(clazz);
-        if (method == null) {
-            throw new NullPointerException("Failed to instantiate '" + clazz + "'. Is a dependency missing?");
-        }
-        return method;
-    }
-
-    private static Map<Class<?>, Annotation> gatherAnnotations(Class<?> methodClass) {
-        // Note ljacqu 20151231: The map could be Map<Class<? extends Annotation>, Annotation> and it has the constraint
-        // that for a key Class<T>, the value is of type T. We write a simple "Class<?>" for brevity.
-        Map<Class<?>, Annotation> collection = new HashMap<>();
-        Class<?> currentMethodClass = methodClass;
-        while (currentMethodClass != null) {
-            getRelevantAnnotations(currentMethodClass, collection);
-            currentMethodClass = getSuperClass(currentMethodClass);
-        }
-        return collection;
-    }
-
-    // Parameters could be Class<? extends EncryptionMethod>; Map<Class<? extends Annotation>, Annotation>
-    // but the constraint doesn't have any technical relevance, so just clutters the code
-    private static void getRelevantAnnotations(Class<?> methodClass, Map<Class<?>, Annotation> collection) {
-        for (Annotation annotation : methodClass.getAnnotations()) {
-            if (RELEVANT_ANNOTATIONS.contains(annotation.annotationType())
-                && !collection.containsKey(annotation.annotationType())) {
-                collection.put(annotation.annotationType(), annotation);
-            }
-        }
-    }
-
-    /**
-     * Returns the super class of the given encryption method if it is also of EncryptionMethod type.
-     * (Anything beyond EncryptionMethod is not of interest.)
-     *
-     * @param methodClass the class to process
-     * @return the super class of the given class if it is also an EncryptionMethod type, otherwise null
-     */
-    private static Class<?> getSuperClass(Class<?> methodClass) {
-        Class<?> zuper = methodClass.getSuperclass();
-        if (EncryptionMethod.class.isAssignableFrom(zuper)) {
-            return zuper;
-        }
-        return null;
-    }
-
-    /**
-     * Set the salt information for the given encryption method and the found {@link HasSalt} annotation.
-     * Also gets the salt length from {@link HexSaltedMethod#getSaltLength()} for such instances.
-     *
-     * @param description The description to update
-     * @param hasSalt     The associated HasSalt annotation
-     * @param method      The encryption method
-     */
-    private static void setSaltInformation(MethodDescription description, HasSalt hasSalt, EncryptionMethod method) {
-        description.setSaltType(hasSalt.value());
-        if (hasSalt.length() != 0) {
-            description.setSaltLength(hasSalt.length());
-        } else if (method instanceof HexSaltedMethod) {
-            int saltLength = ((HexSaltedMethod) method).getSaltLength();
-            description.setSaltLength(saltLength);
-        }
-    }
-
-    // Convenience method for retrieving an annotation in a typed fashion.
-    // We know implicitly that the key of the map always corresponds to the type of the value
-    private static <T> T returnTyped(Map<Class<?>, Annotation> map, Class<T> key) {
-        return key.cast(map.get(key));
-    }
-
-    private static Injector createInitializer() {
-        Settings settings = mock(Settings.class);
-        TestHelper.returnDefaultsForAllProperties(settings);
-
-        // Limit instantiation to the crypts package only so any dependencies need to be passed explicitly
-        Injector injector = new InjectorBuilder().addDefaultHandlers("fr.xephi.authme.security.crypts").create();
-        injector.register(Settings.class, settings);
-        return injector;
-    }
-
-    private static final class Argon2DummyExtension extends Argon2 {
-        @Override
-        public String computeHash(String password) {
-            // Argon2 produces hashes of 96 characters -> return dummy value with this length
-            return Strings.repeat(".", 96);
-        }
-    }
-}
diff --git a/src/test/java/tools/docs/hashmethods/HashAlgorithmsDescriptionTask.java b/src/test/java/tools/docs/hashmethods/HashAlgorithmsDescriptionTask.java
deleted file mode 100644
index 2fd23415..00000000
--- a/src/test/java/tools/docs/hashmethods/HashAlgorithmsDescriptionTask.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package tools.docs.hashmethods;
-
-import fr.xephi.authme.security.HashAlgorithm;
-import tools.utils.AutoToolTask;
-import tools.utils.FileIoUtils;
-import tools.utils.TagValue.NestedTagValue;
-import tools.utils.TagValueHolder;
-import tools.utils.ToolsConstants;
-
-import java.util.Locale;
-import java.util.Map;
-
-/**
- * Task for generating the markdown page describing the AuthMe hash algorithms.
- *
- * @see fr.xephi.authme.security.HashAlgorithm
- */
-public class HashAlgorithmsDescriptionTask implements AutoToolTask {
-
-    private static final String CUR_FOLDER = ToolsConstants.TOOLS_SOURCE_ROOT + "docs/hashmethods/";
-    private static final String OUTPUT_FILE = ToolsConstants.DOCS_FOLDER + "hash_algorithms.md";
-
-    @Override
-    public void executeDefault() {
-        // Gather info and construct a row for each method
-        EncryptionMethodInfoGatherer infoGatherer = new EncryptionMethodInfoGatherer();
-        Map<HashAlgorithm, MethodDescription> descriptions = infoGatherer.getDescriptions();
-        final NestedTagValue methodRows = constructMethodRows(descriptions);
-
-        // Write to the docs file
-        TagValueHolder tags = TagValueHolder.create().put("algorithms", methodRows);
-        FileIoUtils.generateFileFromTemplate(CUR_FOLDER + "hash_algorithms.tpl.md", OUTPUT_FILE, tags);
-        System.out.println("Wrote to '" + OUTPUT_FILE + "'");
-    }
-
-    private static NestedTagValue constructMethodRows(Map<HashAlgorithm, MethodDescription> descriptions) {
-        NestedTagValue methodTags = new NestedTagValue();
-        for (Map.Entry<HashAlgorithm, MethodDescription> entry : descriptions.entrySet()) {
-            MethodDescription description = entry.getValue();
-            TagValueHolder tags = TagValueHolder.create()
-                .put("name",             asString(entry.getKey()))
-                .put("recommendation",   asString(description.getUsage()))
-                .put("hash_length",      asString(description.getHashLength()))
-                .put("ascii_restricted", asString(description.isAsciiRestricted()))
-                .put("salt_type",        asString(description.getSaltType()))
-                .put("salt_length",      asString(description.getSaltLength()))
-                .put("separate_salt",    asString(description.hasSeparateSalt()));
-            methodTags.add(tags);
-        }
-        return methodTags;
-    }
-
-    @Override
-    public String getTaskName() {
-        return "describeHashAlgos";
-    }
-
-    // ----
-    // String representations
-    // ----
-    private static String asString(boolean value) {
-        return value ? "Y" : "";
-    }
-
-    private static String asString(int value) {
-        return String.valueOf(value);
-    }
-
-    private static String asString(Integer value) {
-        if (value == null) {
-            return "";
-        }
-        return String.valueOf(value);
-    }
-
-    private static String asString(HashAlgorithm value) {
-        return value.toString();
-    }
-
-    private static <E extends Enum<E>> String asString(E value) {
-        if (value == null) {
-            return "";
-        }
-        // Get the enum name and replace something like "DO_NOT_USE" to "Do not use"
-        String enumName = value.toString().replace("_", " ");
-        return enumName.length() > 2
-            ? enumName.substring(0, 1) + enumName.substring(1).toLowerCase(Locale.ROOT)
-            : enumName;
-    }
-
-}
diff --git a/src/test/java/tools/docs/hashmethods/MethodDescription.java b/src/test/java/tools/docs/hashmethods/MethodDescription.java
deleted file mode 100644
index f4d8a255..00000000
--- a/src/test/java/tools/docs/hashmethods/MethodDescription.java
+++ /dev/null
@@ -1,85 +0,0 @@
-package tools.docs.hashmethods;
-
-import fr.xephi.authme.security.crypts.EncryptionMethod;
-import fr.xephi.authme.security.crypts.description.SaltType;
-import fr.xephi.authme.security.crypts.description.Usage;
-
-/**
- * Description of a {@link EncryptionMethod}.
- */
-public class MethodDescription {
-
-    /** The implementation class the description belongs to. */
-    private final Class<? extends EncryptionMethod> method;
-    /** The type of the salt that is used. */
-    private SaltType saltType;
-    /** The length of the salt for SaltType.TEXT salts. */
-    private Integer saltLength;
-    /** The usage recommendation. */
-    private Usage usage;
-    /** Whether or not the encryption method is restricted to ASCII characters for proper functioning. */
-    private boolean asciiRestricted;
-    /** Whether or not the encryption method requires its salt stored separately. */
-    private boolean hasSeparateSalt;
-    /** The length of the hash output, based on a test hash (i.e. assumes same length for all hashes.) */
-    private int hashLength;
-
-    public MethodDescription(Class<? extends EncryptionMethod> method) {
-        this.method = method;
-    }
-
-
-    // Trivial getters and setters
-    public Class<? extends EncryptionMethod> getMethod() {
-        return method;
-    }
-
-    public SaltType getSaltType() {
-        return saltType;
-    }
-
-    public void setSaltType(SaltType saltType) {
-        this.saltType = saltType;
-    }
-
-    public Integer getSaltLength() {
-        return saltLength;
-    }
-
-    public void setSaltLength(int saltLength) {
-        this.saltLength = saltLength;
-    }
-
-    public Usage getUsage() {
-        return usage;
-    }
-
-    public void setUsage(Usage usage) {
-        this.usage = usage;
-    }
-
-    public boolean isAsciiRestricted() {
-        return asciiRestricted;
-    }
-
-    public void setAsciiRestricted(boolean asciiRestricted) {
-        this.asciiRestricted = asciiRestricted;
-    }
-
-    public boolean hasSeparateSalt() {
-        return hasSeparateSalt;
-    }
-
-    public void setHasSeparateSalt(boolean hasSeparateSalt) {
-        this.hasSeparateSalt = hasSeparateSalt;
-    }
-
-    public int getHashLength() {
-        return hashLength;
-    }
-
-    public void setHashLength(int hashLength) {
-        this.hashLength = hashLength;
-    }
-
-}
diff --git a/src/test/java/tools/docs/hashmethods/hash_algorithms.tpl.md b/src/test/java/tools/docs/hashmethods/hash_algorithms.tpl.md
deleted file mode 100644
index bb3c8bef..00000000
--- a/src/test/java/tools/docs/hashmethods/hash_algorithms.tpl.md
+++ /dev/null
@@ -1,58 +0,0 @@
-<!-- {gen_warning} -->
-<!-- File auto-generated on {gen_date}. See docs/hashmethods/hash_algorithms.tpl.md -->
-
-## Hash Algorithms
-AuthMe supports the following hash algorithms for storing your passwords safely.
-
-
-Algorithm | Recommendation | Hash length | ASCII |     | Salt type | Length | Separate?
---------- | -------------- | ----------- | ----- | --- | --------- | ------ | ---------
-[#algorithms]
-{name} | {recommendation} | {hash_length} | {ascii_restricted} | | {salt_type} | {salt_length} | {separate_salt}
-[/#algorithms]CUSTOM |  |  |  |  |  |  |  |
-
-<!-- {gen_warning} -->
-
-### Columns
-#### Algorithm
-The algorithm is the hashing algorithm used to store passwords with. Default is SHA256 and is recommended.
-You can change the hashing algorithm in the config.yml: under `security`, locate `passwordHash`.
-
-#### Recommendation
-The recommendation lists our usage recommendation in terms of how secure it is (not how _well_ the algorithm works!).
-- Recommended: The hash algorithm appears to be cryptographically secure and is one we recommend.
-- Acceptable: There are safer algorithms that can be chosen but using the algorithm is generally OK.
-- Deprecated: Cannot be used anymore actively or in the near future.
-- Do not use: Hash algorithm isn't sufficiently secure. Use only if required to hook into another system.
-- Does not work: The algorithm does not work properly; do not use.
-
-#### Hash Length
-The length of the hashes the algorithm produces. Note that the hash length is not (primarily) indicative of
-whether an algorithm is secure or not.
-
-#### ASCII
-If denoted with a **y**, means that the algorithm is restricted to ASCII characters only, i.e. it will simply ignore
-"special characters" such as `ÿ` or `Â`. Note that we do not recommend the use of "special characters" in passwords.
-
-#### Salt Columns
-Before hashing, a _salt_ may be appended to the password to make the hash more secure. The following columns describe
-the salt the algorithm uses.
-<!-- {gen_warning} -->
-
-##### Salt Type
-We do not recommend the usage
-of any algorithm that doesn't use a randomly generated text as salt. This "salt type" column indicates what type of
-salt the algorithm uses:
-- Text: randomly generated text (see also the following column, "Length")
-- Username: the salt is constructed from the username (bad)
-- None: the algorithm uses no salt (bad)
-
-##### Length
-If applicable (salt type is "Text"), indicates the length of the generated salt. The longer the better.
-If this column is empty when the salt type is "Text", it typically means the salt length can be defined in config.yml.
-
-##### Separate
-If denoted with a **y**, it means that the salt is stored in a separate column in the database. This is neither good
-or bad.
-
-{gen_footer}
diff --git a/src/test/java/tools/docs/permissions/PermissionNodesGatherer.java b/src/test/java/tools/docs/permissions/PermissionNodesGatherer.java
deleted file mode 100644
index 0b17ebf6..00000000
--- a/src/test/java/tools/docs/permissions/PermissionNodesGatherer.java
+++ /dev/null
@@ -1,110 +0,0 @@
-package tools.docs.permissions;
-
-import fr.xephi.authme.ClassCollector;
-import fr.xephi.authme.permission.PermissionNode;
-import tools.utils.FileIoUtils;
-import tools.utils.ToolsConstants;
-
-import java.util.EnumSet;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
-/**
- * Gatherer to generate up-to-date lists of the AuthMe permission nodes.
- */
-public class PermissionNodesGatherer {
-
-    /**
-     * Regular expression that should match the JavaDoc comment above an enum, <i>including</i>
-     * the name of the enum value. The first group (i.e. {@code \\1}) should be the JavaDoc description;
-     * the second group should contain the enum value.
-     */
-    private static final Pattern JAVADOC_WITH_ENUM_PATTERN = Pattern.compile(
-        "/\\*\\*(\\s+\\*)?"    // Match starting '/**' and optional whitespace with a '*'
-        + "(.*?)\\s+\\*/"      // Capture everything until we encounter '*/'
-        + "\\s+([A-Z_]+)\\("); // Match the enum name (e.g. 'LOGIN'), until before the first '('
-
-    /**
-     * List of all enum classes that implement the {@link PermissionNode} interface.
-     */
-    private List<Class<? extends PermissionNode>> permissionClasses;
-
-    /**
-     * Return a sorted collection of all permission nodes, including its JavaDoc description.
-     *
-     * @param <T> permission node enum type
-     * @return Ordered map whose keys are the permission nodes and the values the associated JavaDoc
-     */
-    @SuppressWarnings("unchecked")
-    public <T extends Enum<T> & PermissionNode> Map<String, String> gatherNodesWithJavaDoc() {
-        Map<String, String> result = new TreeMap<>();
-        result.put("authme.admin.*", "Give access to all admin commands.");
-        result.put("authme.player.*", "Permission to use all player (non-admin) commands.");
-        result.put("authme.player.email", "Grants all email permissions.");
-
-        getPermissionClasses().forEach(clz -> addDescriptionsForClass((Class<T>) clz, result));
-        return result;
-    }
-
-    /**
-     * Return all enum classes implementing the PermissionNode interface.
-     *
-     * @return all permission node enums
-     */
-    public List<Class<? extends PermissionNode>> getPermissionClasses() {
-        if (permissionClasses == null) {
-            ClassCollector classCollector = new ClassCollector(ToolsConstants.MAIN_SOURCE_ROOT, "");
-            permissionClasses = classCollector
-                .collectClasses(PermissionNode.class)
-                .stream()
-                .filter(Class::isEnum)
-                .collect(Collectors.toList());
-        }
-        return permissionClasses;
-    }
-
-    private <T extends Enum<T> & PermissionNode> void addDescriptionsForClass(Class<T> clazz,
-                                                                              Map<String, String> descriptions) {
-        String classSource = getSourceForClass(clazz);
-        Map<String, String> sourceDescriptions = extractJavaDocFromSource(classSource);
-
-        for (T perm : EnumSet.allOf(clazz)) {
-            String description = sourceDescriptions.get(perm.name());
-            if (description == null) {
-                System.out.println("Note: Could not retrieve description for "
-                    + clazz.getSimpleName() + "#" + perm.name());
-                description = "";
-            }
-            descriptions.put(perm.getNode(), description.trim());
-        }
-    }
-
-    private static Map<String, String> extractJavaDocFromSource(String source) {
-        Map<String, String> allMatches = new HashMap<>();
-        Matcher matcher = JAVADOC_WITH_ENUM_PATTERN.matcher(source);
-        while (matcher.find()) {
-            String description = matcher.group(2);
-            String enumValue = matcher.group(3);
-            allMatches.put(enumValue, description);
-        }
-        return allMatches;
-    }
-
-    /**
-     * Return the Java source code for the given implementation of {@link PermissionNode}.
-     *
-     * @param clazz The clazz to the get the source for
-     * @param <T> The concrete type
-     * @return Source code of the file
-     */
-    private static <T extends Enum<T> & PermissionNode> String getSourceForClass(Class<T> clazz) {
-        String classFile = ToolsConstants.MAIN_SOURCE_ROOT + clazz.getName().replace(".", "/") + ".java";
-        return FileIoUtils.readFromFile(classFile);
-    }
-
-}
diff --git a/src/test/java/tools/docs/permissions/PermissionsListWriter.java b/src/test/java/tools/docs/permissions/PermissionsListWriter.java
deleted file mode 100644
index 1e0e8abd..00000000
--- a/src/test/java/tools/docs/permissions/PermissionsListWriter.java
+++ /dev/null
@@ -1,47 +0,0 @@
-package tools.docs.permissions;
-
-import tools.utils.AutoToolTask;
-import tools.utils.FileIoUtils;
-import tools.utils.TagValue.NestedTagValue;
-import tools.utils.TagValueHolder;
-
-import java.util.Map;
-
-import static tools.utils.ToolsConstants.DOCS_FOLDER;
-import static tools.utils.ToolsConstants.TOOLS_SOURCE_ROOT;
-
-/**
- * Task responsible for formatting a permissions node list and
- * for writing it to a file if desired.
- */
-public class PermissionsListWriter implements AutoToolTask {
-
-    private static final String TEMPLATE_FILE = TOOLS_SOURCE_ROOT + "docs/permissions/permission_nodes.tpl.md";
-    private static final String PERMISSIONS_OUTPUT_FILE = DOCS_FOLDER + "permission_nodes.md";
-
-    @Override
-    public String getTaskName() {
-        return "writePermissionsList";
-    }
-
-    @Override
-    public void executeDefault() {
-        final NestedTagValue permissionsTagValue = generatePermissionsList();
-
-        TagValueHolder tags = TagValueHolder.create().put("nodes", permissionsTagValue);
-        FileIoUtils.generateFileFromTemplate(TEMPLATE_FILE, PERMISSIONS_OUTPUT_FILE, tags);
-        System.out.println("Wrote to '" + PERMISSIONS_OUTPUT_FILE + "'");
-    }
-
-    private static NestedTagValue generatePermissionsList() {
-        PermissionNodesGatherer gatherer = new PermissionNodesGatherer();
-        Map<String, String> permissions = gatherer.gatherNodesWithJavaDoc();
-        NestedTagValue permissionTags = new NestedTagValue();
-        for (Map.Entry<String, String> entry : permissions.entrySet()) {
-            permissionTags.add(TagValueHolder.create()
-                .put("node", entry.getKey())
-                .put("description", entry.getValue()));
-        }
-        return permissionTags;
-    }
-}
diff --git a/src/test/java/tools/docs/permissions/permission_nodes.tpl.md b/src/test/java/tools/docs/permissions/permission_nodes.tpl.md
deleted file mode 100644
index 8987f08b..00000000
--- a/src/test/java/tools/docs/permissions/permission_nodes.tpl.md
+++ /dev/null
@@ -1,11 +0,0 @@
-<!-- {gen_warning} -->
-<!-- File auto-generated on {gen_date}. See docs/permissions/permission_nodes.tpl.md -->
-
-## AuthMe Permission Nodes
-The following are the permission nodes that are currently supported by the latest dev builds.
-
-[#nodes]
-  - **{node}** – {description}
-[/#nodes]
-
-{gen_footer}
diff --git a/src/test/java/tools/docs/translations/TranslationPageGenerator.java b/src/test/java/tools/docs/translations/TranslationPageGenerator.java
deleted file mode 100644
index 8997765f..00000000
--- a/src/test/java/tools/docs/translations/TranslationPageGenerator.java
+++ /dev/null
@@ -1,143 +0,0 @@
-package tools.docs.translations;
-
-import com.google.common.collect.ImmutableMap;
-import tools.docs.translations.TranslationsGatherer.TranslationInfo;
-import tools.utils.AutoToolTask;
-import tools.utils.FileIoUtils;
-import tools.utils.TagValue.NestedTagValue;
-import tools.utils.TagValueHolder;
-import tools.utils.ToolsConstants;
-
-import java.util.Arrays;
-import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-/**
- * Generates the translations page in docs.
- */
-public class TranslationPageGenerator implements AutoToolTask {
-
-    private static final String DOCS_PAGE = ToolsConstants.DOCS_FOLDER + "translations.md";
-    private static final String TEMPLATE_FILE =
-        ToolsConstants.TOOLS_SOURCE_ROOT + "docs/translations/translations.tpl.md";
-    private static final Map<String, String> LANGUAGE_NAMES = buildLanguageNames();
-
-    // Color configuration for the bars shown next to translation percentage
-    /**
-     * Percentage threshold under which the color will be computed from COLOR_0 to COLOR_1;
-     * above which COLOR_1 to COLOR_2 is used.
-     */
-    private static final int COLOR_1_PERCENTAGE = 75;
-    // Colors are in RGB format, displayed as an int array of three values whose entries are in the range [0, 15].
-    private static final int[] COLOR_0 = { 9,  0, 0};
-    private static final int[] COLOR_1 = {12,  9, 0};
-    private static final int[] COLOR_2 = { 6, 15, 6};
-
-    @Override
-    public String getTaskName() {
-        return "updateTranslations";
-    }
-
-    @Override
-    public void executeDefault() {
-        TranslationsGatherer gatherer = new TranslationsGatherer();
-        NestedTagValue translationValuesHolder = new NestedTagValue();
-
-        for (TranslationInfo translation : gatherer.getTranslationInfo()) {
-            int percentage = (int) Math.round(translation.getPercentTranslated() * 100);
-            String name = Optional.ofNullable(LANGUAGE_NAMES.get(translation.getCode())).orElse("?");
-            TagValueHolder valueHolder = TagValueHolder.create()
-                .put("code", translation.getCode())
-                .put("name", name)
-                .put("percentage", Integer.toString(percentage))
-                .put("color", computeColor(percentage));
-            translationValuesHolder.add(valueHolder);
-        }
-
-        TagValueHolder tags = TagValueHolder.create().put("languages", translationValuesHolder);
-        FileIoUtils.generateFileFromTemplate(TEMPLATE_FILE, DOCS_PAGE, tags);
-        System.out.println("Wrote to '" + DOCS_PAGE + "'");
-    }
-
-    /**
-     * Returns the color for the given percentage as a 6-digit hex color code.
-     *
-     * @param percentage the percentage to generate a color for
-     * @return the color
-     */
-    private String computeColor(int percentage) {
-        int[] color;
-        if (percentage < COLOR_1_PERCENTAGE) {
-            color = computeColor(percentage, COLOR_0, COLOR_1, 0, COLOR_1_PERCENTAGE);
-        } else {
-            color = computeColor(percentage, COLOR_1, COLOR_2, COLOR_1_PERCENTAGE, 100);
-        }
-
-        return Arrays.stream(color)
-            .mapToObj(i -> Integer.toString(i, 16))
-            .map(s -> s + s)
-            .collect(Collectors.joining());
-    }
-
-    /**
-     * Computes the color as the transition between two given colors.
-     *
-     * @param percentage the percentage to compute the color for
-     * @param colorA the color at the start of the range
-     * @param colorB the color at the end of the range
-     * @param rangeMin range start
-     * @param rangeMax range end
-     * @return color for the given percentage
-     */
-    private static int[] computeColor(int percentage, int[] colorA, int[] colorB, int rangeMin, int rangeMax) {
-        double max = rangeMax - rangeMin;
-        double n = percentage - rangeMin;
-
-        return new int[]{
-            (int) (colorA[0] + n / max * (colorB[0] - colorA[0])),
-            (int) (colorA[1] + n / max * (colorB[1] - colorA[1])),
-            (int) (colorA[2] + n / max * (colorB[2] - colorA[2]))
-        };
-    }
-
-    /**
-     * @return map of language code -> language name
-     */
-    private static Map<String, String> buildLanguageNames() {
-        return ImmutableMap.<String, String>builder()
-            .put("bg", "Bulgarian")
-            .put("br", "Brazilian")
-            .put("cz", "Czech")
-            .put("de", "German")
-            .put("en", "English")
-            .put("eo", "Esperanto")
-            .put("es", "Spanish")
-            .put("et", "Estonian")
-            .put("eu", "Basque")
-            .put("fi", "Finnish")
-            .put("fr", "French")
-            .put("gl", "Galician")
-            .put("hu", "Hungarian")
-            .put("id", "Indonesian")
-            .put("it", "Italian")
-            .put("ko", "Korean")
-            .put("lt", "Lithuanian")
-            .put("nl", "Dutch")
-            .put("pl", "Polish")
-            .put("pt", "Portuguese")
-            .put("ro", "Romanian")
-            .put("ru", "Russian")
-            .put("si", "Slovenian")
-            .put("sk", "Slovakian")
-            .put("sr", "Serbian")
-            .put("tr", "Turkish")
-            .put("uk", "Ukrainian")
-            .put("vn", "Vietnamese")
-            .put("zhcn", "Chinese (China)")
-            .put("zhhk", "Chinese (Hong Kong)")
-            .put("zhmc", "Chinese (Macau)")
-            .put("zhtw", "Chinese (Taiwan)")
-            .build();
-    }
-}
diff --git a/src/test/java/tools/docs/translations/TranslationsGatherer.java b/src/test/java/tools/docs/translations/TranslationsGatherer.java
deleted file mode 100644
index ebe72f7a..00000000
--- a/src/test/java/tools/docs/translations/TranslationsGatherer.java
+++ /dev/null
@@ -1,84 +0,0 @@
-package tools.docs.translations;
-
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileReader;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.MessagePathHelper;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-
-import static tools.utils.FileIoUtils.listFilesOrThrow;
-import static tools.utils.ToolsConstants.MAIN_RESOURCES_ROOT;
-
-/**
- * Gathers all available translations of AuthMe.
- */
-public class TranslationsGatherer {
-
-    private static final String MESSAGES_FOLDER = MAIN_RESOURCES_ROOT + MessagePathHelper.MESSAGES_FOLDER;
-
-    private List<TranslationInfo> translationInfo = new ArrayList<>();
-
-    public TranslationsGatherer() {
-        gatherTranslations();
-        translationInfo.sort(Comparator.comparing(TranslationsGatherer::getSortCode));
-    }
-
-    public List<TranslationInfo> getTranslationInfo() {
-        return translationInfo;
-    }
-
-    private void gatherTranslations() {
-        File[] files = listFilesOrThrow(new File(MESSAGES_FOLDER));
-        for (File file : files) {
-            String code = MessagePathHelper.getLanguageIfIsMessagesFile(file.getName());
-            if (code != null) {
-                processMessagesFile(code, file);
-            }
-        }
-    }
-
-    private void processMessagesFile(String code, File file) {
-        PropertyReader reader = new YamlFileReader(file);
-        int availableMessages = 0;
-        for (MessageKey key : MessageKey.values()) {
-            if (reader.contains(key.getKey())) {
-                ++availableMessages;
-            }
-        }
-        translationInfo.add(new TranslationInfo(code, (double) availableMessages / MessageKey.values().length));
-    }
-
-    /**
-     * Returns the language code from the translation info for sorting purposes.
-     * Returns "a" for "en" language code to sort English on top.
-     *
-     * @param info the translation info
-     * @return the language code for sorting
-     */
-    private static String getSortCode(TranslationInfo info) {
-        return MessagePathHelper.DEFAULT_LANGUAGE.equals(info.code) ? "a" : info.code;
-    }
-
-    public static final class TranslationInfo {
-        private final String code;
-        private final double percentTranslated;
-
-        TranslationInfo(String code, double percentTranslated) {
-            this.code = code;
-            this.percentTranslated = percentTranslated;
-        }
-
-        public String getCode() {
-            return code;
-        }
-
-        public double getPercentTranslated() {
-            return percentTranslated;
-        }
-    }
-
-}
diff --git a/src/test/java/tools/docs/translations/translations.tpl.md b/src/test/java/tools/docs/translations/translations.tpl.md
deleted file mode 100644
index 51c5aead..00000000
--- a/src/test/java/tools/docs/translations/translations.tpl.md
+++ /dev/null
@@ -1,14 +0,0 @@
-<!-- {gen_warning} -->
-<!-- File auto-generated on {gen_date}. See docs/translations/translations.tpl.md -->
-
-# AuthMe Translations
-The following translations are available in AuthMe. Set `messagesLanguage` to the language code
-in your config.yml to use the language, or use another language code to start a new translation.
-
-Code | Language | Translated | &nbsp;
----- | -------- | ---------: | ------
-[#languages]
-[{code}](https://github.com/AuthMe/AuthMeReloaded/blob/master/src/main/resources/messages/messages_{code}.yml) | {name} | {percentage}% | <img src="https://via.placeholder.com/{percentage}x7/{color}?text=%20" alt="{percentage}" />
-[/#languages]
-
-{gen_footer}
diff --git a/src/test/java/tools/filegeneration/GenerateCommandsYml.java b/src/test/java/tools/filegeneration/GenerateCommandsYml.java
deleted file mode 100644
index 34a1bb1b..00000000
--- a/src/test/java/tools/filegeneration/GenerateCommandsYml.java
+++ /dev/null
@@ -1,40 +0,0 @@
-package tools.filegeneration;
-
-import ch.jalu.configme.SettingsManager;
-import ch.jalu.configme.SettingsManagerBuilder;
-import fr.xephi.authme.settings.commandconfig.CommandConfig;
-import fr.xephi.authme.settings.commandconfig.CommandSettingsHolder;
-import tools.utils.AutoToolTask;
-import tools.utils.ToolsConstants;
-
-import java.io.File;
-
-/**
- * Generates the commands.yml file that corresponds to the default in the code.
- */
-public class GenerateCommandsYml implements AutoToolTask {
-
-    private static final String COMMANDS_YML_FILE = ToolsConstants.MAIN_RESOURCES_ROOT + "commands.yml";
-
-    @Override
-    public void executeDefault() {
-        File file = new File(COMMANDS_YML_FILE);
-
-        // Get the default
-        CommandConfig commandConfig = CommandSettingsHolder.COMMANDS.getDefaultValue();
-
-        // Export the value to the file
-        SettingsManager settingsManager = SettingsManagerBuilder.withYamlFile(file)
-            .configurationData(CommandSettingsHolder.class)
-            .create();
-        settingsManager.setProperty(CommandSettingsHolder.COMMANDS, commandConfig);
-        settingsManager.save();
-
-        System.out.println("Updated " + COMMANDS_YML_FILE);
-    }
-
-    @Override
-    public String getTaskName() {
-        return "generateCommandsYml";
-    }
-}
diff --git a/src/test/java/tools/filegeneration/GeneratePluginYml.java b/src/test/java/tools/filegeneration/GeneratePluginYml.java
deleted file mode 100644
index cf833b00..00000000
--- a/src/test/java/tools/filegeneration/GeneratePluginYml.java
+++ /dev/null
@@ -1,182 +0,0 @@
-package tools.filegeneration;
-
-import com.google.common.collect.ImmutableMap;
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.CommandInitializer;
-import fr.xephi.authme.command.CommandUtils;
-import fr.xephi.authme.permission.DefaultPermission;
-import fr.xephi.authme.permission.PermissionNode;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import tools.docs.permissions.PermissionNodesGatherer;
-import tools.utils.AutoToolTask;
-import tools.utils.FileIoUtils;
-import tools.utils.ToolsConstants;
-
-import java.io.StringReader;
-import java.nio.file.Paths;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-import java.util.stream.Collectors;
-
-/**
- * Generates the command and permission section of plugin.yml.
- */
-public class GeneratePluginYml implements AutoToolTask {
-
-    private static final String PLUGIN_YML_FILE = ToolsConstants.MAIN_RESOURCES_ROOT + "plugin.yml";
-
-    private static final Map<String, String> WILDCARD_PERMISSIONS = ImmutableMap.of(
-        "authme.player.*", "Gives access to all player commands",
-        "authme.player.email", "Gives access to all email commands",
-        "authme.admin.*", "Gives access to all admin commands",
-        "authme.debug", "Gives access to /authme debug and all its sections");
-
-    private List<PermissionNode> permissionNodes;
-
-    private String pluginYmlStart;
-
-    @Override
-    public void executeDefault() {
-        FileConfiguration configuration = loadPartialPluginYmlFile();
-
-        configuration.set("commands", generateCommands());
-        configuration.set("permissions", generatePermissions());
-
-        FileIoUtils.writeToFile(PLUGIN_YML_FILE,
-        pluginYmlStart + "\n" + configuration.saveToString());
-    }
-
-    @Override
-    public String getTaskName() {
-        return "generatePluginYml";
-    }
-
-    /**
-     * Because some parts above the commands section have placeholders that aren't valid YAML, we need
-     * to split the contents into an upper part that we ignore and a lower part we load as YAML. When
-     * saving we prepend the YAML export with the stripped off part of the file again.
-     *
-     * @return file configuration with the lower part of the plugin.yml file
-     */
-    private FileConfiguration loadPartialPluginYmlFile() {
-        List<String> pluginYmlLines = FileIoUtils.readLinesFromFile(Paths.get(PLUGIN_YML_FILE));
-        int lineNr = 0;
-        for (String line : pluginYmlLines) {
-            if ("commands:".equals(line)) {
-                break;
-            }
-            ++lineNr;
-        }
-        if (lineNr == pluginYmlLines.size()) {
-            throw new IllegalStateException("Could not find line starting 'commands:' section");
-        }
-        pluginYmlStart = String.join("\n", pluginYmlLines.subList(0, lineNr));
-        String yamlContents = String.join("\n", pluginYmlLines.subList(lineNr, pluginYmlLines.size()));
-        return YamlConfiguration.loadConfiguration(new StringReader(yamlContents));
-    }
-
-    private static Map<String, Object> generateCommands() {
-        Collection<CommandDescription> commands = new CommandInitializer().getCommands();
-        Map<String, Object> entries = new LinkedHashMap<>();
-        for (CommandDescription command : commands) {
-            entries.put(command.getLabels().get(0), buildCommandEntry(command));
-        }
-        return entries;
-    }
-
-    private Map<String, Object> generatePermissions() {
-        PermissionNodesGatherer gatherer = new PermissionNodesGatherer();
-        Map<String, String> permissionDescriptions = gatherer.gatherNodesWithJavaDoc();
-
-        permissionNodes = gatherer.getPermissionClasses().stream()
-            // Note ljacqu 20161023: The compiler fails if we use method references below
-            .map(clz -> clz.getEnumConstants())
-            .flatMap((PermissionNode[] nodes) -> Arrays.stream(nodes))
-            .collect(Collectors.toList());
-
-        Map<String, Object> descriptions = new TreeMap<>();
-        for (PermissionNode node : permissionNodes) {
-            descriptions.put(node.getNode(), buildPermissionEntry(node, permissionDescriptions.get(node.getNode())));
-        }
-        addWildcardPermissions(descriptions);
-        return descriptions;
-    }
-
-    private void addWildcardPermissions(Map<String, Object> permissions) {
-        for (Map.Entry<String, String> entry : WILDCARD_PERMISSIONS.entrySet()) {
-            permissions.put(entry.getKey(),
-                buildWildcardPermissionEntry(entry.getValue(), gatherChildren(entry.getKey())));
-        }
-    }
-
-    private Map<String, Boolean> gatherChildren(String parentNode) {
-        String parentPath = parentNode.replaceAll("\\.\\*$", "");
-
-        Map<String, Boolean> children = new TreeMap<>();
-        for (PermissionNode node : permissionNodes) {
-            if (node.getNode().startsWith(parentPath)) {
-                children.put(node.getNode(), Boolean.TRUE);
-            }
-        }
-        return children;
-    }
-
-    private static Map<String, Object> buildCommandEntry(CommandDescription command) {
-        if (command.getLabels().size() > 1) {
-            return ImmutableMap.of(
-                "description", command.getDescription(),
-                "usage", buildUsage(command),
-                "aliases", command.getLabels().subList(1, command.getLabels().size()));
-        } else {
-            return ImmutableMap.of(
-                "description", command.getDescription(),
-                "usage", buildUsage(command));
-        }
-    }
-
-    private static String buildUsage(CommandDescription command) {
-        final String commandStart = "/" + command.getLabels().get(0);
-        if (!command.getArguments().isEmpty()) {
-            // Command has arguments, so generate something like /authme register <password> <confirmPass>
-            final String arguments = command.getArguments().stream()
-                .map(CommandUtils::formatArgument)
-                .collect(Collectors.joining(" "));
-            return commandStart + " " + arguments;
-        }
-        // Argument-less command, list all children: /authme register|login|firstspawn|spawn|...
-        String usage = commandStart + " " + command.getChildren()
-            .stream()
-            .filter(cmd -> !cmd.getLabels().contains("help"))
-            .map(cmd -> cmd.getLabels().get(0))
-            .collect(Collectors.joining("|"));
-        return usage.trim();
-    }
-
-    private static Map<String, Object> buildPermissionEntry(PermissionNode permissionNode, String description) {
-        return ImmutableMap.of(
-            "description", description,
-            "default", convertDefaultPermission(permissionNode.getDefaultPermission()));
-    }
-
-    private static Map<String, Object> buildWildcardPermissionEntry(String description, Map<String, Boolean> children) {
-        return ImmutableMap.of(
-            "description", description,
-            "children", children);
-    }
-
-    private static Object convertDefaultPermission(DefaultPermission defaultPermission) {
-        switch (defaultPermission) {
-            // Returning true/false as booleans will make SnakeYAML avoid using quotes
-            case ALLOWED: return true;
-            case NOT_ALLOWED: return false;
-            case OP_ONLY: return "op";
-            default:
-                throw new IllegalArgumentException("Unknown default permission '" + defaultPermission + "'");
-        }
-    }
-}
diff --git a/src/test/java/tools/helptranslation/HelpTranslationVerifier.java b/src/test/java/tools/helptranslation/HelpTranslationVerifier.java
deleted file mode 100644
index 08a446de..00000000
--- a/src/test/java/tools/helptranslation/HelpTranslationVerifier.java
+++ /dev/null
@@ -1,177 +0,0 @@
-package tools.helptranslation;
-
-import com.google.common.collect.Sets;
-import fr.xephi.authme.command.CommandDescription;
-import fr.xephi.authme.command.CommandInitializer;
-import fr.xephi.authme.command.CommandUtils;
-import fr.xephi.authme.command.help.HelpMessage;
-import fr.xephi.authme.command.help.HelpSection;
-import org.bukkit.configuration.MemorySection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import static com.google.common.collect.Lists.newArrayList;
-
-/**
- * Verifies a help messages translation.
- */
-public class HelpTranslationVerifier {
-
-    private final FileConfiguration configuration;
-
-    // missing and unknown HelpSection and HelpMessage entries
-    private final List<String> missingSections = new ArrayList<>();
-    private final List<String> unknownSections = new ArrayList<>();
-    // missing and unknown command entries
-    private final List<String> missingCommands = new ArrayList<>();
-    private final List<String> unknownCommands = new ArrayList<>();
-
-    public HelpTranslationVerifier(File translation) {
-        this.configuration = YamlConfiguration.loadConfiguration(translation);
-        checkFile();
-    }
-
-    private void checkFile() {
-        checkHelpSections();
-        checkCommands();
-    }
-
-    public List<String> getMissingSections() {
-        return missingSections;
-    }
-
-    public List<String> getUnknownSections() {
-        return unknownSections;
-    }
-
-    public List<String> getMissingCommands() {
-        // All entries start with "command.", so remove that
-        return missingCommands.stream()
-            .map(s -> s.substring(9)).collect(Collectors.toList());
-    }
-
-    public List<String> getUnknownCommands() {
-        // All entries start with "command.", so remove that
-        return unknownCommands.stream()
-            .map(s -> s.substring(9)).collect(Collectors.toList());
-    }
-
-    /**
-     * Verifies that the file has the expected entries for {@link HelpSection} and {@link HelpMessage}.
-     */
-    private void checkHelpSections() {
-        Set<String> knownSections = Arrays.stream(HelpSection.values())
-            .map(HelpSection::getKey).collect(Collectors.toSet());
-        knownSections.addAll(Arrays.stream(HelpMessage.values()).map(HelpMessage::getKey).collect(Collectors.toSet()));
-        knownSections.addAll(Arrays.asList("common.defaultPermissions.notAllowed",
-            "common.defaultPermissions.opOnly", "common.defaultPermissions.allowed"));
-        Set<String> sectionKeys = getLeafKeys("section");
-        sectionKeys.addAll(getLeafKeys("common"));
-
-        if (sectionKeys.isEmpty()) {
-            missingSections.addAll(knownSections);
-        } else {
-            missingSections.addAll(Sets.difference(knownSections, sectionKeys));
-            unknownSections.addAll(Sets.difference(sectionKeys, knownSections));
-        }
-    }
-
-    /**
-     * Verifies that the file has the expected entries for AuthMe commands.
-     */
-    private void checkCommands() {
-        Set<String> commandPaths = buildCommandPaths();
-        Set<String> existingKeys = getLeafKeys("commands");
-        if (existingKeys.isEmpty()) {
-            missingCommands.addAll(commandPaths); // commandPaths should be empty in this case
-        } else {
-            missingCommands.addAll(Sets.difference(commandPaths, existingKeys));
-            unknownCommands.addAll(Sets.difference(existingKeys, commandPaths));
-        }
-    }
-
-    private Set<String> buildCommandPaths() {
-        Set<String> commandPaths = new LinkedHashSet<>();
-        for (CommandDescription command : new CommandInitializer().getCommands()) {
-            commandPaths.addAll(getYamlPaths(command));
-            command.getChildren().forEach(child -> commandPaths.addAll(getYamlPaths(child)));
-        }
-        return commandPaths;
-    }
-
-    /**
-     * Creates all paths of the properties that are used to define the help translation of the given command definition.
-     *
-     * @param command the command to create the paths for
-     * @return all yaml paths that can be used to translate the command
-     */
-    private List<String> getYamlPaths(CommandDescription command) {
-        // e.g. commands.authme.register
-        String commandPath = "commands." + CommandUtils.constructParentList(command).stream()
-            .map(cmd -> cmd.getLabels().get(0))
-            .collect(Collectors.joining("."));
-        // The entire command is not present, so just add it as a missing command and don't return any YAML path
-        if (!configuration.contains(commandPath)) {
-            missingCommands.add(commandPath);
-            return Collections.emptyList();
-        }
-
-        // Entries each command can have
-        List<String> paths = newArrayList(commandPath + ".description", commandPath + ".detailedDescription");
-
-        // Add argument entries that may exist
-        for (int argIndex = 1; argIndex <= command.getArguments().size(); ++argIndex) {
-            String argPath = String.format("%s.arg%d", commandPath, argIndex);
-            paths.add(argPath + ".label");
-            paths.add(argPath + ".description");
-        }
-        return paths;
-    }
-
-    /**
-     * Returns the leaf keys of the section at the given path of the file configuration.
-     *
-     * @param path the path whose leaf keys should be retrieved
-     * @return leaf keys of the memory section,
-     *         empty set if the configuration does not have a memory section at the given path
-     */
-    private Set<String> getLeafKeys(String path) {
-        if (!(configuration.get(path) instanceof MemorySection)) {
-            return Collections.emptySet();
-        }
-        MemorySection memorySection = (MemorySection) configuration.get(path);
-
-        // MemorySection#getKeys(true) returns all keys on all levels, e.g. if the configuration has
-        // 'commands.authme.register' then it also has 'commands.authme' and 'commands'. We can traverse each node and
-        // build its parents (e.g. for commands.authme.register.description: commands.authme.register, commands.authme,
-        // and commands, which we can remove from the collection since we know they are not a leaf.
-        Set<String> leafKeys = memorySection.getKeys(true);
-        Set<String> allKeys = new HashSet<>(leafKeys);
-
-        for (String key : allKeys) {
-            List<String> pathParts = Arrays.asList(key.split("\\."));
-
-            // We perform construction of parents & their removal in reverse order so we can build the lowest-level
-            // parent of a node first. As soon as the parent doesn't exist in the set already, we know we can continue
-            // with the next node since another node has already removed the concerned parents.
-            for (int i = pathParts.size() - 1; i > 0; --i) {
-                // e.g. for commands.authme.register -> i = {2, 1} => {commands.authme, commands}
-                String parentPath = String.join(".", pathParts.subList(0, i));
-                if (!leafKeys.remove(parentPath)) {
-                    break;
-                }
-            }
-        }
-        return leafKeys.stream().map(leaf -> path + "." + leaf).collect(Collectors.toSet());
-    }
-}
diff --git a/src/test/java/tools/helptranslation/VerifyHelpTranslations.java b/src/test/java/tools/helptranslation/VerifyHelpTranslations.java
deleted file mode 100644
index a8a8daa9..00000000
--- a/src/test/java/tools/helptranslation/VerifyHelpTranslations.java
+++ /dev/null
@@ -1,71 +0,0 @@
-package tools.helptranslation;
-
-import tools.utils.ToolTask;
-import tools.utils.ToolsConstants;
-
-import java.io.File;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Scanner;
-import java.util.regex.Pattern;
-import java.util.stream.Collectors;
-
-import static tools.utils.FileIoUtils.listFilesOrThrow;
-
-/**
- * Verifies the help translations for validity and completeness.
- */
-public class VerifyHelpTranslations implements ToolTask {
-
-    private static final Pattern HELP_MESSAGE_PATTERN = Pattern.compile("help_[a-z]{2,7}\\.yml");
-    private static final String FOLDER = ToolsConstants.MAIN_RESOURCES_ROOT + "messages/";
-
-    @Override
-    public String getTaskName() {
-        return "verifyHelpTranslations";
-    }
-
-    @Override
-    public void execute(Scanner scanner) {
-        System.out.println("Check specific language file?");
-        System.out.println("Enter the language code for a specific file (e.g. 'it' for help_it.yml)");
-        System.out.println("Empty line will check all files in the resources messages folder (default)");
-
-        String language = scanner.nextLine();
-        if (language.isEmpty()) {
-            getHelpTranslations().forEach(this::processFile);
-        } else {
-            processFile(new File(FOLDER, "help_" + language + ".yml"));
-        }
-    }
-
-    private void processFile(File file) {
-        System.out.println("Checking '" + file.getName() + "'");
-        HelpTranslationVerifier verifier = new HelpTranslationVerifier(file);
-
-        // Check and output errors
-        if (!verifier.getMissingSections().isEmpty()) {
-            System.out.println("Missing sections: " + String.join(", ", verifier.getMissingSections()));
-        }
-        if (!verifier.getUnknownSections().isEmpty()) {
-            System.out.println("Unknown sections: " + String.join(", ", verifier.getUnknownSections()));
-        }
-        if (!verifier.getMissingCommands().isEmpty()) {
-            System.out.println("Missing command entries: " + String.join(", ", verifier.getMissingCommands()));
-        }
-        if (!verifier.getUnknownCommands().isEmpty()) {
-            System.out.println("Unknown command entries: " + String.join(", ", verifier.getUnknownCommands()));
-        }
-    }
-
-    private static List<File> getHelpTranslations() {
-        File[] files = listFilesOrThrow(new File(FOLDER));
-        List<File> helpFiles = Arrays.stream(files)
-            .filter(file -> HELP_MESSAGE_PATTERN.matcher(file.getName()).matches())
-            .collect(Collectors.toList());
-        if (helpFiles.isEmpty()) {
-            throw new IllegalStateException("Could not get any matching files!");
-        }
-        return helpFiles;
-    }
-}
diff --git a/src/test/java/tools/messages/AddJavaDocToMessageEnumTask.java b/src/test/java/tools/messages/AddJavaDocToMessageEnumTask.java
deleted file mode 100644
index 383a3e96..00000000
--- a/src/test/java/tools/messages/AddJavaDocToMessageEnumTask.java
+++ /dev/null
@@ -1,53 +0,0 @@
-package tools.messages;
-
-import fr.xephi.authme.message.MessagePathHelper;
-import fr.xephi.authme.message.MessageKey;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import tools.utils.AutoToolTask;
-import tools.utils.ToolsConstants;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Task to add English messages as javadoc comment to each MessageKey enum entry.
- */
-public class AddJavaDocToMessageEnumTask implements AutoToolTask {
-
-    private static final String MESSAGES_FILE =
-        ToolsConstants.MAIN_RESOURCES_ROOT + MessagePathHelper.DEFAULT_MESSAGES_FILE;
-
-    private FileConfiguration configuration;
-
-    @Override
-    public void executeDefault() {
-        configuration = YamlConfiguration.loadConfiguration(new File(MESSAGES_FILE));
-
-        List<String> entries = new ArrayList<>();
-        for (MessageKey entry : MessageKey.values()) {
-            String tags = entry.getTags().length == 0
-                ? ""
-                : ", \"" + String.join("\", \"", entry.getTags()) + "\"";
-
-            entries.add("/** " + getMessageForJavaDoc(entry) + " */"
-                + "\n\t" + entry.name() + "(\"" + entry.getKey() + "\"" + tags + ")");
-        }
-
-        System.out.println("\t" + String.join(",\n\n\t", entries) + ";");
-    }
-
-    @Override
-    public String getTaskName() {
-        return "addJavaDocToMessageEnum";
-    }
-
-    private String getMessageForJavaDoc(MessageKey key) {
-        return configuration.getString(key.getKey())
-            .replaceAll("&[0-9a-f]", "")
-            .replace("&", "&amp;")
-            .replace("<", "&lt;")
-            .replace(">", "&gt;");
-    }
-}
diff --git a/src/test/java/tools/messages/CheckMessageKeyUsages.java b/src/test/java/tools/messages/CheckMessageKeyUsages.java
deleted file mode 100644
index 7387f002..00000000
--- a/src/test/java/tools/messages/CheckMessageKeyUsages.java
+++ /dev/null
@@ -1,63 +0,0 @@
-package tools.messages;
-
-import com.google.common.collect.Lists;
-import fr.xephi.authme.message.MessageKey;
-import tools.utils.AutoToolTask;
-import tools.utils.FileIoUtils;
-import tools.utils.ToolsConstants;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-
-import static java.util.Arrays.asList;
-
-/**
- * Task which checks for {@link MessageKey} usages.
- */
-public class CheckMessageKeyUsages implements AutoToolTask {
-
-    private static final Predicate<File> SHOULD_CHECK_FILE =
-        file -> file.getName().endsWith(".java") && !file.getName().endsWith("MessageKey.java");
-
-    @Override
-    public String getTaskName() {
-        return "checkMessageUses";
-    }
-
-    @Override
-    public void executeDefault() {
-        List<MessageKey> unusedKeys = findUnusedKeys();
-        if (unusedKeys.isEmpty()) {
-            System.out.println("No unused MessageKey entries found :)");
-        } else {
-            System.out.println("Did not find usages for keys:\n- "
-                + String.join("\n- ", Lists.transform(unusedKeys, MessageKey::name)));
-        }
-    }
-
-    private List<MessageKey> findUnusedKeys() {
-        List<MessageKey> keys = new ArrayList<>(asList(MessageKey.values()));
-        File sourceFolder = new File(ToolsConstants.MAIN_SOURCE_ROOT);
-
-        Consumer<File> fileProcessor = file -> {
-            String source = FileIoUtils.readFromFile(file.toPath());
-            keys.removeIf(key -> source.contains("MessageKey." + key.name()));
-        };
-
-        walkJavaFileTree(sourceFolder, fileProcessor);
-        return keys;
-    }
-
-    private static void walkJavaFileTree(File folder, Consumer<File> javaFileConsumer) {
-        for (File file : FileIoUtils.listFilesOrThrow(folder)) {
-            if (file.isDirectory()) {
-                walkJavaFileTree(file, javaFileConsumer);
-            } else if (file.isFile() && SHOULD_CHECK_FILE.test(file)) {
-                javaFileConsumer.accept(file);
-            }
-        }
-    }
-}
diff --git a/src/test/java/tools/messages/MessageFileVerifier.java b/src/test/java/tools/messages/MessageFileVerifier.java
deleted file mode 100644
index 650c9ff7..00000000
--- a/src/test/java/tools/messages/MessageFileVerifier.java
+++ /dev/null
@@ -1,118 +0,0 @@
-package tools.messages;
-
-import com.google.common.base.Preconditions;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-import fr.xephi.authme.message.MessageKey;
-import org.bukkit.configuration.MemorySection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-
-import java.io.File;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * Verifies a message file's keys to ensure that it is in sync with {@link MessageKey}, i.e. that the file contains
- * all keys and that it doesn't have any unknown ones.
- */
-public class MessageFileVerifier {
-
-    private final File messagesFile;
-    private final Set<String> unknownKeys = new HashSet<>();
-    private final Set<MessageKey> missingKeys = new HashSet<>();
-    private final Multimap<MessageKey, String> missingTags = HashMultimap.create();
-
-    /**
-     * Create a verifier that verifies the given messages file.
-     *
-     * @param messagesFile The messages file to process
-     */
-    public MessageFileVerifier(File messagesFile) {
-        Preconditions.checkArgument(messagesFile.exists(), "Message file '" + messagesFile + "' does not exist");
-        this.messagesFile = messagesFile;
-        verifyKeys();
-    }
-
-    /**
-     * Return the list of unknown keys, i.e. the list of keys present in the file that are not
-     * part of the {@link MessageKey} enum.
-     *
-     * @return List of unknown keys
-     */
-    public Set<String> getUnknownKeys() {
-        return unknownKeys;
-    }
-
-    /**
-     * Return the list of missing keys, i.e. all keys that are part of {@link MessageKey} but absent
-     * in the messages file.
-     *
-     * @return The list of missing keys in the file
-     */
-    public Set<MessageKey> getMissingKeys() {
-        return missingKeys;
-    }
-
-    /**
-     * Return the collection of tags the message key defines that aren't present in the read line.
-     *
-     * @return Collection of missing tags per message key
-     */
-    public Multimap<MessageKey, String> getMissingTags() {
-        return missingTags;
-    }
-
-    /**
-     * @return true if the verifier has found an issue with the analyzed file, false otherwise
-     */
-    public boolean hasErrors() {
-        return !missingKeys.isEmpty() || !missingTags.isEmpty() || !unknownKeys.isEmpty();
-    }
-
-    /**
-     * Performs the actual verification for the given file and collects all found issues into this
-     * instance's fields.
-     */
-    private void verifyKeys() {
-        FileConfiguration configuration = YamlConfiguration.loadConfiguration(messagesFile);
-
-        // Check known keys (their existence + presence of all tags)
-        for (MessageKey messageKey : MessageKey.values()) {
-            final String key = messageKey.getKey();
-            if (configuration.isString(key)) {
-                checkTagsInMessage(messageKey, configuration.getString(key));
-            } else {
-                missingKeys.add(messageKey);
-            }
-        }
-
-        // Check FileConfiguration for all of its keys to find unknown keys
-        for (String key : configuration.getValues(true).keySet()) {
-            if (isNotInnerNode(key, configuration) && !messageKeyExists(key)) {
-                unknownKeys.add(key);
-            }
-        }
-    }
-
-    private static boolean isNotInnerNode(String key, FileConfiguration configuration) {
-        return !(configuration.get(key) instanceof MemorySection);
-    }
-
-    private void checkTagsInMessage(MessageKey messageKey, String message) {
-        for (String tag : messageKey.getTags()) {
-            if (!message.contains(tag)) {
-                missingTags.put(messageKey, tag);
-            }
-        }
-    }
-
-    private static boolean messageKeyExists(String key) {
-        for (MessageKey messageKey : MessageKey.values()) {
-            if (messageKey.getKey().equals(key)) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
diff --git a/src/test/java/tools/messages/MessagesFileWriter.java b/src/test/java/tools/messages/MessagesFileWriter.java
deleted file mode 100644
index 8f43247a..00000000
--- a/src/test/java/tools/messages/MessagesFileWriter.java
+++ /dev/null
@@ -1,161 +0,0 @@
-package tools.messages;
-
-import ch.jalu.configme.configurationdata.ConfigurationData;
-import ch.jalu.configme.properties.Property;
-import ch.jalu.configme.resource.PropertyReader;
-import ch.jalu.configme.resource.YamlFileResource;
-import fr.xephi.authme.message.updater.MessageKeyConfigurationData;
-import fr.xephi.authme.message.updater.MessageUpdater;
-import fr.xephi.authme.message.updater.MigraterYamlFileResource;
-import org.bukkit.configuration.file.FileConfiguration;
-import tools.utils.FileIoUtils;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Writes to a messages file, adding comments with the default file's message where
- * entries are missing.
- * <p>
- * This writer writes to the file twice: once with ConfigMe to ensure a proper order
- * of the properties and comments, and a second time to add any custom comments that
- * were at the top of the file and to separate comments by new lines (which ConfigMe
- * currently doesn't support).
- */
-public final class MessagesFileWriter {
-
-    /** Marker used inside a text to signal that it should be a comment later on. */
-    private static final String COMMENT_MARKER = "::COMMENT::";
-
-    private static final Pattern SPACES_BEFORE_TEXT_PATTERN = Pattern.compile("(\\s+)\\w.*");
-
-    /** The messages file to update. */
-    private final File file;
-    /** Messages from the default file. */
-    private final FileConfiguration defaultFile;
-
-    private MessagesFileWriter(File file, FileConfiguration defaultFile) {
-        this.file = file;
-        this.defaultFile = defaultFile;
-    }
-
-    public static void writeToFileWithCommentsFromDefault(File file, FileConfiguration configuration) {
-        new MessagesFileWriter(file, configuration).performWrite();
-    }
-
-    private void performWrite() {
-        // Initialize ConfigMe classes
-        MessageKeyConfigurationData configurationData = MessageUpdater.createConfigurationData();
-        YamlFileResource resource = new MigraterYamlFileResource(file);
-        PropertyReader reader = resource.createReader();
-        configurationData.initializeValues(reader);
-
-        // Store initial comments so we can add them back later
-        List<String> initialComments = getInitialUserComments(configurationData);
-
-        // Create property resource with new defaults, save with ConfigMe for proper sections & comments
-        addMissingMessagesWithCommentMarker(reader, configurationData);
-        resource.exportProperties(configurationData);
-
-        // Go through the newly saved file and replace texts with comment marker to actual YAML comments
-        // and add initial comments back to the file
-        rewriteToFileWithComments(initialComments);
-    }
-
-    /**
-     * Returns the comments at the top which are custom to the file.
-     *
-     * @param configurationData the configuration data
-     * @return any custom comments at the top of the file, for later usage
-     */
-    private List<String> getInitialUserComments(ConfigurationData configurationData) {
-        final List<String> initialComments = new ArrayList<>();
-        final String firstCommentByConfigMe = getFirstCommentByConfigMe(configurationData);
-
-        for (String line : FileIoUtils.readLinesFromFile(file.toPath())) {
-            if (line.isEmpty() || line.startsWith("#") && !line.equals(firstCommentByConfigMe)) {
-                initialComments.add(line);
-            } else {
-                break;
-            }
-        }
-        // Small fix: so we can keep running this writer and get the same result, we need to make sure that any ending
-        // empty lines are removed
-        for (int i = initialComments.size() - 1; i >= 0; --i) {
-            if (initialComments.get(i).isEmpty()) {
-                initialComments.remove(i);
-            } else {
-                break;
-            }
-        }
-        return initialComments;
-    }
-
-    /**
-     * Returns the first comment generated by ConfigMe (comment of the first root path).
-     *
-     * @param configurationData the configuration data
-     * @return first comment which is generated by ConfigMe
-     */
-    private static String getFirstCommentByConfigMe(ConfigurationData configurationData) {
-        String firstRootPath = configurationData.getProperties().get(0).getPath().split("\\.")[0];
-        return "# " + configurationData.getCommentsForSection(firstRootPath).get(0);
-    }
-
-    /**
-     * Adds a text with a {@link #COMMENT_MARKER} for all properties which are not yet present in the reader.
-     *
-     * @param reader the property reader
-     * @param configurationData the configuration data
-     */
-    private void addMissingMessagesWithCommentMarker(PropertyReader reader,
-                                                     MessageKeyConfigurationData configurationData) {
-        for (Property<String> property : configurationData.getAllMessageProperties()) {
-            String text = reader.getString(property.getPath());
-            if (text == null) {
-                configurationData.setValue(property, COMMENT_MARKER + defaultFile.getString(property.getPath()));
-            }
-        }
-    }
-
-    /**
-     * Writes to the file again, adding the provided initial comments at the top of the file and converting
-     * any entries marked with {@link #COMMENT_MARKER} to YAML comments.
-     *
-     * @param initialComments the comments at the top of the file to add back
-     */
-    private void rewriteToFileWithComments(List<String> initialComments) {
-        List<String> newLines = new ArrayList<>(initialComments);
-
-        for (String line : FileIoUtils.readLinesFromFile(file.toPath())) {
-            if (line.contains(COMMENT_MARKER)) {
-                String lineAsYamlComment = convertLineWithCommentMarkerToYamlComment(line);
-                newLines.add(lineAsYamlComment);
-            } else if (line.startsWith("#") && !newLines.isEmpty()) {
-                // ConfigMe doesn't support empty line between comments, so here we check if we have a comment that
-                // isn't at the very top and sneak in an empty line if so.
-                newLines.add("");
-                newLines.add(line);
-            } else if (!line.isEmpty()) {
-                // ConfigMe adds an empty line at the beginning, so check here that we don't include any empty lines...
-                newLines.add(line);
-            }
-        }
-        newLines.add(""); // Makes sure file ends with new line
-
-        FileIoUtils.writeToFile(file.toPath(), String.join("\n", newLines));
-    }
-
-    private static String convertLineWithCommentMarkerToYamlComment(String line) {
-        Matcher matcher = SPACES_BEFORE_TEXT_PATTERN.matcher(line);
-        if (matcher.matches()) {
-            String spacesBefore = matcher.group(1);
-            return spacesBefore + "# TODO " + line.replace(COMMENT_MARKER, "").trim();
-        } else {
-            throw new IllegalStateException("Space-counting pattern unexpectedly did not match on line '" + line + "'");
-        }
-    }
-}
diff --git a/src/test/java/tools/messages/README.md b/src/test/java/tools/messages/README.md
deleted file mode 100644
index 594558a4..00000000
--- a/src/test/java/tools/messages/README.md
+++ /dev/null
@@ -1,2 +0,0 @@
-## Messages
-Verifies the messages files and adds any missing indices with the English content as default.
diff --git a/src/test/java/tools/messages/VerifyMessagesTask.java b/src/test/java/tools/messages/VerifyMessagesTask.java
deleted file mode 100644
index 04e17bba..00000000
--- a/src/test/java/tools/messages/VerifyMessagesTask.java
+++ /dev/null
@@ -1,128 +0,0 @@
-package tools.messages;
-
-import com.google.common.collect.Multimap;
-import fr.xephi.authme.message.MessageKey;
-import fr.xephi.authme.message.MessagePathHelper;
-import fr.xephi.authme.util.StringUtils;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import tools.utils.ToolTask;
-
-import java.io.File;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Scanner;
-import java.util.Set;
-
-import static fr.xephi.authme.message.MessagePathHelper.DEFAULT_MESSAGES_FILE;
-import static tools.utils.FileIoUtils.listFilesOrThrow;
-import static tools.utils.ToolsConstants.MAIN_RESOURCES_ROOT;
-
-/**
- * Task to verify the keys in the messages files.
- */
-public final class VerifyMessagesTask implements ToolTask {
-
-    /** The folder containing the message files. */
-    private static final String MESSAGES_FOLDER = MAIN_RESOURCES_ROOT + MessagePathHelper.MESSAGES_FOLDER;
-
-    @Override
-    public String getTaskName() {
-        return "verifyMessages";
-    }
-
-    @Override
-    public void execute(Scanner scanner) {
-        System.out.println("Check a specific file only?");
-        System.out.println("Enter the language code for a specific file (e.g. 'es' for messages_es.yml)");
-        System.out.println("- Empty line will check all files in the resources messages folder (default)");
-        String inputFile = scanner.nextLine();
-
-        System.out.println("Add any missing keys to files? ['y' = yes]");
-        boolean addMissingKeys = "y".equalsIgnoreCase(scanner.nextLine());
-
-        List<File> messageFiles;
-        if (StringUtils.isBlank(inputFile)) {
-            messageFiles = getMessagesFiles();
-        } else {
-            File customFile = new File(MAIN_RESOURCES_ROOT, MessagePathHelper.createMessageFilePath(inputFile));
-            messageFiles = Collections.singletonList(customFile);
-        }
-
-        FileConfiguration defaultFileConfiguration = null;
-        if (addMissingKeys) {
-            defaultFileConfiguration = YamlConfiguration.loadConfiguration(
-                new File(MAIN_RESOURCES_ROOT, DEFAULT_MESSAGES_FILE));
-        }
-
-        // Verify the given files
-        for (File file : messageFiles) {
-            System.out.println("Verifying '" + file.getName() + "'");
-            MessageFileVerifier verifier = new MessageFileVerifier(file);
-            if (addMissingKeys) {
-                outputVerificationResults(verifier);
-                updateMessagesFile(file, verifier, defaultFileConfiguration);
-            } else {
-                outputVerificationResults(verifier);
-            }
-        }
-
-        if (messageFiles.size() > 1) {
-            System.out.println("Checked " + messageFiles.size() + " files");
-        }
-    }
-
-    /**
-     * Outputs the verification results to the console.
-     *
-     * @param verifier the verifier whose results should be output
-     */
-    private static void outputVerificationResults(MessageFileVerifier verifier) {
-        Set<MessageKey> missingKeys = verifier.getMissingKeys();
-        if (!missingKeys.isEmpty()) {
-            System.out.println("  Missing keys: " + missingKeys);
-        }
-
-        Set<String> unknownKeys = verifier.getUnknownKeys();
-        if (!unknownKeys.isEmpty()) {
-            System.out.println("  Unknown keys: " + unknownKeys);
-        }
-
-        Multimap<MessageKey, String> missingTags = verifier.getMissingTags();
-        for (Map.Entry<MessageKey, String> entry : missingTags.entries()) {
-            System.out.println("  Missing tag '" + entry.getValue() + "' in entry '" + entry.getKey() + "'");
-        }
-    }
-
-    /**
-     * Updates a messages file to have the same order as the default file and to contain all
-     * failed verifications as comments.
-     *
-     * @param file the file to update
-     * @param verifier the verifier whose results should be used
-     * @param defaultConfiguration default file configuration to retrieve missing texts from
-     */
-    private static void updateMessagesFile(File file, MessageFileVerifier verifier,
-                                           FileConfiguration defaultConfiguration) {
-        if (verifier.hasErrors()) {
-            MessagesFileWriter.writeToFileWithCommentsFromDefault(file, defaultConfiguration);
-        }
-    }
-
-
-    private static List<File> getMessagesFiles() {
-        File[] files = listFilesOrThrow(new File(MESSAGES_FOLDER));
-        List<File> messageFiles = new ArrayList<>();
-        for (File file : files) {
-            if (MessagePathHelper.isMessagesFile(file.getName())) {
-                messageFiles.add(file);
-            }
-        }
-        if (messageFiles.isEmpty()) {
-            throw new IllegalStateException("Error getting message files: list of files is empty");
-        }
-        return messageFiles;
-    }
-}
diff --git a/src/test/java/tools/shhelpers/build_project.sh b/src/test/java/tools/shhelpers/build_project.sh
deleted file mode 100644
index a9775c7a..00000000
--- a/src/test/java/tools/shhelpers/build_project.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-#
-# Usage: ./build_project.sh
-#
-
-if [ -z $jarfile ];
-   then
-       ./setvars.sh
-fi
-
-mvn clean install -f $pomfile -B
diff --git a/src/test/java/tools/shhelpers/list_files.sh b/src/test/java/tools/shhelpers/list_files.sh
deleted file mode 100644
index 24d1c4ef..00000000
--- a/src/test/java/tools/shhelpers/list_files.sh
+++ /dev/null
@@ -1,2 +0,0 @@
-#!/bin/sh
-ls -aB *.sh
diff --git a/src/test/java/tools/shhelpers/move_plugin.sh b/src/test/java/tools/shhelpers/move_plugin.sh
deleted file mode 100644
index c2278b53..00000000
--- a/src/test/java/tools/shhelpers/move_plugin.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/sh
-#
-# Usage: ./move_plugin.sh
-#
-
-if [ -z $jarfile ];
-   then
-       ./setvars.sh
-fi
-
-if [ -f $jarfile ]
-then
-    cp $jarfile $plugins
-else
-    echo "Target file not found: $jarfile"
-fi
diff --git a/src/test/java/tools/shhelpers/quick_build.sh b/src/test/java/tools/shhelpers/quick_build.sh
deleted file mode 100644
index b882bde6..00000000
--- a/src/test/java/tools/shhelpers/quick_build.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-#
-# Usage: ./analyze_project.sh
-#
-
-if [ -z $jarfile ];
-   then
-       ./setvars.sh
-fi
-
-mvn install -f $pomfile -Dmaven.test.skip -PskipJavadocGeneration
diff --git a/src/test/java/tools/shhelpers/run_server.sh b/src/test/java/tools/shhelpers/run_server.sh
deleted file mode 100644
index 24fa5057..00000000
--- a/src/test/java/tools/shhelpers/run_server.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-
-if [ -z $jarfile ]
-then
-    ./setvars.sh
-fi
-
-cd $server
-java -Xmx1024M -Xms1024M -jar spigot_server.jar
-cd $batdir
-./list_files.sh
diff --git a/src/test/java/tools/shhelpers/setvars.sh b/src/test/java/tools/shhelpers/setvars.sh
deleted file mode 100644
index 60b067eb..00000000
--- a/src/test/java/tools/shhelpers/setvars.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/sh
-
-#The folder in which these .sh files are located
-EXPORT batdir=/home/yourhome/IdeaProjects/AuthMeReloaded/src/tools/shhelpers/
-
-#The location of the generated JAR file
-EXPORT jarfile=/home/yourhome/IdeaProjects/AuthMeReloaded/target/AuthMe-5.2-SNAPSHOT.jar
-
-#The location of the pom.xml file of the project
-EXPORT pomfile=/home/yourhome/IdeaProjects/AuthMeReloaded/pom.xml
-
-#The folder in which the server is located
-EXPORT server=/home/yourhome/AUTHME_DEV/spigot-server/
-
-#The Location of the plugins folder of the Minecraft server
-EXPORT plugins=$server/plugins/
diff --git a/src/test/java/tools/shhelpers/sort_file_content.sh b/src/test/java/tools/shhelpers/sort_file_content.sh
deleted file mode 100644
index 2c9c9907..00000000
--- a/src/test/java/tools/shhelpers/sort_file_content.sh
+++ /dev/null
@@ -1,6 +0,0 @@
-#!/bin/sh
-#
-# That script sort the content of all files in the current directory
-#
-ls | grep -v .sort | while read file; do sort "$file" > "$file".sort; done
-for file in *.sort; do mv "$file" "${file%%.sort}"; done
diff --git a/src/test/java/tools/utils/AutoToolTask.java b/src/test/java/tools/utils/AutoToolTask.java
deleted file mode 100644
index 61b909a5..00000000
--- a/src/test/java/tools/utils/AutoToolTask.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package tools.utils;
-
-import java.util.Scanner;
-
-/**
- * Interface for tasks that can be run automatically, i.e. without any user input.
- */
-public interface AutoToolTask extends ToolTask {
-
-    /**
-     * Execute the task with default settings.
-     */
-    void executeDefault();
-
-    @Override
-    default void execute(Scanner scanner) {
-        executeDefault();
-    }
-
-}
diff --git a/src/test/java/tools/utils/FileIoUtils.java b/src/test/java/tools/utils/FileIoUtils.java
deleted file mode 100644
index 995c71a0..00000000
--- a/src/test/java/tools/utils/FileIoUtils.java
+++ /dev/null
@@ -1,105 +0,0 @@
-package tools.utils;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
-import java.util.List;
-
-/**
- * Utility class for I/O operations on files.
- */
-public final class FileIoUtils {
-
-    private FileIoUtils() {
-    }
-
-    public static void generateFileFromTemplate(String templateFile, String destinationFile, TagValueHolder tags) {
-        String template = readFromFile(templateFile);
-        String result = TagReplacer.applyReplacements(template, tags);
-        writeToFile(destinationFile, result);
-    }
-
-    public static void writeToFile(String outputFile, String contents) {
-        writeToFile(Paths.get(outputFile), contents);
-    }
-
-    /**
-     * Writes the given contents to the file, overriding any existing content.
-     *
-     * @param path the file to write to
-     * @param contents the contents to write
-     */
-    public static void writeToFile(Path path, String contents) {
-        try {
-            Files.write(path, contents.getBytes());
-        } catch (IOException e) {
-            throw new UnsupportedOperationException("Failed to write to file '" + path + "'", e);
-        }
-    }
-
-    /**
-     * Adds the given contents to the file while keeping any existing content.
-     *
-     * @param outputFile the file to write to
-     * @param contents the contents to append
-     */
-    public static void appendToFile(String outputFile, String contents) {
-        try {
-            Files.write(Paths.get(outputFile), contents.getBytes(), StandardOpenOption.APPEND);
-        } catch (IOException e) {
-            throw new UnsupportedOperationException("Failed to append to file '" + outputFile + "'", e);
-        }
-    }
-
-    public static String readFromFile(String file) {
-        return readFromFile(Paths.get(file));
-    }
-
-    /**
-     * Returns the given file's contents as string.
-     *
-     * @param file the file to read
-     * @return the file's contents
-     */
-    public static String readFromFile(Path file) {
-        try {
-            return new String(Files.readAllBytes(file), StandardCharsets.UTF_8);
-        } catch (IOException e) {
-            throw new UnsupportedOperationException("Could not read from file '" + file + "'", e);
-        }
-    }
-
-    /**
-     * Returns the lines of the given file.
-     *
-     * @param path the path of the file to read
-     * @return the lines of the file
-     */
-    public static List<String> readLinesFromFile(Path path) {
-        try {
-            return Files.readAllLines(path, StandardCharsets.UTF_8);
-        } catch (IOException e) {
-            throw new UnsupportedOperationException("Could not read from file '" + path + "'", e);
-        }
-    }
-
-    /**
-     * Returns a folder's files or throws an exception if the folder could not be read or if it is empty.
-     *
-     * @param folder the folder to read
-     * @return the files in the folder
-     */
-    public static File[] listFilesOrThrow(File folder) {
-        File[] files = folder.listFiles();
-        if (files == null) {
-            throw new IllegalStateException("Could not read folder '" + folder + "'");
-        } else if (files.length == 0) {
-            throw new IllegalStateException("Folder '" + folder + "' is empty");
-        }
-        return files;
-    }
-}
diff --git a/src/test/java/tools/utils/InjectorUtils.java b/src/test/java/tools/utils/InjectorUtils.java
deleted file mode 100644
index 27150125..00000000
--- a/src/test/java/tools/utils/InjectorUtils.java
+++ /dev/null
@@ -1,60 +0,0 @@
-package tools.utils;
-
-import ch.jalu.injector.context.ObjectIdentifier;
-import ch.jalu.injector.handlers.instantiation.Resolution;
-import ch.jalu.injector.handlers.instantiation.StandardInjectionProvider;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * Utility for operations with the injector.
- */
-public final class InjectorUtils {
-
-    private InjectorUtils() {
-    }
-
-    /**
-     * Returns a class' dependencies as determined by the injector.
-     *
-     * @param clazz the class to process
-     * @return the class' dependencies, or null if no instantiation method found
-     */
-    public static Set<Class<?>> getDependencies(Class<?> clazz) {
-        Resolution<?> instantiation = new StandardInjectionProvider().safeGet(clazz);
-        if (instantiation == null) {
-            return null;
-        }
-        Set<Class<?>> dependencies = new HashSet<>();
-        for (ObjectIdentifier description : instantiation.getDependencies()) {
-            dependencies.add(convertToClass(description.getType()));
-        }
-        return dependencies;
-    }
-
-    /**
-     * Returns the given type as a {@link Class}.
-     *
-     * @param type the type to convert
-     * @return class corresponding to the provided type
-     */
-    public static Class<?> convertToClass(Type type) {
-        if (type instanceof Class<?>) {
-            return (Class<?>) type;
-        } else if (type instanceof ParameterizedType) {
-            Type rawType = ((ParameterizedType) type).getRawType();
-            if (rawType instanceof Class<?>) {
-                return (Class<?>) rawType;
-            } else {
-                throw new IllegalStateException("Got raw type '" + rawType + "' of type '"
-                    + rawType.getClass() + "' for genericType '" + type + "'");
-            }
-        }
-        Class<?> typeClass = type == null ? null : type.getClass();
-        throw new IllegalStateException("Unknown type implementation '" + typeClass + "' for '" + type + "'");
-    }
-
-}
diff --git a/src/test/java/tools/utils/TagReplacer.java b/src/test/java/tools/utils/TagReplacer.java
deleted file mode 100644
index df3f5bdb..00000000
--- a/src/test/java/tools/utils/TagReplacer.java
+++ /dev/null
@@ -1,110 +0,0 @@
-package tools.utils;
-
-import tools.utils.TagValue.NestedTagValue;
-import tools.utils.TagValue.TextTagValue;
-
-import java.util.Date;
-import java.util.Map;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * Class responsible for replacing template tags to actual content.
- * For all files, the following tags are defined:
- * <ul>
- *   <li>{gen_date}    – the generation date</li>
- *   <li>{gen_warning} - warning not to edit the generated file directly</li>
- *   <li>{gen_footer}  - info footer with a link to the dev repo so users can find the most up-to-date
- *                       version (in case the page is viewed on a fork)</li>
- * </ul>
- */
-public final class TagReplacer {
-
-    private TagReplacer() {
-    }
-
-    /**
-     * Replace a template with default tags and custom ones supplied by a map.
-     *
-     * @param template The template to process
-     * @param tagValues Container with tags and their associated values
-     * @return The filled template
-     */
-    public static String applyReplacements(String template, TagValueHolder tagValues) {
-        String result = template;
-        for (Map.Entry<String, TagValue<?>> tagRule : tagValues.getValues().entrySet()) {
-            final String name = tagRule.getKey();
-
-            if (tagRule.getValue() instanceof TextTagValue) {
-                final TextTagValue value = (TextTagValue) tagRule.getValue();
-                result = replaceOptionalTag(result, name, value)
-                    .replace("{" + name + "}", value.getValue());
-            } else if (tagRule.getValue() instanceof NestedTagValue) {
-                final NestedTagValue value = (NestedTagValue) tagRule.getValue();
-                result = replaceIterateTag(replaceOptionalTag(result, name, value), name, value);
-            } else {
-                throw new IllegalStateException("Unknown tag value type");
-            }
-        }
-        return applyReplacements(result);
-    }
-
-    /**
-     * Apply the default tag replacements.
-     *
-     * @param template The template to process
-     * @return The filled template
-     */
-    public static String applyReplacements(String template) {
-        String curDate = new Date().toString();
-        return template
-            .replace("{gen_date}", curDate)
-            .replace("{gen_warning}", "AUTO-GENERATED FILE! Do not edit this directly")
-            .replace("{gen_footer}", "---\n\nThis page was automatically generated on the"
-                + " [AuthMe/AuthMeReloaded repository](" + ToolsConstants.DOCS_FOLDER_URL + ")"
-                + " on " + curDate);
-    }
-
-    private static String replaceOptionalTag(String text, String tagName, TagValue<?> tagValue) {
-        Pattern regex = Pattern.compile("\\[" + tagName + "](.*?)\\[/" + tagName + "]", Pattern.DOTALL);
-        Matcher matcher = regex.matcher(text);
-
-        if (!matcher.find()) {
-            // Couldn't find results, so just return text as it is
-            return text;
-        } else if (tagValue.isEmpty()) {
-            // Tag is empty, replace [tagName]some_text[/tagName] to nothing
-            return matcher.replaceAll("");
-        } else {
-            // Tag is not empty, so replace [tagName]some_text[/tagName] to some_text
-            return matcher.replaceAll(matcher.group(1));
-        }
-    }
-
-    /**
-     * Replace iterating tags with the value. Tags of the type [#tag]...[/#tag] specify to iterate over the
-     * entries in {@link NestedTagValue} and to apply any replacements in there.
-     *
-     * @param text The file text
-     * @param tagName The tag name to handle
-     * @param tagValue The associated value
-     * @return The text with the applied replacement
-     */
-    private static String replaceIterateTag(String text, String tagName, NestedTagValue tagValue) {
-        Pattern regex = Pattern.compile("\\[#" + tagName + "](.*?)\\[/#" + tagName + "]\\s?", Pattern.DOTALL);
-        Matcher matcher = regex.matcher(text);
-
-        if (!matcher.find()) {
-            return text;
-        } else if (tagValue.isEmpty()) {
-            return matcher.replaceAll("");
-        }
-        final String innerTemplate = matcher.group(1).trim() + "\n";
-        String result = "";
-        for (TagValueHolder entry : tagValue.getValue()) {
-            result += applyReplacements(innerTemplate, entry);
-        }
-        return matcher.replaceAll(result);
-    }
-
-}
diff --git a/src/test/java/tools/utils/TagValue.java b/src/test/java/tools/utils/TagValue.java
deleted file mode 100644
index 3941ee5c..00000000
--- a/src/test/java/tools/utils/TagValue.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package tools.utils;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * Value of a tag.
- *
- * @param <T> the tag value type
- * @see TagReplacer
- */
-public abstract class TagValue<T> {
-
-    private final T value;
-
-    public TagValue(T value) {
-        this.value = value;
-    }
-
-    public T getValue() {
-        return value;
-    }
-
-    public abstract boolean isEmpty();
-
-    /**
-     * Text value.
-     */
-    public static final class TextTagValue extends TagValue<String> {
-        public TextTagValue(String value) {
-            super(value);
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return getValue().isEmpty();
-        }
-    }
-
-    /**
-     * List value (iterable).
-     */
-    public static final class NestedTagValue extends TagValue<List<TagValueHolder>> {
-        public NestedTagValue() {
-            super(new ArrayList<>());
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return getValue().isEmpty();
-        }
-
-        public void add(TagValueHolder entry) {
-            getValue().add(entry);
-        }
-    }
-}
diff --git a/src/test/java/tools/utils/TagValueHolder.java b/src/test/java/tools/utils/TagValueHolder.java
deleted file mode 100644
index f6c9ec55..00000000
--- a/src/test/java/tools/utils/TagValueHolder.java
+++ /dev/null
@@ -1,34 +0,0 @@
-package tools.utils;
-
-import tools.utils.TagValue.TextTagValue;
-
-import java.util.HashMap;
-import java.util.Map;
-
-
-public final class TagValueHolder {
-
-    private Map<String, TagValue<?>> values;
-
-    private TagValueHolder() {
-        this.values = new HashMap<>();
-    }
-
-    public static TagValueHolder create() {
-        return new TagValueHolder();
-    }
-
-    public TagValueHolder put(String key, TagValue<?> value) {
-        values.put(key, value);
-        return this;
-    }
-
-    public TagValueHolder put(String key, String value) {
-        values.put(key, new TextTagValue(value));
-        return this;
-    }
-
-    public Map<String, TagValue<?>> getValues() {
-        return values;
-    }
-}
diff --git a/src/test/java/tools/utils/ToolTask.java b/src/test/java/tools/utils/ToolTask.java
deleted file mode 100644
index d5cec152..00000000
--- a/src/test/java/tools/utils/ToolTask.java
+++ /dev/null
@@ -1,25 +0,0 @@
-package tools.utils;
-
-import java.util.Scanner;
-
-/**
- * Common interface for tool tasks. Note that the implementing tasks are instantiated
- * with the default constructor. It is required that it be public.
- */
-public interface ToolTask {
-
-    /**
-     * Return the name of the task.
-     *
-     * @return Name of the task
-     */
-    String getTaskName();
-
-    /**
-     * Execute the task.
-     *
-     * @param scanner Scanner to prompt the user with for options. Do not close it.
-     */
-    void execute(Scanner scanner);
-
-}
diff --git a/src/test/java/tools/utils/ToolsConstants.java b/src/test/java/tools/utils/ToolsConstants.java
deleted file mode 100644
index e7ba3e05..00000000
--- a/src/test/java/tools/utils/ToolsConstants.java
+++ /dev/null
@@ -1,21 +0,0 @@
-package tools.utils;
-
-/**
- * Constants for the src/tools folder.
- */
-public final class ToolsConstants {
-
-    public static final String MAIN_SOURCE_ROOT = "src/main/java/";
-
-    public static final String MAIN_RESOURCES_ROOT = "src/main/resources/";
-
-    public static final String TOOLS_SOURCE_ROOT = "src/test/java/tools/";
-
-    public static final String DOCS_FOLDER = "docs/";
-
-    public static final String DOCS_FOLDER_URL = "https://github.com/AuthMe/AuthMeReloaded/tree/master/docs/";
-
-    private ToolsConstants() {
-    }
-
-}
diff --git a/src/test/resources/fr/xephi/authme/command/help/help_test.yml b/src/test/resources/fr/xephi/authme/command/help/help_test.yml
deleted file mode 100644
index 2fe4ee44..00000000
--- a/src/test/resources/fr/xephi/authme/command/help/help_test.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-common:
-    result: 'res.'
-    defaultPermissions:
-        opOnly: 'only op'
-
-section:
-    arguments: 'arg.'
-
-commands:
-    authme:
-        detailedDescription: 'Main command'
-    authme.register:
-        description: 'Registration'
-        detailedDescription: 'Registers the player'
-        arg1:
-            label: 'password'
-            description: 'The password'
-        arg2:
-            label: 'confirmation'
-            description: 'The confirmation'
-    authme.login:
-        description: 'Logging in'
-        arg1:
-            label: 'user password'
diff --git a/src/test/resources/fr/xephi/authme/config.test.yml b/src/test/resources/fr/xephi/authme/config.test.yml
deleted file mode 100644
index f77d55dd..00000000
--- a/src/test/resources/fr/xephi/authme/config.test.yml
+++ /dev/null
@@ -1,389 +0,0 @@
-# Copy of config.yml for integration testing the initialization of AuthMe components
-# Removed DataSource section: DataSource is not concretely instantiated so they should be largely unused
-
-settings:
-    # The name shown in the help messages.
-    helpHeader: AuthMeReloaded
-    sessions:
-        # Do you want to enable the session feature?
-        # If enabled, when a player authenticates successfully,
-        # his IP and his nickname is saved.
-        # The next time the player joins the server, if his IP
-        # is the same of the last time, and the timeout time
-        # hasn't expired, he will not need to authenticate.
-        enabled: false
-        # After how many minutes a session should expire?
-        # 0 for unlimited time (Very dangerous, use it at your own risk!)
-        # Consider that session will end only after the timeout time, and
-        # if the player's ip has changed but the timeout hasn't expired,
-        # player will be kicked out of sever due to invalidSession!
-        timeout: 10
-        # Should the session expire if the player try to login with an
-        # another IP Address?
-        sessionExpireOnIpChange: true
-    restrictions:
-        # Can not authenticated players chat and see the chat log?
-        # Care that this feature blocks also all the commands not
-        # listed in the list below.
-        allowChat: false
-        # Can not authenticated players see the chat log?
-        hideChat: false
-        # Commands allowed when a player is not authenticated
-        allowCommands:
-        - /login
-        - /register
-        - /l
-        - /reg
-        - /email
-        - /captcha
-        # Max number of allowed registrations per IP (default: 1)
-        maxRegPerIp: 1
-        # Max allowed username length
-        maxNicknameLength: 16
-        # When this setting is enabled, online players can't be kicked out
-        # due to "Logged in from another Location"
-        # This setting will prevent potential security exploits.
-        ForceSingleSession: true
-        ForceSpawnLocOnJoin:
-            # If enabled, every player will be teleported to the world spawnpoint
-            # after successful authentication.
-            # The quit location of the player will be overwritten.
-            # This is different from "teleportUnAuthedToSpawn" that teleport player
-            # back to his quit location after the authentication.
-            enabled: false
-            # WorldNames where we need to force the spawn location
-            # Case-sensitive!
-            worlds:
-            - 'world'
-            - 'world_nether'
-            - 'world_the_end'
-        # This option will save the quit location of the players.
-        SaveQuitLocation: false
-        # To activate the restricted user feature you need
-        # to enable this option and configure the
-        # AllowedRestrictedUser field.
-        AllowRestrictedUser: false
-        # The restricted user feature will kick players listed below
-        # if they don't match of the defined ip address.
-        # Example:
-        #   AllowedRestrictedUser:
-        #   - playername;127.0.0.1
-        AllowedRestrictedUser: []
-        # Should unregistered players be kicked immediately?
-        kickNonRegistered: false
-        # Should players be kicked on wrong password?
-        kickOnWrongPassword: false
-        # Should not logged in players be teleported to the spawn?
-        # After the authentication they will be teleported back to
-        # their normal position.
-        teleportUnAuthedToSpawn: false
-        # Minimum allowed nick length
-        minNicknameLength: 4
-        # Can unregistered players walk around?
-        allowMovement: false
-        # Should not authenticated players have speed = 0?
-        # This will reset the fly/walk speed to default value after the login.
-        removeSpeed: true
-        # After how many time players who fail to login or register
-        # should be kicked? Set to 0 to disable.
-        timeout: 30
-        # Regex syntax of allowed characters in the player name.
-        allowedNicknameCharacters: '[a-zA-Z0-9_]*'
-        # How far can unregistered players walk? Set to 0
-        # for unlimited radius
-        allowedMovementRadius: 100
-        # Enable double check of password when you register
-        # when it's true, registration require that kind of command:
-        # /register <password> <confirmPassword>
-        enablePasswordConfirmation: true
-        # Should we protect the player inventory before logging in? Requires ProtocolLib.
-        ProtectInventoryBeforeLogIn: true
-        # Should we deny the tabcomplete feature before logging in? Requires ProtocolLib.
-        DenyTabCompleteBeforeLogin: true
-        # Should we hide the tablist before logging in? Requires ProtocolLib.
-        HideTablistBeforeLogin: true
-        # Should we display all other accounts from a player when he joins?
-        # permission: /authme.admin.accounts
-        displayOtherAccounts: true
-        # Ban ip when the ip is not the ip registered in database
-        banUnsafedIP: false
-        # Spawn Priority, Values : authme, essentials, multiverse, default
-        spawnPriority: authme,essentials,multiverse,default
-        # Maximum Login authorized by IP
-        maxLoginPerIp: 0
-        # Maximum Join authorized by IP
-        maxJoinPerIp: 0
-        # AuthMe will NEVER teleport players !
-        noTeleport: false
-        # Regex syntax for allowed Chars in passwords.
-        allowedPasswordCharacters: '[\x21-\x7E]*'
-        # Keeps collisions disabled for logged players
-        # Works only with MC 1.9
-        keepCollisionsDisabled: false
-    GameMode:
-        # ForceSurvivalMode to player when join ?
-        ForceSurvivalMode: false
-    security:
-        # Minimum length of password
-        minPasswordLength: 5
-        # Maximum length of password
-        passwordMaxLength: 30
-        # this is very important options,
-        # every time player join the server,
-        # if they are registered, AuthMe will switch him
-        # to unLoggedInGroup, this
-        # should prevent all major exploit.
-        # So you can set up on your Permission Plugin
-        # this special group with 0 permissions, or permissions to chat,
-        # or permission to
-        # send private message or all other perms that you want,
-        # the better way is to set up
-        # this group with few permissions,
-        # so if player try to exploit some account,
-        # they can
-        # do anything except what you set in perm Group.
-        # After a correct logged-in player will be
-        # moved to his correct permissions group!
-        # Pay attention group name is case sensitive,
-        # so Admin is different from admin,
-        # otherwise your group will be wiped,
-        # and player join in default group []!
-        # Example unLoggedinGroup: NotLogged
-        unLoggedinGroup: unLoggedinGroup
-        # possible values: MD5, SHA1, SHA256, WHIRLPOOL, XAUTH, MD5VB, PHPBB,
-        # MYBB, IPB3, IPB4, PHPFUSION, SMF, XENFORO, SALTED2MD5, JOOMLA, BCRYPT, WBB3, SHA512,
-        # DOUBLEMD5, PBKDF2, PBKDF2DJANGO, WORDPRESS, ROYALAUTH, CUSTOM(for developpers only)
-        passwordHash: SHA256
-        # salt length for the SALTED2MD5 MD5(MD5(password)+salt)
-        doubleMD5SaltLength: 8
-        # If password checking return false, do we need to check with all
-        # other password algorithm to check an old password?
-        # AuthMe will update the password to the new passwordHash!
-        supportOldPasswordHash: false
-        # Cancel unsafe passwords for being used, put them on lowercase!
-        #unsafePasswords:
-        #- '123456'
-        #- 'password'
-        unsafePasswords:
-        - '123456'
-        - 'password'
-        - 'qwerty'
-        - '12345'
-        - '54321'
-    registration:
-        # enable registration on the server?
-        enabled: true
-        # Send every X seconds a message to a player to
-        # remind him that he has to login/register
-        messageInterval: 5
-        # Only registered and logged in players can play.
-        # See restrictions for exceptions
-        force: true
-        # Do we replace password registration by an email registration method?
-        enableEmailRegistrationSystem: false
-        # Enable double check of email when you register
-        # when it's true, registration require that kind of command:
-        # /register <email> <confirmEmail>
-        doubleEmailCheck: false
-        # Do we force kicking player after a successful registration?
-        # Do not use with login feature below
-        forceKickAfterRegister: false
-        # Does AuthMe need to enforce a /login after a successful registration?
-        forceLoginAfterRegister: false
-    unrestrictions:
-        # below you can list all account names that
-        # AuthMe will ignore for registration or login, configure it
-        # at your own risk!! Remember that if you are going to add
-        # nickname with [], you have to delimit name with ' '.
-        # this option add compatibility with BuildCraft and some
-        # other mods.
-        # It is CaseSensitive!
-        UnrestrictedName: []
-    # Message language, available : en, de, br, cz, pl, fr, ru, hu, sk, es, zhtw, fi, zhcn, lt, it, ko, pt
-    messagesLanguage: en
-    # Force these commands after /login, without any '/', use %p for replace with player name
-    forceCommands: []
-    # Force these commands after /login as a server console, without any '/', use %p for replace with player name
-    forceCommandsAsConsole: []
-    # Force these commands after /register, without any '/', use %p for replace with player name
-    forceRegisterCommands: []
-    # Force these commands after /register as a server console, without any '/', use %p for replace with player name
-    forceRegisterCommandsAsConsole: []
-    # Do we need to display the welcome message (welcome.txt) after a login?
-    # You can use colors in this welcome.txt + some replaced strings:
-    # {PLAYER}: player name, {ONLINE}: display number of online players, {MAXPLAYERS}: display server slots,
-    # {IP}: player ip, {LOGINS}: number of players logged, {WORLD}: player current world, {SERVER}: server name
-    # {VERSION}: get current bukkit version, {COUNTRY}: player country
-    useWelcomeMessage: true
-    # Do we need to broadcast the welcome message to all server or only to the player? set true for server or false for player
-    broadcastWelcomeMessage: false
-    # Should we delay the join message and display it once the player has logged in?
-    delayJoinMessage: false
-    # Should we remove join messages altogether?
-    removeJoinMessage: false
-    # Should we remove leave messages?
-    removeLeaveMessage: false
-    # Do we need to add potion effect Blinding before login/register?
-    applyBlindEffect: false
-    # Do we need to prevent people to login with another case?
-    # If Xephi is registered, then Xephi can login, but not XEPHI/xephi/XePhI
-    preventOtherCase: false
-ExternalBoardOptions:
-    # MySQL column for the salt, needed for some forum/cms support
-    mySQLColumnSalt: ''
-    # MySQL column for the group, needed for some forum/cms support
-    mySQLColumnGroup: ''
-    # -1 mean disabled. If u want that only
-    # activated player can login in your server
-    # u can put in this options the group number
-    # of unactivated user, needed for some forum/cms support
-    nonActivedUserGroup: -1
-    # Other MySQL columns where we need to put the Username (case sensitive)
-    mySQLOtherUsernameColumns: []
-    # How much Log to Round needed in BCrypt(do not change it if you do not know what's your doing)
-    bCryptLog2Round: 10
-    # phpBB prefix defined during phpbb installation process
-    phpbbTablePrefix: 'phpbb_'
-    # phpBB activated group id, 2 is default registered group defined by phpbb
-    phpbbActivatedGroupId: 2
-    # WordPress prefix defined during WordPress installation process
-    wordpressTablePrefix: 'wp_'
-permission:
-    # Take care with this options, if you dont want
-    # to use Vault and Group Switching of
-    # AuthMe for unloggedIn players put true
-    # below, default is false.
-    EnablePermissionCheck: false
-BackupSystem:
-   # Enable or Disable Automatic Backup
-    ActivateBackup: false
-   # set Backup at every start of Server
-    OnServerStart: false
-   # set Backup at every stop of Server
-    OnServerStop: true
-   # Windows only mysql installation Path
-    MysqlWindowsPath: 'C:\Program Files\MySQL\MySQL Server 5.1\'
-Security:
-    SQLProblem:
-        # Stop the server if we can't contact the sql database
-        # Take care with this, if you set that to false,
-        # AuthMe automatically disable and the server is not protected!
-        stopServer: true
-    ReloadCommand:
-        # /reload support
-        useReloadCommandSupport: true
-    console:
-        # Remove spam console
-        noConsoleSpam: false
-        # Copy AuthMe log output in a separate file as well?
-        logConsole: true
-    captcha:
-        # Enable captcha when a player uses wrong password too many times
-        useCaptcha: false
-        # Max allowed tries before a captcha is required
-        maxLoginTry: 5
-        # Captcha length
-        captchaLength: 5
-    stop:
-        # Kick players before stopping the server, that allow us to save position of players, and all needed
-        # information correctly without any corruption.
-        kickPlayersBeforeStopping: true
-    tempban:
-        # Tempban a user's IP address if they enter the wrong password too many times
-        enableTempban: false
-        # How many times a user can attempt to login before their IP being tempbanned
-        maxLoginTries: 10
-        # The length of time a IP address will be tempbanned in minutes
-        # Default: 480 minutes, or 8 hours
-        tempbanLength: 480
-Converter:
-    Rakamak:
-        # Rakamak file name
-        fileName: users.rak
-        # Rakamak use ip ?
-        useIP: false
-        # IP file name for rakamak
-        ipFileName: UsersIp.rak
-    CrazyLogin:
-        # CrazyLogin database file
-        fileName: accounts.db
-Email:
-    # Email SMTP server host
-    mailSMTP: smtp.gmail.com
-    # Email SMTP server port
-    mailPort: 465
-    # Email account that send the mail
-    mailAccount: ''
-    # Email account password
-    mailPassword: ''
-    # Email address, fill when mailAccount is not email address of the account
-    mailAddress: ''
-    # Custom SenderName, that replace the mailAccount name in the email
-    mailSenderName: ''
-    # Random password length
-    RecoveryPasswordLength: 8
-    # Email subject of password get
-    mailSubject: 'Your new AuthMe password'
-    # Like maxRegPerIp but with email
-    maxRegPerEmail: 1
-    # Recall players to add an email?
-    recallPlayers: false
-    # Delay in minute for the recall scheduler
-    delayRecall: 5
-    # Blacklist these domains for emails
-    emailBlacklisted:
-    - 10minutemail.com
-    # WhiteList only these domains for emails
-    emailWhitelisted: []
-    # Do we need to send new password draw in an image?
-    generateImage: false
-    # The email OAuth 2 token (leave empty if not used)
-    emailOauth2Token: ''
-Hooks:
-    # Do we need to hook with multiverse for spawn checking?
-    multiverse: true
-    # Do we need to hook with BungeeCord ?
-    bungeecord: false
-    # Send player to this BungeeCord server after register/login
-    sendPlayerTo: ''
-    # Do we need to disable Essentials SocialSpy on join?
-    disableSocialSpy: true
-    # Do we need to force /motd Essentials command on join?
-    useEssentialsMotd: false
-    # Do we need to cache custom Attributes?
-    customAttributes: false
-Purge:
-    # If enabled, AuthMe automatically purges old, unused accounts
-    useAutoPurge: false
-    # Number of Days an account become Unused
-    daysBeforeRemovePlayer: 60
-    # Do we need to remove the player.dat file during purge process?
-    removePlayerDat: false
-    # Do we need to remove the Essentials/users/player.yml file during purge process?
-    removeEssentialsFile: false
-    # World where are players.dat stores
-    defaultWorld: 'world'
-    # Do we need to remove LimitedCreative/inventories/player.yml, player_creative.yml files during purge process ?
-    removeLimitedCreativesInventories: false
-    # Do we need to remove the AntiXRayData/PlayerData/player file during purge process?
-    removeAntiXRayFile: false
-    # Do we need to remove permissions?
-    removePermissions: false
-Protection:
-    # Enable some servers protection ( country based login, antibot )
-    enableProtection: false
-    # Countries allowed to join the server and register, see http://dev.bukkit.org/bukkit-plugins/authme-reloaded/pages/countries-codes/ for countries' codes
-    # PLEASE USE QUOTES!
-    countries:
-    - 'US'
-    - 'GB'
-    # Countries blacklisted automatically (without any needed to enable protection)
-    # PLEASE USE QUOTES!
-    countriesBlacklist:
-    - 'A1'
-    # Do we need to enable automatic antibot system?
-    enableAntiBot: true
-    # Max number of player allowed to login in 5 secs before enable AntiBot system automatically
-    antiBotSensibility: 10
-    # Duration in minutes of the antibot automatic system
-    antiBotDuration: 10
diff --git a/src/test/resources/fr/xephi/authme/data/backup/sample-folder/data.json b/src/test/resources/fr/xephi/authme/data/backup/sample-folder/data.json
deleted file mode 100644
index ee1ae20a..00000000
--- a/src/test/resources/fr/xephi/authme/data/backup/sample-folder/data.json
+++ /dev/null
@@ -1,15 +0,0 @@
-{
-  "location": {
-    "world": "nether",
-    "x": -113.219,
-    "y": 72.0,
-    "z": 130.637,
-    "yaw": -292.484,
-    "pitch": 24.15
-  },
-  "operator": true,
-  "can-fly": true,
-  "walk-speed": 0.2,
-  "fly-speed": 0.1,
-  "group": "players"
-}
diff --git a/src/test/resources/fr/xephi/authme/data/limbo/seg16-8-limbo.json b/src/test/resources/fr/xephi/authme/data/limbo/seg16-8-limbo.json
deleted file mode 100644
index f22e472a..00000000
--- a/src/test/resources/fr/xephi/authme/data/limbo/seg16-8-limbo.json
+++ /dev/null
@@ -1,35 +0,0 @@
-{
-  "88897c88-7c8f-c12e-4931-6206d4ca067d": {
-    "location": {
-      "world": "world",
-      "x": -196.69999998807907,
-      "y": 67.0,
-      "z": 5.699999988079071,
-      "yaw": 222.14977,
-      "pitch": 10.649977
-    },
-    "groups": [
-      "staff",
-      "mod"
-    ],
-    "operator": true,
-    "can-fly": false,
-    "walk-speed": 0.3,
-    "fly-speed": 0.1
-  },
-  "8c679491-1234-abcd-9102-1fa6e0cc3f81": {
-    "location": {
-      "world": "nether",
-      "x": 300.12345,
-      "y": 42.3,
-      "z": -72.482749988079071,
-      "yaw": 100.27788,
-      "pitch": 4.242111
-    },
-    "group": "primary",
-    "operator": false,
-    "can-fly": true,
-    "walk-speed": 0.1,
-    "fly-speed": 0.0
-  }
-}
diff --git a/src/test/resources/fr/xephi/authme/data/limbo/seg16-f-limbo.json b/src/test/resources/fr/xephi/authme/data/limbo/seg16-f-limbo.json
deleted file mode 100644
index 9f256262..00000000
--- a/src/test/resources/fr/xephi/authme/data/limbo/seg16-f-limbo.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "fab69c88-2cd0-1fed-f00d-dead14ca067d": {
-    "location": {
-      "world": "world",
-      "x": -196.69999998807907,
-      "y": 67.0,
-      "z": 5.699999988079071,
-      "yaw": 222.14977,
-      "pitch": 10.649977
-    },
-    "group": "",
-    "operator": false,
-    "can-fly": false,
-    "walk-speed": 0.2,
-    "fly-speed": 0.1
-  }
-}
diff --git a/src/test/resources/fr/xephi/authme/data/limbo/seg32-01011-limbo.json b/src/test/resources/fr/xephi/authme/data/limbo/seg32-01011-limbo.json
deleted file mode 100644
index 0967ef42..00000000
--- a/src/test/resources/fr/xephi/authme/data/limbo/seg32-01011-limbo.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
diff --git a/src/test/resources/fr/xephi/authme/data/limbo/seg32-10110-limbo.json b/src/test/resources/fr/xephi/authme/data/limbo/seg32-10110-limbo.json
deleted file mode 100644
index b50fb8bd..00000000
--- a/src/test/resources/fr/xephi/authme/data/limbo/seg32-10110-limbo.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "f6a97c88-7c8f-c12e-4931-6206d4ca067d": {
-    "location": {
-      "world": "lobby",
-      "x": -120.31415,
-      "y": 25.0,
-      "z": -80.71234,
-      "yaw": 22.14977,
-      "pitch": 40.649977
-    },
-    "group": "noob",
-    "operator": false,
-    "can-fly": true,
-    "walk-speed": 0.2,
-    "fly-speed": 0.1
-  }
-}
diff --git a/src/test/resources/fr/xephi/authme/datasource/converter/LoginSecurity.db b/src/test/resources/fr/xephi/authme/datasource/converter/LoginSecurity.db
deleted file mode 100644
index 5f989c9b..00000000
Binary files a/src/test/resources/fr/xephi/authme/datasource/converter/LoginSecurity.db and /dev/null differ
diff --git a/src/test/resources/fr/xephi/authme/datasource/converter/crazylogin.db b/src/test/resources/fr/xephi/authme/datasource/converter/crazylogin.db
deleted file mode 100644
index 5498db81..00000000
--- a/src/test/resources/fr/xephi/authme/datasource/converter/crazylogin.db
+++ /dev/null
@@ -1,3 +0,0 @@
-name|password|ips|lastAction|loginFails|passwordExpired
-qotaTo|8267663ab198a96437b9f455429a2c1b6c943111613c217bf2703c14d08a309d34e510ddb5549507b1500759dbcf9d4a99bc765ff37b32bd31adbb1e92e74ac5|127.0.0.1|2016-05-27 21:45:57|0|false
-Bobby|ad50dbc841e6321210530801f5219a5ffb4c7c41f11878d465374a4b8db2965c50f69b6098918a58e4adea312e3633c7724b15e24a217009e6fa2b3c299d55f2|127.0.0.1|2016-05-27 21:45:40|0|false
diff --git a/src/test/resources/fr/xephi/authme/datasource/converter/loginsecurity.sql b/src/test/resources/fr/xephi/authme/datasource/converter/loginsecurity.sql
deleted file mode 100644
index 361fe87a..00000000
--- a/src/test/resources/fr/xephi/authme/datasource/converter/loginsecurity.sql
+++ /dev/null
@@ -1,34 +0,0 @@
-CREATE TABLE ls_players (
-    id integer not null,
-    unique_user_id varchar(128),
-    last_name varchar(16),
-    ip_address varchar(64),
-    password varchar(512),
-    hashing_algorithm integer,
-    location_id integer,
-    inventory_id integer,
-    last_login datetime,
-    registration_date date,
-    optlock integer not null,
-    uuid_mode varchar(1) check ( uuid_mode in ('M','U','O')),
-    constraint uq_ls_players_unique_user_id unique (unique_user_id),
-    constraint uq_ls_players_location_id unique (location_id),
-    constraint uq_ls_players_inventory_id unique (inventory_id),
-    constraint pk_ls_players primary key (id)
-);
-CREATE TABLE ls_locations (
-    id integer not null,
-    world varchar(255),
-    x double,
-    y double,
-    z double,
-    yaw integer,
-    pitch integer,
-    constraint pk_ls_locations primary key (id)
-);
-
-INSERT INTO ls_players VALUES(1,'0cb1fa9b-846a-3cda-a1d9-5a9d6939ce14','Player1',NULL,'$2a$10$E1Ri7XKeIIBv4qVaiPplgepT7QH9xGFh3hbHfcmCjq7hiW.UBTiGK',7,NULL,NULL,'2017-05-08T11:14:53+00:00','2017-05-08',1,'O');
-INSERT INTO ls_players VALUES(2,'6765ad15-4e42-364e-a116-3ca7a7433d08','Player2','127.4.5.6','$2a$10$p27YkDQWrDHS/7k/l/86xeHW5NBnFEL61.2o2Y.BM5IEn/yrZC5VW',7,NULL,NULL,'2017-03-12T11:22:33+00:00','2017-01-04',1,'O');
-INSERT INTO ls_players VALUES(3,'1a1975b9-0bbd-3ced-afb8-1059d8c22c9e','Player3','127.8.9.0','$2a$10$WFui8KSXMLDOVXKFpCLyPukPi4M82w1cv/rNojsAnwJjba3pp8sba',7,NULL,NULL,'2017-04-20T15:02:19+00:00','2017-03-17',1,'O');
-
-INSERT INTO ls_locations VALUES(3, 'hubb', 14.24, 67.99, -12.83, -10, 185);
diff --git a/src/test/resources/fr/xephi/authme/datasource/flatfile-test.txt b/src/test/resources/fr/xephi/authme/datasource/flatfile-test.txt
deleted file mode 100644
index d0ac4aa5..00000000
--- a/src/test/resources/fr/xephi/authme/datasource/flatfile-test.txt
+++ /dev/null
@@ -1,7 +0,0 @@
-bobby:$SHA$11aa0706173d7272$dbba966:123.45.67.89:1449136800:1.05:2.1:4.2:world:your@email.com
-user:b28c32f624a4eb161d6adc9acb5bfc5b:34.56.78.90:1453242857:124.1:76.3:-127.8:nether:user@example.org
-twofields:hash1234
-threefields:hash369:33.33.33.33
-fourfields:$hash$4444:4.4.4.4:404040404
-sevenfields:hash7749:5.5.5.55:1414141414:7.7:14.14:21.21
-eightfields:hash8168:6.6.6.66:1234567888:8.8:17.6:26.4:eightworld
diff --git a/src/test/resources/fr/xephi/authme/datasource/sql-initialize.sql b/src/test/resources/fr/xephi/authme/datasource/sql-initialize.sql
deleted file mode 100644
index 9af52499..00000000
--- a/src/test/resources/fr/xephi/authme/datasource/sql-initialize.sql
+++ /dev/null
@@ -1,28 +0,0 @@
--- Important: separate SQL statements by ; followed directly by a newline. We split the file contents by ";\n"
-
-CREATE TABLE authme (
-    id INTEGER AUTO_INCREMENT PRIMARY KEY,
-    username VARCHAR(255) NOT NULL UNIQUE,
-    password VARCHAR(255) NOT NULL,
-    totp VARCHAR(16),
-    ip VARCHAR(40),
-    lastlogin BIGINT,
-    regdate BIGINT NOT NULL,
-    regip VARCHAR(40),
-    x DOUBLE NOT NULL DEFAULT '0.0',
-    y DOUBLE NOT NULL DEFAULT '0.0',
-    z DOUBLE NOT NULL DEFAULT '0.0',
-    world VARCHAR(255) NOT NULL DEFAULT 'world',
-    yaw FLOAT,
-    pitch FLOAT,
-    email VARCHAR(255),
-    isLogged INT DEFAULT '0',
-    realname VARCHAR(255) NOT NULL DEFAULT 'Player',
-    salt varchar(255),
-    hasSession INT NOT NULL DEFAULT '0'
-);
-
-INSERT INTO authme (username, password, ip, lastlogin, x, y, z, world, yaw, pitch, email, isLogged, realname, salt, regdate, regip, totp)
-VALUES ('bobby','$SHA$11aa0706173d7272$dbba966','123.45.67.89',1449136800,1.05,2.1,4.2,'world',-0.44,2.77,'your@email.com',0,'Bobby',NULL,1436778723,'127.0.4.22','JBSWY3DPEHPK3PXP');
-INSERT INTO authme (username, password, ip, lastlogin, x, y, z, world, yaw, pitch, email, isLogged, realname, salt, regdate)
-VALUES ('user','b28c32f624a4eb161d6adc9acb5bfc5b','34.56.78.90',1453242857,124.1,76.3,-127.8,'nether',0.23,4.88,'user@example.org',0,'user','f750ba32',0);
diff --git a/src/test/resources/fr/xephi/authme/datasource/sqlite.april2016.db b/src/test/resources/fr/xephi/authme/datasource/sqlite.april2016.db
deleted file mode 100644
index 8973f01d..00000000
Binary files a/src/test/resources/fr/xephi/authme/datasource/sqlite.april2016.db and /dev/null differ
diff --git a/src/test/resources/fr/xephi/authme/message/chinese_texts.yml b/src/test/resources/fr/xephi/authme/message/chinese_texts.yml
deleted file mode 100644
index 5cb7228b..00000000
--- a/src/test/resources/fr/xephi/authme/message/chinese_texts.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-first: '错误的密码'
-second: '为了验证您的身份，您需要将一个电子邮件地址与您的帐户绑定！'
-third: '您已经可以在当前会话中执行任何敏感命令！'
diff --git a/src/test/resources/fr/xephi/authme/message/help_test.yml b/src/test/resources/fr/xephi/authme/message/help_test.yml
deleted file mode 100644
index d6970daa..00000000
--- a/src/test/resources/fr/xephi/authme/message/help_test.yml
+++ /dev/null
@@ -1,109 +0,0 @@
-common:
-  header: 'My custom help header'
-  optional: t-opt
-  result: t-res
-  defaultPermissions:
-    notAllowed: t-noperm
-    allowed: t-allperm
-
-section:
-  command: my command translation
-  description: ''  # <-- empty! Must be kept
-  children: ''
-
-commands:
-  # Full command entries
-  authme:
-    description: test auth desc
-    detailedDescription: test auth long desc
-  authme.register:
-    description: test reg desc
-    detailedDescription: test reg long desc
-    arg1:
-      label: test reg arg1
-      description: test reg arg1 text
-    arg2:
-      label: test reg arg2
-      description: test reg arg2 text
-
-  # Command with only one property specified
-  authme.unregister:
-    detailedDescription: Detailed description for unregister.
-
-  # Command with only one argument present
-  authme.password:
-    arg2:
-      label: pwd
-      description: New password
-
-  # Subcommand without an entry for the parent (email)
-  email.add:
-    description: email add desc
-    detailedDescription: email add long desc
-    arg1:
-      label: add arg1
-      description: add arg1 text
-    arg2:
-      label: add arg2
-      description: add arg2 text
-
-  # Unknown subcommand
-  email.doesNotExist:
-    description: Command that doesn't exist
-    detailedDescription: Command that doesn't exist
-    arg1:
-      label: arg1
-      description: Command that doesn't exist
-    arg2:
-      label: arg2
-      description: Command that doesn't exist
-
-  # Command with unknown properties
-  login:
-    unknownProperty: This does not exist
-    detailedDescription: /login detailed desc.
-    arg1:
-      label: loginArg
-      nonExistent: does not exist
-    someProp:
-      label: '''someProp'' does not exist'
-      description: idk
-
-  # Command that is not present at all
-  #logout:
-  #  description: Logout command
-  #  detailedDescription: Command to logout using AuthMeReloaded.
-
-  # Entry with too many args
-  unregister:
-    description: unreg_desc
-    detailedDescription: unreg_detail_desc
-    arg1:
-      label: unreg_arg_label
-      description: unreg_arg_desc
-    arg2:
-      label: This argument does not exist.
-      description: argument does not exist
-
-  # Entry with invalid data types
-  changepassword:
-    description:
-    - a list
-    - instead of text
-    detailedDescription: 1337
-    arg1:
-      label: true
-      description: []
-    arg2:
-      label:
-        unexpected: 5
-        object: 4
-      description: null
-
-  # Entry with empty texts! These need to be preserved
-  captcha:
-    description: Captcha command
-    detailedDescription: 'Captcha detail'
-    arg1:
-      label: ''
-      description: ''
diff --git a/src/test/resources/fr/xephi/authme/message/messages_default.yml b/src/test/resources/fr/xephi/authme/message/messages_default.yml
deleted file mode 100644
index 786d296b..00000000
--- a/src/test/resources/fr/xephi/authme/message/messages_default.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-# Simulates a default file
-
-wrong_pwd: 'This message is overridden in messages_test.yml'
-reg_only: 'Message from default file'
-logged_in: '&cYou''re already logged in!'
diff --git a/src/test/resources/fr/xephi/authme/message/messages_en_old.yml b/src/test/resources/fr/xephi/authme/message/messages_en_old.yml
deleted file mode 100644
index 92def98f..00000000
--- a/src/test/resources/fr/xephi/authme/message/messages_en_old.yml
+++ /dev/null
@@ -1,121 +0,0 @@
-# messages_en.yml file with old keys and placeholders (prior to 5.5)
-# Messages commented with '# Custom' don't correspond to the default messages,
-# allowing to check that they have not been overridden
-
-# Registration
-reg_msg: '&3Please, register to the server with the command: /register <password> <ConfirmPassword>'
-usage_reg: '&cUsage: /register <password> <ConfirmPassword>'
-reg_only: '&4Only registered users can join the server! Please visit http://example.com to register yourself!'
-kicked_admin_registered: 'An admin just registered you; please log in again'
-registered: '&2Successfully registered!'
-reg_disabled: '&cIn-game registration is disabled!'
-user_regged: '&cYou already have registered this username!'
-
-# Password errors on registration
-password_error: 'Password error message'  ## Custom
-password_error_nick: '&cYou can''t use your name as password, please choose another one...'
-password_error_unsafe: '&cThe chosen password isn''t safe, please choose another one...'
-password_error_chars: '&4Your password contains illegal characters. Allowed chars: REG_EX'
-pass_len: '&cYour password is too short or too long! Please try with another one!'
-
-# Login
-usage_log: '&cUsage: /login <password>'
-wrong_pwd: '&cWrong password!'
-login: '&2Successful login!'
-login_msg: '&cPlease, login with the command: /login <password>'
-timeout: '&4Login timeout exceeded, you have been kicked from the server, please try again!'
-
-# Errors
-unknown_user: '&cThis user isn''t registered!'
-denied_command: '&cIn order to use this command you must be authenticated!'
-denied_chat: '&cIn order to chat you must be authenticated!'
-not_logged_in: '&cYou''re not logged in!'
-tempban_max_logins: '&cYou have been temporarily banned for failing to log in too many times.'
-max_reg: '&cYou have exceeded the maximum number of registrations (%reg_count/%max_acc %reg_names) for your connection!'
-no_perm: '&4You don''t have the permission to perform this action!'
-error: '&4An unexpected error occurred, please contact an administrator!'
-kick_forvip: '&3A VIP player has joined the server when it was full!'
-
-# AntiBot
-kick_antibot: 'AntiBot protection mode is enabled! You have to wait some minutes before joining the server.'
-antibot_auto_enabled: '&4[AntiBotService] AntiBot enabled due to the huge number of connections!'
-antibot_auto_disabled: '&2[AntiBotService] AntiBot disabled after %m minutes!'
-
-# Other messages
-unregistered: '&cSuccessfully unregistered!'
-accounts_owned_self: 'You own %count accounts:'
-accounts_owned_other: 'The player %name has %count accounts:'
-two_factor_create: '&2Your secret code is %code. You can scan it from here %url'
-recovery_code_sent: 'A recovery code to reset your password has been sent to your email.'
-recovery_code_incorrect: 'The recovery code is not correct! You have %count tries remaining.'
-recovery_tries_exceeded: 'You have exceeded the maximum number attempts to enter the recovery code. Use "/email recovery [email]" to generate a new one.'
-recovery_code_correct: 'Recovery code entered correctly!'
-recovery_change_password: 'Please use the command /email setpassword <new password> to change your password immediately.'
-vb_nonActiv: '&cYour account isn''t activated yet, please check your emails!'
-usage_unreg: '&cUsage: /unregister <password>'
-pwd_changed: '&2Password changed successfully!'
-logged_in: '&cYou''re already logged in!'
-logout: '&2Logged out successfully!'
-reload: '&2Configuration and database have been reloaded correctly!'
-usage_changepassword: '&cUsage: /changepassword <oldPassword> <newPassword>'
-
-# Session messages
-invalid_session: '&cYour IP has been changed and your session data has expired!'
-valid_session: '&2Logged-in due to Session Reconnection.'
-
-# Error messages when joining
-name_len: '&4Your username is either too short or too long!'
-regex: 'not valid username: Allowed chars are REG_EX'  ## Custom
-country_banned: '&4Your country is banned from this server!'
-not_owner_error: 'You are not the owner of this account. Please choose another name!'
-kick_fullserver: '&4The server is full, try again later!'
-same_nick: '&4The same username is already playing on the server!'
-invalid_name_case: 'You should join using username %valid, not %invalid.'
-same_ip_online: 'A player with the same IP is already in game!'
-
-# Email
-usage_email_add: '&cUsage: /email add <email> <confirmEmail>'
-usage_email_change: '&cUsage: /email change <oldEmail> <newEmail>'
-usage_email_recovery: '&cUsage: /email recovery <Email>'
-new_email_invalid: '&cInvalid new email, try again!'
-old_email_invalid: 'Email (old) is not valid!!'  ## Custom
-email_invalid: '&cInvalid email address, try again!'
-email_added: '&2Email address successfully added to your account!'
-email_confirm: '&cPlease confirm your email address!'
-email_changed: '&2Email address changed correctly!'
-email_send: '&2Recovery email sent successfully! Please check your email inbox!'
-email_show: '&2Your current email address is: &f%email'
-incomplete_email_settings: 'Error: not all required settings are set for sending emails. Please contact an admin.'
-email_already_used: '&4The email address is already being used'
-email_send_failure: 'The email could not be sent. Please contact an administrator.'
-show_no_email: '&2You currently don''t have email address associated with this account.'
-add_email: '&3Please add your email to your account with the command: /email add <yourEmail> <confirmEmail>'
-recovery_email: '&3Forgot your password? Please use the command: /email recovery <yourEmail>'
-change_password_expired: 'You cannot change your password using this command anymore.'
-email_cooldown_error: '&cAn email was already sent recently. You must wait %time before you can send a new one.'
-
-# Captcha
-usage_captcha: '&3To log in you have to solve a captcha code, please use the command: /captcha <theCaptcha>'
-wrong_captcha: 'The captcha code is THE_CAPTCHA for you' ## Custom
-valid_captcha: '&2Captcha code solved correctly!'
-captcha_for_registration: 'Now type /captcha <theCaptcha>' ## Custom
-register_captcha_valid: '&2Valid captcha! You may now register with /register'
-
-# Verification code
-verification_code_required: '&3This command is sensitive and requires an email verification! Check your inbox and follow the email''s instructions.'
-usage_verification_code: '&cUsage: /verification <code>'
-incorrect_verification_code: '&cIncorrect code, please type "/verification <code>" into the chat, using the code you received by email'
-verification_code_verified: '&2Your identity has been verified! You can now execute all commands within the current session!'
-verification_code_already_verified: '&2You can already execute every sensitive command within the current session!'
-verification_code_expired: '&3Your code has expired! Execute another sensitive command to get a new code!'
-verification_code_email_needed: '&3To verify your identity you need to link an email address with your account!!'
-
-# Time units
-second: 'second'
-seconds: 'seconds in plural' ## Custom
-minute: 'minute'
-minutes: 'minutes'
-hour: 'hour'
-hours: 'hours'
-day: 'day'
-days: 'days'
diff --git a/src/test/resources/fr/xephi/authme/message/messages_test.yml b/src/test/resources/fr/xephi/authme/message/messages_test.yml
deleted file mode 100644
index 93287786..00000000
--- a/src/test/resources/fr/xephi/authme/message/messages_test.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-# Sample messages file
-
-error:
-  unregistered_user: 'We''ve got%nl%new lines%nl%and '' apostrophes'
-registration:
-  register_request: '&3Please %username%, register to the %displayname%&3.'
-login:
-  success: '&cHere we have&bdefined some colors &dand some other &lthings'
-  wrong_password: '&cWrong password!'
-  command_usage: '&cUsage: /login <password>'
-reg_voluntarily: 'You can register yourself to the server with the command "/register <password> <ConfirmPassword>"'
-captcha:
-  wrong_captcha: 'Use /captcha %captcha_code to solve the captcha'
-email:
-  already_used: ''
diff --git a/src/test/resources/fr/xephi/authme/message/messages_test2.yml b/src/test/resources/fr/xephi/authme/message/messages_test2.yml
deleted file mode 100644
index f2871ddb..00000000
--- a/src/test/resources/fr/xephi/authme/message/messages_test2.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-# Sample messages file
-
-unknown_user: 'Message from test2'
-login: 'test2 - login'
-not_logged_in: 'test2 - not logged in'
-wrong_pwd: 'test2 - wrong password'
-misc:
-  two_factor_create: 'Old 2fa create text'
diff --git a/src/test/resources/fr/xephi/authme/service/yaml/invalidYaml.yml b/src/test/resources/fr/xephi/authme/service/yaml/invalidYaml.yml
deleted file mode 100644
index 02daab8c..00000000
--- a/src/test/resources/fr/xephi/authme/service/yaml/invalidYaml.yml
+++ /dev/null
@@ -1,5 +0,0 @@
-# File with invalid YAML
-test:
-  abc: 'test'
-  def: 'Going to forget a quote here
-  jkl: 'Test test'
diff --git a/src/test/resources/fr/xephi/authme/service/yaml/validYaml.yml b/src/test/resources/fr/xephi/authme/service/yaml/validYaml.yml
deleted file mode 100644
index cebbd0b9..00000000
--- a/src/test/resources/fr/xephi/authme/service/yaml/validYaml.yml
+++ /dev/null
@@ -1,4 +0,0 @@
-test:
-  abc: 'test'
-  def: 'All quotes are good here'
-  jkl: 'Test test'
diff --git a/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.complete.yml b/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.complete.yml
deleted file mode 100644
index a2919ee7..00000000
--- a/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.complete.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-# Sample commands.yml file
-
-onJoin:
-    broadcast:
-        command: 'broadcast %nick has joined'
-        executor: CONSOLE
-onRegister:
-    announce:
-        command: 'me I just registered'
-        executor: PLAYER
-        delay: 100
-    notify:
-        command: 'log %p (%ip, %country) registered'
-        executor: CONSOLE
-        delay: 100
-onLogin:
-    welcome:
-        command: 'msg %p Welcome back'
-        executor: CONSOLE
-    show_motd:
-        command: 'motd'
-        executor: PLAYER
-        delay: 60
-    display_list:
-        command: 'list'
-        executor: PLAYER
-        delay: 120
-    warn_for_alts:
-        command: 'helpop Player %p has more than 1 account'
-        executor: CONSOLE
-        ifNumberOfAccountsAtLeast: 2
-        delay: 180
-    log_suspicious_user:
-        command: 'log %p %ip many accounts'
-        executor: CONSOLE
-        ifNumberOfAccountsAtLeast: 5
-        ifNumberOfAccountsLessThan: 20
-        delay: 240
-onSessionLogin:
-    welcome:
-        command: 'msg %p Session login!'
-        executor: CONSOLE
-onFirstLogin:
-    give_money:
-        command: 'pay %p 30'
-        executor: CONSOLE
-        ifNumberOfAccountsLessThan: 3
-onUnregister: {}
-onLogout:
-    announce:
-        command: 'broadcast %p (%ip) logged out'
-        executor: CONSOLE
diff --git a/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.empty.yml b/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.empty.yml
deleted file mode 100644
index e69de29b..00000000
diff --git a/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.incomplete.yml b/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.incomplete.yml
deleted file mode 100644
index 2c2edaad..00000000
--- a/src/test/resources/fr/xephi/authme/settings/commandconfig/commands.incomplete.yml
+++ /dev/null
@@ -1,26 +0,0 @@
-# Sample commands.yml file with wrong and missing sections
-
-onJoin:
-    broadcast:
-        command: 'broadcast %p has joined'
-        executor: CONSOLE
-onLogin:
-    welcome:
-        command: 'msg %p Welcome back, %nick'
-        executor: CONSOLE
-        delay: 0
-    show_motd:
-        # command: 'motd' <-- mandatory property, so entry should be ignored
-        executor: PLAYER
-    display_list:
-        command: 'list'
-        executor: WRONG_EXECUTOR
-        delay: 100
-doesNotExist:
-    wrongEntry:
-        command: 'should be ignored'
-        executor: PLAYER
-onUnregister:
-    farewell:
-        command: 'msg %p sad to see you go!'
-        executor: CONSOLE
diff --git a/src/test/resources/fr/xephi/authme/settings/config-incomplete-sample.yml b/src/test/resources/fr/xephi/authme/settings/config-incomplete-sample.yml
deleted file mode 100644
index 65990e84..00000000
--- a/src/test/resources/fr/xephi/authme/settings/config-incomplete-sample.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-# Test config file with missing options from TestConfiguration
-# Notice the commented out lines!
-
-test:
-    duration: 22
-#    systemName: 'Custom sys name'
-sample:
-    ratio:
-#        order: 'THIRD'
-        fields:
-            - 'Australia'
-            - 'Burundi'
-            - 'Colombia'
-#version: 2492
-features:
-#    boring:
-#        skip: false
-#        colors:
-#            - 'beige'
-#            - 'gray'
-#        dustLevel: 1
-    cool:
-#        enabled: true
-        options:
-            - 'Dinosaurs'
-            - 'Explosions'
-            - 'Big trucks'
diff --git a/src/test/resources/fr/xephi/authme/settings/config-old.yml b/src/test/resources/fr/xephi/authme/settings/config-old.yml
deleted file mode 100644
index 2e34180c..00000000
--- a/src/test/resources/fr/xephi/authme/settings/config-old.yml
+++ /dev/null
@@ -1,422 +0,0 @@
-# Old default config file, based on commit 1f001f2 (2015-12-06)
-
-DataSource:
-    # What type of database do you want to use?
-    # Valid values: sqlite, mysql
-    backend: sqlite
-    # Enable database caching, should improve database performance
-    caching: true
-    # Database location
-    mySQLHost: 127.0.0.1
-    # Database Port
-    mySQLPort: '3306'
-    # Username about Database Connection Infos
-    mySQLUsername: authme
-    # Password about Database Connection Infos
-    mySQLPassword: '12345'
-    # Database Name, use with converters or as SQLITE database name
-    mySQLDatabase: authme
-    # Table of the database
-    mySQLTablename: authme
-    # Column of IDs to sort data
-    mySQLColumnId: id
-    # Column for storing or checking players nickname
-    mySQLColumnName: username
-    # Column for storing players passwords
-    mySQLColumnPassword: password
-    # Column for storing players emails
-    mySQLColumnEmail: email
-    # Column for Saving if a player is logged in or not
-    mySQLColumnLogged: isLogged
-    # Column for storing players IPs
-    mySQLColumnIp: ip
-    # Column for storing players lastlogins
-    mySQLColumnLastLogin: lastlogin
-    # Column for SaveQuitLocation - X
-    mySQLlastlocX: x
-    # Column for SaveQuitLocation - Y
-    mySQLlastlocY: y
-    # Column for SaveQuitLocation - Z
-    mySQLlastlocZ: z
-    # Column for SaveQuitLocation - World name
-    mySQLlastlocWorld: world
-    # Column for RealName
-    mySQLRealName: realname
-    # Enable this when you allow registration through a website
-    mySQLWebsite: false
-settings:
-    # The name shown in the help messages.
-    helpHeader: AuthMeReloaded
-    sessions:
-        # Do you want to enable the session feature?
-        # If enabled, when a player authenticates successfully,
-        # his IP and his nickname is saved.
-        # The next time the player joins the server, if his IP
-        # is the same of the last time, and the timeout time
-        # hasn't expired, he will not need to authenticate.
-        enabled: false
-        # After how many minutes a session should expire?
-        # 0 for unlimited time (Very dangerous, use it at your own risk!)
-        # Consider that session will end only after the timeout time, and
-        # if the player's ip has changed but the timeout hasn't expired,
-        # player will be kicked out of sever due to invalidSession!
-        timeout: 10
-        # Should the session expire if the player try to login with an
-        # another IP Address?
-        sessionExpireOnIpChange: true
-    restrictions:
-        # Can not authenticated players chat and see the chat log?
-        # Care that this feature blocks also all the commands not
-        # listed in the list below.
-        allowChat: false
-        # Commands allowed when a player is not authenticated
-        allowCommands:
-        - /login
-        - /register
-        - /l
-        - /reg
-        - /email
-        - /captcha
-        # Max number of allowed registrations per IP (default: 1)
-        maxRegPerIp: 1
-        # Max allowed username length
-        maxNicknameLength: 16
-        # When this setting is enabled, online players can't be kicked out
-        # due to "Logged in from another Location"
-        # This setting will prevent potetial security exploits.
-        ForceSingleSession: true
-        # If enabled, every player will be teleported to the world spawnpoint
-        # after successful authentication.
-        # The quit location of the player will be overwritten.
-        # This is different from "teleportUnAuthedToSpawn" that teleport player
-        # back to his quit location after the authentication.
-        ForceSpawnLocOnJoinEnabled: true
-        # This option will save the quit location of the players.
-        SaveQuitLocation: false
-        # To activate the restricted user feature you need
-        # to enable this option and configure the
-        # AllowedRestrctedUser field.
-        AllowRestrictedUser: false
-        # The restricted user feature will kick players listed below
-        # if they dont match of the defined ip address.
-        # Example:
-        #   AllowedRestrictedUser:
-        #   - playername;127.0.0.1
-        AllowedRestrictedUser:
-        - playername;127.0.0.1
-        # Should unregistered players be kicked immediatly?
-        kickNonRegistered: false
-        # Should players be kicked on wrong password?
-        kickOnWrongPassword: false
-        # Should not logged in players be teleported to the spawn?
-        # After the authentication they will be teleported back to
-        # their normal position.
-        teleportUnAuthedToSpawn: false
-        # Minimum allowed nick length
-        minNicknameLength: 4
-        # Can unregistered players walk around?
-        allowMovement: false
-        # Should not authenticated players have speed = 0?
-        # This will reset the fly/walk speed to default value after the login.
-        removeSpeed: true
-        # After how many time players who fail to login or register
-        # should be kicked? Set to 0 to disable.
-        timeout: 30
-        # Regex sintax of allowed characters in the player name.
-        allowedNicknameCharacters: '[a-zA-Z0-9_?]*'
-        # How far can unregistered players walk? Set to 0
-        # for unlimited radius
-        allowedMovementRadius: 100
-        # Enable double check of password when you register
-        # when it's true, registration require that kind of command:
-        # /register <password> <confirmPassword>
-        enablePasswordVerifier: true
-        # Should we protect the player inventory before logging in?
-        ProtectInventoryBeforeLogIn: true
-        # Should we display all other accounts from a player when he joins?
-        # permission: /authme.admin.accounts
-        displayOtherAccounts: true
-        # WorldNames where we need to force the spawn location for ForceSpawnLocOnJoinEnabled
-        # CASE SENSITIVE
-        ForceSpawnOnTheseWorlds:
-        - survival
-        - survival_nether
-        - creative
-        # Ban ip when the ip is not the ip registered in database
-        banUnsafedIP: false
-        # Spawn Priority, Values : authme, essentials, multiverse, default
-        spawnPriority: authme,essentials,multiverse,default
-        # Maximum Login authorized by IP
-        maxLoginPerIp: 0
-        # Maximum Join authorized by IP
-        maxJoinPerIp: 0
-        # AuthMe will NEVER teleport players !
-        noTeleport: false
-        # Regex sintax for allowed Chars in passwords.
-        allowedPasswordCharacters: '[\x21-\x7E]*'
-        # Command to run when a user has more accounts than the configured threshold.
-        # Available variables: %playername%, %playerip%
-        otherAccountsCmd: 'msg admin %playername% has a lot of accounts!'
-        # Threshold of the other accounts command, a value less than 2 means disabled.
-        otherAccountsCmdThreshold: 5
-    GameMode:
-        # ForceSurvivalMode to player when join ?
-        ForceSurvivalMode: false
-        # if player join with CreativeMode and ForceSurvivalMode: true
-        # inventory will be wipped
-        ResetInventoryIfCreative: false
-        # Do we need to force the survival mode ONLY after /login process ?
-        ForceOnlyAfterLogin: false
-    security:
-        # minimum Length of password
-        minPasswordLength: 5
-        # this is very important options,
-        # every time player join the server,
-        # if they are registered, AuthMe will switch him
-        # to unLoggedInGroup, this
-        # should prevent all major exploit.
-        # So you can set up on your Permission Plugin
-        # this special group with 0 permissions, or permissions to chat,
-        # or permission to
-        # send private message or all other perms that you want,
-        # the better way is to set up
-        # this group with few permissions,
-        # so if player try to exploit some account,
-        # they can
-        # do anything except what you set in perm Group.
-        # After a correct logged-in player will be
-        # moved to his correct permissions group!
-        # Pay attention group name is case sensitive,
-        # so Admin is different from admin,
-        # otherwise your group will be wiped,
-        # and player join in default group []!
-        # Example unLoggedinGroup: NotLogged
-        unLoggedinGroup: unLoggedinGroup
-        # possible values: MD5, SHA1, SHA256, WHIRLPOOL, XAUTH, MD5VB, PHPBB,
-        # PLAINTEXT ( unhashed password),
-        # MYBB, IPB3, PHPFUSION, SMF, XENFORO, SALTED2MD5, JOOMLA, BCRYPT, WBB3, SHA512,
-        # DOUBLEMD5, PBKDF2, PBKDF2DJANGO, WORDPRESS, ROYALAUTH, CUSTOM(for developpers only)
-        passwordHash: SHA512
-        legacyHashes:
-        - PBKDF2
-        - WORDPRESS
-        # salt length for the SALTED2MD5 MD5(MD5(password)+salt)
-        doubleMD5SaltLength: 8
-        # If password checking return false , do we need to check with all
-        # other password algorithm to check an old password ?
-        # AuthMe will update the password to the new passwordHash !
-        supportOldPasswordHash: false
-        # Cancel unsafe passwords for being used, put them on lowercase!
-        #unsafePasswords:
-        #- '123456'
-        #- 'password'
-        unsafePasswords:
-        - '123456'
-        - 'password'
-        - 'qwerty'
-        - '12345'
-        - '54321'
-    registration:
-        # enable registration on the server?
-        enabled: true
-        # Send every X seconds a message to a player to
-        # remind him that he has to login/register
-        messageInterval: 5
-        # Only registered and logged in players can play.
-        # See restrictions for exceptions
-        force: true
-        # Does we replace password registration by an Email registration method ?
-        enableEmailRegistrationSystem: true
-        # Enable double check of email when you register
-        # when it's true, registration require that kind of command:
-        # /register <email> <confirmEmail>
-        doubleEmailCheck: true
-        # Do we force kicking player after a successful registration ?
-        # Do not use with login feature below
-        forceKickAfterRegister: false
-        # Does AuthMe need to enforce a /login after a successful registration ?
-        forceLoginAfterRegister: false
-    unrestrictions:
-        # below you can list all your account name, that
-        # AuthMe will ignore for registration or login, configure it
-        # at your own risk!! Remember that if you are going to add
-        # nickname with [], you have to delimit name with ' '.
-        # this option add compatibility with BuildCraft and some
-        # other mods.
-        # It is CaseSensitive!
-        UnrestrictedName: []
-    # Message language, available : en, de, br, cz, pl, fr, ru, hu, sk, es, zhtw, fi, zhcn, lt, it, ko, pt
-    messagesLanguage: en
-    # Force these commands after /login, without any '/', use %p for replace with player name
-    forceCommands:
-    - spawn
-    # Force these commands after /login as a server console, without any '/', use %p for replace with player name
-    forceCommandsAsConsole:
-    - sethome %p:lastloc
-    - msg %p Welcome back
-    # Force these commands after /register, without any '/', use %p for replace with player name
-    forceRegisterCommands:
-    - me registers
-    - msg CONSOLE hi
-    # Force these commands after /register as a server console, without any '/', use %p for replace with player name
-    forceRegisterCommandsAsConsole:
-    - sethome %p:regloc
-    # Do we need to display the welcome message (welcome.txt) after a register or a login?
-    # You can use colors in this welcome.txt + some replaced strings :
-    # {PLAYER} : player name, {ONLINE} : display number of online players, {MAXPLAYERS} : display server slots,
-    # {IP} : player ip, {LOGINS} : number of players logged, {WORLD} : player current world, {SERVER} : server name
-    # {VERSION} : get current bukkit version, {COUNTRY} : player country
-    useWelcomeMessage: true
-    # Do we need to broadcast the welcome message to all server or only to the player? set true for server or false for player
-    broadcastWelcomeMessage: false
-    # Do we need to delay the join/leave message to be displayed only when the player is authenticated ?
-    delayJoinLeaveMessages: true
-    # Do we need to add potion effect Blinding before login/register ?
-    applyBlindEffect: false
-ExternalBoardOptions:
-    # MySQL column for the salt , needed for some forum/cms support
-    mySQLColumnSalt: 'salt_col_name'
-    # MySQL column for the group, needed for some forum/cms support
-    mySQLColumnGroup: ''
-    # -1 mean disabled. If u want that only
-    # activated player can login in your server
-    # u can put in this options the group number
-    # of unactivated user, needed for some forum/cms support
-    nonActivedUserGroup: -1
-    # Other MySQL columns where we need to put the Username (case sensitive)
-    mySQLOtherUsernameColumns: []
-    # How much Log to Round needed in BCrypt(do not change it if you do not know what's your doing)
-    bCryptLog2Round: 10
-    # phpBB prefix defined during phpbb installation process
-    phpbbTablePrefix: 'phpbb_'
-    # phpBB activated group id , 2 is default registered group defined by phpbb
-    phpbbActivatedGroupId: 2
-    # WordPress prefix defined during WordPress installation process
-    wordpressTablePrefix: 'wp_'
-permission:
-    # Take care with this options, if you dont want
-    # to use Vault and Group Switching of
-    # AuthMe for unloggedIn players put true
-    # below, default is false.
-    EnablePermissionCheck: true
-BackupSystem:
-   # Enable or Disable Automatic Backup
-    ActivateBackup: false
-   # set Backup at every start of Server
-    OnServerStart: false
-   # set Backup at every stop of Server
-    OnServerStop: true
-   # Windows only mysql installation Path
-    MysqlWindowsPath: 'C:\\Program Files\\MySQL\\MySQL Server 5.1\\'
-Security:
-    SQLProblem:
-        # Stop the server if we can't contact the sql database
-        # Take care with this, if you set that to false,
-        # AuthMe automatically disable and the server is not protected!
-        stopServer: true
-    ReloadCommand:
-        # /reload support
-        useReloadCommandSupport: true
-    console:
-        # Remove spam console
-        noConsoleSpam: true
-        # Replace passwords in the console when player type a command like /login
-        removePassword: true
-    captcha:
-        # Player need to put a captcha when he fails too lot the password
-        useCaptcha: false
-        # Max allowed tries before request a captcha
-        maxLoginTry: 5
-        # Captcha length
-        captchaLength: 5
-Converter:
-    Rakamak:
-        # Rakamak file name
-        fileName: users.rak
-        # Rakamak use ip ?
-        useIP: false
-        # IP file name for rakamak
-        ipFileName: UsersIp.rak
-    CrazyLogin:
-        # CrazyLogin database file
-        fileName: accounts.db
-Email:
-    # Email SMTP server host
-    mailSMTP: smtp.gmail.com
-    # Email SMTP server port
-    mailPort: 465
-    # Email account that send the mail
-    mailAccount: ''
-    # Email account password
-    mailPassword: ''
-    # Custom SenderName, that replace the mailAccount name in the email
-    mailSenderName: ''
-    # Random password length
-    RecoveryPasswordLength: 8
-    # Email subject of password get
-    mailSubject: 'Your new AuthMe Password'
-    # Email text here
-    mailText: 'Dear <playername>, <br /><br /> This is your new AuthMe password for the server <br /><br /> %servername% : <br /><br /> <generatedpass><br /><image><br />Do not forget to change password after login! <br /> /changepassword %generatedpass% newPassword'
-    # Like maxRegPerIp but with email
-    maxRegPerEmail: 1
-    # Recall players to add an email ?
-    recallPlayers: false
-    # Delay in minute for the recall scheduler
-    delayRecall: 5
-    # Blacklist these domains for emails
-    emailBlacklisted:
-    - 10minutemail.com
-    # WhiteList only these domains for emails
-    emailWhitelisted: []
-    # Do we need to send new password draw in an image ?
-    generateImage: false
-Hooks:
-    # Do we need to hook with multiverse for spawn checking?
-    multiverse: true
-    # Do we need to hook with BungeeCord for get the real Player ip ?
-    bungeecord: false
-    # Do we need to disable Essentials SocialSpy on join ?
-    disableSocialSpy: true
-    # Do we need to force /motd Essentials command on join ?
-    useEssentialsMotd: false
-    # Do we need to cache custom Attributes ?
-    customAttributes: false
-Purge:
-    # On Enable , does AuthMe need to purge automatically old accounts unused ?
-    useAutoPurge: false
-    # Number of Days an account become Unused
-    daysBeforeRemovePlayer: 60
-    # Do we need to remove the player.dat file during purge process ?
-    removePlayerDat: false
-    # Do we need to remove the Essentials/users/player.yml file during purge process ?
-    removeEssentialsFile: false
-    # World where are players.dat stores
-    defaultWorld: 'world'
-    # Do we need to remove LimitedCreative/inventories/player.yml , player_creative.yml files during purge process ?
-    removeLimitedCreativesInventories: false
-    # Do we need to remove the AntiXRayData/PlayerData/player file during purge process ?
-    removeAntiXRayFile: false
-    # Do we need to remove permissions ?
-    removePermissions: false
-Protection:
-    # Enable some servers protection ( country based login, antibot )
-    enableProtection: false
-    # Countries allowed to join the server and register, see http://dev.bukkit.org/bukkit-plugins/authme-reloaded/pages/countries-codes/ for countries' codes
-    # PLEASE USE QUOTES!
-    countries:
-    - 'US'
-    - 'GB'
-    # Countries blacklisted automatically ( without any needed to enable protection )
-    # PLEASE USE QUOTES!
-    countriesBlacklist:
-    - 'A1'
-    # Do we need to enable automatic antibot system?
-    enableAntiBot: false
-    # Max number of player allowed to login in 5 secs before enable AntiBot system automatically
-    antiBotSensibility: 5
-    # Duration in minutes of the antibot automatic system
-    antiBotDuration: 10
-VeryGames:
-    # These features are only available on VeryGames Server Provider
-    enableIpCheck: false
-
diff --git a/src/test/resources/fr/xephi/authme/settings/config-sample-values.yml b/src/test/resources/fr/xephi/authme/settings/config-sample-values.yml
deleted file mode 100644
index 72cdeb79..00000000
--- a/src/test/resources/fr/xephi/authme/settings/config-sample-values.yml
+++ /dev/null
@@ -1,27 +0,0 @@
-# Test config file with all options
-# defined in the TestConfiguration class
-
-test:
-    duration: 22
-    systemName: 'Custom sys name'
-sample:
-    ratio:
-        order: 'first'
-        fields:
-            - 'Australia'
-            - 'Burundi'
-            - 'Colombia'
-version: 2492
-features:
-    boring:
-        skip: false
-        colors:
-            - 'beige'
-            - 'gray'
-        dustLevel: 2
-    cool:
-        enabled: true
-        options:
-            - 'Dinosaurs'
-            - 'Explosions'
-            - 'Big trucks'
diff --git a/src/test/resources/fr/xephi/authme/settings/spawn-firstspawn.yml b/src/test/resources/fr/xephi/authme/settings/spawn-firstspawn.yml
deleted file mode 100644
index dbb7bd89..00000000
--- a/src/test/resources/fr/xephi/authme/settings/spawn-firstspawn.yml
+++ /dev/null
@@ -1,15 +0,0 @@
-# Sample spawn.yml file with both spawn and firstspawn defined
-spawn:
-  world: 'world'
-  x: 300.12
-  y: 120.34
-  z: -89.12
-  yaw: 0.23
-  pitch: 112.25
-firstspawn:
-  world: 'firstspawn'
-  x: -30.12
-  y: 204.43
-  z: 10.32
-  yaw: 0.00
-  pitch: 10.23
diff --git a/src/test/resources/simplelogger.properties b/src/test/resources/simplelogger.properties
deleted file mode 100644
index 56bab219..00000000
--- a/src/test/resources/simplelogger.properties
+++ /dev/null
@@ -1,2 +0,0 @@
-# Suppress INFO statements when a new Hikari pool is being created
-org.slf4j.simpleLogger.log.com.zaxxer.hikari=WARN