Mockito: Replace deprecated verifyZeroInteractions with verifyNoInteractions

2019-10-26 21:56:54 +02:00 · 2019-10-26 21:56:54 +02:00 · 2673eb0f8e
commit 2673eb0f8e
parent 776d1e5fa3
51 changed files with 205 additions and 206 deletions
--- a/src/test/java/fr/xephi/authme/api/v3/AuthMeApiTest.java
+++ b/src/test/java/fr/xephi/authme/api/v3/AuthMeApiTest.java
@ -24,11 +24,11 @@ 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.stream.Collectors;
-import java.time.Instant;

 import static fr.xephi.authme.IsEqualByReflectionMatcher.hasEqualValuesOnAllFields;
 import static org.hamcrest.Matchers.contains;
@ -43,7 +43,7 @@ import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.only;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -478,7 +478,7 @@ public class AuthMeApiTest {
        // then
        assertThat(result, equalTo(false));
        verify(dataSource, only()).isAuthAvailable(name);
-        verifyZeroInteractions(management, passwordSecurity);
+        verifyNoInteractions(management, passwordSecurity);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/HelpCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/HelpCommandTest.java
@ -33,7 +33,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -64,7 +64,7 @@ public class HelpCommandTest {

        // then
        verify(sender).sendMessage(argThat(containsString("Could not get base command")));
-        verifyZeroInteractions(helpProvider);
+        verifyNoInteractions(helpProvider);
    }

    @Test
@ -102,7 +102,7 @@ public class HelpCommandTest {
        ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
        verify(sender).sendMessage(captor.capture());
        assertThat(removeColors(captor.getValue()), containsString("Unknown command"));
-        verifyZeroInteractions(helpProvider);
+        verifyNoInteractions(helpProvider);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/authme/ChangePasswordAdminCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/authme/ChangePasswordAdminCommandTest.java
@ -17,7 +17,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link ChangePasswordAdminCommand}.
@ -68,6 +68,6 @@ public class ChangePasswordAdminCommandTest {
        // then
        verify(validationService).validatePassword(pass, name);
        verify(commonService).send(sender, MessageKey.INVALID_PASSWORD_LENGTH, "7");
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }
 }
--- a/src/test/java/fr/xephi/authme/command/executable/authme/ConverterCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/authme/ConverterCommandTest.java
@ -29,8 +29,8 @@ 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.Mockito.verifyZeroInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -67,7 +67,7 @@ public class ConverterCommandTest {
        // then
        String converters = String.join(", ", ConverterCommand.CONVERTERS.keySet());
        verify(sender).sendMessage(argThat(containsString(converters)));
-        verifyZeroInteractions(commonService, converterFactory, bukkitService);
+        verifyNoInteractions(commonService, converterFactory, bukkitService);
    }

    @Test
