Meishin/LoginSystem
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/AuthMe/AuthMeReloaded into 1128-camel-case-rename

Browse Source
This commit is contained in:
ljacqu
2017-03-17 18:50:57 +01:00
parent 731d085ccd 17415493f5
commit 8ebb3c6b5a
203 changed files with 5111 additions and 1980 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/test/java/fr/xephi/authme/AuthMeInitializationTest.java
+5 -1
View File
@@ -8,6 +8,7 @@ import fr.xephi.authme.api.NewAPI;
import fr.xephi.authme.command.CommandHandler;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.initialization.DataFolder;
import fr.xephi.authme.initialization.factory.FactoryDependencyHandler;
import fr.xephi.authme.listener.BlockListener;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.process.Management;
@@ -91,7 +92,10 @@ public class AuthMeInitializationTest {
Settings settings =
new Settings(dataFolder, mock(PropertyResource.class), null, buildConfigurationData());
Injector injector = new InjectorBuilder().addDefaultHandlers("fr.xephi.authme").create();
Injector injector = new InjectorBuilder()
.addHandlers(new FactoryDependencyHandler())
.addDefaultHandlers("fr.xephi.authme")
.create();
injector.provide(DataFolder.class, dataFolder);
injector.register(Server.class, server);
injector.register(PluginManager.class, pluginManager);
src/test/java/fr/xephi/authme/ConsoleLoggerTest.java
+32 -4
View File
@@ -19,8 +19,10 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.List;
import java.util.logging.Level;
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;
@@ -42,9 +44,6 @@ public class ConsoleLoggerTest {
@Mock
private Logger logger;
@Mock
private Settings settings;
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
@@ -106,7 +105,7 @@ public class ConsoleLoggerTest {
ConsoleLogger.warning("Encountered a warning");
// then
verify(logger).info("Debug: Created test");
verify(logger).info("[DEBUG] Created test");
verify(logger).warning("Encountered a warning");
verifyNoMoreInteractions(logger);
assertThat(logFile.length(), equalTo(0L));
@@ -137,6 +136,35 @@ public class ConsoleLoggerTest {
assertThat(String.join("", loggedLines), containsString(getClass().getCanonicalName()));
}
@Test
public void shouldSupportVariousDebugMethods() throws IOException {
// given
ConsoleLogger.setLoggingOptions(newSettings(true, LogLevel.DEBUG));
// when
ConsoleLogger.debug("Got {0} entries", "test");
ConsoleLogger.debug("Player `{0}` is in world `{1}`", "Bobby", "world");
ConsoleLogger.debug("The {0} is {1} the {2}", "fox", "behind", "chicken");
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).log(Level.INFO, "[DEBUG] Got {0} entries", "test");
verify(logger).log(Level.INFO, "[DEBUG] Player `{0}` is in world `{1}`", new Object[]{"Bobby", "world"});
verify(logger).log(Level.INFO, "[DEBUG] The {0} is {1} the {2}", new Object[]{"fox", "behind", "chicken"});
verify(logger).log(Level.INFO, "[DEBUG] {0} quick {1} jump over {2} lazy {3} (reason: {4})",
new Object[]{"5", "foxes", "3", "dogs", "null"});
verify(logger).info("[DEBUG] Too little too late");
List<String> loggedLines = Files.readAllLines(logFile.toPath(), StandardCharsets.UTF_8);
assertThat(loggedLines, contains(
containsString("[DEBUG] Got {0} entries {test}"),
containsString("[DEBUG] Player `{0}` is in world `{1}` {Bobby, world}"),
containsString("[DEBUG] The {0} is {1} the {2} {fox, behind, chicken}"),
containsString("[DEBUG] {0} quick {1} jump over {2} lazy {3} (reason: {4}) {5, foxes, 3, dogs, null}"),
containsString("[DEBUG] Too little too late")));
}
@Test
public void shouldHaveHiddenConstructor() {
TestHelper.validateHasOnlyPrivateEmptyConstructor(ConsoleLogger.class);
src/test/java/fr/xephi/authme/command/CommandHandlerTest.java
+4 -3
View File
@@ -6,6 +6,7 @@ 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.initialization.factory.Factory;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.message.Messages;
import fr.xephi.authme.permission.PermissionsManager;
@@ -56,7 +57,7 @@ public class CommandHandlerTest {
private CommandHandler handler;
@Mock
private Injector injector;
private Factory<ExecutableCommand> commandFactory;
@Mock
private CommandMapper commandMapper;
@Mock
@@ -75,7 +76,7 @@ public class CommandHandlerTest {
ExecutableCommand.class, TestLoginCommand.class, TestRegisterCommand.class, TestUnregisterCommand.class));
setInjectorToMockExecutableCommandClasses();
handler = new CommandHandler(injector, commandMapper, permissionsManager, messages, helpProvider);
handler = new CommandHandler(commandFactory, commandMapper, permissionsManager, messages, helpProvider);
}
/**
@@ -86,7 +87,7 @@ public class CommandHandlerTest {
*/
@SuppressWarnings("unchecked")
private void setInjectorToMockExecutableCommandClasses() {
given(injector.newInstance(any(Class.class))).willAnswer(new Answer<Object>() {
given(commandFactory.newInstance(any(Class.class))).willAnswer(new Answer<Object>() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Class<?> clazz = invocation.getArgument(0);
src/test/java/fr/xephi/authme/command/CommandInitializerTest.java
-29
View File
@@ -1,7 +1,5 @@
package fr.xephi.authme.command;
import fr.xephi.authme.permission.AdminPermission;
import fr.xephi.authme.permission.PermissionNode;
import fr.xephi.authme.util.StringUtils;
import org.junit.BeforeClass;
import org.junit.Test;
@@ -16,7 +14,6 @@ import java.util.Set;
import java.util.function.BiConsumer;
import java.util.regex.Pattern;
import static fr.xephi.authme.permission.DefaultPermission.OP_ONLY;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.hasSize;
import static org.junit.Assert.assertThat;
@@ -199,32 +196,6 @@ public class CommandInitializerTest {
walkThroughCommands(commands, noArgumentForParentChecker);
}
/**
* Test that commands defined with the OP_ONLY default permission have at least one admin permission node.
*/
@Test
public void shouldNotHavePlayerPermissionIfDefaultsToOpOnly() {
// given
BiConsumer<CommandDescription, Integer> adminPermissionChecker = new BiConsumer<CommandDescription, Integer>() {
@Override
public void accept(CommandDescription command, Integer depth) {
PermissionNode permission = command.getPermission();
if (permission != null && OP_ONLY.equals(permission.getDefaultPermission())
&& !hasAdminNode(permission)) {
fail("The command with labels " + command.getLabels() + " has OP_ONLY default "
+ "permission but no permission node on admin level");
}
}
private boolean hasAdminNode(PermissionNode permission) {
return permission instanceof AdminPermission;
}
};
// when/then
walkThroughCommands(commands, adminPermissionChecker);
}
/**
* Tests that multiple CommandDescription instances pointing to the same ExecutableCommand use the same
* count of arguments.
src/test/java/fr/xephi/authme/command/CommandMapperTest.java
+15
View File
@@ -290,6 +290,21 @@ public class CommandMapperTest {
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() {
src/test/java/fr/xephi/authme/command/executable/authme/ConverterCommandTest.java
+8 -8
View File
@@ -1,8 +1,8 @@
package fr.xephi.authme.command.executable.authme;
import ch.jalu.injector.Injector;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.datasource.converter.Converter;
import fr.xephi.authme.initialization.factory.Factory;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.service.CommonService;
@@ -48,7 +48,7 @@ public class ConverterCommandTest {
private BukkitService bukkitService;
@Mock
private Injector injector;
private Factory<Converter> converterFactory;
@BeforeClass
public static void initLogger() {
@@ -66,7 +66,7 @@ public class ConverterCommandTest {
// then
verify(sender).sendMessage(argThat(containsString("Converter does not exist")));
verifyNoMoreInteractions(commandService);
verifyZeroInteractions(injector);
verifyZeroInteractions(converterFactory);
verifyZeroInteractions(bukkitService);
}
@@ -100,8 +100,8 @@ public class ConverterCommandTest {
// then
verify(converter).execute(sender);
verifyNoMoreInteractions(converter);
verify(injector).newInstance(converterClass);
verifyNoMoreInteractions(injector);
verify(converterFactory).newInstance(converterClass);
verifyNoMoreInteractions(converterFactory);
}
@Test
@@ -120,14 +120,14 @@ public class ConverterCommandTest {
// then
verify(converter).execute(sender);
verifyNoMoreInteractions(converter);
verify(injector).newInstance(converterClass);
verifyNoMoreInteractions(injector);
verify(converterFactory).newInstance(converterClass);
verifyNoMoreInteractions(converterFactory);
verify(commandService).send(sender, MessageKey.ERROR);
}
private <T extends Converter> T createMockReturnedByInjector(Class<T> clazz) {
T converter = mock(clazz);
given(injector.newInstance(clazz)).willReturn(converter);
given(converterFactory.newInstance(clazz)).willReturn(converter);
return converter;
}
src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugSectionConsistencyTest.java
+51
View File
@@ -0,0 +1,51 @@
package fr.xephi.authme.command.executable.authme.debug;
import fr.xephi.authme.ClassCollector;
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.junit.Assert.assertThat;
import static org.junit.Assert.fail;
/**
* Consistency tests for {@link DebugSection} implementors.
*/
public class DebugSectionConsistencyTest {
private static List<Class<?>> debugClasses;
@BeforeClass
public static void collectClasses() {
debugClasses = new ClassCollector("src/main/java", "fr/xephi/authme/command/executable/authme/debug")
.collectClasses();
}
@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 (Class<?> clazz : debugClasses) {
if (DebugSection.class.isAssignableFrom(clazz) && !clazz.isInterface()) {
DebugSection debugSection = (DebugSection) clazz.newInstance();
if (!names.add(debugSection.getName())) {
fail("Encountered name '" + debugSection.getName() + "' a second time in " + clazz);
}
}
}
}
}
src/test/java/fr/xephi/authme/command/executable/email/RecoverEmailCommandTest.java
+93 -42
View File
@@ -1,29 +1,39 @@
package fr.xephi.authme.command.executable.email;
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.data.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.mail.SendMailSSL;
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.security.crypts.HashedPassword;
import fr.xephi.authme.service.CommonService;
import fr.xephi.authme.service.RecoveryCodeService;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.util.expiring.Duration;
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 org.mockito.Mockito;
import java.util.Arrays;
import java.util.Collections;
import java.util.concurrent.TimeUnit;
import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
import static org.hamcrest.Matchers.both;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.lessThan;
import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
@@ -38,19 +48,19 @@ import static org.mockito.Mockito.verifyZeroInteractions;
/**
* Test for {@link RecoverEmailCommand}.
*/
@RunWith(MockitoJUnitRunner.class)
@RunWith(DelayedInjectionRunner.class)
public class RecoverEmailCommandTest {
private static final String DEFAULT_EMAIL = "your@email.com";
@InjectMocks
@InjectDelayed
private RecoverEmailCommand command;
@Mock
private PasswordSecurity passwordSecurity;
@Mock
private CommonService commandService;
private CommonService commonService;
@Mock
private DataSource dataSource;
@@ -59,27 +69,35 @@ public class RecoverEmailCommandTest {
private PlayerCache playerCache;
@Mock
private SendMailSSL sendMailSsl;
private EmailService emailService;
@Mock
private RecoveryCodeService recoveryCodeService;
@Mock
private Messages messages;
@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(sendMailSsl.hasAllInformation()).willReturn(false);
given(emailService.hasAllInformation()).willReturn(false);
Player sender = mock(Player.class);
// when
command.executeCommand(sender, Collections.singletonList("some@email.tld"));
// then
verify(commandService).send(sender, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
verify(commonService).send(sender, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
verifyZeroInteractions(dataSource, passwordSecurity);
}
@@ -89,16 +107,16 @@ public class RecoverEmailCommandTest {
String name = "Bobby";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
given(playerCache.isAuthenticated(name)).willReturn(true);
// when
command.executeCommand(sender, Collections.singletonList("bobby@example.org"));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verifyZeroInteractions(dataSource);
verify(commandService).send(sender, MessageKey.ALREADY_LOGGED_IN_ERROR);
verify(commonService).send(sender, MessageKey.ALREADY_LOGGED_IN_ERROR);
}
@Test
@@ -107,7 +125,7 @@ public class RecoverEmailCommandTest {
String name = "Player123";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
given(playerCache.isAuthenticated(name)).willReturn(false);
given(dataSource.getAuth(name)).willReturn(null);
@@ -115,10 +133,10 @@ public class RecoverEmailCommandTest {
command.executeCommand(sender, Collections.singletonList("someone@example.com"));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(dataSource).getAuth(name);
verifyNoMoreInteractions(dataSource);
verify(commandService).send(sender, MessageKey.USAGE_REGISTER);
verify(commonService).send(sender, MessageKey.USAGE_REGISTER);
}
@Test
@@ -127,7 +145,7 @@ public class RecoverEmailCommandTest {
String name = "Tract0r";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
given(playerCache.isAuthenticated(name)).willReturn(false);
given(dataSource.getAuth(name)).willReturn(newAuthWithEmail(DEFAULT_EMAIL));
@@ -135,10 +153,10 @@ public class RecoverEmailCommandTest {
command.executeCommand(sender, Collections.singletonList(DEFAULT_EMAIL));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(dataSource).getAuth(name);
verifyNoMoreInteractions(dataSource);
verify(commandService).send(sender, MessageKey.INVALID_EMAIL);
verify(commonService).send(sender, MessageKey.INVALID_EMAIL);
}
@Test
@@ -147,7 +165,7 @@ public class RecoverEmailCommandTest {
String name = "Rapt0r";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
given(playerCache.isAuthenticated(name)).willReturn(false);
given(dataSource.getAuth(name)).willReturn(newAuthWithEmail("raptor@example.org"));
@@ -155,10 +173,10 @@ public class RecoverEmailCommandTest {
command.executeCommand(sender, Collections.singletonList("wrong-email@example.com"));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(dataSource).getAuth(name);
verifyNoMoreInteractions(dataSource);
verify(commandService).send(sender, MessageKey.INVALID_EMAIL);
verify(commonService).send(sender, MessageKey.INVALID_EMAIL);
}
@Test
@@ -167,8 +185,8 @@ public class RecoverEmailCommandTest {
String name = "Vultur3";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(sendMailSsl.sendRecoveryCode(anyString(), anyString(), anyString())).willReturn(true);
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.getAuth(name)).willReturn(newAuthWithEmail(email));
@@ -180,11 +198,11 @@ public class RecoverEmailCommandTest {
command.executeCommand(sender, Collections.singletonList(email.toUpperCase()));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(dataSource).getAuth(name);
verify(recoveryCodeService).generateCode(name);
verify(commandService).send(sender, MessageKey.RECOVERY_CODE_SENT);
verify(sendMailSsl).sendRecoveryCode(name, email, code);
verify(commonService).send(sender, MessageKey.RECOVERY_CODE_SENT);
verify(emailService).sendRecoveryCode(name, email, code);
}
@Test
@@ -193,7 +211,7 @@ public class RecoverEmailCommandTest {
String name = "Vultur3";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
given(playerCache.isAuthenticated(name)).willReturn(false);
String email = "vulture@example.com";
PlayerAuth auth = newAuthWithEmail(email);
@@ -205,10 +223,10 @@ public class RecoverEmailCommandTest {
command.executeCommand(sender, Arrays.asList(email, "bogus"));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(dataSource, only()).getAuth(name);
verify(commandService).send(sender, MessageKey.INCORRECT_RECOVERY_CODE);
verifyNoMoreInteractions(sendMailSsl);
verify(commonService).send(sender, MessageKey.INCORRECT_RECOVERY_CODE);
verifyNoMoreInteractions(emailService);
}
@Test
@@ -217,14 +235,14 @@ public class RecoverEmailCommandTest {
String name = "Vultur3";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(sendMailSsl.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
given(emailService.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
given(playerCache.isAuthenticated(name)).willReturn(false);
String email = "vulture@example.com";
String code = "A6EF3AC8";
PlayerAuth auth = newAuthWithEmail(email);
given(dataSource.getAuth(name)).willReturn(auth);
given(commandService.getProperty(EmailSettings.RECOVERY_PASSWORD_LENGTH)).willReturn(20);
given(commonService.getProperty(EmailSettings.RECOVERY_PASSWORD_LENGTH)).willReturn(20);
given(passwordSecurity.computeHash(anyString(), eq(name)))
.willAnswer(invocation -> new HashedPassword(invocation.getArgument(0)));
given(recoveryCodeService.isRecoveryCodeNeeded()).willReturn(true);
@@ -234,7 +252,7 @@ public class RecoverEmailCommandTest {
command.executeCommand(sender, Arrays.asList(email, code));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(dataSource).getAuth(name);
ArgumentCaptor<String> passwordCaptor = ArgumentCaptor.forClass(String.class);
verify(passwordSecurity).computeHash(passwordCaptor.capture(), eq(name));
@@ -242,8 +260,8 @@ public class RecoverEmailCommandTest {
assertThat(generatedPassword, stringWithLength(20));
verify(dataSource).updatePassword(eq(name), any(HashedPassword.class));
verify(recoveryCodeService).removeCode(name);
verify(sendMailSsl).sendPasswordMail(name, email, generatedPassword);
verify(commandService).send(sender, MessageKey.RECOVERY_EMAIL_SENT_MESSAGE);
verify(emailService).sendPasswordMail(name, email, generatedPassword);
verify(commonService).send(sender, MessageKey.RECOVERY_EMAIL_SENT_MESSAGE);
}
@Test
@@ -252,13 +270,13 @@ public class RecoverEmailCommandTest {
String name = "sh4rK";
Player sender = mock(Player.class);
given(sender.getName()).willReturn(name);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(sendMailSsl.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
given(emailService.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
given(playerCache.isAuthenticated(name)).willReturn(false);
String email = "shark@example.org";
PlayerAuth auth = newAuthWithEmail(email);
given(dataSource.getAuth(name)).willReturn(auth);
given(commandService.getProperty(EmailSettings.RECOVERY_PASSWORD_LENGTH)).willReturn(20);
given(commonService.getProperty(EmailSettings.RECOVERY_PASSWORD_LENGTH)).willReturn(20);
given(passwordSecurity.computeHash(anyString(), eq(name)))
.willAnswer(invocation -> new HashedPassword(invocation.getArgument(0)));
given(recoveryCodeService.isRecoveryCodeNeeded()).willReturn(false);
@@ -267,15 +285,48 @@ public class RecoverEmailCommandTest {
command.executeCommand(sender, Collections.singletonList(email));
// then
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(dataSource).getAuth(name);
ArgumentCaptor<String> passwordCaptor = ArgumentCaptor.forClass(String.class);
verify(passwordSecurity).computeHash(passwordCaptor.capture(), eq(name));
String generatedPassword = passwordCaptor.getValue();
assertThat(generatedPassword, stringWithLength(20));
verify(dataSource).updatePassword(eq(name), any(HashedPassword.class));
verify(sendMailSsl).sendPasswordMail(name, email, generatedPassword);
verify(commandService).send(sender, MessageKey.RECOVERY_EMAIL_SENT_MESSAGE);
verify(emailService).sendPasswordMail(name, email, generatedPassword);
verify(commonService).send(sender, MessageKey.RECOVERY_EMAIL_SENT_MESSAGE);
}
@Test
public void shouldNotSendEmailIfCooldownCheckFails() {
// given
String name = "feverRay";
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 = "mymail@example.org";
PlayerAuth auth = newAuthWithEmail(email);
given(dataSource.getAuth(name)).willReturn(auth);
given(recoveryCodeService.isRecoveryCodeNeeded()).willReturn(true);
given(recoveryCodeService.generateCode(anyString())).willReturn("Code");
// Trigger sending of recovery code
command.executeCommand(sender, Collections.singletonList(email));
Mockito.reset(emailService, commonService);
given(emailService.hasAllInformation()).willReturn(true);
given(messages.formatDuration(any(Duration.class))).willReturn("8 minutes");
// when
command.executeCommand(sender, Collections.singletonList(email));
// then
verify(emailService, only()).hasAllInformation();
ArgumentCaptor<Duration> durationCaptor = ArgumentCaptor.forClass(Duration.class);
verify(messages).formatDuration(durationCaptor.capture());
assertThat(durationCaptor.getValue().getDuration(), both(lessThan(41L)).and(greaterThan(36L)));
assertThat(durationCaptor.getValue().getTimeUnit(), equalTo(TimeUnit.SECONDS));
verify(messages).send(sender, MessageKey.EMAIL_COOLDOWN_ERROR, "8 minutes");
}
src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java
+15 -15
View File
@@ -1,7 +1,7 @@
package fr.xephi.authme.command.executable.register;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.mail.SendMailSSL;
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;
@@ -52,7 +52,7 @@ public class RegisterCommandTest {
private Management management;
@Mock
private SendMailSSL sendMailSsl;
private EmailService emailService;
@Mock
private ValidationService validationService;
@@ -82,7 +82,7 @@ public class RegisterCommandTest {
// then
verify(sender).sendMessage(argThat(containsString("Player only!")));
verifyZeroInteractions(management, sendMailSsl);
verifyZeroInteractions(management, emailService);
}
@Test
@@ -98,7 +98,7 @@ public class RegisterCommandTest {
// then
verify(management).performRegister(player, executor);
verifyZeroInteractions(sendMailSsl);
verifyZeroInteractions(emailService);
}
@Test
@@ -111,7 +111,7 @@ public class RegisterCommandTest {
// then
verify(commonService).send(player, MessageKey.USAGE_REGISTER);
verifyZeroInteractions(management, sendMailSsl);
verifyZeroInteractions(management, emailService);
}
@Test
@@ -126,13 +126,13 @@ public class RegisterCommandTest {
// then
verify(commonService).send(player, MessageKey.USAGE_REGISTER);
verifyZeroInteractions(management, sendMailSsl);
verifyZeroInteractions(management, emailService);
}
@Test
public void shouldReturnErrorForMissingEmailConfirmation() {
// given
given(sendMailSsl.hasAllInformation()).willReturn(true);
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);
@@ -150,7 +150,7 @@ public class RegisterCommandTest {
public void shouldThrowErrorForMissingEmailConfiguration() {
// given
given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL);
given(sendMailSsl.hasAllInformation()).willReturn(false);
given(emailService.hasAllInformation()).willReturn(false);
Player player = mock(Player.class);
// when
@@ -158,7 +158,7 @@ public class RegisterCommandTest {
// then
verify(commonService).send(player, MessageKey.INCOMPLETE_EMAIL_SETTINGS);
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verifyZeroInteractions(management);
}
@@ -168,7 +168,7 @@ public class RegisterCommandTest {
String playerMail = "player@example.org";
given(validationService.validateEmail(playerMail)).willReturn(false);
given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.EMAIL);
given(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
Player player = mock(Player.class);
// when
@@ -187,7 +187,7 @@ public class RegisterCommandTest {
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(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
Player player = mock(Player.class);
// when
@@ -195,7 +195,7 @@ public class RegisterCommandTest {
// then
verify(commonService).send(player, MessageKey.USAGE_REGISTER);
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verifyZeroInteractions(management);
}
@@ -206,7 +206,7 @@ public class RegisterCommandTest {
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(sendMailSsl.hasAllInformation()).willReturn(true);
given(emailService.hasAllInformation()).willReturn(true);
Player player = mock(Player.class);
RegistrationExecutor executor = mock(RegistrationExecutor.class);
given(registrationExecutorProvider.getEmailRegisterExecutor(player, playerMail)).willReturn(executor);
@@ -216,7 +216,7 @@ public class RegisterCommandTest {
// then
verify(validationService).validateEmail(playerMail);
verify(sendMailSsl).hasAllInformation();
verify(emailService).hasAllInformation();
verify(management).performRegister(player, executor);
}
@@ -232,7 +232,7 @@ public class RegisterCommandTest {
// then
verify(commonService).send(player, MessageKey.PASSWORD_MATCH_ERROR);
verifyZeroInteractions(management, sendMailSsl);
verifyZeroInteractions(management, emailService);
}
@Test
src/test/java/fr/xephi/authme/command/help/HelpMessagesServiceTest.java
+2 -2
View File
@@ -39,10 +39,10 @@ public class HelpMessagesServiceTest {
@Mock
private MessageFileHandlerProvider messageFileHandlerProvider;
@SuppressWarnings("unchecked")
@BeforeInjecting
@SuppressWarnings("unchecked")
public void initializeHandler() {
MessageFileHandler handler = new MessageFileHandler(getJarFile(TEST_FILE), "messages/messages_en.yml");
MessageFileHandler handler = new MessageFileHandler(getJarFile(TEST_FILE), "messages/messages_en.yml", null);
given(messageFileHandlerProvider.initializeHandler(any(Function.class))).willReturn(handler);
}
src/test/java/fr/xephi/authme/data/CaptchaManagerTest.java
+10 -20
View File
@@ -3,12 +3,10 @@ package fr.xephi.authme.data;
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.junit.Test;
import java.util.Map;
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;
@@ -57,11 +55,6 @@ public class CaptchaManagerTest {
assertThat(manager.checkCode(player, "bogus"), equalTo(true));
}
/**
* Tests {@link CaptchaManager#getCaptchaCode} and {@link CaptchaManager#getCaptchaCodeOrGenerateNew}.
* The former method should never change the code (and so return {@code null} for no code) while the latter should
* generate a new code if no code is yet present. If a code is saved, it should never generate a new one.
*/
@Test
public void shouldHaveSameCodeAfterGeneration() {
// given
@@ -70,18 +63,14 @@ public class CaptchaManagerTest {
CaptchaManager manager = new CaptchaManager(settings);
// when
String code1 = manager.getCaptchaCode(player);
String code1 = manager.getCaptchaCodeOrGenerateNew(player);
String code2 = manager.getCaptchaCodeOrGenerateNew(player);
String code3 = manager.getCaptchaCode(player);
String code4 = manager.getCaptchaCodeOrGenerateNew(player);
String code5 = manager.getCaptchaCode(player);
String code3 = manager.getCaptchaCodeOrGenerateNew(player);
// then
assertThat(code1, nullValue());
assertThat(code2.length(), equalTo(5));
assertThat(code3, equalTo(code2));
assertThat(code4, equalTo(code2));
assertThat(code5, equalTo(code2));
assertThat(code1.length(), equalTo(5));
assertThat(code2, equalTo(code1));
assertThat(code3, equalTo(code1));
}
@Test
@@ -104,7 +93,7 @@ public class CaptchaManagerTest {
// then 2
assertThat(manager.isCaptchaRequired(player), equalTo(false));
assertHasCount(manager, player, null);
assertHasCount(manager, player, 0);
}
@Test
@@ -120,7 +109,7 @@ public class CaptchaManagerTest {
// then
assertThat(manager.isCaptchaRequired(player), equalTo(false));
assertHasCount(manager, player, null);
assertHasCount(manager, player, 0);
}
@Test
@@ -149,11 +138,12 @@ public class CaptchaManagerTest {
given(settings.getProperty(SecuritySettings.USE_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(CaptchaManager manager, String player, Integer count) {
Map<String, Integer> playerCounts = ReflectionTestUtils
TimedCounter<String> playerCounts = ReflectionTestUtils
.getFieldValue(CaptchaManager.class, manager, "playerCounts");
assertThat(playerCounts.get(player.toLowerCase()), equalTo(count));
}
src/test/java/fr/xephi/authme/data/SessionManagerTest.java
+19 -38
View File
@@ -3,19 +3,17 @@ package fr.xephi.authme.data;
import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.PluginSettings;
import fr.xephi.authme.util.expiring.ExpiringSet;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Map;
import static org.hamcrest.Matchers.aMapWithSize;
import static org.hamcrest.Matchers.anEmptyMap;
import static org.hamcrest.Matchers.containsInAnyOrder;
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.never;
import static org.mockito.Mockito.verify;
/**
* Test for {@link SessionManager}.
@@ -91,24 +89,6 @@ public class SessionManagerTest {
assertThat(manager.hasSession(player), equalTo(false));
}
@Test
public void shouldDenySessionIfTimeoutHasExpired() {
// given
int timeout = 20;
Settings settings = mockSettings(true, timeout);
String player = "patrick";
SessionManager manager = new SessionManager(settings);
Map<String, Long> sessions = getSessionsMap(manager);
// Add session entry for player that just has expired
sessions.put(player, System.currentTimeMillis() - 1000);
// when
boolean result = manager.hasSession(player);
// then
assertThat(result, equalTo(false));
}
@Test
public void shouldClearAllSessionsAfterDisable() {
// given
@@ -121,7 +101,7 @@ public class SessionManagerTest {
manager.reload(mockSettings(false, 20));
// then
assertThat(getSessionsMap(manager), anEmptyMap());
assertThat(getSessionsMap(manager).isEmpty(), equalTo(true));
}
@Test
@@ -129,18 +109,14 @@ public class SessionManagerTest {
// given
Settings settings = mockSettings(true, 1);
SessionManager manager = new SessionManager(settings);
Map<String, Long> sessions = getSessionsMap(manager);
sessions.put("somebody", System.currentTimeMillis() - 123L);
sessions.put("someone", System.currentTimeMillis() + 4040L);
sessions.put("anyone", System.currentTimeMillis() - 1000L);
sessions.put("everyone", System.currentTimeMillis() + 60000L);
ExpiringSet<String> expiringSet = mockExpiringSet();
setSessionsMap(manager, expiringSet);
// when
manager.performCleanup();
// then
assertThat(sessions, aMapWithSize(2));
assertThat(sessions.keySet(), containsInAnyOrder("someone", "everyone"));
verify(expiringSet).removeExpiredEntries();
}
@Test
@@ -148,23 +124,28 @@ public class SessionManagerTest {
// given
Settings settings = mockSettings(false, 1);
SessionManager manager = new SessionManager(settings);
Map<String, Long> sessions = getSessionsMap(manager);
sessions.put("somebody", System.currentTimeMillis() - 123L);
sessions.put("someone", System.currentTimeMillis() + 4040L);
sessions.put("anyone", System.currentTimeMillis() - 1000L);
sessions.put("everyone", System.currentTimeMillis() + 60000L);
ExpiringSet<String> expiringSet = mockExpiringSet();
setSessionsMap(manager, expiringSet);
// when
manager.performCleanup();
// then
assertThat(sessions, aMapWithSize(4)); // map not changed -> no cleanup performed
verify(expiringSet, never()).removeExpiredEntries();
}
private static Map<String, Long> getSessionsMap(SessionManager manager) {
private static ExpiringSet<String> getSessionsMap(SessionManager manager) {
return ReflectionTestUtils.getFieldValue(SessionManager.class, manager, "sessions");
}
private static void setSessionsMap(SessionManager manager, ExpiringSet<String> sessionsMap) {
ReflectionTestUtils.setField(SessionManager.class, manager, "sessions", sessionsMap);
}
@SuppressWarnings("unchecked")
private static <T> ExpiringSet<T> mockExpiringSet() {
return mock(ExpiringSet.class);
}
private static Settings mockSettings(boolean isEnabled, int sessionTimeout) {
Settings settings = mock(Settings.class);
src/test/java/fr/xephi/authme/data/TempbanManagerTest.java
+22 -42
View File
@@ -2,12 +2,12 @@ package fr.xephi.authme.data;
import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.data.TempbanManager.TimedCounter;
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;
@@ -20,8 +20,7 @@ import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import static org.hamcrest.Matchers.aMapWithSize;
import static org.hamcrest.Matchers.anEmptyMap;
import static org.hamcrest.Matchers.contains;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.lessThan;
import static org.junit.Assert.assertThat;
@@ -195,42 +194,24 @@ public class TempbanManagerTest {
@Test
public void shouldPerformCleanup() {
// given
// `expirationPoint` is the approximate timestamp until which entries should be considered, so subtracting
// from it will create expired entries, and adding a reasonably large number makes it still valid
final long expirationPoint = System.currentTimeMillis() - TEST_EXPIRATION_THRESHOLD;
// 2 current entries with total 6 failed tries
Map<String, TimedCounter> map1 = new HashMap<>();
map1.put("name", newTimedCounter(4, expirationPoint + 20_000));
map1.put("other", newTimedCounter(2, expirationPoint + 40_000));
// 0 current entries
Map<String, TimedCounter> map2 = new HashMap<>();
map2.put("someone", newTimedCounter(10, expirationPoint - 5_000));
map2.put("somebody", newTimedCounter(10, expirationPoint - 8_000));
// 1 current entry with total 4 failed tries
Map<String, TimedCounter> map3 = new HashMap<>();
map3.put("some", newTimedCounter(5, expirationPoint - 12_000));
map3.put("test", newTimedCounter(4, expirationPoint + 8_000));
map3.put("values", newTimedCounter(2, expirationPoint - 80_000));
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);
String[] addresses = {"123.45.67.89", "127.0.0.1", "192.168.0.1"};
Map<String, Map<String, TimedCounter>> counterMap = new HashMap<>();
counterMap.put(addresses[0], map1);
counterMap.put(addresses[1], map2);
counterMap.put(addresses[2], map3);
TempbanManager manager = new TempbanManager(bukkitService, messages, mockSettings(5, 250));
ReflectionTestUtils.setField(TempbanManager.class, manager, "ipLoginFailureCounts", counterMap);
TempbanManager manager = new TempbanManager(bukkitService, messages, mockSettings(3, 10));
ReflectionTestUtils.setField(TempbanManager.class, manager, "ipLoginFailureCounts", counts);
// when
manager.performCleanup();
// then
assertThat(counterMap.get(addresses[0]), aMapWithSize(2));
assertHasCount(manager, addresses[0], "name", 4);
assertHasCount(manager, addresses[0], "other", 2);
assertThat(counterMap.get(addresses[1]), anEmptyMap());
assertThat(counterMap.get(addresses[2]), aMapWithSize(1));
assertHasCount(manager, addresses[2], "test", 4);
verify(counter1).removeExpiredEntries();
verify(counter2).removeExpiredEntries();
assertThat(counts.keySet(), contains("33.33.33.33"));
}
private static Settings mockSettings(int maxTries, int tempbanLength) {
@@ -244,21 +225,20 @@ public class TempbanManagerTest {
}
private static void assertHasNoEntries(TempbanManager manager, String address) {
Map<String, Map<String, TimedCounter>> playerCounts = ReflectionTestUtils
Map<String, TimedCounter<String>> playerCounts = ReflectionTestUtils
.getFieldValue(TempbanManager.class, manager, "ipLoginFailureCounts");
Map<String, TimedCounter> map = playerCounts.get(address);
assertThat(map == null || map.isEmpty(), equalTo(true));
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, Map<String, TimedCounter>> playerCounts = ReflectionTestUtils
Map<String, TimedCounter<String>> playerCounts = ReflectionTestUtils
.getFieldValue(TempbanManager.class, manager, "ipLoginFailureCounts");
assertThat(playerCounts.get(address).get(name).getCount(TEST_EXPIRATION_THRESHOLD), equalTo(count));
assertThat(playerCounts.get(address).get(name), equalTo(count));
}
private static TimedCounter newTimedCounter(int count, long timestamp) {
TimedCounter counter = new TimedCounter(count);
ReflectionTestUtils.setField(TimedCounter.class, counter, "lastIncrementTimestamp", timestamp);
return counter;
@SuppressWarnings("unchecked")
private static <T> TimedCounter<T> mockCounter() {
return mock(TimedCounter.class);
}
}
src/test/java/fr/xephi/authme/data/limbo/LimboCacheTest.java
+2 -17
View File
@@ -1,11 +1,8 @@
package fr.xephi.authme.data.limbo;
import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.data.backup.LimboPlayerStorage;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.SpawnLoader;
import fr.xephi.authme.settings.properties.PluginSettings;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.junit.Test;
@@ -34,9 +31,6 @@ public class LimboCacheTest {
@InjectMocks
private LimboCache limboCache;
@Mock
private Settings settings;
@Mock
private PermissionsManager permissionsManager;
@@ -119,11 +113,7 @@ public class LimboCacheTest {
given(limboPlayer.isCanFly()).willReturn(true);
float flySpeed = 1.0f;
given(limboPlayer.getFlySpeed()).willReturn(flySpeed);
String group = "primary-group";
given(limboPlayer.getGroup()).willReturn(group);
getCache().put(name.toLowerCase(), limboPlayer);
given(settings.getProperty(PluginSettings.ENABLE_PERMISSION_CHECK)).willReturn(true);
given(permissionsManager.hasGroupSupport()).willReturn(true);
// when
limboCache.restoreData(player);
@@ -133,7 +123,6 @@ public class LimboCacheTest {
verify(player).setWalkSpeed(walkSpeed);
verify(player).setAllowFlight(true);
verify(player).setFlySpeed(flySpeed);
verify(permissionsManager).setGroup(player, group);
verify(limboPlayer).clearTasks();
}
@@ -148,18 +137,14 @@ public class LimboCacheTest {
given(limboPlayer.getWalkSpeed()).willReturn(0f);
given(limboPlayer.isCanFly()).willReturn(true);
given(limboPlayer.getFlySpeed()).willReturn(0f);
String group = "primary-group";
given(limboPlayer.getGroup()).willReturn(group);
getCache().put(name.toLowerCase(), limboPlayer);
given(settings.getProperty(PluginSettings.ENABLE_PERMISSION_CHECK)).willReturn(true);
given(permissionsManager.hasGroupSupport()).willReturn(true);
// when
limboCache.restoreData(player);
// then
verify(player).setWalkSpeed(0.2f);
verify(player).setFlySpeed(0.2f);
verify(player).setWalkSpeed(LimboPlayer.DEFAULT_WALK_SPEED);
verify(player).setFlySpeed(LimboPlayer.DEFAULT_FLY_SPEED);
}
@Test
src/test/java/fr/xephi/authme/data/backup/LimboPlayerStorageTest.java → src/test/java/fr/xephi/authme/data/limbo/LimboPlayerStorageTest.java
+2 -3
View File
@@ -1,14 +1,13 @@
package fr.xephi.authme.data.backup;
package fr.xephi.authme.data.limbo;
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.initialization.DataFolder;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.settings.SpawnLoader;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.settings.SpawnLoader;
import fr.xephi.authme.util.FileUtils;
import org.bukkit.Location;
import org.bukkit.World;
src/test/java/fr/xephi/authme/datasource/FlatFileIntegrationTest.java
+4 -4
View File
@@ -61,13 +61,13 @@ public class FlatFileIntegrationTest {
// then
assertThat(authList, hasSize(7));
assertThat(getName("bobby", authList), hasAuthBasicData("bobby", "Bobby", "your@email.com", "123.45.67.89"));
assertThat(getName("bobby", authList), hasAuthBasicData("bobby", "bobby", "your@email.com", "123.45.67.89"));
assertThat(getName("bobby", authList), hasAuthLocation(1.05, 2.1, 4.2, "world"));
assertThat(getName("bobby", authList).getPassword(), equalToHash("$SHA$11aa0706173d7272$dbba966"));
assertThat(getName("twofields", authList), hasAuthBasicData("twofields", "twoFields", "your@email.com", "127.0.0.1"));
assertThat(getName("twofields", authList), hasAuthBasicData("twofields", "twofields", "your@email.com", "127.0.0.1"));
assertThat(getName("twofields", authList).getPassword(), equalToHash("hash1234"));
assertThat(getName("threefields", authList), hasAuthBasicData("threefields", "threeFields", "your@email.com", "33.33.33.33"));
assertThat(getName("fourfields", authList), hasAuthBasicData("fourfields", "fourFields", "your@email.com", "4.4.4.4"));
assertThat(getName("threefields", authList), hasAuthBasicData("threefields", "threefields", "your@email.com", "33.33.33.33"));
assertThat(getName("fourfields", authList), hasAuthBasicData("fourfields", "fourfields", "your@email.com", "4.4.4.4"));
assertThat(getName("fourfields", authList).getLastLogin(), equalTo(404040404L));
assertThat(getName("sevenfields", authList), hasAuthLocation(7.7, 14.14, 21.21, "world"));
assertThat(getName("eightfields", authList), hasAuthLocation(8.8, 17.6, 26.4, "eightworld"));
src/test/java/fr/xephi/authme/datasource/converter/ForceFlatToSqliteTest.java
+3 -3
View File
@@ -63,11 +63,11 @@ public class ForceFlatToSqliteTest {
ArgumentCaptor<PlayerAuth> authCaptor = ArgumentCaptor.forClass(PlayerAuth.class);
verify(dataSource, times(7)).saveAuth(authCaptor.capture());
List<PlayerAuth> auths = authCaptor.getAllValues();
assertThat(auths, hasItem(hasAuthBasicData("bobby", "Bobby", "your@email.com", "123.45.67.89")));
assertThat(auths, hasItem(hasAuthBasicData("bobby", "Player", "your@email.com", "123.45.67.89")));
assertThat(auths, hasItem(hasAuthLocation(1.05, 2.1, 4.2, "world")));
assertThat(auths, hasItem(hasAuthBasicData("user", "user", "user@example.org", "34.56.78.90")));
assertThat(auths, hasItem(hasAuthBasicData("user", "Player", "user@example.org", "34.56.78.90")));
assertThat(auths, hasItem(hasAuthLocation(124.1, 76.3, -127.8, "nether")));
assertThat(auths, hasItem(hasAuthBasicData("eightfields", "eightFields", "your@email.com", "6.6.6.66")));
assertThat(auths, hasItem(hasAuthBasicData("eightfields", "Player", "your@email.com", "6.6.6.66")));
assertThat(auths, hasItem(hasAuthLocation(8.8, 17.6, 26.4, "eightworld")));
}
src/test/java/fr/xephi/authme/mail/EmailServiceTest.java
+190
View File
@@ -0,0 +1,190 @@
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.SecuritySettings;
import org.apache.commons.mail.EmailException;
import org.apache.commons.mail.HtmlEmail;
import org.bukkit.Server;
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 Server server;
@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(server.getServerName()).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"));
}
}
src/test/java/fr/xephi/authme/mail/SendMailSSLTest.java
+4 -138
View File
@@ -4,22 +4,19 @@ 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.output.LogLevel;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import fr.xephi.authme.settings.properties.PluginSettings;
import org.apache.commons.mail.EmailException;
import org.apache.commons.mail.HtmlEmail;
import org.bukkit.Server;
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 java.util.Properties;
@@ -28,16 +25,7 @@ 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.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.doReturn;
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 SendMailSSL}.
@@ -50,10 +38,6 @@ public class SendMailSSLTest {
@Mock
private Settings settings;
@Mock
private Server server;
@DataFolder
private File dataFolder;
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
@@ -65,10 +49,9 @@ public class SendMailSSLTest {
@BeforeInjecting
public void initFields() throws IOException {
dataFolder = temporaryFolder.newFolder();
given(server.getServerName()).willReturn("serverName");
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
@@ -77,123 +60,6 @@ public class SendMailSSLTest {
assertThat(sendMailSSL.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);
SendMailSSL sendMailSpy = spy(sendMailSSL);
HtmlEmail email = mock(HtmlEmail.class);
doReturn(email).when(sendMailSpy).initializeMail(anyString());
doReturn(true).when(sendMailSpy).sendEmail(anyString(), any(HtmlEmail.class));
// when
boolean result = sendMailSpy.sendPasswordMail("Player", "user@example.com", "new_password");
// then
assertThat(result, equalTo(true));
verify(sendMailSpy).initializeMail("user@example.com");
ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
verify(sendMailSpy).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
SendMailSSL sendMailSpy = spy(sendMailSSL);
doThrow(EmailException.class).when(sendMailSpy).initializeMail(anyString());
// when
boolean result = sendMailSpy.sendPasswordMail("Player", "user@example.com", "new_password");
// then
assertThat(result, equalTo(false));
verify(sendMailSpy).initializeMail("user@example.com");
verify(sendMailSpy, 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);
SendMailSSL sendMailSpy = spy(sendMailSSL);
HtmlEmail email = mock(HtmlEmail.class);
doReturn(email).when(sendMailSpy).initializeMail(anyString());
doReturn(false).when(sendMailSpy).sendEmail(anyString(), any(HtmlEmail.class));
// when
boolean result = sendMailSpy.sendPasswordMail("bobby", "user@example.com", "myPassw0rd");
// then
assertThat(result, equalTo(false));
verify(sendMailSpy).initializeMail("user@example.com");
ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
verify(sendMailSpy).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)");
SendMailSSL sendMailSpy = spy(sendMailSSL);
HtmlEmail email = mock(HtmlEmail.class);
doReturn(email).when(sendMailSpy).initializeMail(anyString());
doReturn(true).when(sendMailSpy).sendEmail(anyString(), any(HtmlEmail.class));
// when
boolean result = sendMailSpy.sendRecoveryCode("Timmy", "tim@example.com", "12C56A");
// then
assertThat(result, equalTo(true));
verify(sendMailSpy).initializeMail("tim@example.com");
ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
verify(sendMailSpy).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
SendMailSSL sendMailSpy = spy(sendMailSSL);
doThrow(EmailException.class).when(sendMailSpy).initializeMail(anyString());
// when
boolean result = sendMailSpy.sendRecoveryCode("Player", "player@example.org", "ABC1234");
// then
assertThat(result, equalTo(false));
verify(sendMailSpy).initializeMail("player@example.org");
verify(sendMailSpy, 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 />");
SendMailSSL sendMailSpy = spy(sendMailSSL);
HtmlEmail email = mock(HtmlEmail.class);
doReturn(email).when(sendMailSpy).initializeMail(anyString());
doReturn(false).when(sendMailSpy).sendEmail(anyString(), any(HtmlEmail.class));
// when
boolean result = sendMailSpy.sendRecoveryCode("John", "user@example.com", "1DEF77");
// then
assertThat(result, equalTo(false));
verify(sendMailSpy).initializeMail("user@example.com");
ArgumentCaptor<String> messageCaptor = ArgumentCaptor.forClass(String.class);
verify(sendMailSpy).sendEmail(messageCaptor.capture(), eq(email));
assertThat(messageCaptor.getValue(), equalTo("Hi John, your code is 1DEF77"));
}
@Test
public void shouldCreateEmailObject() throws EmailException {
// given
@@ -204,6 +70,7 @@ public class SendMailSSLTest {
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");
@@ -270,5 +137,4 @@ public class SendMailSSLTest {
assertThat(mailProperties.getProperty("mail.smtp.auth.plain.disable"), equalTo("true"));
assertThat(mailProperties.getProperty(OAuth2SaslClientFactory.OAUTH_TOKEN_PROP), equalTo("oAuth2 token"));
}
}
src/test/java/fr/xephi/authme/message/HelpMessageConsistencyTest.java
+93
View File
@@ -0,0 +1,93 @@
package fr.xephi.authme.message;
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.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
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.regex.Pattern;
import java.util.stream.Collectors;
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 static final String MESSAGES_FOLDER = "/messages";
private static final Pattern HELP_MESSAGES_FILE = Pattern.compile("help_[a-z]+\\.yml");
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 -> HELP_MESSAGES_FILE.matcher(file.getName()).matches())
.collect(Collectors.toList());
}
@Test
public void shouldHaveRequiredEntries() {
for (File file : helpFiles) {
// given
FileConfiguration configuration = YamlConfiguration.loadConfiguration(file);
// when / then
assertHasAllHelpSectionEntries(file.getName(), configuration);
}
}
private void assertHasAllHelpSectionEntries(String filename, FileConfiguration configuration) {
for (HelpSection section : HelpSection.values()) {
assertThat(filename + " should have entry for HelpSection '" + section + "'",
configuration.getString(section.getKey()), notEmptyString());
}
for (HelpMessage message : HelpMessage.values()) {
assertThat(filename + " should have entry for HelpMessage '" + message + "'",
configuration.getString(message.getKey()), notEmptyString());
}
for (DefaultPermission defaultPermission : DefaultPermission.values()) {
assertThat(filename + " should have entry for DefaultPermission '" + defaultPermission + "'",
configuration.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()));
}
}
src/test/java/fr/xephi/authme/message/MessagesIntegrationTest.java
+26 -2
View File
@@ -1,7 +1,9 @@
package fr.xephi.authme.message;
import com.google.common.collect.ImmutableMap;
import fr.xephi.authme.ConsoleLogger;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.util.expiring.Duration;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.junit.Before;
@@ -11,6 +13,8 @@ import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import java.io.File;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.logging.Logger;
@@ -230,11 +234,31 @@ public class MessagesIntegrationTest {
assertThat(result, equalTo("Use /captcha 24680 to solve the captcha"));
}
@Test
public void shouldFormatDurationObjects() {
// given
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()));
}
}
@SuppressWarnings("unchecked")
private static MessageFileHandlerProvider providerReturning(File file, String defaultFile) {
MessageFileHandlerProvider handler = mock(MessageFileHandlerProvider.class);
given(handler.initializeHandler(any(Function.class)))
.willReturn(new MessageFileHandler(file, defaultFile));
given(handler.initializeHandler(any(Function.class), anyString()))
.willReturn(new MessageFileHandler(file, defaultFile, "/authme messages"));
return handler;
}
}
src/test/java/fr/xephi/authme/output/LogFilterHelperTest.java
+88
View File
@@ -0,0 +1,88 @@
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")
);
// 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());
}
}
src/test/java/fr/xephi/authme/process/login/AsynchronousLoginTest.java
+7 -10
View File
@@ -6,10 +6,9 @@ import fr.xephi.authme.data.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.events.AuthMeAsyncPreLoginEvent;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PlayerStatePermission;
import fr.xephi.authme.service.CommonService;
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;
@@ -61,8 +60,6 @@ public class AsynchronousLoginTest {
private LimboPlayerTaskManager limboPlayerTaskManager;
@Mock
private BukkitService bukkitService;
@Mock
private PermissionsManager permissionsManager;
@BeforeClass
public static void initLogger() {
@@ -182,7 +179,7 @@ public class AsynchronousLoginTest {
// given
Player player = mockPlayer("Carl");
given(commonService.getProperty(RestrictionSettings.MAX_LOGIN_PER_IP)).willReturn(2);
given(permissionsManager.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(false);
given(commonService.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(false);
mockOnlinePlayersInBukkitService();
// when
@@ -190,7 +187,7 @@ public class AsynchronousLoginTest {
// then
assertThat(result, equalTo(false));
verify(permissionsManager).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
verify(commonService).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
verify(bukkitService).getOnlinePlayers();
}
@@ -213,14 +210,14 @@ public class AsynchronousLoginTest {
// given
Player player = mockPlayer("Frank");
given(commonService.getProperty(RestrictionSettings.MAX_LOGIN_PER_IP)).willReturn(1);
given(permissionsManager.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(true);
given(commonService.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(true);
// when
boolean result = asynchronousLogin.hasReachedMaxLoggedInPlayersForIp(player, "127.0.0.4");
// then
assertThat(result, equalTo(false));
verify(permissionsManager).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
verify(commonService).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
verifyZeroInteractions(bukkitService);
}
@@ -229,7 +226,7 @@ public class AsynchronousLoginTest {
// given
Player player = mockPlayer("Ian");
given(commonService.getProperty(RestrictionSettings.MAX_LOGIN_PER_IP)).willReturn(2);
given(permissionsManager.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(false);
given(commonService.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(false);
mockOnlinePlayersInBukkitService();
// when
@@ -237,7 +234,7 @@ public class AsynchronousLoginTest {
// then
assertThat(result, equalTo(true));
verify(permissionsManager).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
verify(commonService).hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS);
verify(bukkitService).getOnlinePlayers();
}
src/test/java/fr/xephi/authme/process/register/executors/EmailRegisterExecutorProviderTest.java
+6 -6
View File
@@ -4,7 +4,7 @@ import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.data.auth.PlayerAuth;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.mail.SendMailSSL;
import fr.xephi.authme.mail.EmailService;
import fr.xephi.authme.message.MessageKey;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PlayerStatePermission;
@@ -49,7 +49,7 @@ public class EmailRegisterExecutorProviderTest {
@Mock
private CommonService commonService;
@Mock
private SendMailSSL sendMailSsl;
private EmailService emailService;
@Mock
private SyncProcessManager syncProcessManager;
@Mock
@@ -135,7 +135,7 @@ public class EmailRegisterExecutorProviderTest {
@SuppressWarnings("unchecked")
public void shouldPerformActionAfterDataSourceSave() {
// given
given(sendMailSsl.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
given(emailService.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(true);
Player player = mock(Player.class);
given(player.getName()).willReturn("Laleh");
RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
@@ -146,7 +146,7 @@ public class EmailRegisterExecutorProviderTest {
executor.executePostPersistAction();
// then
verify(sendMailSsl).sendPasswordMail("Laleh", "test@example.com", password);
verify(emailService).sendPasswordMail("Laleh", "test@example.com", password);
verify(syncProcessManager).processSyncEmailRegister(player);
}
@@ -154,7 +154,7 @@ public class EmailRegisterExecutorProviderTest {
@SuppressWarnings("unchecked")
public void shouldHandleEmailSendingFailure() {
// given
given(sendMailSsl.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(false);
given(emailService.sendPasswordMail(anyString(), anyString(), anyString())).willReturn(false);
Player player = mock(Player.class);
given(player.getName()).willReturn("Laleh");
RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
@@ -165,7 +165,7 @@ public class EmailRegisterExecutorProviderTest {
executor.executePostPersistAction();
// then
verify(sendMailSsl).sendPasswordMail("Laleh", "test@example.com", password);
verify(emailService).sendPasswordMail("Laleh", "test@example.com", password);
verify(commonService).send(player, MessageKey.EMAIL_SEND_FAILURE);
verifyZeroInteractions(syncProcessManager);
}
src/test/java/fr/xephi/authme/security/PasswordSecurityTest.java
+4 -1
View File
@@ -6,6 +6,7 @@ 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.initialization.factory.FactoryDependencyHandler;
import fr.xephi.authme.security.crypts.EncryptionMethod;
import fr.xephi.authme.security.crypts.HashedPassword;
import fr.xephi.authme.security.crypts.JOOMLA;
@@ -84,7 +85,9 @@ public class PasswordSecurityTest {
return null;
}
}).when(pluginManager).callEvent(any(Event.class));
injector = new InjectorBuilder().addDefaultHandlers("fr.xephi.authme").create();
injector = new InjectorBuilder()
.addHandlers(new FactoryDependencyHandler())
.addDefaultHandlers("fr.xephi.authme").create();
injector.register(Settings.class, settings);
injector.register(DataSource.class, dataSource);
injector.register(PluginManager.class, pluginManager);
src/test/java/fr/xephi/authme/service/BukkitServiceTest.java
+196
View File
@@ -9,10 +9,14 @@ import org.bukkit.Server;
import org.bukkit.command.CommandSender;
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.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.MockitoJUnitRunner;
import java.util.Collection;
@@ -20,9 +24,13 @@ import java.util.Collection;
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.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.verifyZeroInteractions;
/**
* Test for {@link BukkitService}.
@@ -38,10 +46,13 @@ public class BukkitServiceTest {
private Settings settings;
@Mock
private Server server;
@Mock
private BukkitScheduler scheduler;
@Before
public void constructBukkitService() {
ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
given(server.getScheduler()).willReturn(scheduler);
given(settings.getProperty(PluginSettings.USE_ASYNC_TASKS)).willReturn(true);
bukkitService = new BukkitService(authMe, settings);
}
@@ -101,6 +112,191 @@ public class BukkitServiceTest {
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);
verifyZeroInteractions(task);
}
@Test
public void shouldRunTaskDirectly() {
// 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.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
verifyZeroInteractions(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
Runnable task = () -> {/* */};
long delay = 20L;
long period = 4000L;
BukkitTask bukkitTask = mock(BukkitTask.class);
given(scheduler.runTaskTimerAsynchronously(authMe, task, delay, period)).willReturn(bukkitTask);
// when
BukkitTask resultingTask = bukkitService.runTaskTimerAsynchronously(task, delay, period);
// then
assertThat(resultingTask, equalTo(bukkitTask));
verify(scheduler).runTaskTimerAsynchronously(authMe, task, delay, period);
}
@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);
}
// Note: This method is used through reflections
public static Player[] onlinePlayersImpl() {
return new Player[]{
src/test/java/fr/xephi/authme/service/CommonServiceTest.java
+1 -18
View File
@@ -84,21 +84,6 @@ public class CommonServiceTest {
verify(messages).send(sender, key, replacements);
}
@Test
public void shouldRetrieveMessage() {
// given
MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
String[] lines = new String[]{"First message line", "second line"};
given(messages.retrieve(key)).willReturn(lines);
// when
String[] result = commonService.retrieveMessage(key);
// then
assertThat(result, equalTo(lines));
verify(messages).retrieve(key);
}
@Test
public void shouldRetrieveSingleMessage() {
// given
@@ -134,13 +119,11 @@ public class CommonServiceTest {
// given
Player player = mock(Player.class);
AuthGroupType type = AuthGroupType.LOGGED_IN;
given(authGroupHandler.setGroup(player, type)).willReturn(true);
// when
boolean result = commonService.setGroup(player, type);
commonService.setGroup(player, type);
// then
verify(authGroupHandler).setGroup(player, type);
assertThat(result, equalTo(true));
}
}
src/test/java/fr/xephi/authme/service/PluginHookServiceTest.java
+1 -1
View File
@@ -58,7 +58,7 @@ public class PluginHookServiceTest {
assertThat(pluginHookService.isEssentialsAvailable(), equalTo(true));
}
// Note ljacqu 20160312: Cannot test with Multiverse or CombatTagPlus because their classes are declared final
// Note ljacqu 20160312: Cannot test with CombatTagPlus because its class is declared final
@Test
public void shouldHookIntoEssentialsAtInitialization() {
src/test/java/fr/xephi/authme/service/RecoveryCodeServiceTest.java
+4 -25
View File
@@ -4,15 +4,13 @@ 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.service.RecoveryCodeService.ExpiringEntry;
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 java.util.Map;
import static fr.xephi.authme.AuthMeMatchers.stringWithLength;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
@@ -60,22 +58,8 @@ public class RecoveryCodeServiceTest {
recoveryCodeService.generateCode(name);
// then
ExpiringEntry entry = getCodeMap().get(name);
assertThat(entry.getCode(), stringWithLength(5));
}
@Test
public void shouldNotConsiderExpiredCode() {
// given
String player = "Cat";
String code = "11F235";
setCodeInMap(player, code, System.currentTimeMillis() - 500);
// when
boolean result = recoveryCodeService.isCodeValid(player, code);
// then
assertThat(result, equalTo(false));
String code = getCodeMap().get(name);
assertThat(code, stringWithLength(5));
}
@Test
@@ -106,12 +90,7 @@ public class RecoveryCodeServiceTest {
}
private Map<String, ExpiringEntry> getCodeMap() {
private ExpiringMap<String, String> getCodeMap() {
return ReflectionTestUtils.getFieldValue(RecoveryCodeService.class, recoveryCodeService, "recoveryCodes");
}
private void setCodeInMap(String player, String code, long expiration) {
Map<String, ExpiringEntry> map = getCodeMap();
map.put(player, new ExpiringEntry(code, expiration));
}
}
src/test/java/fr/xephi/authme/service/ValidationServiceTest.java
+68 -13
View File
@@ -4,24 +4,30 @@ 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 fr.xephi.authme.service.ValidationService.ValidationResult;
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 java.util.Arrays;
import java.util.Collections;
import java.util.logging.Logger;
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.BDDMockito.given;
@@ -55,6 +61,7 @@ public class ValidationServiceTest {
.willReturn(asList("unsafe", "other-unsafe"));
given(settings.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(3);
given(settings.getProperty(RestrictionSettings.UNRESTRICTED_NAMES)).willReturn(asList("name01", "npc"));
given(settings.getProperty(RestrictionSettings.ENABLE_RESTRICTED_USERS)).willReturn(false);
}
@Test
@@ -115,8 +122,8 @@ public class ValidationServiceTest {
@Test
public void shouldAcceptEmailWithEmptyLists() {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String>emptyList());
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");
@@ -130,7 +137,7 @@ public class ValidationServiceTest {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
.willReturn(asList("domain.tld", "example.com"));
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.emptyList());
// when
boolean result = validationService.validateEmail("TesT@Example.com");
@@ -144,7 +151,7 @@ public class ValidationServiceTest {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
.willReturn(asList("domain.tld", "example.com"));
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.emptyList());
// when
boolean result = validationService.validateEmail("email@other-domain.abc");
@@ -156,7 +163,7 @@ public class ValidationServiceTest {
@Test
public void shouldAcceptEmailNotInBlacklist() {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
.willReturn(asList("Example.org", "a-test-name.tld"));
@@ -170,7 +177,7 @@ public class ValidationServiceTest {
@Test
public void shouldRejectEmailInBlacklist() {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
.willReturn(asList("Example.org", "a-test-name.tld"));
@@ -263,8 +270,8 @@ public class ValidationServiceTest {
@Test
public void shouldNotInvokeGeoLiteApiIfCountryListsAreEmpty() {
// given
given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(Collections.emptyList());
given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.emptyList());
// when
boolean result = validationService.isCountryAdmitted("addr");
@@ -278,7 +285,7 @@ public class ValidationServiceTest {
public void shouldAcceptCountryInWhitelist() {
// given
given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(asList("ch", "it"));
given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.emptyList());
String ip = "127.0.0.1";
given(geoIpService.getCountryCode(ip)).willReturn("CH");
@@ -294,7 +301,7 @@ public class ValidationServiceTest {
public void shouldRejectCountryMissingFromWhitelist() {
// given
given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(asList("ch", "it"));
given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(ProtectionSettings.COUNTRIES_BLACKLIST)).willReturn(Collections.emptyList());
String ip = "123.45.67.89";
given(geoIpService.getCountryCode(ip)).willReturn("BR");
@@ -309,7 +316,7 @@ public class ValidationServiceTest {
@Test
public void shouldAcceptCountryAbsentFromBlacklist() {
// given
given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(Collections.<String>emptyList());
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");
@@ -325,7 +332,7 @@ public class ValidationServiceTest {
@Test
public void shouldRejectCountryInBlacklist() {
// given
given(settings.getProperty(ProtectionSettings.COUNTRIES_WHITELIST)).willReturn(Collections.<String>emptyList());
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");
@@ -338,6 +345,54 @@ public class ValidationServiceTest {
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(Arrays.asList("Bobby;127.0.0.4", "Tamara;32.24.16.8"));
validationService.reload();
Player bobby = mockPlayer("bobby", "127.0.0.4");
Player tamara = mockPlayer("taMARA", "8.8.8.8");
Player notRestricted = mockPlayer("notRestricted", "0.0.0.0");
// when
boolean isBobbyAdmitted = validationService.fulfillsNameRestrictions(bobby);
boolean isTamaraAdmitted = validationService.fulfillsNameRestrictions(tamara);
boolean isNotRestrictedAdmitted = validationService.fulfillsNameRestrictions(notRestricted);
// then
assertThat(isBobbyAdmitted, equalTo(true));
assertThat(isTamaraAdmitted, equalTo(false));
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(Arrays.asList("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.mockPlayerIp(player, ip);
given(player.getAddress().getHostName()).willReturn("--");
return player;
}
private static void assertErrorEquals(ValidationResult validationResult, MessageKey messageKey, String... args) {
assertThat(validationResult.hasError(), equalTo(true));
assertThat(validationResult.getMessageKey(), equalTo(messageKey));
src/test/java/fr/xephi/authme/settings/SettingsConsistencyTest.java
+80
View File
@@ -1,15 +1,25 @@
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.ImmutableSetMultimap;
import com.google.common.collect.Multimap;
import fr.xephi.authme.datasource.DataSourceType;
import fr.xephi.authme.settings.properties.AuthMeSettingsRetriever;
import fr.xephi.authme.settings.properties.DatabaseSettings;
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.stream.Collectors;
import static fr.xephi.authme.ReflectionTestUtils.getFieldValue;
import static org.junit.Assert.fail;
/**
@@ -22,6 +32,17 @@ public class SettingsConsistencyTest {
*/
private static final int MAX_COMMENT_LENGTH = 90;
/**
* Exclusions for the enum in comments check. Use {@link Exclude#ALL}
* to skip an entire property from being checked.
*/
private static final Multimap<Property<?>, Enum<?>> EXCLUDED_ENUMS =
ImmutableSetMultimap.<Property<?>, Enum<?>>builder()
.put(DatabaseSettings.BACKEND, DataSourceType.FILE)
.put(SecuritySettings.PASSWORD_HASH, Exclude.ALL)
.put(SecuritySettings.LEGACY_HASHES, Exclude.ALL)
.build();
private static ConfigurationData configurationData;
@BeforeClass
@@ -66,4 +87,63 @@ public class SettingsConsistencyTest {
}
}
/**
* 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) {
String comments = String.join("\n", configurationData.getCommentsForSection(property.getPath()));
Arrays.stream(enumClass.getEnumConstants())
.filter(e -> !comments.contains(e.name()) && !isExcluded(property, 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<?>) {
return getFieldValue(EnumProperty.class, (EnumProperty<?>) property, "clazz");
} else if (property instanceof EnumSetProperty<?>) {
return getFieldValue(EnumSetProperty.class, (EnumSetProperty<?>) property, "enumClass");
}
return null;
}
private static boolean isExcluded(Property<?> property, Enum<?> enumValue) {
return EXCLUDED_ENUMS.get(property).contains(Exclude.ALL)
|| EXCLUDED_ENUMS.get(property).contains(enumValue);
}
/**
* Dummy enum to specify in the exclusion that all enum values
* should be skipped. See its usages.
*/
private enum Exclude {
ALL
}
}
src/test/java/fr/xephi/authme/settings/SettingsMigrationServiceTest.java
+6
View File
@@ -18,7 +18,10 @@ import java.io.IOException;
import java.nio.charset.StandardCharsets;
import static fr.xephi.authme.TestHelper.getJarFile;
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;
@@ -65,6 +68,9 @@ public class SettingsMigrationServiceTest {
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(""));
// Check migration of old setting to email.html
assertThat(Files.readLines(new File(dataFolder, "email.html"), StandardCharsets.UTF_8),
src/test/java/fr/xephi/authme/settings/SettingsTest.java
-24
View File
@@ -4,7 +4,6 @@ import ch.jalu.configme.configurationdata.ConfigurationData;
import ch.jalu.configme.configurationdata.ConfigurationDataBuilder;
import ch.jalu.configme.resource.PropertyResource;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.settings.properties.TestConfiguration;
import org.junit.Before;
import org.junit.BeforeClass;
@@ -16,11 +15,8 @@ import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import static org.hamcrest.Matchers.arrayContaining;
import static org.hamcrest.Matchers.arrayWithSize;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Mockito.mock;
/**
@@ -45,26 +41,6 @@ public class SettingsTest {
testPluginFolder = temporaryFolder.newFolder();
}
@Test
public void shouldLoadWelcomeMessage() throws IOException {
// given
String welcomeMessage = "This is my welcome message for testing\nBye!";
File welcomeFile = new File(testPluginFolder, "welcome.txt");
createFile(welcomeFile);
Files.write(welcomeFile.toPath(), welcomeMessage.getBytes());
PropertyResource resource = mock(PropertyResource.class);
given(resource.getBoolean(RegistrationSettings.USE_WELCOME_MESSAGE.getPath())).willReturn(true);
Settings settings = new Settings(testPluginFolder, resource, null, CONFIG_DATA);
// when
String[] result = settings.getWelcomeMessage();
// then
assertThat(result, arrayWithSize(2));
assertThat(result, arrayContaining(welcomeMessage.split("\\n")));
}
@Test
public void shouldLoadEmailMessage() throws IOException {
// given
src/test/java/fr/xephi/authme/settings/SpawnLoaderTest.java
+1 -5
View File
@@ -5,9 +5,8 @@ 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.datasource.DataSource;
import fr.xephi.authme.service.PluginHookService;
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;
@@ -38,9 +37,6 @@ public class SpawnLoaderTest {
@Mock
private Settings settings;
@Mock
private DataSource dataSource;
@Mock
private PluginHookService pluginHookService;
src/test/java/fr/xephi/authme/settings/WelcomeMessageConfigurationTest.java
+141
View File
@@ -0,0 +1,141 @@
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.GeoIpService;
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.only;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
/**
* 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;
@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();
}
@Test
public void shouldLoadWelcomeMessage() throws IOException {
// 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")));
verifyZeroInteractions(player, playerCache, geoIpService, bukkitService, server);
}
@Test
public void shouldReplaceNameAndIpAndCountry() throws IOException {
// 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.mockPlayerIp(player, "123.45.66.77");
given(geoIpService.getCountryName("123.45.66.77")).willReturn("Syldavia");
given(server.getServerName()).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!"));
verify(server, only()).getServerName();
verifyZeroInteractions(playerCache);
}
@Test
public void shouldApplyOtherReplacements() throws IOException {
// given
String welcomeMessage = "{ONLINE}/{MAXPLAYERS} online\n{LOGINS} logged in\nYour world is {WORLD}\nServer: {VERSION}";
setWelcomeMessageAndReload(welcomeMessage);
given(bukkitService.getOnlinePlayers()).willReturn((List) 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();
}
}
src/test/java/fr/xephi/authme/settings/commandconfig/CommandManagerTest.java
+97 -91
View File
@@ -1,9 +1,9 @@
package fr.xephi.authme.settings.commandconfig;
import com.google.common.io.Files;
import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.service.BukkitService;
import fr.xephi.authme.service.GeoIpService;
import fr.xephi.authme.settings.SettingsMigrationService;
import org.bukkit.entity.Player;
import org.junit.Before;
@@ -17,13 +17,7 @@ import org.mockito.junit.MockitoJUnitRunner;
import java.io.File;
import java.io.IOException;
import java.util.function.BiConsumer;
import static fr.xephi.authme.settings.commandconfig.CommandConfigTestHelper.isCommand;
import static java.lang.String.format;
import static org.hamcrest.Matchers.anEmptyMap;
import static org.hamcrest.Matchers.contains;
import static org.junit.Assert.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.BDDMockito.given;
@@ -31,6 +25,7 @@ import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.only;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.verifyZeroInteractions;
/**
* Test for {@link CommandManager}.
@@ -41,104 +36,116 @@ 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;
@Rule
public TemporaryFolder temporaryFolder = new TemporaryFolder();
@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();
}
@Test
@SuppressWarnings("unchecked")
public void shouldLoadCompleteFile() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
// when
initManager();
// then
CommandConfig commandConfig = ReflectionTestUtils.getFieldValue(CommandManager.class, manager, "commandConfig");
assertThat(commandConfig.getOnJoin().keySet(), contains("broadcast"));
assertThat(commandConfig.getOnJoin().values(), contains(isCommand("broadcast %p has joined", Executor.CONSOLE)));
assertThat(commandConfig.getOnRegister().keySet(), contains("announce", "notify"));
assertThat(commandConfig.getOnRegister().values(), contains(
isCommand("me I just registered", Executor.PLAYER),
isCommand("log %p registered", Executor.CONSOLE)));
assertThat(commandConfig.getOnLogin().keySet(), contains("welcome", "show_motd", "display_list"));
assertThat(commandConfig.getOnLogin().values(), contains(
isCommand("msg %p Welcome back", Executor.CONSOLE),
isCommand("motd", Executor.PLAYER),
isCommand("list", Executor.PLAYER)));
}
@Test
public void shouldLoadIncompleteFile() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.incomplete.yml");
// when
initManager();
// then
CommandConfig commandConfig = ReflectionTestUtils.getFieldValue(CommandManager.class, manager, "commandConfig");
assertThat(commandConfig.getOnJoin().values(), contains(isCommand("broadcast %p has joined", Executor.CONSOLE)));
assertThat(commandConfig.getOnLogin().values(), contains(
isCommand("msg %p Welcome back", Executor.CONSOLE),
isCommand("list", Executor.PLAYER)));
assertThat(commandConfig.getOnRegister(), anEmptyMap());
}
@Test
public void shouldExecuteCommandsOnJoin() {
// given
String name = "Bobby1";
// when
testCommandExecution(name, CommandManager::runCommandsOnJoin);
// then
verify(bukkitService, only()).dispatchConsoleCommand(format("broadcast %s has joined", name));
}
@Test
public void shouldExecuteCommandsOnRegister() {
// given
String name = "luis";
// when
testCommandExecution(name, CommandManager::runCommandsOnRegister);
// then
verify(bukkitService).dispatchCommand(any(Player.class), eq("me I just registered"));
verify(bukkitService).dispatchConsoleCommand(format("log %s registered", name));
verifyNoMoreInteractions(bukkitService);
player = mockPlayer();
}
@Test
public void shouldExecuteCommandsOnLogin() {
// given
String name = "plaYer01";
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
initManager();
// when
testCommandExecution(name, CommandManager::runCommandsOnLogin);
manager.runCommandsOnLogin(player);
// then
verify(bukkitService).dispatchConsoleCommand(format("msg %s Welcome back", name));
verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back");
verify(bukkitService).dispatchCommand(any(Player.class), eq("motd"));
verify(bukkitService).dispatchCommand(any(Player.class), eq("list"));
verifyNoMoreInteractions(bukkitService);
verifyZeroInteractions(geoIpService);
}
@Test
public void shouldExecuteCommandsOnLoginWithIncompleteConfig() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.incomplete.yml");
initManager();
// when
manager.runCommandsOnLogin(player);
// then
verify(bukkitService).dispatchConsoleCommand("msg Bobby Welcome back, bob");
verify(bukkitService).dispatchCommand(any(Player.class), eq("list"));
verifyNoMoreInteractions(bukkitService);
verifyZeroInteractions(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");
verifyZeroInteractions(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");
verifyZeroInteractions(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");
verifyNoMoreInteractions(bukkitService);
}
@Test
public void shouldExecuteCommandsOnRegisterWithIncompleteConfig() {
// given
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.incomplete.yml");
initManager();
// when
manager.runCommandsOnRegister(player);
// then
verifyZeroInteractions(bukkitService, geoIpService);
}
@Test
@@ -147,18 +154,8 @@ public class CommandManagerTest {
TestHelper.validateHasOnlyPrivateEmptyConstructor(CommandSettingsHolder.class);
}
private void testCommandExecution(String playerName, BiConsumer<CommandManager, Player> testMethod) {
copyJarFileAsCommandsYml(TEST_FILES_FOLDER + "commands.complete.yml");
initManager();
Player player = mock(Player.class);
given(player.getName()).willReturn(playerName);
testMethod.accept(manager, player);
}
private void initManager() {
manager = new CommandManager(testFolder, bukkitService, commandMigrationService);
manager = new CommandManager(testFolder, bukkitService, geoIpService, commandMigrationService);
}
private void copyJarFileAsCommandsYml(String path) {
@@ -171,4 +168,13 @@ public class CommandManagerTest {
}
}
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.mockPlayerIp(player, ip);
given(geoIpService.getCountryName(ip)).willReturn("Syldavia");
return player;
}
}
src/test/java/fr/xephi/authme/util/CollectionUtilsTest.java
-102
View File
@@ -1,102 +0,0 @@
package fr.xephi.authme.util;
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;
import static org.hamcrest.Matchers.empty;
/**
* Test for {@link CollectionUtils}.
*/
public class CollectionUtilsTest {
@Test
public void shouldGetFullList() {
// given
List<String> list = Arrays.asList("test", "1", "2", "3", "4");
// when
List<String> result = CollectionUtils.getRange(list, 0, 24);
// then
assertThat(result, equalTo(list));
}
@Test
public void shouldReturnEmptyListForZeroCount() {
// given
List<String> list = Arrays.asList("test", "1", "2", "3", "4");
// when
List<String> result = CollectionUtils.getRange(list, 2, 0);
// then
assertThat(result, empty());
}
@Test
public void shouldReturnEmptyListForTooHighStart() {
// given
List<String> list = Arrays.asList("test", "1", "2", "3", "4");
// when
List<String> result = CollectionUtils.getRange(list, 12, 2);
// then
assertThat(result, empty());
}
@Test
public void shouldReturnSubList() {
// given
List<String> list = Arrays.asList("test", "1", "2", "3", "4");
// when
List<String> result = CollectionUtils.getRange(list, 1, 3);
// then
assertThat(result, contains("1", "2", "3"));
}
@Test
public void shouldReturnTillEnd() {
// given
List<String> list = Arrays.asList("test", "1", "2", "3", "4");
// when
List<String> result = CollectionUtils.getRange(list, 2, 3);
// then
assertThat(result, contains("2", "3", "4"));
}
@Test
public void shouldRemoveFirstTwo() {
// given
List<String> list = Arrays.asList("test", "1", "2", "3", "4");
// when
List<String> result = CollectionUtils.getRange(list, 2);
// then
assertThat(result, contains("2", "3", "4"));
}
@Test
public void shouldHandleNegativeStart() {
// given
List<String> list = Arrays.asList("test", "1", "2", "3", "4");
// when
List<String> result = CollectionUtils.getRange(list, -4);
// then
assertThat(result, equalTo(list));
}
}
src/test/java/fr/xephi/authme/util/FileUtilsTest.java
+5
View File
@@ -137,6 +137,11 @@ public class FileUtilsTest {
assertThat(result, equalTo("path" + File.separator + "to" + File.separator + "test-file.txt"));
}
@Test
public void shouldHaveHiddenConstructor() {
TestHelper.validateHasOnlyPrivateEmptyConstructor(FileUtils.class);
}
private static void createFiles(File... files) throws IOException {
for (File file : files) {
boolean result = file.getParentFile().mkdirs() & file.createNewFile();
src/test/java/fr/xephi/authme/util/PlayerUtilsTest.java
+6
View File
@@ -64,4 +64,10 @@ public class PlayerUtilsTest {
// then
assertThat(result, equalTo(name));
}
@Test
public void shouldHaveHiddenConstructor() {
// given / when / then
TestHelper.validateHasOnlyPrivateEmptyConstructor(PlayerUtils.class);
}
}
src/test/java/fr/xephi/authme/util/RandomStringUtilsTest.java
+7
View File
@@ -1,5 +1,6 @@
package fr.xephi.authme.util;
import fr.xephi.authme.TestHelper;
import org.junit.Test;
import java.util.regex.Pattern;
@@ -68,4 +69,10 @@ public class RandomStringUtilsTest {
// then - throw exception
}
@Test
public void shouldHaveHiddenConstructor() {
// given / when / then
TestHelper.validateHasOnlyPrivateEmptyConstructor(RandomStringUtils.class);
}
}
src/test/java/fr/xephi/authme/util/StringUtilsTest.java
+14 -3
View File
@@ -5,6 +5,7 @@ import org.junit.Test;
import java.net.MalformedURLException;
import static java.util.Arrays.asList;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.assertFalse;
@@ -23,7 +24,7 @@ public class StringUtilsTest {
String piece = "test";
// when
boolean result = StringUtils.containsAny(text, "some", "words", "that", "do not", "exist", piece);
boolean result = StringUtils.containsAny(text, asList("some", "words", "that", "do not", "exist", piece));
// then
assertThat(result, equalTo(true));
@@ -35,7 +36,7 @@ public class StringUtilsTest {
String text = "This is a test string";
// when
boolean result = StringUtils.containsAny(text, "some", "other", "words", null);
boolean result = StringUtils.containsAny(text, asList("some", "other", "words", null));
// then
assertThat(result, equalTo(false));
@@ -44,7 +45,7 @@ public class StringUtilsTest {
@Test
public void shouldReturnFalseForNullString() {
// given/when
boolean result = StringUtils.containsAny(null, "some", "words", "to", "check");
boolean result = StringUtils.containsAny(null, asList("some", "words", "to", "check"));
// then
assertThat(result, equalTo(false));
@@ -94,4 +95,14 @@ public class StringUtilsTest {
public void shouldHaveHiddenConstructor() {
TestHelper.validateHasOnlyPrivateEmptyConstructor(StringUtils.class);
}
@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));
}
}
src/test/java/fr/xephi/authme/util/UtilsTest.java
+50
View File
@@ -1,13 +1,20 @@
package fr.xephi.authme.util;
import fr.xephi.authme.TestHelper;
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.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.verifyZeroInteractions;
/**
* Test for {@link Utils}.
@@ -49,6 +56,49 @@ public class UtilsTest {
TestHelper.validateHasOnlyPrivateEmptyConstructor(Utils.class);
}
@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);
verifyZeroInteractions(sender);
}
@Test
public void shouldCheckIfClassIsLoaded() {
// given / when / then
src/test/java/fr/xephi/authme/util/expiring/DurationTest.java
+43
View File
@@ -0,0 +1,43 @@
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));
}
}
src/test/java/fr/xephi/authme/util/expiring/ExpiringMapTest.java
+95
View File
@@ -0,0 +1,95 @@
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.entries;
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));
}
}
src/test/java/fr/xephi/authme/util/expiring/ExpiringSetTest.java
+143
View File
@@ -0,0 +1,143 @@
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));
}
}
src/test/java/fr/xephi/authme/util/expiring/TimedCounterTest.java
+55
View File
@@ -0,0 +1,55 @@
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 shouldSumUpEntries() {
// given
TimedCounter<String> counter = new TimedCounter<>(90, TimeUnit.SECONDS);
counter.entries.put("expired", new ExpiringMap.ExpiringEntry<>(800, 0));
counter.entries.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));
}
}
src/test/java/fr/xephi/authme/util/lazytags/TagBuilderTest.java
+50
View File
@@ -0,0 +1,50 @@
package fr.xephi.authme.util.lazytags;
import fr.xephi.authme.TestHelper;
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"));
}
@Test
public void shouldHaveHiddenConstructor() {
// given / when / then
TestHelper.validateHasOnlyPrivateEmptyConstructor(TagBuilder.class);
}
}
src/test/java/fr/xephi/authme/util/lazytags/TagReplacerTest.java
+90
View File
@@ -0,0 +1,90 @@
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));
}
}
}
src/test/java/fr/xephi/authme/util/lazytags/WrappedTagReplacerTest.java
+76
View File
@@ -0,0 +1,76 @@
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;
}
}
}
src/test/java/tools/dependencygraph/DrawDependency.java
+2 -2
View File
@@ -2,6 +2,7 @@ package tools.dependencygraph;
import ch.jalu.injector.handlers.instantiation.DependencyDescription;
import ch.jalu.injector.handlers.instantiation.Instantiation;
import ch.jalu.injector.handlers.instantiation.StandardInjectionProvider;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Multimap;
@@ -14,7 +15,6 @@ import fr.xephi.authme.process.AsynchronousProcess;
import fr.xephi.authme.process.SynchronousProcess;
import fr.xephi.authme.security.crypts.EncryptionMethod;
import org.bukkit.event.Listener;
import tools.utils.InjectorUtils;
import tools.utils.ToolTask;
import tools.utils.ToolsConstants;
@@ -114,7 +114,7 @@ public class DrawDependency implements ToolTask {
}
private List<String> getDependencies(Class<?> clazz) {
Instantiation<?> instantiation = InjectorUtils.getInstantiationMethod(clazz);
Instantiation<?> instantiation = new StandardInjectionProvider().safeGet(clazz);
return instantiation == null ? null : formatInjectionDependencies(instantiation);
}
src/test/java/tools/filegeneration/GenerateCommandsYml.java
+1 -13
View File
@@ -2,11 +2,8 @@ package tools.filegeneration;
import ch.jalu.configme.SettingsManager;
import ch.jalu.configme.resource.YamlFileResource;
import com.google.common.collect.ImmutableMap;
import fr.xephi.authme.settings.commandconfig.Command;
import fr.xephi.authme.settings.commandconfig.CommandConfig;
import fr.xephi.authme.settings.commandconfig.CommandSettingsHolder;
import fr.xephi.authme.settings.commandconfig.Executor;
import tools.utils.AutoToolTask;
import tools.utils.ToolsConstants;
@@ -23,10 +20,8 @@ public class GenerateCommandsYml implements AutoToolTask {
public void executeDefault() {
File file = new File(COMMANDS_YML_FILE);
// Get default and add sample entry
// Get the default
CommandConfig commandConfig = CommandSettingsHolder.COMMANDS.getDefaultValue();
commandConfig.setOnLogin(
ImmutableMap.of("welcome", newCommand("msg %p Welcome back!", Executor.PLAYER)));
// Export the value to the file
SettingsManager settingsManager = new SettingsManager(
@@ -41,11 +36,4 @@ public class GenerateCommandsYml implements AutoToolTask {
public String getTaskName() {
return "generateCommandsYml";
}
private static Command newCommand(String commandLine, Executor executor) {
Command command = new Command();
command.setCommand(commandLine);
command.setExecutor(executor);
return command;
}
}
src/test/java/tools/messages/AddJavaDocToMessageEnumTask.java
+2 -1
View File
@@ -45,6 +45,7 @@ public class AddJavaDocToMessageEnumTask implements AutoToolTask {
return configuration.getString(key.getKey())
.replaceAll("&[0-9a-f]", "")
.replace("&", "&amp;")
.replace("<", "&lt;");
.replace("<", "&lt;")
.replace(">", "&gt;");
}
}
src/test/java/tools/utils/InjectorUtils.java
+2 -21
View File
@@ -1,12 +1,10 @@
package tools.utils;
import ch.jalu.injector.InjectorBuilder;
import ch.jalu.injector.handlers.instantiation.DependencyDescription;
import ch.jalu.injector.handlers.instantiation.Instantiation;
import ch.jalu.injector.handlers.instantiation.InstantiationProvider;
import ch.jalu.injector.handlers.instantiation.StandardInjectionProvider;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
/**
@@ -24,7 +22,7 @@ public final class InjectorUtils {
* @return the class' dependencies, or null if no instantiation method found
*/
public static Set<Class<?>> getDependencies(Class<?> clazz) {
Instantiation<?> instantiation = getInstantiationMethod(clazz);
Instantiation<?> instantiation = new StandardInjectionProvider().safeGet(clazz);
if (instantiation == null) {
return null;
}
@@ -35,21 +33,4 @@ public final class InjectorUtils {
return dependencies;
}
/**
* Returns the instantiation method for the given class.
*
* @param clazz the class to process
* @return the instantiation method for the class, or null if none applicable
*/
public static Instantiation<?> getInstantiationMethod(Class<?> clazz) {
List<InstantiationProvider> providers = InjectorBuilder.createInstantiationProviders();
for (InstantiationProvider provider : providers) {
Instantiation<?> instantiation = provider.get(clazz);
if (instantiation != null) {
return instantiation;
}
}
return null;
}
}
src/test/resources/fr/xephi/authme/datasource/flatfile-test.txt
+6 -6
View File
@@ -1,7 +1,7 @@
Bobby:$SHA$11aa0706173d7272$dbba966:123.45.67.89:1449136800:1.05:2.1:4.2:world:your@email.com
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
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
src/test/resources/fr/xephi/authme/settings/commandconfig/commands.complete.yml
+2 -2
View File
@@ -2,14 +2,14 @@
onJoin:
broadcast:
command: 'broadcast %p has joined'
command: 'broadcast %nick has joined'
executor: CONSOLE
onRegister:
announce:
command: 'me I just registered'
executor: PLAYER
notify:
command: 'log %p registered'
command: 'log %p (%ip, %country) registered'
executor: CONSOLE
onLogin:
welcome:
src/test/resources/fr/xephi/authme/settings/commandconfig/commands.incomplete.yml
+1 -1
View File
@@ -6,7 +6,7 @@ onJoin:
executor: CONSOLE
onLogin:
welcome:
command: 'msg %p Welcome back'
command: 'msg %p Welcome back, %nick'
executor: CONSOLE
show_motd:
# command: 'motd' <-- mandatory property, so entry should be ignored
src/test/resources/fr/xephi/authme/settings/config-old.yml
+1 -1
View File
@@ -290,7 +290,7 @@ permission:
# to use Vault and Group Switching of
# AuthMe for unloggedIn players put true
# below, default is false.
EnablePermissionCheck: false
EnablePermissionCheck: true
BackupSystem:
# Enable or Disable Automatic Backup
ActivateBackup: false