@ -81,7 +81,7 @@ public class ConverterCommandTest {
        // then
        String converters = String.join(", ", ConverterCommand.CONVERTERS.keySet());
        verify(sender).sendMessage(argThat(containsString(converters)));
-        verifyZeroInteractions(commonService, converterFactory, bukkitService);
+        verifyNoInteractions(commonService, converterFactory, bukkitService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/authme/ForceLoginCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/authme/ForceLoginCommandTest.java
@ -18,7 +18,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -53,7 +53,7 @@ public class ForceLoginCommandTest {
        // then
        verify(bukkitService).getPlayerExact(playerName);
        verify(sender).sendMessage("Player needs to be online!");
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -69,7 +69,7 @@ public class ForceLoginCommandTest {
        // then
        verify(bukkitService).getPlayerExact(playerName);
        verify(sender).sendMessage("Player needs to be online!");
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -87,7 +87,7 @@ public class ForceLoginCommandTest {
        // then
        verify(bukkitService).getPlayerExact(playerName);
        verify(sender).sendMessage(argThat(containsString("You cannot force login the player")));
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/authme/PurgeCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/authme/PurgeCommandTest.java
@ -19,7 +19,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -45,7 +45,7 @@ public class PurgeCommandTest {

        // then
        verify(sender).sendMessage(argThat(containsString("The value you've entered is invalid")));
-        verifyZeroInteractions(purgeService);
+        verifyNoInteractions(purgeService);
    }

    @Test
@ -59,7 +59,7 @@ public class PurgeCommandTest {

        // then
        verify(sender).sendMessage(argThat(containsString("You can only purge data older than 30 days")));
-        verifyZeroInteractions(purgeService);
+        verifyNoInteractions(purgeService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/authme/PurgePlayerCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/authme/PurgePlayerCommandTest.java
@ -18,7 +18,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -52,7 +52,7 @@ public class PurgePlayerCommandTest {

        // then
        verify(sender).sendMessage(argThat(containsString("This player is still registered")));
-        verifyZeroInteractions(purgeExecutor);
+        verifyNoInteractions(purgeExecutor);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/authme/SetEmailCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/authme/SetEmailCommandTest.java
@ -22,8 +22,8 @@ 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;
-import static org.mockito.Mockito.verifyZeroInteractions;

 /**
 * Test for {@link SetEmailCommand}.
@ -63,7 +63,7 @@ public class SetEmailCommandTest {
        // then
        verify(validationService).validateEmail(email);
        verify(commandService).send(sender, MessageKey.INVALID_EMAIL);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -107,7 +107,7 @@ public class SetEmailCommandTest {
        verify(validationService).isEmailFreeForRegistration(email, sender);
        verify(commandService).send(sender, MessageKey.EMAIL_ALREADY_USED_ERROR);
        verifyNoMoreInteractions(dataSource);
-        verifyZeroInteractions(auth);
+        verifyNoInteractions(auth);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/authme/UpdateHelpMessagesCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/authme/UpdateHelpMessagesCommandTest.java
@ -18,7 +18,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link UpdateHelpMessagesCommand}.
@ -65,6 +65,6 @@ public class UpdateHelpMessagesCommandTest {

        // then
        verify(sender).sendMessage("Could not update help file: Couldn't do the thing");
-        verifyZeroInteractions(helpMessagesService);
+        verifyNoInteractions(helpMessagesService);
    }
 }
--- a/src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java
@ -19,7 +19,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link AddEmailCommand}.
@ -45,7 +45,7 @@ public class AddEmailCommandTest {
        command.executeCommand(sender, Collections.emptyList());

        // then
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -71,7 +71,7 @@ public class AddEmailCommandTest {
        command.executeCommand(sender, Arrays.asList(email, "wrongConf"));

        // then
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
        verify(commandService).send(sender, MessageKey.CONFIRM_EMAIL_MESSAGE);
    }

--- a/src/test/java/fr/xephi/authme/command/executable/email/ChangeEmailCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/email/ChangeEmailCommandTest.java
@ -21,7 +21,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.when;

 /**
@ -52,7 +52,7 @@ public class ChangeEmailCommandTest {
        command.executeCommand(sender, Collections.emptyList());

        // then
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -68,7 +68,7 @@ public class ChangeEmailCommandTest {
        // then
        verify(codeManager).codeExistOrGenerateNew(name);
        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_REQUIRED);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/email/EmailSetPasswordCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/email/EmailSetPasswordCommandTest.java
@ -21,7 +21,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Tests for {@link EmailSetPasswordCommand}.
@ -102,7 +102,7 @@ public class EmailSetPasswordCommandTest {
        command.runCommand(player, Collections.singletonList("abc123"));

        // then
-        verifyZeroInteractions(validationService, dataSource);
+        verifyNoInteractions(validationService, dataSource);
        verify(commonService).send(player, MessageKey.CHANGE_PASSWORD_EXPIRED);
    }
 }
--- a/src/test/java/fr/xephi/authme/command/executable/email/RecoverEmailCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/email/RecoverEmailCommandTest.java
@ -30,8 +30,8 @@ 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;
-import static org.mockito.Mockito.verifyZeroInteractions;

 /**
 * Test for {@link RecoverEmailCommand}.
@ -89,7 +89,7 @@ public class RecoverEmailCommandTest {

        // then
        verify(commonService).send(sender, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
-        verifyZeroInteractions(dataSource, passwordSecurity);
+        verifyNoInteractions(dataSource, passwordSecurity);
    }

    @Test
@ -106,7 +106,7 @@ public class RecoverEmailCommandTest {

        // then
        verify(emailService).hasAllInformation();
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
        verify(commonService).send(sender, MessageKey.ALREADY_LOGGED_IN_ERROR);
    }

--- a/src/test/java/fr/xephi/authme/command/executable/login/LoginCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/login/LoginCommandTest.java
@ -18,7 +18,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -43,7 +43,7 @@ public class LoginCommandTest {
        command.executeCommand(sender, Collections.emptyList());

        // then
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
        verify(sender).sendMessage(argThat(containsString("/authme forcelogin <player>")));
    }

--- a/src/test/java/fr/xephi/authme/command/executable/logout/LogoutCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/logout/LogoutCommandTest.java
@ -16,7 +16,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -41,7 +41,7 @@ public class LogoutCommandTest {
        command.executeCommand(sender, new ArrayList<String>());

        // then
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
        verify(sender).sendMessage(argThat(containsString("only for players")));
    }

--- a/src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java
@ -37,7 +37,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -86,7 +86,7 @@ public class RegisterCommandTest {

        // then
        verify(sender).sendMessage(argThat(containsString("Player only!")));
-        verifyZeroInteractions(management, emailService);
+        verifyNoInteractions(management, emailService);
    }

    @Test
@ -102,7 +102,7 @@ public class RegisterCommandTest {
        verify(registrationCaptchaManager).isCaptchaRequired("test2");
        verify(management).performRegister(eq(RegistrationMethod.TWO_FACTOR_REGISTRATION),
            argThat(hasEqualValuesOnAllFields(TwoFactorRegisterParams.of(player))));
-        verifyZeroInteractions(emailService);
+        verifyNoInteractions(emailService);
    }

    @Test
@ -115,7 +115,7 @@ public class RegisterCommandTest {

        // then
        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
-        verifyZeroInteractions(management, emailService);
+        verifyNoInteractions(management, emailService);
    }

    @Test
@ -130,7 +130,7 @@ public class RegisterCommandTest {

        // then
        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
-        verifyZeroInteractions(management, emailService);
+        verifyNoInteractions(management, emailService);
    }

    @Test
@ -147,7 +147,7 @@ public class RegisterCommandTest {

        // then
        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -163,7 +163,7 @@ public class RegisterCommandTest {
        // then
        verify(commonService).send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
        verify(emailService).hasAllInformation();
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -181,7 +181,7 @@ public class RegisterCommandTest {
        // then
        verify(validationService).validateEmail(playerMail);
        verify(commonService).send(player, MessageKey.INVALID_EMAIL);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -200,7 +200,7 @@ public class RegisterCommandTest {
        // then
        verify(commonService).send(player, MessageKey.USAGE_REGISTER);
        verify(emailService).hasAllInformation();
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -236,7 +236,7 @@ public class RegisterCommandTest {

        // then
        verify(commonService).send(player, MessageKey.PASSWORD_MATCH_ERROR);
-        verifyZeroInteractions(management, emailService);
+        verifyNoInteractions(management, emailService);
    }

    @Test
@ -287,7 +287,7 @@ public class RegisterCommandTest {
        verify(registrationCaptchaManager).isCaptchaRequired("Waaa");
        verify(validationService).validateEmail(email);
        verify(commonService).send(player, MessageKey.INVALID_EMAIL);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -321,7 +321,7 @@ public class RegisterCommandTest {
        // then
        verify(registrationCaptchaManager).isCaptchaRequired(name);
        verify(commonService).send(player, MessageKey.CAPTCHA_FOR_REGISTRATION_REQUIRED, captcha);
-        verifyZeroInteractions(management, validationService);
+        verifyNoInteractions(management, validationService);
    }

    private static Player mockPlayerWithName(String name) {
--- a/src/test/java/fr/xephi/authme/command/executable/totp/AddTotpCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/totp/AddTotpCommandTest.java
@ -18,7 +18,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link AddTotpCommand}.
@ -47,7 +47,7 @@ public class AddTotpCommandTest {

        // then
        verify(messages).send(player, MessageKey.NOT_LOGGED_IN);
-        verifyZeroInteractions(generateTotpService);
+        verifyNoInteractions(generateTotpService);
    }

    @Test
@ -63,7 +63,7 @@ public class AddTotpCommandTest {

        // then
        verify(messages).send(player, MessageKey.TWO_FACTOR_ALREADY_ENABLED);
-        verifyZeroInteractions(generateTotpService);
+        verifyNoInteractions(generateTotpService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/command/executable/totp/ConfirmTotpCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/totp/ConfirmTotpCommandTest.java
@ -27,7 +27,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link ConfirmTotpCommand}.
@ -98,7 +98,7 @@ public class ConfirmTotpCommandTest {
        verify(generateTotpService, never()).removeGenerateTotpKey(any(Player.class));
        verify(playerCache, only()).getAuth(playerName);
        verify(messages).send(player, MessageKey.TWO_FACTOR_ENABLE_ERROR_WRONG_CODE);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -118,7 +118,7 @@ public class ConfirmTotpCommandTest {
        verify(generateTotpService, only()).getGeneratedTotpKey(player);
        verify(playerCache, only()).getAuth(playerName);
        verify(messages).send(player, MessageKey.TWO_FACTOR_ENABLE_ERROR_NO_CODE);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -135,7 +135,7 @@ public class ConfirmTotpCommandTest {

        // then
        verify(playerCache, only()).getAuth(playerName);
-        verifyZeroInteractions(generateTotpService, dataSource);
+        verifyNoInteractions(generateTotpService, dataSource);
        verify(messages).send(player, MessageKey.TWO_FACTOR_ALREADY_ENABLED);
    }

@ -152,7 +152,7 @@ public class ConfirmTotpCommandTest {

        // then
        verify(playerCache, only()).getAuth(playerName);
-        verifyZeroInteractions(generateTotpService, dataSource);
+        verifyNoInteractions(generateTotpService, dataSource);
        verify(messages).send(player, MessageKey.NOT_LOGGED_IN);
    }
 }
--- a/src/test/java/fr/xephi/authme/command/executable/totp/RemoveTotpCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/totp/RemoveTotpCommandTest.java
@ -22,7 +22,7 @@ import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.only;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link RemoveTotpCommand}.
@ -105,7 +105,7 @@ public class RemoveTotpCommandTest {
        command.runCommand(player, singletonList(inputCode));

        // then
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
        verify(messages, only()).send(player, MessageKey.TWO_FACTOR_INVALID_CODE);
        verify(playerCache, only()).getAuth(name);
    }
@ -124,7 +124,7 @@ public class RemoveTotpCommandTest {
        command.runCommand(player, singletonList(inputCode));

        // then
-        verifyZeroInteractions(dataSource, totpAuthenticator);
+        verifyNoInteractions(dataSource, totpAuthenticator);
        verify(messages, only()).send(player, MessageKey.TWO_FACTOR_NOT_ENABLED_ERROR);
        verify(playerCache, only()).getAuth(name);
    }
@ -142,7 +142,7 @@ public class RemoveTotpCommandTest {
        command.runCommand(player, singletonList(inputCode));

        // then
-        verifyZeroInteractions(dataSource, totpAuthenticator);
+        verifyNoInteractions(dataSource, totpAuthenticator);
        verify(messages, only()).send(player, MessageKey.NOT_LOGGED_IN);
        verify(playerCache, only()).getAuth(name);
    }
--- a/src/test/java/fr/xephi/authme/command/executable/unregister/UnregisterCommandTest.java
+++ b/src/test/java/fr/xephi/authme/command/executable/unregister/UnregisterCommandTest.java
@ -21,7 +21,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -60,7 +60,7 @@ public class UnregisterCommandTest {
        // then
        verify(playerCache).isAuthenticated(name);
        verify(commonService).send(player, MessageKey.NOT_LOGGED_IN);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -79,7 +79,7 @@ public class UnregisterCommandTest {
        verify(playerCache).isAuthenticated(name);
        verify(codeManager).codeExistOrGenerateNew(name);
        verify(commonService).send(player, MessageKey.VERIFICATION_CODE_REQUIRED);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -110,7 +110,7 @@ public class UnregisterCommandTest {
        command.executeCommand(sender, Collections.singletonList("password"));

        // then
-        verifyZeroInteractions(playerCache, management);
+        verifyNoInteractions(playerCache, management);
        verify(sender).sendMessage(argThat(containsString("/authme unregister <player>")));
    }

--- a/src/test/java/fr/xephi/authme/data/TempbanManagerTest.java
+++ b/src/test/java/fr/xephi/authme/data/TempbanManagerTest.java
@ -29,7 +29,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link TempbanManager}.
@ -139,7 +139,7 @@ public class TempbanManagerTest {
        manager.tempbanPlayer(player);

        // then
-        verifyZeroInteractions(player, bukkitService);
+        verifyNoInteractions(player, bukkitService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/data/VerificationCodeManagerTest.java
+++ b/src/test/java/fr/xephi/authme/data/VerificationCodeManagerTest.java
@ -20,7 +20,7 @@ import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.only;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link VerificationCodeManager}.
@ -82,7 +82,7 @@ public class VerificationCodeManagerTest {

        // then
        assertThat(result, equalTo(false));
-        verifyZeroInteractions(permissionsManager, dataSource);
+        verifyNoInteractions(permissionsManager, dataSource);
    }

    @Test
@ -98,7 +98,7 @@ public class VerificationCodeManagerTest {
        // then
        assertThat(result, equalTo(false));
        verify(permissionsManager).hasPermission(player, PlayerPermission.VERIFICATION_CODE);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/data/limbo/AllowFlightRestoreTypeTest.java
+++ b/src/test/java/fr/xephi/authme/data/limbo/AllowFlightRestoreTypeTest.java
@ -6,7 +6,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link AllowFlightRestoreType}.
@ -78,7 +78,7 @@ public class AllowFlightRestoreTypeTest {
        AllowFlightRestoreType.NOTHING.restoreAllowFlight(player2, limboWithoutFly);

        // then
-        verifyZeroInteractions(player1, player2);
+        verifyNoInteractions(player1, player2);
    }

    @Test
@ -94,7 +94,7 @@ public class AllowFlightRestoreTypeTest {

            // then
            if (type == noInteractionType) {
-                verifyZeroInteractions(player);
+                verifyNoInteractions(player);
            } else {
                verify(player).setAllowFlight(false);
            }
--- a/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManagerTest.java
+++ b/src/test/java/fr/xephi/authme/data/limbo/LimboPlayerTaskManagerTest.java
@ -34,7 +34,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link LimboPlayerTaskManager}.
@ -97,7 +97,7 @@ public class LimboPlayerTaskManagerTest {
        limboPlayerTaskManager.registerMessageTask(player, limboPlayer, LimboMessageType.LOG_IN);

        // then
-        verifyZeroInteractions(limboPlayer, bukkitService);
+        verifyNoInteractions(limboPlayer, bukkitService);
    }

    @Test
@ -173,7 +173,7 @@ public class LimboPlayerTaskManagerTest {
        limboPlayerTaskManager.registerTimeoutTask(player, limboPlayer);

        // then
-        verifyZeroInteractions(limboPlayer, bukkitService);
+        verifyNoInteractions(limboPlayer, bukkitService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/data/limbo/LimboServiceHelperTest.java
+++ b/src/test/java/fr/xephi/authme/data/limbo/LimboServiceHelperTest.java
@ -15,7 +15,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link LimboServiceHelper}.
@ -83,7 +83,7 @@ public class LimboServiceHelperTest {
        LimboPlayer result3 = limboServiceHelper.merge(null, null);

        // then
-        verifyZeroInteractions(limbo);
+        verifyNoInteractions(limbo);
        assertThat(result1, equalTo(limbo));
        assertThat(result2, equalTo(limbo));
        assertThat(result3, nullValue());
--- a/src/test/java/fr/xephi/authme/data/limbo/LimboServiceTest.java
+++ b/src/test/java/fr/xephi/authme/data/limbo/LimboServiceTest.java
@ -34,7 +34,7 @@ import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.only;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link LimboService}, and {@link LimboServiceHelper}.
@ -222,7 +222,7 @@ public class LimboServiceTest {
        limboService.replaceTasksAfterRegistration(player);

        // then
-        verifyZeroInteractions(taskManager);
+        verifyNoInteractions(taskManager);
        verify(authGroupHandler).setGroup(player, null, AuthGroupType.REGISTERED_UNAUTHENTICATED);
    }

--- a/src/test/java/fr/xephi/authme/datasource/converter/AbstractDataSourceConverterTest.java
+++ b/src/test/java/fr/xephi/authme/datasource/converter/AbstractDataSourceConverterTest.java
@ -21,8 +21,8 @@ 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.Mockito.verifyZeroInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -51,7 +51,7 @@ public class AbstractDataSourceConverterTest {
        // then
        verify(sender).sendMessage(argThat(containsString("Please configure your connection to SQLITE")));
        verify(destination, only()).getType();
-        verifyZeroInteractions(source);
+        verifyNoInteractions(source);
    }

    @Test
@ -72,7 +72,7 @@ public class AbstractDataSourceConverterTest {
        // then
        verify(sender).sendMessage("The data source to convert from could not be initialized");
        verify(destination, only()).getType();
-        verifyZeroInteractions(source);
+        verifyNoInteractions(source);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/datasource/converter/CrazyLoginConverterTest.java
+++ b/src/test/java/fr/xephi/authme/datasource/converter/CrazyLoginConverterTest.java
@ -26,7 +26,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -81,7 +81,7 @@ public class CrazyLoginConverterTest {
        crazyLoginConverter.execute(sender);

        // then
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
        verify(sender).sendMessage(argThat(containsString("file not found")));
    }

--- a/src/test/java/fr/xephi/authme/datasource/mysqlextensions/NoOpExtensionTest.java
+++ b/src/test/java/fr/xephi/authme/datasource/mysqlextensions/NoOpExtensionTest.java
@ -14,7 +14,7 @@ import java.sql.Connection;
 import java.sql.SQLException;

 import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link NoOpExtension}.
@ -49,6 +49,6 @@ public class NoOpExtensionTest {
        extension.saveAuth(auth, connection);

        // then
-        verifyZeroInteractions(connection, auth);
+        verifyNoInteractions(connection, auth);
    }
 }
--- a/src/test/java/fr/xephi/authme/listener/EntityListenerTest.java
+++ b/src/test/java/fr/xephi/authme/listener/EntityListenerTest.java
@ -27,7 +27,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link EntityListener}.
@ -76,7 +76,7 @@ public class EntityListenerTest {

        // then
        verify(listenerService).shouldCancelEvent(event);
-        verifyZeroInteractions(event);
+        verifyNoInteractions(event);
    }

    @Test
@ -140,7 +140,7 @@ public class EntityListenerTest {

        // then
        verify(listenerService).shouldCancelEvent(event);
-        verifyZeroInteractions(event);
+        verifyNoInteractions(event);
    }

    @Test
@ -156,7 +156,7 @@ public class EntityListenerTest {
        listener.onProjectileLaunch(event);

        // then
-        verifyZeroInteractions(listenerService);
+        verifyNoInteractions(listenerService);
        verify(event, never()).setCancelled(anyBoolean());
    }

--- a/src/test/java/fr/xephi/authme/listener/EventCancelVerifier.java
+++ b/src/test/java/fr/xephi/authme/listener/EventCancelVerifier.java
@ -10,7 +10,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Tests simple listener methods that should cancel an event when the listener service says so.
@ -54,7 +54,7 @@ public final class EventCancelVerifier {
        event = mock(clazz);
        mockShouldCancel(false, listenerService, event);
        listenerMethod.accept(event);
-        verifyZeroInteractions(event);
+        verifyNoInteractions(event);

        return this;
    }
--- a/src/test/java/fr/xephi/authme/listener/ListenerServiceTest.java
+++ b/src/test/java/fr/xephi/authme/listener/ListenerServiceTest.java
@ -22,7 +22,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link ListenerService}.
@ -91,7 +91,7 @@ public class ListenerServiceTest {
        // then
        assertThat(result, equalTo(false));
        verify(playerCache).isAuthenticated(playerName);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -110,7 +110,7 @@ public class ListenerServiceTest {
        assertThat(result, equalTo(true));
        verify(playerCache).isAuthenticated(playerName);
        // makes sure the setting is checked first = avoid unnecessary DB operation
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -147,7 +147,7 @@ public class ListenerServiceTest {

        // then
        assertThat(result, equalTo(false));
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -182,7 +182,7 @@ public class ListenerServiceTest {
        // then
        assertThat(result, equalTo(false));
        verify(playerCache).isAuthenticated(playerName);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -210,7 +210,7 @@ public class ListenerServiceTest {
        // then
        assertThat(result, equalTo(true));
        verify(playerCache).isAuthenticated(playerName);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    private static Player mockPlayerWithName(String name) {
--- a/src/test/java/fr/xephi/authme/listener/OnJoinVerifierTest.java
+++ b/src/test/java/fr/xephi/authme/listener/OnJoinVerifierTest.java
@ -39,8 +39,8 @@ 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;
-import static org.mockito.Mockito.verifyZeroInteractions;

 /**
 * Test for {@link OnJoinVerifier}.
@ -89,7 +89,7 @@ public class OnJoinVerifierTest {
        assertThat(result, equalTo(false));
        verify(event).getResult();
        verifyNoMoreInteractions(event);
-        verifyZeroInteractions(bukkitService, dataSource, permissionsManager);
+        verifyNoInteractions(bukkitService, dataSource, permissionsManager);
    }

    @Test
@ -109,7 +109,7 @@ public class OnJoinVerifierTest {
        assertThat(result, equalTo(true));
        assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
        assertThat(event.getKickMessage(), equalTo(serverFullMessage));
-        verifyZeroInteractions(bukkitService, dataSource);
+        verifyNoInteractions(bukkitService, dataSource);
    }

    @Test
@ -133,7 +133,7 @@ public class OnJoinVerifierTest {
        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
-        verifyZeroInteractions(onlinePlayers.get(0));
+        verifyNoInteractions(onlinePlayers.get(0));
        verify(onlinePlayers.get(1)).kickPlayer("kick for vip");
    }

@ -157,7 +157,7 @@ public class OnJoinVerifierTest {
        assertThat(result, equalTo(true));
        assertThat(event.getResult(), equalTo(PlayerLoginEvent.Result.KICK_FULL));
        assertThat(event.getKickMessage(), equalTo("kick full server"));
-        verifyZeroInteractions(onlinePlayers.get(0));
+        verifyNoInteractions(onlinePlayers.get(0));
    }

    @Test
@ -254,7 +254,7 @@ public class OnJoinVerifierTest {
        onJoinVerifier.checkNameCasing(name, auth);

        // then
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -269,7 +269,7 @@ public class OnJoinVerifierTest {

        // when / then
        onJoinVerifier.checkNameCasing(name, auth);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -311,7 +311,7 @@ public class OnJoinVerifierTest {
        onJoinVerifier.checkNameCasing(name, auth);

        // then
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -324,7 +324,7 @@ public class OnJoinVerifierTest {
        onJoinVerifier.checkNameCasing(name, auth);

        // then
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -368,7 +368,7 @@ public class OnJoinVerifierTest {
        onJoinVerifier.checkSingleSession(name);

        // then
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
@ -397,7 +397,7 @@ public class OnJoinVerifierTest {
        onJoinVerifier.checkAntibot(name, isAuthAvailable);

        // then
-        verifyZeroInteractions(permissionsManager, antiBotService);
+        verifyNoInteractions(permissionsManager, antiBotService);
    }

    @Test
@ -412,7 +412,7 @@ public class OnJoinVerifierTest {

        // then
        verify(permissionsManager).hasPermissionOffline(name, PlayerStatePermission.BYPASS_ANTIBOT);
-        verifyZeroInteractions(antiBotService);
+        verifyNoInteractions(antiBotService);
    }

    @Test
@ -446,12 +446,12 @@ public class OnJoinVerifierTest {
        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION)).willReturn(false);
        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION_REGISTERED)).willReturn(true);
        onJoinVerifier.checkPlayerCountry(name, ip, false);
-        verifyZeroInteractions(validationService);
+        verifyNoInteractions(validationService);

        // protection for registered players disabled
        given(settings.getProperty(ProtectionSettings.ENABLE_PROTECTION_REGISTERED)).willReturn(false);
        onJoinVerifier.checkPlayerCountry(name, ip, true);
-        verifyZeroInteractions(validationService);
+        verifyNoInteractions(validationService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/listener/PlayerListenerTest.java
+++ b/src/test/java/fr/xephi/authme/listener/PlayerListenerTest.java
@ -83,8 +83,8 @@ 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;
-import static org.mockito.Mockito.verifyZeroInteractions;

 /**
 * Test for {@link PlayerListener}.
@ -140,7 +140,7 @@ public class PlayerListenerTest {

        // then
        assertThat(event.isCancelled(), equalTo(true));
-        verifyZeroInteractions(player, management, antiBotService);
+        verifyNoInteractions(player, management, antiBotService);
    }

    @Test
@ -176,7 +176,7 @@ public class PlayerListenerTest {
        // then
        assertThat(event.isCancelled(), equalTo(false));
        verify(antiBotService).wasPlayerKicked(name);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -205,7 +205,7 @@ public class PlayerListenerTest {

        // then
        verify(event, only()).getMessage();
-        verifyZeroInteractions(listenerService, messages);
+        verifyNoInteractions(listenerService, messages);
    }

    @Test
@ -220,7 +220,7 @@ public class PlayerListenerTest {

        // then
        verify(event, only()).getMessage();
-        verifyZeroInteractions(listenerService, messages);
+        verifyNoInteractions(listenerService, messages);
    }

    @Test
@ -241,7 +241,7 @@ public class PlayerListenerTest {
        verify(event).getMessage();
        verifyNoMoreInteractions(event);
        verify(listenerService).shouldCancelEvent(player);
-        verifyZeroInteractions(messages);
+        verifyNoInteractions(messages);
    }

    @Test
@ -290,7 +290,7 @@ public class PlayerListenerTest {
        listener.onPlayerChat(event);

        // then
-        verifyZeroInteractions(event, listenerService, messages);
+        verifyNoInteractions(event, listenerService, messages);
    }

    @Test
@ -324,7 +324,7 @@ public class PlayerListenerTest {

        // then
        verify(listenerService).shouldCancelEvent(event.getPlayer());
-        verifyZeroInteractions(event, messages);
+        verifyNoInteractions(event, messages);
    }

    @Test
@ -400,7 +400,7 @@ public class PlayerListenerTest {
        listener.onPlayerMove(event);

        // then
-        verifyZeroInteractions(event);
+        verifyNoInteractions(event);
    }

    @Test
@ -551,7 +551,7 @@ public class PlayerListenerTest {
        listener.onPlayerRespawn(event);

        // then
-        verifyZeroInteractions(listenerService);
+        verifyNoInteractions(listenerService);
        verify(event, never()).setRespawnLocation(any());
    }

@ -568,7 +568,7 @@ public class PlayerListenerTest {
        listener.onPlayerRespawn(event);

        // then
-        verifyZeroInteractions(spawnLoader);
+        verifyNoInteractions(spawnLoader);
        verify(event, never()).setRespawnLocation(any());
    }

@ -659,7 +659,7 @@ public class PlayerListenerTest {
        // then
        verify(validationService).isUnrestricted(name);
        verifyNoModifyingCalls(event);
-        verifyZeroInteractions(onJoinVerifier);
+        verifyNoInteractions(onJoinVerifier);
    }

    @Test
@ -717,7 +717,7 @@ public class PlayerListenerTest {
        verify(validationService).isUnrestricted(name);
        verify(onJoinVerifier).checkSingleSession(name);
        verify(onJoinVerifier).checkIsValidName(name);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
        verifyNoModifyingCalls(preLoginEvent);
    }

@ -780,7 +780,7 @@ public class PlayerListenerTest {
        // then
        verify(validationService).isUnrestricted(name);
        verify(onJoinVerifier).refusePlayerForFullServer(loginEvent);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
        verifyNoModifyingCalls(loginEvent);
    }

@ -805,7 +805,7 @@ public class PlayerListenerTest {
        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
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
        verify(event).setKickMessage(message);
        verify(event).setLoginResult(AsyncPlayerPreLoginEvent.Result.KICK_OTHER);
    }
@ -844,7 +844,7 @@ public class PlayerListenerTest {
        // then
        assertThat(event.getQuitMessage(), nullValue());
        verify(antiBotService).wasPlayerKicked(name);
-        verifyZeroInteractions(management);
+        verifyNoInteractions(management);
    }

    @Test
@ -942,7 +942,7 @@ public class PlayerListenerTest {

        // then
        assertThat(event.isCancelled(), equalTo(false));
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
@ -980,7 +980,7 @@ public class PlayerListenerTest {

        // then
        assertThat(event.getJoinMessage(), equalTo(joinMsg));
-        verifyZeroInteractions(joinMessageService);
+        verifyNoInteractions(joinMessageService);
    }

    @Test
@ -996,7 +996,7 @@ public class PlayerListenerTest {

        // then
        assertThat(event.getJoinMessage(), nullValue());
-        verifyZeroInteractions(joinMessageService);
+        verifyNoInteractions(joinMessageService);
    }

    @Test
@ -1017,7 +1017,7 @@ public class PlayerListenerTest {

        // then
        assertThat(event.getJoinMessage(), equalTo("Hello doooew (aka Displ)"));
-        verifyZeroInteractions(joinMessageService);
+        verifyNoInteractions(joinMessageService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/listener/ServerListenerTest.java
+++ b/src/test/java/fr/xephi/authme/listener/ServerListenerTest.java
@ -1,9 +1,9 @@
 package fr.xephi.authme.listener;

 import fr.xephi.authme.TestHelper;
-import fr.xephi.authme.service.PluginHookService;
 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;
@ -20,8 +20,8 @@ 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;
-import static org.mockito.Mockito.verifyZeroInteractions;

 /**
 * Test for {@link ServerListener}.
@ -65,7 +65,7 @@ public class ServerListenerTest {
        });
        checkEnableHandling(MULTIVERSE,       () -> verify(pluginHookService).tryHookToMultiverse());
        checkEnableHandling(PROTOCOL_LIB,     () -> verify(protocolLibService).setup());
-        checkEnableHandling("UnknownPlugin",  () -> verifyZeroInteractions(pluginHookService, spawnLoader));
+        checkEnableHandling("UnknownPlugin",  () -> verifyNoInteractions(pluginHookService, spawnLoader));
    }

    @Test
@ -78,7 +78,7 @@ public class ServerListenerTest {
        });
        checkDisableHandling(MULTIVERSE,       () -> verify(pluginHookService).unhookMultiverse());
        checkDisableHandling(PROTOCOL_LIB,     () -> verify(protocolLibService).disable());
-        checkDisableHandling("UnknownPlugin",  () -> verifyZeroInteractions(pluginHookService, spawnLoader));
+        checkDisableHandling("UnknownPlugin",  () -> verifyNoInteractions(pluginHookService, spawnLoader));
    }

    private void checkEnableHandling(String pluginName, Runnable verifier) {
--- a/src/test/java/fr/xephi/authme/process/login/AsynchronousLoginTest.java
+++ b/src/test/java/fr/xephi/authme/process/login/AsynchronousLoginTest.java
@ -36,7 +36,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.internal.verification.VerificationModeFactory.only;

 /**
@ -78,7 +78,7 @@ public class AsynchronousLoginTest {
        // then
        verify(playerCache, only()).isAuthenticated(name);
        verify(commonService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
@ -198,7 +198,7 @@ public class AsynchronousLoginTest {

        // then
        assertThat(result, equalTo(false));
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
@ -214,7 +214,7 @@ public class AsynchronousLoginTest {
        // then
        assertThat(result, equalTo(false));
        verify(commonService).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/process/register/AsyncRegisterTest.java
+++ b/src/test/java/fr/xephi/authme/process/register/AsyncRegisterTest.java
@ -28,7 +28,7 @@ import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.only;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link AsyncRegister}.
@ -64,7 +64,7 @@ public class AsyncRegisterTest {

        // then
        verify(commonService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
-        verifyZeroInteractions(dataSource, executor);
+        verifyNoInteractions(dataSource, executor);
    }

    @Test
@ -82,7 +82,7 @@ public class AsyncRegisterTest {

        // then
        verify(commonService).send(player, MessageKey.REGISTRATION_DISABLED);
-        verifyZeroInteractions(dataSource, executor);
+        verifyNoInteractions(dataSource, executor);
    }

    @Test
@ -102,7 +102,7 @@ public class AsyncRegisterTest {
        // then
        verify(commonService).send(player, MessageKey.NAME_ALREADY_REGISTERED);
        verify(dataSource, only()).isAuthAvailable(name);
-        verifyZeroInteractions(executor);
+        verifyNoInteractions(executor);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorTest.java
+++ b/src/test/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorTest.java
@ -28,7 +28,7 @@ import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link EmailRegisterExecutor}.
@ -158,7 +158,7 @@ public class EmailRegisterExecutorTest {
        // then
        verify(emailService).sendPasswordMail("Laleh", "test@example.com", password);
        verify(commonService).send(player, MessageKey.EMAIL_SEND_FAILURE);
-        verifyZeroInteractions(syncProcessManager);
+        verifyNoInteractions(syncProcessManager);
    }

    private static void assertIsCloseTo(long value1, long value2, long tolerance) {
--- a/src/test/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutorTest.java
+++ b/src/test/java/fr/xephi/authme/process/register/executors/PasswordRegisterExecutorTest.java
@ -31,7 +31,7 @@ import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link PasswordRegisterExecutor}.
@ -138,7 +138,7 @@ public class PasswordRegisterExecutorTest {
        executor.executePostPersistAction(params);

        // then
-        verifyZeroInteractions(bukkitService, asynchronousLogin);
+        verifyNoInteractions(bukkitService, asynchronousLogin);
        verify(syncProcessManager).processSyncPasswordRegister(player);
    }

--- a/src/test/java/fr/xephi/authme/process/unregister/AsynchronousUnregisterTest.java
+++ b/src/test/java/fr/xephi/authme/process/unregister/AsynchronousUnregisterTest.java
@ -40,7 +40,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link AsynchronousUnregister}.
@ -94,7 +94,7 @@ public class AsynchronousUnregisterTest {
        // then
        verify(service).send(player, MessageKey.WRONG_PASSWORD);
        verify(passwordSecurity).comparePassword(userPassword, password, name);
-        verifyZeroInteractions(dataSource, limboService, teleportationService, bukkitService, bungeeSender);
+        verifyNoInteractions(dataSource, limboService, teleportationService, bukkitService, bungeeSender);
        verify(player, only()).getName();
    }

@ -189,7 +189,7 @@ public class AsynchronousUnregisterTest {
        verify(passwordSecurity).comparePassword(userPassword, password, name);
        verify(dataSource).removeAuth(name);
        verify(playerCache).removePlayer(name);
-        verifyZeroInteractions(teleportationService, limboService);
+        verifyNoInteractions(teleportationService, limboService);
        verifyCalledUnregisterEventFor(player);
        verify(bungeeSender).sendAuthMeBungeecordMessage(MessageType.UNREGISTER, name);
        verify(commandManager).runCommandsOnUnregister(player);
@ -216,7 +216,7 @@ public class AsynchronousUnregisterTest {
        verify(passwordSecurity).comparePassword(userPassword, password, name);
        verify(dataSource).removeAuth(name);
        verify(service).send(player, MessageKey.ERROR);
-        verifyZeroInteractions(teleportationService, bukkitService, bungeeSender);
+        verifyNoInteractions(teleportationService, bukkitService, bungeeSender);
    }

    @Test
@ -241,7 +241,7 @@ public class AsynchronousUnregisterTest {
        verify(passwordSecurity).comparePassword(userPassword, password, name);
        verify(dataSource).removeAuth(name);
        verify(playerCache).removePlayer(name);
-        verifyZeroInteractions(teleportationService);
+        verifyNoInteractions(teleportationService);
        verifyCalledUnregisterEventFor(player);
        verify(bungeeSender).sendAuthMeBungeecordMessage(MessageType.UNREGISTER, name);
    }
@ -285,7 +285,7 @@ public class AsynchronousUnregisterTest {
        // then
        verify(dataSource).removeAuth(name);
        verify(playerCache).removePlayer(name);
-        verifyZeroInteractions(teleportationService);
+        verifyNoInteractions(teleportationService);
        verifyCalledUnregisterEventFor(null);
        verify(bungeeSender).sendAuthMeBungeecordMessage(MessageType.UNREGISTER, name);
    }
@ -303,7 +303,7 @@ public class AsynchronousUnregisterTest {
        // then
        verify(dataSource).removeAuth(name);
        verify(service).send(initiator, MessageKey.ERROR);
-        verifyZeroInteractions(playerCache, teleportationService, bukkitService, bungeeSender);
+        verifyNoInteractions(playerCache, teleportationService, bukkitService, bungeeSender);
    }

    @SuppressWarnings("unchecked")
--- a/src/test/java/fr/xephi/authme/security/totp/TotpAuthenticatorTest.java
+++ b/src/test/java/fr/xephi/authme/security/totp/TotpAuthenticatorTest.java
@ -24,7 +24,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link TotpAuthenticator}.
@ -92,7 +92,7 @@ public class TotpAuthenticatorTest {

        // then
        assertThat(result, equalTo(false));
-        verifyZeroInteractions(googleAuthenticator);
+        verifyNoInteractions(googleAuthenticator);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/service/AntiBotServiceTest.java
+++ b/src/test/java/fr/xephi/authme/service/AntiBotServiceTest.java
@ -29,7 +29,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link AntiBotService}.
@ -76,7 +76,7 @@ public class AntiBotServiceTest {

        // then
        assertThat(antiBotService.getAntiBotStatus(), equalTo(AntiBotService.AntiBotStatus.DISABLED));
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/service/BukkitServiceTest.java
+++ b/src/test/java/fr/xephi/authme/service/BukkitServiceTest.java
@ -29,7 +29,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link BukkitService}.
@ -127,7 +127,7 @@ public class BukkitServiceTest {

        // then
        verify(spy).scheduleSyncDelayedTask(task);
-        verifyZeroInteractions(task);
+        verifyNoInteractions(task);
    }

    @Test
@ -188,7 +188,7 @@ public class BukkitServiceTest {
        spy.runTaskOptionallyAsync(task);

        // then
-        verifyZeroInteractions(task);
+        verifyNoInteractions(task);
        verify(spy).runTaskAsynchronously(task);
    }

--- a/src/test/java/fr/xephi/authme/service/SessionServiceTest.java
+++ b/src/test/java/fr/xephi/authme/service/SessionServiceTest.java
@ -25,8 +25,8 @@ 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;
-import static org.mockito.Mockito.verifyZeroInteractions;

 /**
 * Test for {@link SessionService}.
@ -66,7 +66,7 @@ public class SessionServiceTest {

        // then
        assertThat(result, equalTo(false));
-        verifyZeroInteractions(dataSource);
+        verifyNoInteractions(dataSource);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/service/TeleportationServiceTest.java
+++ b/src/test/java/fr/xephi/authme/service/TeleportationServiceTest.java
@ -32,7 +32,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link TeleportationService}.
@ -77,8 +77,8 @@ public class TeleportationServiceTest {
        teleportationService.teleportOnJoin(player);

        // then
-        verifyZeroInteractions(player);
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(player);
+        verifyNoInteractions(bukkitService);
    }

    @Test
@ -134,7 +134,7 @@ public class TeleportationServiceTest {
        verify(player, never()).teleport(any(Location.class));
        verify(spawnLoader).getFirstSpawn();
        verify(spawnLoader, never()).getSpawnLocation(any(Player.class));
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
@ -148,7 +148,7 @@ public class TeleportationServiceTest {

        // then
        verify(player, never()).teleport(any(Location.class));
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
@ -162,7 +162,7 @@ public class TeleportationServiceTest {

        // then
        verify(player, never()).teleport(any(Location.class));
-        verifyZeroInteractions(bukkitService);
+        verifyNoInteractions(bukkitService);
    }

    @Test
@ -226,7 +226,7 @@ public class TeleportationServiceTest {
        teleportationService.teleportOnLogin(player, auth, limbo);

        // then
-        verifyZeroInteractions(player, auth, limbo, bukkitService, spawnLoader);
+        verifyNoInteractions(player, auth, limbo, bukkitService, spawnLoader);
    }

    @Test
@ -270,7 +270,7 @@ public class TeleportationServiceTest {

        // then
        verify(player, never()).teleport(spawn);
-        verifyZeroInteractions(bukkitService, spawnLoader);
+        verifyNoInteractions(bukkitService, spawnLoader);
    }

    @Test
@ -387,7 +387,7 @@ public class TeleportationServiceTest {
        teleportationService.teleportOnLogin(player, auth, limbo);

        // then
-        verifyZeroInteractions(player);
+        verifyNoInteractions(player);
        verify(limbo, times(2)).getLocation();
    }

--- a/src/test/java/fr/xephi/authme/service/ValidationServiceTest.java
+++ b/src/test/java/fr/xephi/authme/service/ValidationServiceTest.java
@ -33,7 +33,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link ValidationService}.
@ -277,7 +277,7 @@ public class ValidationServiceTest {

        // then
        assertThat(result, equalTo(true));
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/settings/SettingsWarnerTest.java
+++ b/src/test/java/fr/xephi/authme/settings/SettingsWarnerTest.java
@ -21,7 +21,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.internal.verification.VerificationModeFactory.times;

 /**
@ -76,6 +76,6 @@ public class SettingsWarnerTest {
        settingsWarner.logWarningsForMisconfigurations();

        // then
-        verifyZeroInteractions(logger);
+        verifyNoInteractions(logger);
    }
 }
--- a/src/test/java/fr/xephi/authme/settings/WelcomeMessageConfigurationTest.java
+++ b/src/test/java/fr/xephi/authme/settings/WelcomeMessageConfigurationTest.java
@ -32,7 +32,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link WelcomeMessageConfiguration}.
@ -81,7 +81,7 @@ public class WelcomeMessageConfigurationTest {
        // then
        assertThat(result, hasSize(2));
        assertThat(result, contains(welcomeMessage.split("\\n")));
-        verifyZeroInteractions(player, playerCache, geoIpService, bukkitService, server);
+        verifyNoInteractions(player, playerCache, geoIpService, bukkitService, server);
    }

    @Test
@ -104,7 +104,7 @@ public class WelcomeMessageConfigurationTest {
        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!"));
-        verifyZeroInteractions(server, playerCache);
+        verifyNoInteractions(server, playerCache);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/settings/commandconfig/CommandManagerTest.java
+++ b/src/test/java/fr/xephi/authme/settings/commandconfig/CommandManagerTest.java
@ -28,8 +28,8 @@ 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.Mockito.verifyZeroInteractions;

 /**
 * Test for {@link CommandManager}.
@ -80,7 +80,7 @@ public class CommandManagerTest {
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(60L));
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(120L));
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -101,7 +101,7 @@ public class CommandManagerTest {
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(120L));
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(180L));
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -124,7 +124,7 @@ public class CommandManagerTest {
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(180L));
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(240L));
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -145,7 +145,7 @@ public class CommandManagerTest {
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(120L));
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(180L));
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -163,7 +163,7 @@ public class CommandManagerTest {
        verify(bukkitService).dispatchCommand(any(Player.class), eq("list"));
        verify(bukkitService).scheduleSyncDelayedTask(any(Runnable.class), eq(100L));
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -178,7 +178,7 @@ public class CommandManagerTest {
        // then
        verify(bukkitService).dispatchConsoleCommand("msg Bobby Session login!");
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -193,7 +193,7 @@ public class CommandManagerTest {
        // then
        verify(bukkitService).dispatchConsoleCommand("pay Bobby 30");
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -206,7 +206,7 @@ public class CommandManagerTest {
        manager.runCommandsOnFirstLogin(player, Arrays.asList("u", "wot", "m8"));

        // then
-        verifyZeroInteractions(bukkitService, geoIpService);
+        verifyNoInteractions(bukkitService, geoIpService);
    }

    @Test
@ -220,7 +220,7 @@ public class CommandManagerTest {

        // then
        verify(bukkitService, only()).dispatchConsoleCommand("broadcast bob has joined");
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -234,7 +234,7 @@ public class CommandManagerTest {

        // then
        verify(bukkitService, only()).dispatchConsoleCommand("broadcast Bobby has joined");
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -265,7 +265,7 @@ public class CommandManagerTest {
        // then
        verify(bukkitService).dispatchConsoleCommand("broadcast Bobby (127.0.0.3) logged out");
        verifyNoMoreInteractions(bukkitService);
-        verifyZeroInteractions(geoIpService);
+        verifyNoInteractions(geoIpService);
    }

    @Test
@ -278,7 +278,7 @@ public class CommandManagerTest {
        manager.runCommandsOnRegister(player);

        // then
-        verifyZeroInteractions(bukkitService, geoIpService);
+        verifyNoInteractions(bukkitService, geoIpService);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/task/purge/PurgeServiceTest.java
+++ b/src/test/java/fr/xephi/authme/task/purge/PurgeServiceTest.java
@ -39,7 +39,7 @@ 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.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.hamcrest.MockitoHamcrest.argThat;

 /**
@ -77,7 +77,7 @@ public class PurgeServiceTest {
        purgeService.runAutoPurge();

        // then
-        verifyZeroInteractions(bukkitService, dataSource);
+        verifyNoInteractions(bukkitService, dataSource);
    }

    @Test
@ -90,7 +90,7 @@ public class PurgeServiceTest {
        purgeService.runAutoPurge();

        // then
-        verifyZeroInteractions(bukkitService, dataSource);
+        verifyNoInteractions(bukkitService, dataSource);
    }

    @Test
@ -127,7 +127,7 @@ public class PurgeServiceTest {
        verify(dataSource).getRecordsToPurge(delay);
        verify(dataSource, never()).purgeRecords(anyCollection());
        verify(sender).sendMessage("No players to purge");
-        verifyZeroInteractions(bukkitService, permissionsManager);
+        verifyNoInteractions(bukkitService, permissionsManager);
    }

    @Test
@ -160,7 +160,7 @@ public class PurgeServiceTest {

        // then
        verify(sender).sendMessage(argThat(containsString("Purge is already in progress")));
-        verifyZeroInteractions(bukkitService, dataSource, permissionsManager);
+        verifyNoInteractions(bukkitService, dataSource, permissionsManager);
    }

    @Test
--- a/src/test/java/fr/xephi/authme/util/UtilsTest.java
+++ b/src/test/java/fr/xephi/authme/util/UtilsTest.java
@ -16,11 +16,10 @@ import java.util.logging.Logger;
 import java.util.regex.Pattern;

 import static org.hamcrest.Matchers.equalTo;
-import static org.hamcrest.Matchers.greaterThan;
 import static org.junit.Assert.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.verifyNoInteractions;

 /**
 * Test for {@link Utils}.
@ -102,7 +101,7 @@ public class UtilsTest {

        // then
        verify(logger).info(message);
-        verifyZeroInteractions(sender);
+        verifyNoInteractions(sender);
    }

    @Test
@ -144,7 +143,7 @@ public class UtilsTest {

        // then
        verify(logger).warning(message);
-        verifyZeroInteractions(sender);
+        verifyNoInteractions(sender);
    }

    @Test