Merge branches 'master' and 'passwd_recovery_process' of https://github.com/AuthMe/AuthMeReloaded into passwd_recovery_process
# Conflicts: # docs/config.md # src/main/resources/messages/messages_bg.yml # src/main/resources/messages/messages_es.yml # src/main/resources/messages/messages_pt.yml # src/main/resources/messages/messages_zhcn.yml
This commit is contained in:
Gnat008
@@ -9,6 +9,7 @@ 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.initialization.factory.SingletonStoreDependencyHandler;
|
||||
import fr.xephi.authme.listener.BlockListener;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.process.Management;
|
||||
@@ -93,7 +94,7 @@ public class AuthMeInitializationTest {
|
||||
new Settings(dataFolder, mock(PropertyResource.class), null, buildConfigurationData());
|
||||
|
||||
Injector injector = new InjectorBuilder()
|
||||
.addHandlers(new FactoryDependencyHandler())
|
||||
.addHandlers(new FactoryDependencyHandler(), new SingletonStoreDependencyHandler())
|
||||
.addDefaultHandlers("fr.xephi.authme")
|
||||
.create();
|
||||
injector.provide(DataFolder.class, dataFolder);
|
||||
|
||||
@@ -25,7 +25,7 @@ public final class ReflectionTestUtils {
|
||||
*/
|
||||
public static <T> void setField(Class<T> clazz, T instance, String fieldName, Object value) {
|
||||
try {
|
||||
Field field = getField(clazz, instance, fieldName);
|
||||
Field field = getField(clazz, fieldName);
|
||||
field.set(instance, value);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new UnsupportedOperationException(
|
||||
@@ -34,24 +34,30 @@ public final class ReflectionTestUtils {
|
||||
}
|
||||
}
|
||||
|
||||
private static <T> Field getField(Class<T> clazz, T instance, String fieldName) {
|
||||
private static <T> Field getField(Class<T> clazz, String fieldName) {
|
||||
try {
|
||||
Field field = clazz.getDeclaredField(fieldName);
|
||||
field.setAccessible(true);
|
||||
return field;
|
||||
} catch (NoSuchFieldException e) {
|
||||
throw new UnsupportedOperationException(format("Could not get field '%s' for instance '%s' of class '%s'",
|
||||
fieldName, instance, clazz.getName()), e);
|
||||
throw new UnsupportedOperationException(format("Could not get field '%s' from class '%s'",
|
||||
fieldName, clazz.getName()), e);
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <T, V> V getFieldValue(Class<T> clazz, T instance, String fieldName) {
|
||||
Field field = getField(clazz, instance, fieldName);
|
||||
Field field = getField(clazz, fieldName);
|
||||
return getFieldValue(field, instance);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <V> V getFieldValue(Field field, Object instance) {
|
||||
field.setAccessible(true);
|
||||
try {
|
||||
return (V) field.get(instance);
|
||||
} catch (IllegalAccessException e) {
|
||||
throw new UnsupportedOperationException("Could not get value of field '" + fieldName + "'", e);
|
||||
throw new UnsupportedOperationException("Could not get value of field '" + field.getName() + "'", e);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -75,10 +81,11 @@ public final class ReflectionTestUtils {
|
||||
}
|
||||
}
|
||||
|
||||
public static Object invokeMethod(Method method, Object instance, Object... parameters) {
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <V> V invokeMethod(Method method, Object instance, Object... parameters) {
|
||||
method.setAccessible(true);
|
||||
try {
|
||||
return method.invoke(instance, parameters);
|
||||
return (V) method.invoke(instance, parameters);
|
||||
} catch (InvocationTargetException | IllegalAccessException e) {
|
||||
throw new UnsupportedOperationException("Could not invoke method '" + method + "'", e);
|
||||
}
|
||||
|
||||
@@ -2,7 +2,6 @@ package fr.xephi.authme.command.executable.authme;
|
||||
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.auth.PlayerAuth;
|
||||
import fr.xephi.authme.data.limbo.LimboCache;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.security.PasswordSecurity;
|
||||
@@ -56,9 +55,6 @@ public class RegisterAdminCommandTest {
|
||||
@Mock
|
||||
private ValidationService validationService;
|
||||
|
||||
@Mock
|
||||
private LimboCache limboCache;
|
||||
|
||||
@BeforeClass
|
||||
public static void setUpLogger() {
|
||||
TestHelper.setupLogger();
|
||||
|
||||
+51
@@ -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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+69
@@ -0,0 +1,69 @@
|
||||
package fr.xephi.authme.command.executable.authme.debug;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.limbo.LimboPlayer;
|
||||
import fr.xephi.authme.data.limbo.LimboService;
|
||||
import org.bukkit.Location;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.function.Function;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.sameInstance;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link DebugSectionUtils}.
|
||||
*/
|
||||
public class DebugSectionUtilsTest {
|
||||
|
||||
@Test
|
||||
public void shouldFormatLocation() {
|
||||
// given / when
|
||||
String result = DebugSectionUtils.formatLocation(0.0, 10.248592, -18934.2349023, "Main");
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo("(0, 10.25, -18934.23) in 'Main'"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleNullWorld() {
|
||||
// given
|
||||
Location location = new Location(null, 3.7777, 2.14156, 1);
|
||||
|
||||
// when
|
||||
String result = DebugSectionUtils.formatLocation(location);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo("(3.78, 2.14, 1) in 'null'"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleNullLocation() {
|
||||
// given / when / then
|
||||
assertThat(DebugSectionUtils.formatLocation(null), equalTo("null"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHaveHiddenConstructor() {
|
||||
TestHelper.validateHasOnlyPrivateEmptyConstructor(DebugSectionUtils.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldFetchMapInLimboService() {
|
||||
// given
|
||||
LimboService limboService = mock(LimboService.class);
|
||||
Map<String, LimboPlayer> limboMap = new HashMap<>();
|
||||
ReflectionTestUtils.setField(LimboService.class, limboService, "entries", limboMap);
|
||||
|
||||
// when
|
||||
Map map = DebugSectionUtils.applyToLimboPlayersMap(limboService, Function.identity());
|
||||
|
||||
// then
|
||||
assertThat(map, sameInstance(limboMap));
|
||||
}
|
||||
}
|
||||
+97
@@ -0,0 +1,97 @@
|
||||
package fr.xephi.authme.command.executable.authme.debug;
|
||||
|
||||
import fr.xephi.authme.ClassCollector;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.permission.AdminPermission;
|
||||
import fr.xephi.authme.permission.PermissionNode;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.service.BukkitService;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static java.util.Arrays.asList;
|
||||
import static java.util.Collections.emptyList;
|
||||
import static org.hamcrest.Matchers.containsString;
|
||||
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.atLeast;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
|
||||
|
||||
/**
|
||||
* Test for {@link HasPermissionChecker}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class HasPermissionCheckerTest {
|
||||
|
||||
@InjectMocks
|
||||
private HasPermissionChecker hasPermissionChecker;
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@Mock
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Test
|
||||
public void shouldListAllPermissionNodeClasses() {
|
||||
// given
|
||||
List<Class<? extends PermissionNode>> permissionClasses =
|
||||
new ClassCollector(TestHelper.SOURCES_FOLDER, TestHelper.PROJECT_ROOT)
|
||||
.collectClasses(PermissionNode.class).stream()
|
||||
.filter(clz -> !clz.isInterface())
|
||||
.collect(Collectors.toList());
|
||||
|
||||
// when / then
|
||||
assertThat(HasPermissionChecker.PERMISSION_NODE_CLASSES.containsAll(permissionClasses), equalTo(true));
|
||||
assertThat(HasPermissionChecker.PERMISSION_NODE_CLASSES, hasSize(permissionClasses.size()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldShowUsageInfo() {
|
||||
// given
|
||||
CommandSender sender = mock(CommandSender.class);
|
||||
|
||||
// when
|
||||
hasPermissionChecker.execute(sender, emptyList());
|
||||
|
||||
// then
|
||||
ArgumentCaptor<String> msgCaptor = ArgumentCaptor.forClass(String.class);
|
||||
verify(sender, atLeast(2)).sendMessage(msgCaptor.capture());
|
||||
assertThat(
|
||||
msgCaptor.getAllValues().stream().anyMatch(msg -> msg.contains("/authme debug perm bobby my.perm.node")),
|
||||
equalTo(true));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldShowSuccessfulTestWithRegularPlayer() {
|
||||
// given
|
||||
String name = "Chuck";
|
||||
Player player = mock(Player.class);
|
||||
given(bukkitService.getPlayerExact(name)).willReturn(player);
|
||||
PermissionNode permission = AdminPermission.CHANGE_EMAIL;
|
||||
given(permissionsManager.hasPermission(player, permission)).willReturn(true);
|
||||
CommandSender sender = mock(CommandSender.class);
|
||||
|
||||
// when
|
||||
hasPermissionChecker.execute(sender, asList(name, permission.getNode()));
|
||||
|
||||
// then
|
||||
verify(bukkitService).getPlayerExact(name);
|
||||
verify(permissionsManager).hasPermission(player, permission);
|
||||
verify(sender).sendMessage(argThat(containsString("Success: player '" + player.getName()
|
||||
+ "' has permission '" + permission.getNode() + "'")));
|
||||
}
|
||||
}
|
||||
@@ -2,11 +2,9 @@ package fr.xephi.authme.command.executable.captcha;
|
||||
|
||||
import fr.xephi.authme.data.CaptchaManager;
|
||||
import fr.xephi.authme.data.auth.PlayerCache;
|
||||
import fr.xephi.authme.service.CommonService;
|
||||
import fr.xephi.authme.data.limbo.LimboCache;
|
||||
import fr.xephi.authme.data.limbo.LimboPlayer;
|
||||
import fr.xephi.authme.data.limbo.LimboService;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.task.MessageTask;
|
||||
import fr.xephi.authme.service.CommonService;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
@@ -40,7 +38,7 @@ public class CaptchaCommandTest {
|
||||
private CommonService commandService;
|
||||
|
||||
@Mock
|
||||
private LimboCache limboCache;
|
||||
private LimboService limboService;
|
||||
|
||||
@Test
|
||||
public void shouldDetectIfPlayerIsLoggedIn() {
|
||||
@@ -82,10 +80,6 @@ public class CaptchaCommandTest {
|
||||
given(captchaManager.isCaptchaRequired(name)).willReturn(true);
|
||||
String captchaCode = "3991";
|
||||
given(captchaManager.checkCode(name, captchaCode)).willReturn(true);
|
||||
MessageTask messageTask = mock(MessageTask.class);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboPlayer.getMessageTask()).willReturn(messageTask);
|
||||
given(limboCache.getPlayerData(name)).willReturn(limboPlayer);
|
||||
|
||||
// when
|
||||
command.executeCommand(player, Collections.singletonList(captchaCode));
|
||||
@@ -96,7 +90,7 @@ public class CaptchaCommandTest {
|
||||
verifyNoMoreInteractions(captchaManager);
|
||||
verify(commandService).send(player, MessageKey.CAPTCHA_SUCCESS);
|
||||
verify(commandService).send(player, MessageKey.LOGIN_MESSAGE);
|
||||
verify(messageTask).setMuted(false);
|
||||
verify(limboService).unmuteMessageTask(player);
|
||||
verifyNoMoreInteractions(commandService);
|
||||
}
|
||||
|
||||
|
||||
+77
-21
@@ -1,13 +1,17 @@
|
||||
package fr.xephi.authme.command.executable.register;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.mail.EmailService;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.process.Management;
|
||||
import fr.xephi.authme.process.register.RegisterSecondaryArgument;
|
||||
import fr.xephi.authme.process.register.RegistrationType;
|
||||
import fr.xephi.authme.process.register.executors.RegistrationExecutor;
|
||||
import fr.xephi.authme.process.register.executors.RegistrationExecutorProvider;
|
||||
import fr.xephi.authme.process.register.executors.EmailRegisterParams;
|
||||
import fr.xephi.authme.process.register.executors.PasswordRegisterParams;
|
||||
import fr.xephi.authme.process.register.executors.RegistrationMethod;
|
||||
import fr.xephi.authme.process.register.executors.RegistrationParameters;
|
||||
import fr.xephi.authme.process.register.executors.TwoFactorRegisterParams;
|
||||
import fr.xephi.authme.security.HashAlgorithm;
|
||||
import fr.xephi.authme.service.CommonService;
|
||||
import fr.xephi.authme.service.ValidationService;
|
||||
@@ -16,6 +20,9 @@ import fr.xephi.authme.settings.properties.SecuritySettings;
|
||||
import org.bukkit.command.BlockCommandSender;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.hamcrest.Description;
|
||||
import org.hamcrest.Matcher;
|
||||
import org.hamcrest.TypeSafeMatcher;
|
||||
import org.junit.Before;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
@@ -24,10 +31,16 @@ import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
|
||||
import static org.hamcrest.Matchers.containsString;
|
||||
import static org.junit.Assert.fail;
|
||||
import static org.mockito.ArgumentMatchers.anyString;
|
||||
import static org.mockito.ArgumentMatchers.eq;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
@@ -57,9 +70,6 @@ public class RegisterCommandTest {
|
||||
@Mock
|
||||
private ValidationService validationService;
|
||||
|
||||
@Mock
|
||||
private RegistrationExecutorProvider registrationExecutorProvider;
|
||||
|
||||
@BeforeClass
|
||||
public static void setup() {
|
||||
TestHelper.setupLogger();
|
||||
@@ -90,14 +100,13 @@ public class RegisterCommandTest {
|
||||
// given
|
||||
given(commonService.getProperty(SecuritySettings.PASSWORD_HASH)).willReturn(HashAlgorithm.TWO_FACTOR);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
given(registrationExecutorProvider.getTwoFactorRegisterExecutor(player)).willReturn(executor);
|
||||
|
||||
// when
|
||||
command.executeCommand(player, Collections.emptyList());
|
||||
|
||||
// then
|
||||
verify(management).performRegister(player, executor);
|
||||
verify(management).performRegister(eq(RegistrationMethod.TWO_FACTOR_REGISTRATION),
|
||||
argThat(isEqualTo(TwoFactorRegisterParams.of(player))));
|
||||
verifyZeroInteractions(emailService);
|
||||
}
|
||||
|
||||
@@ -208,8 +217,6 @@ public class RegisterCommandTest {
|
||||
given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.CONFIRMATION);
|
||||
given(emailService.hasAllInformation()).willReturn(true);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
given(registrationExecutorProvider.getEmailRegisterExecutor(player, playerMail)).willReturn(executor);
|
||||
|
||||
// when
|
||||
command.executeCommand(player, Arrays.asList(playerMail, playerMail));
|
||||
@@ -217,7 +224,8 @@ public class RegisterCommandTest {
|
||||
// then
|
||||
verify(validationService).validateEmail(playerMail);
|
||||
verify(emailService).hasAllInformation();
|
||||
verify(management).performRegister(player, executor);
|
||||
verify(management).performRegister(eq(RegistrationMethod.EMAIL_REGISTRATION),
|
||||
argThat(isEqualTo(EmailRegisterParams.of(player, playerMail))));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -239,14 +247,13 @@ public class RegisterCommandTest {
|
||||
public void shouldPerformPasswordRegistration() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
given(registrationExecutorProvider.getPasswordRegisterExecutor(player, "myPass", null)).willReturn(executor);
|
||||
|
||||
// when
|
||||
command.executeCommand(player, Collections.singletonList("myPass"));
|
||||
|
||||
// then
|
||||
verify(management).performRegister(player, executor);
|
||||
verify(management).performRegister(eq(RegistrationMethod.PASSWORD_REGISTRATION),
|
||||
argThat(isEqualTo(PasswordRegisterParams.of(player, "myPass", null))));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -257,15 +264,14 @@ public class RegisterCommandTest {
|
||||
String email = "email@example.org";
|
||||
given(validationService.validateEmail(email)).willReturn(true);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
given(registrationExecutorProvider.getPasswordRegisterExecutor(player, "myPass", email)).willReturn(executor);
|
||||
|
||||
// when
|
||||
command.executeCommand(player, Arrays.asList("myPass", email));
|
||||
|
||||
// then
|
||||
verify(validationService).validateEmail(email);
|
||||
verify(management).performRegister(player, executor);
|
||||
verify(management).performRegister(eq(RegistrationMethod.PASSWORD_REGISTRATION),
|
||||
argThat(isEqualTo(PasswordRegisterParams.of(player, "myPass", email))));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -292,14 +298,64 @@ public class RegisterCommandTest {
|
||||
given(commonService.getProperty(RegistrationSettings.REGISTRATION_TYPE)).willReturn(RegistrationType.PASSWORD);
|
||||
given(commonService.getProperty(RegistrationSettings.REGISTER_SECOND_ARGUMENT)).willReturn(RegisterSecondaryArgument.EMAIL_OPTIONAL);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
given(registrationExecutorProvider.getPasswordRegisterExecutor(eq(player), anyString(), eq(null))).willReturn(executor);
|
||||
|
||||
// when
|
||||
command.executeCommand(player, Collections.singletonList("myPass"));
|
||||
|
||||
// then
|
||||
verify(registrationExecutorProvider).getPasswordRegisterExecutor(player, "myPass", null);
|
||||
verify(management).performRegister(player, executor);
|
||||
verify(management).performRegister(eq(RegistrationMethod.PASSWORD_REGISTRATION),
|
||||
argThat(isEqualTo(PasswordRegisterParams.of(player, "myPass", null))));
|
||||
}
|
||||
|
||||
|
||||
// TODO ljacqu 20170317: Document and extract as util
|
||||
|
||||
private static <P extends RegistrationParameters> Matcher<P> isEqualTo(P expected) {
|
||||
return new TypeSafeMatcher<P>() {
|
||||
@Override
|
||||
protected boolean matchesSafely(RegistrationParameters item) {
|
||||
assertAreParamsEqual(expected, item);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void describeTo(Description description) {
|
||||
description.appendText("parameters " + expected);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
private static void assertAreParamsEqual(RegistrationParameters lhs, RegistrationParameters rhs) {
|
||||
if (lhs.getClass() != rhs.getClass()) {
|
||||
fail("Params classes don't match, got " + lhs.getClass().getSimpleName()
|
||||
+ " and " + rhs.getClass().getSimpleName());
|
||||
}
|
||||
|
||||
List<Field> fieldsToCheck = getFields(lhs);
|
||||
for (Field field : fieldsToCheck) {
|
||||
Object lhsValue = ReflectionTestUtils.getFieldValue(field, lhs);
|
||||
Object rhsValue = ReflectionTestUtils.getFieldValue(field, rhs);
|
||||
if (!Objects.equals(lhsValue, rhsValue)) {
|
||||
fail("Field '" + field.getName() + "' does not have same value: '"
|
||||
+ lhsValue + "' vs. '" + rhsValue + "'");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static List<Field> getFields(RegistrationParameters params) {
|
||||
List<Field> fields = new ArrayList<>();
|
||||
Class<?> currentClass = params.getClass();
|
||||
while (currentClass != null) {
|
||||
for (Field f : currentClass.getDeclaredFields()) {
|
||||
if (!Modifier.isStatic(f.getModifiers())) {
|
||||
fields.add(f);
|
||||
}
|
||||
}
|
||||
if (currentClass == RegistrationParameters.class) {
|
||||
break;
|
||||
}
|
||||
currentClass = currentClass.getSuperclass();
|
||||
}
|
||||
return fields;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Test;
|
||||
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
/**
|
||||
* Test for {@link AllowFlightRestoreType}.
|
||||
*/
|
||||
public class AllowFlightRestoreTypeTest {
|
||||
|
||||
@Test
|
||||
public void shouldRestoreValue() {
|
||||
// given
|
||||
LimboPlayer limboWithFly = newLimboWithAllowFlight(true);
|
||||
LimboPlayer limboWithoutFly = newLimboWithAllowFlight(false);
|
||||
Player player1 = mock(Player.class);
|
||||
Player player2 = mock(Player.class);
|
||||
|
||||
// when
|
||||
AllowFlightRestoreType.RESTORE.restoreAllowFlight(player1, limboWithFly);
|
||||
AllowFlightRestoreType.RESTORE.restoreAllowFlight(player2, limboWithoutFly);
|
||||
|
||||
// then
|
||||
verify(player1).setAllowFlight(true);
|
||||
verify(player2).setAllowFlight(false);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldEnableFlight() {
|
||||
// given
|
||||
LimboPlayer limboWithFly = newLimboWithAllowFlight(true);
|
||||
LimboPlayer limboWithoutFly = newLimboWithAllowFlight(false);
|
||||
Player player1 = mock(Player.class);
|
||||
Player player2 = mock(Player.class);
|
||||
|
||||
// when
|
||||
AllowFlightRestoreType.ENABLE.restoreAllowFlight(player1, limboWithFly);
|
||||
AllowFlightRestoreType.ENABLE.restoreAllowFlight(player2, limboWithoutFly);
|
||||
|
||||
// then
|
||||
verify(player1).setAllowFlight(true);
|
||||
verify(player2).setAllowFlight(true);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void shouldDisableFlight() {
|
||||
// given
|
||||
LimboPlayer limboWithFly = newLimboWithAllowFlight(true);
|
||||
LimboPlayer limboWithoutFly = newLimboWithAllowFlight(false);
|
||||
Player player1 = mock(Player.class);
|
||||
Player player2 = mock(Player.class);
|
||||
|
||||
// when
|
||||
AllowFlightRestoreType.DISABLE.restoreAllowFlight(player1, limboWithFly);
|
||||
AllowFlightRestoreType.DISABLE.restoreAllowFlight(player2, limboWithoutFly);
|
||||
|
||||
// then
|
||||
verify(player1).setAllowFlight(false);
|
||||
verify(player2).setAllowFlight(false);
|
||||
}
|
||||
|
||||
private static LimboPlayer newLimboWithAllowFlight(boolean allowFlight) {
|
||||
LimboPlayer limbo = mock(LimboPlayer.class);
|
||||
given(limbo.isCanFly()).willReturn(allowFlight);
|
||||
return limbo;
|
||||
}
|
||||
}
|
||||
@@ -1,215 +0,0 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.settings.SpawnLoader;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import static org.hamcrest.Matchers.aMapWithSize;
|
||||
import static org.hamcrest.Matchers.anEmptyMap;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboCache}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LimboCacheTest {
|
||||
|
||||
@InjectMocks
|
||||
private LimboCache limboCache;
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@Mock
|
||||
private SpawnLoader spawnLoader;
|
||||
|
||||
@Mock
|
||||
private LimboPlayerStorage limboPlayerStorage;
|
||||
|
||||
@Test
|
||||
public void shouldAddPlayerData() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
String name = "Bobby";
|
||||
given(player.getName()).willReturn(name);
|
||||
Location location = mock(Location.class);
|
||||
given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(location);
|
||||
given(player.isOp()).willReturn(true);
|
||||
float walkSpeed = 2.1f;
|
||||
given(player.getWalkSpeed()).willReturn(walkSpeed);
|
||||
given(player.getAllowFlight()).willReturn(true);
|
||||
float flySpeed = 3.0f;
|
||||
given(player.getFlySpeed()).willReturn(flySpeed);
|
||||
given(permissionsManager.hasGroupSupport()).willReturn(true);
|
||||
String group = "test-group";
|
||||
given(permissionsManager.getPrimaryGroup(player)).willReturn(group);
|
||||
given(limboPlayerStorage.hasData(player)).willReturn(false);
|
||||
|
||||
// when
|
||||
limboCache.addPlayerData(player);
|
||||
|
||||
// then
|
||||
LimboPlayer limboPlayer = limboCache.getPlayerData(name);
|
||||
assertThat(limboPlayer.getLocation(), equalTo(location));
|
||||
assertThat(limboPlayer.isOperator(), equalTo(true));
|
||||
assertThat(limboPlayer.getWalkSpeed(), equalTo(walkSpeed));
|
||||
assertThat(limboPlayer.isCanFly(), equalTo(true));
|
||||
assertThat(limboPlayer.getFlySpeed(), equalTo(flySpeed));
|
||||
assertThat(limboPlayer.getGroup(), equalTo(group));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldGetPlayerDataFromDisk() {
|
||||
// given
|
||||
String name = "player01";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
given(limboPlayerStorage.hasData(player)).willReturn(true);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboPlayerStorage.readData(player)).willReturn(limboPlayer);
|
||||
float walkSpeed = 2.4f;
|
||||
given(limboPlayer.getWalkSpeed()).willReturn(walkSpeed);
|
||||
given(limboPlayer.isCanFly()).willReturn(true);
|
||||
float flySpeed = 1.0f;
|
||||
given(limboPlayer.getFlySpeed()).willReturn(flySpeed);
|
||||
String group = "primary-group";
|
||||
given(limboPlayer.getGroup()).willReturn(group);
|
||||
|
||||
// when
|
||||
limboCache.addPlayerData(player);
|
||||
|
||||
// then
|
||||
LimboPlayer result = limboCache.getPlayerData(name);
|
||||
assertThat(result.getWalkSpeed(), equalTo(walkSpeed));
|
||||
assertThat(result.isCanFly(), equalTo(true));
|
||||
assertThat(result.getFlySpeed(), equalTo(flySpeed));
|
||||
assertThat(result.getGroup(), equalTo(group));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRestorePlayerInfo() {
|
||||
// given
|
||||
String name = "Champ";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboPlayer.isOperator()).willReturn(true);
|
||||
float walkSpeed = 2.4f;
|
||||
given(limboPlayer.getWalkSpeed()).willReturn(walkSpeed);
|
||||
given(limboPlayer.isCanFly()).willReturn(true);
|
||||
float flySpeed = 1.0f;
|
||||
given(limboPlayer.getFlySpeed()).willReturn(flySpeed);
|
||||
getCache().put(name.toLowerCase(), limboPlayer);
|
||||
|
||||
// when
|
||||
limboCache.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player).setOp(true);
|
||||
verify(player).setWalkSpeed(walkSpeed);
|
||||
verify(player).setAllowFlight(true);
|
||||
verify(player).setFlySpeed(flySpeed);
|
||||
verify(limboPlayer).clearTasks();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldResetPlayerSpeed() {
|
||||
// given
|
||||
String name = "Champ";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboPlayer.isOperator()).willReturn(true);
|
||||
given(limboPlayer.getWalkSpeed()).willReturn(0f);
|
||||
given(limboPlayer.isCanFly()).willReturn(true);
|
||||
given(limboPlayer.getFlySpeed()).willReturn(0f);
|
||||
getCache().put(name.toLowerCase(), limboPlayer);
|
||||
|
||||
// when
|
||||
limboCache.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player).setWalkSpeed(LimboPlayer.DEFAULT_WALK_SPEED);
|
||||
verify(player).setFlySpeed(LimboPlayer.DEFAULT_FLY_SPEED);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotInteractWithPlayerIfNoDataAvailable() {
|
||||
// given
|
||||
String name = "player";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
|
||||
// when
|
||||
limboCache.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player).getName();
|
||||
verifyNoMoreInteractions(player);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRemoveAndClearTasks() {
|
||||
// given
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
String name = "abcdef";
|
||||
getCache().put(name, limboPlayer);
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
|
||||
// when
|
||||
limboCache.removeFromCache(player);
|
||||
|
||||
// then
|
||||
assertThat(getCache(), anEmptyMap());
|
||||
verify(limboPlayer).clearTasks();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldDeleteFromCacheAndStorage() {
|
||||
// given
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
String name = "SomeName";
|
||||
getCache().put(name.toLowerCase(), limboPlayer);
|
||||
getCache().put("othername", mock(LimboPlayer.class));
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
|
||||
// when
|
||||
limboCache.deletePlayerData(player);
|
||||
|
||||
// then
|
||||
assertThat(getCache(), aMapWithSize(1));
|
||||
verify(limboPlayer).clearTasks();
|
||||
verify(limboPlayerStorage).removeData(player);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReturnIfHasData() {
|
||||
// given
|
||||
String name = "tester";
|
||||
getCache().put(name, mock(LimboPlayer.class));
|
||||
|
||||
// when / then
|
||||
assertThat(limboCache.hasPlayerData(name), equalTo(true));
|
||||
assertThat(limboCache.hasPlayerData("someone_else"), equalTo(false));
|
||||
}
|
||||
|
||||
private Map<String, LimboPlayer> getCache() {
|
||||
return ReflectionTestUtils.getFieldValue(LimboCache.class, limboCache, "cache");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.World;
|
||||
import org.hamcrest.Description;
|
||||
import org.hamcrest.Matcher;
|
||||
import org.hamcrest.TypeSafeMatcher;
|
||||
|
||||
import static java.lang.String.format;
|
||||
|
||||
/**
|
||||
* Contains matchers for LimboPlayer.
|
||||
*/
|
||||
public final class LimboPlayerMatchers {
|
||||
|
||||
private LimboPlayerMatchers() {
|
||||
}
|
||||
|
||||
public static Matcher<LimboPlayer> isLimbo(LimboPlayer limbo) {
|
||||
return isLimbo(limbo.isOperator(), limbo.getGroup(), limbo.isCanFly(),
|
||||
limbo.getWalkSpeed(), limbo.getFlySpeed());
|
||||
}
|
||||
|
||||
public static Matcher<LimboPlayer> isLimbo(boolean isOp, String group, boolean canFly,
|
||||
float walkSpeed, float flySpeed) {
|
||||
return new TypeSafeMatcher<LimboPlayer>() {
|
||||
@Override
|
||||
protected boolean matchesSafely(LimboPlayer item) {
|
||||
return item.isOperator() == isOp && item.getGroup().equals(group) && item.isCanFly() == canFly
|
||||
&& walkSpeed == item.getWalkSpeed() && flySpeed == item.getFlySpeed();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void describeTo(Description description) {
|
||||
description.appendText(format("Limbo with isOp=%s, group=%s, canFly=%s, walkSpeed=%f, flySpeed=%f",
|
||||
isOp, group, canFly, walkSpeed, flySpeed));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void describeMismatchSafely(LimboPlayer item, Description description) {
|
||||
description.appendText(format("Limbo with isOp=%s, group=%s, canFly=%s, walkSpeed=%f, flySpeed=%f",
|
||||
item.isOperator(), item.getGroup(), item.isCanFly(), item.getWalkSpeed(), item.getFlySpeed()));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public static Matcher<LimboPlayer> hasLocation(String world, double x, double y, double z) {
|
||||
return new TypeSafeMatcher<LimboPlayer>() {
|
||||
@Override
|
||||
protected boolean matchesSafely(LimboPlayer item) {
|
||||
Location location = item.getLocation();
|
||||
return location.getWorld().getName().equals(world)
|
||||
&& location.getX() == x && location.getY() == y && location.getZ() == z;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void describeTo(Description description) {
|
||||
description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f",
|
||||
world, x, y, z));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void describeMismatchSafely(LimboPlayer item, Description description) {
|
||||
Location location = item.getLocation();
|
||||
if (location == null) {
|
||||
description.appendText("Limbo with location = null");
|
||||
} else {
|
||||
description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f",
|
||||
location.getWorld().getName(), location.getX(), location.getY(), location.getZ()));
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public static Matcher<LimboPlayer> hasLocation(World world, double x, double y, double z) {
|
||||
return hasLocation(world.getName(), x, y, z);
|
||||
}
|
||||
|
||||
public static Matcher<LimboPlayer> hasLocation(String world, double x, double y, double z, float yaw, float pitch) {
|
||||
return new TypeSafeMatcher<LimboPlayer>() {
|
||||
@Override
|
||||
protected boolean matchesSafely(LimboPlayer item) {
|
||||
Location location = item.getLocation();
|
||||
return hasLocation(location.getWorld(), location.getX(), location.getY(), location.getZ()).matches(item)
|
||||
&& location.getYaw() == yaw && location.getPitch() == pitch;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void describeTo(Description description) {
|
||||
description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f, yaw=%f, pitch=%f",
|
||||
world, x, y, z, yaw, pitch));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void describeMismatchSafely(LimboPlayer item, Description description) {
|
||||
Location location = item.getLocation();
|
||||
if (location == null) {
|
||||
description.appendText("Limbo with location = null");
|
||||
} else {
|
||||
description.appendText(format("Limbo with location: world=%s, x=%f, y=%f, z=%f, yaw=%f, pitch=%f",
|
||||
location.getWorld().getName(), location.getX(), location.getY(), location.getZ(),
|
||||
location.getYaw(), location.getPitch()));
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public static Matcher<LimboPlayer> hasLocation(Location location) {
|
||||
return hasLocation(location.getWorld().getName(), location.getX(), location.getY(), location.getZ(),
|
||||
location.getYaw(), location.getPitch());
|
||||
}
|
||||
}
|
||||
+24
-62
@@ -1,15 +1,15 @@
|
||||
package fr.xephi.authme.task;
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.auth.PlayerCache;
|
||||
import fr.xephi.authme.data.limbo.LimboCache;
|
||||
import fr.xephi.authme.data.limbo.LimboPlayer;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.message.Messages;
|
||||
import fr.xephi.authme.service.BukkitService;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.RegistrationSettings;
|
||||
import fr.xephi.authme.settings.properties.RestrictionSettings;
|
||||
import fr.xephi.authme.task.MessageTask;
|
||||
import fr.xephi.authme.task.TimeoutTask;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.scheduler.BukkitTask;
|
||||
import org.junit.BeforeClass;
|
||||
@@ -20,6 +20,11 @@ import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import static fr.xephi.authme.service.BukkitService.TICKS_PER_SECOND;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.hamcrest.Matchers.sameInstance;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.anyLong;
|
||||
import static org.mockito.ArgumentMatchers.eq;
|
||||
@@ -46,9 +51,6 @@ public class LimboPlayerTaskManagerTest {
|
||||
@Mock
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Mock
|
||||
private LimboCache limboCache;
|
||||
|
||||
@Mock
|
||||
private PlayerCache playerCache;
|
||||
|
||||
@@ -60,16 +62,15 @@ public class LimboPlayerTaskManagerTest {
|
||||
@Test
|
||||
public void shouldRegisterMessageTask() {
|
||||
// given
|
||||
String name = "bobby";
|
||||
Player player = mock(Player.class);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboCache.getPlayerData(name)).willReturn(limboPlayer);
|
||||
MessageKey key = MessageKey.REGISTER_MESSAGE;
|
||||
given(messages.retrieve(key)).willReturn(new String[]{"Please register!"});
|
||||
int interval = 12;
|
||||
given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(interval);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerMessageTask(name, false);
|
||||
limboPlayerTaskManager.registerMessageTask(player, limboPlayer, false);
|
||||
|
||||
// then
|
||||
verify(limboPlayer).setMessageTask(any(MessageTask.class));
|
||||
@@ -78,32 +79,16 @@ public class LimboPlayerTaskManagerTest {
|
||||
any(MessageTask.class), eq(2L * TICKS_PER_SECOND), eq((long) interval * TICKS_PER_SECOND));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotScheduleTaskForMissingLimboPlayer() {
|
||||
// given
|
||||
String name = "ghost";
|
||||
given(limboCache.getPlayerData(name)).willReturn(null);
|
||||
given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(5);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerMessageTask(name, true);
|
||||
|
||||
// then
|
||||
verify(limboCache).getPlayerData(name);
|
||||
verifyZeroInteractions(bukkitService);
|
||||
verifyZeroInteractions(messages);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotScheduleTaskForZeroAsInterval() {
|
||||
// given
|
||||
String name = "Tester1";
|
||||
Player player = mock(Player.class);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
|
||||
given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(0);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerMessageTask(name, true);
|
||||
limboPlayerTaskManager.registerMessageTask(player, limboPlayer, true);
|
||||
|
||||
// then
|
||||
verifyZeroInteractions(limboPlayer, bukkitService);
|
||||
@@ -112,19 +97,18 @@ public class LimboPlayerTaskManagerTest {
|
||||
@Test
|
||||
public void shouldCancelExistingMessageTask() {
|
||||
// given
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
Player player = mock(Player.class);
|
||||
LimboPlayer limboPlayer = new LimboPlayer(null, true, "grp", false, 0.1f, 0.0f);
|
||||
MessageTask existingMessageTask = mock(MessageTask.class);
|
||||
given(limboPlayer.getMessageTask()).willReturn(existingMessageTask);
|
||||
|
||||
String name = "bobby";
|
||||
given(limboCache.getPlayerData(name)).willReturn(limboPlayer);
|
||||
limboPlayer.setMessageTask(existingMessageTask);
|
||||
given(settings.getProperty(RegistrationSettings.MESSAGE_INTERVAL)).willReturn(8);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerMessageTask(name, false);
|
||||
limboPlayerTaskManager.registerMessageTask(player, limboPlayer, false);
|
||||
|
||||
// then
|
||||
verify(limboPlayer).setMessageTask(any(MessageTask.class));
|
||||
assertThat(limboPlayer.getMessageTask(), not(nullValue()));
|
||||
assertThat(limboPlayer.getMessageTask(), not(sameInstance(existingMessageTask)));
|
||||
verify(messages).retrieve(MessageKey.REGISTER_MESSAGE);
|
||||
verify(existingMessageTask).cancel();
|
||||
}
|
||||
@@ -132,17 +116,14 @@ public class LimboPlayerTaskManagerTest {
|
||||
@Test
|
||||
public void shouldRegisterTimeoutTask() {
|
||||
// given
|
||||
String name = "l33tPlayer";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
given(limboCache.getPlayerData(name)).willReturn(limboPlayer);
|
||||
given(settings.getProperty(RestrictionSettings.TIMEOUT)).willReturn(30);
|
||||
BukkitTask bukkitTask = mock(BukkitTask.class);
|
||||
given(bukkitService.runTaskLater(any(TimeoutTask.class), anyLong())).willReturn(bukkitTask);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerTimeoutTask(player);
|
||||
limboPlayerTaskManager.registerTimeoutTask(player, limboPlayer);
|
||||
|
||||
// then
|
||||
verify(limboPlayer).setTimeoutTask(bukkitTask);
|
||||
@@ -150,22 +131,6 @@ public class LimboPlayerTaskManagerTest {
|
||||
verify(messages).retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotRegisterTimeoutTaskForMissingLimboPlayer() {
|
||||
// given
|
||||
String name = "Phantom_";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
given(limboCache.getPlayerData(name)).willReturn(null);
|
||||
given(settings.getProperty(RestrictionSettings.TIMEOUT)).willReturn(27);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerTimeoutTask(player);
|
||||
|
||||
// then
|
||||
verifyZeroInteractions(bukkitService, messages);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotRegisterTimeoutTaskForZeroTimeout() {
|
||||
// given
|
||||
@@ -174,7 +139,7 @@ public class LimboPlayerTaskManagerTest {
|
||||
given(settings.getProperty(RestrictionSettings.TIMEOUT)).willReturn(0);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerTimeoutTask(player);
|
||||
limboPlayerTaskManager.registerTimeoutTask(player, limboPlayer);
|
||||
|
||||
// then
|
||||
verifyZeroInteractions(limboPlayer, bukkitService);
|
||||
@@ -183,23 +148,20 @@ public class LimboPlayerTaskManagerTest {
|
||||
@Test
|
||||
public void shouldCancelExistingTimeoutTask() {
|
||||
// given
|
||||
String name = "l33tPlayer";
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
LimboPlayer limboPlayer = mock(LimboPlayer.class);
|
||||
LimboPlayer limboPlayer = new LimboPlayer(null, false, "", true, 0.3f, 0.1f);
|
||||
BukkitTask existingTask = mock(BukkitTask.class);
|
||||
given(limboPlayer.getTimeoutTask()).willReturn(existingTask);
|
||||
given(limboCache.getPlayerData(name)).willReturn(limboPlayer);
|
||||
limboPlayer.setTimeoutTask(existingTask);
|
||||
given(settings.getProperty(RestrictionSettings.TIMEOUT)).willReturn(18);
|
||||
BukkitTask bukkitTask = mock(BukkitTask.class);
|
||||
given(bukkitService.runTaskLater(any(TimeoutTask.class), anyLong())).willReturn(bukkitTask);
|
||||
|
||||
// when
|
||||
limboPlayerTaskManager.registerTimeoutTask(player);
|
||||
limboPlayerTaskManager.registerTimeoutTask(player, limboPlayer);
|
||||
|
||||
// then
|
||||
verify(existingTask).cancel();
|
||||
verify(limboPlayer).setTimeoutTask(bukkitTask);
|
||||
assertThat(limboPlayer.getTimeoutTask(), equalTo(bukkitTask));
|
||||
verify(bukkitService).runTaskLater(any(TimeoutTask.class), eq(360L)); // 18 * TICKS_PER_SECOND
|
||||
verify(messages).retrieveSingle(MessageKey.LOGIN_TIMEOUT_ERROR);
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InjectMocks;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboServiceHelper}.
|
||||
* <p>
|
||||
* Note: some methods are tested directly where they are used via {@link LimboServiceTest}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class LimboServiceHelperTest {
|
||||
|
||||
@InjectMocks
|
||||
private LimboServiceHelper limboServiceHelper;
|
||||
|
||||
@Test
|
||||
public void shouldMergeLimboPlayers() {
|
||||
// given
|
||||
Location newLocation = mock(Location.class);
|
||||
LimboPlayer newLimbo = new LimboPlayer(newLocation, false, "grp-new", false, 0.0f, 0.0f);
|
||||
Location oldLocation = mock(Location.class);
|
||||
LimboPlayer oldLimbo = new LimboPlayer(oldLocation, true, "grp-old", true, 0.1f, 0.8f);
|
||||
|
||||
// when
|
||||
LimboPlayer result = limboServiceHelper.merge(newLimbo, oldLimbo);
|
||||
|
||||
// then
|
||||
assertThat(result.getLocation(), equalTo(oldLocation));
|
||||
assertThat(result.isOperator(), equalTo(true));
|
||||
assertThat(result.getGroup(), equalTo("grp-old"));
|
||||
assertThat(result.isCanFly(), equalTo(true));
|
||||
assertThat(result.getWalkSpeed(), equalTo(0.1f));
|
||||
assertThat(result.getFlySpeed(), equalTo(0.8f));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldFallBackToNewLimboForMissingData() {
|
||||
// given
|
||||
Location newLocation = mock(Location.class);
|
||||
LimboPlayer newLimbo = new LimboPlayer(newLocation, false, "grp-new", true, 0.3f, 0.0f);
|
||||
LimboPlayer oldLimbo = new LimboPlayer(null, false, "", false, 0.1f, 0.1f);
|
||||
|
||||
// when
|
||||
LimboPlayer result = limboServiceHelper.merge(newLimbo, oldLimbo);
|
||||
|
||||
// then
|
||||
assertThat(result.getLocation(), equalTo(newLocation));
|
||||
assertThat(result.isOperator(), equalTo(false));
|
||||
assertThat(result.getGroup(), equalTo("grp-new"));
|
||||
assertThat(result.isCanFly(), equalTo(true));
|
||||
assertThat(result.getWalkSpeed(), equalTo(0.3f));
|
||||
assertThat(result.getFlySpeed(), equalTo(0.1f));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleNullInputs() {
|
||||
// given
|
||||
LimboPlayer limbo = mock(LimboPlayer.class);
|
||||
|
||||
// when
|
||||
LimboPlayer result1 = limboServiceHelper.merge(limbo, null);
|
||||
LimboPlayer result2 = limboServiceHelper.merge(null, limbo);
|
||||
LimboPlayer result3 = limboServiceHelper.merge(null, null);
|
||||
|
||||
// then
|
||||
verifyZeroInteractions(limbo);
|
||||
assertThat(result1, equalTo(limbo));
|
||||
assertThat(result2, equalTo(limbo));
|
||||
assertThat(result3, nullValue());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,238 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import ch.jalu.injector.testing.DelayedInjectionRunner;
|
||||
import ch.jalu.injector.testing.InjectDelayed;
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.limbo.persistence.LimboPersistence;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.SpawnLoader;
|
||||
import fr.xephi.authme.settings.properties.LimboSettings;
|
||||
import fr.xephi.authme.settings.properties.RestrictionSettings;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Before;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.Mockito;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.hamcrest.Matchers.sameInstance;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.eq;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.only;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboService}, and {@link LimboServiceHelper}.
|
||||
*/
|
||||
@RunWith(DelayedInjectionRunner.class)
|
||||
public class LimboServiceTest {
|
||||
|
||||
@InjectDelayed
|
||||
private LimboService limboService;
|
||||
|
||||
@InjectDelayed
|
||||
private LimboServiceHelper limboServiceHelper;
|
||||
|
||||
@Mock
|
||||
private SpawnLoader spawnLoader;
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@Mock
|
||||
private Settings settings;
|
||||
|
||||
@Mock
|
||||
private LimboPlayerTaskManager taskManager;
|
||||
|
||||
@Mock
|
||||
private LimboPersistence limboPersistence;
|
||||
|
||||
@BeforeClass
|
||||
public static void initLogger() {
|
||||
TestHelper.setupLogger();
|
||||
}
|
||||
|
||||
@Before
|
||||
public void mockSettings() {
|
||||
given(settings.getProperty(RestrictionSettings.ALLOW_UNAUTHED_MOVEMENT)).willReturn(false);
|
||||
given(settings.getProperty(RestrictionSettings.REMOVE_SPEED)).willReturn(true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateLimboPlayer() {
|
||||
// given
|
||||
Player player = newPlayer("Bobby", true, 0.3f, false, 0.2f);
|
||||
Location playerLoc = mock(Location.class);
|
||||
given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(playerLoc);
|
||||
given(permissionsManager.hasGroupSupport()).willReturn(true);
|
||||
given(permissionsManager.getPrimaryGroup(player)).willReturn("permgrwp");
|
||||
|
||||
// when
|
||||
limboService.createLimboPlayer(player, true);
|
||||
|
||||
// then
|
||||
verify(taskManager).registerMessageTask(eq(player), any(LimboPlayer.class), eq(true));
|
||||
verify(taskManager).registerTimeoutTask(eq(player), any(LimboPlayer.class));
|
||||
verify(player).setAllowFlight(false);
|
||||
verify(player).setFlySpeed(0.0f);
|
||||
verify(player).setWalkSpeed(0.0f);
|
||||
|
||||
assertThat(limboService.hasLimboPlayer("Bobby"), equalTo(true));
|
||||
LimboPlayer limbo = limboService.getLimboPlayer("Bobby");
|
||||
assertThat(limbo, not(nullValue()));
|
||||
assertThat(limbo.isOperator(), equalTo(true));
|
||||
assertThat(limbo.getWalkSpeed(), equalTo(0.3f));
|
||||
assertThat(limbo.isCanFly(), equalTo(false));
|
||||
assertThat(limbo.getFlySpeed(), equalTo(0.2f));
|
||||
assertThat(limbo.getLocation(), equalTo(playerLoc));
|
||||
assertThat(limbo.getGroup(), equalTo("permgrwp"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotKeepOpStatusForUnregisteredPlayer() {
|
||||
// given
|
||||
Player player = newPlayer("CharleS", true, 0.1f, true, 0.4f);
|
||||
Location playerLoc = mock(Location.class);
|
||||
given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(playerLoc);
|
||||
given(permissionsManager.hasGroupSupport()).willReturn(false);
|
||||
|
||||
// when
|
||||
limboService.createLimboPlayer(player, false);
|
||||
|
||||
// then
|
||||
verify(taskManager).registerMessageTask(eq(player), any(LimboPlayer.class), eq(false));
|
||||
verify(taskManager).registerTimeoutTask(eq(player), any(LimboPlayer.class));
|
||||
verify(permissionsManager, only()).hasGroupSupport();
|
||||
verify(player).setAllowFlight(false);
|
||||
verify(player).setFlySpeed(0.0f);
|
||||
verify(player).setWalkSpeed(0.0f);
|
||||
|
||||
LimboPlayer limbo = limboService.getLimboPlayer("charles");
|
||||
assertThat(limbo, not(nullValue()));
|
||||
assertThat(limbo.isOperator(), equalTo(false));
|
||||
assertThat(limbo.getWalkSpeed(), equalTo(0.1f));
|
||||
assertThat(limbo.isCanFly(), equalTo(true));
|
||||
assertThat(limbo.getFlySpeed(), equalTo(0.4f));
|
||||
assertThat(limbo.getLocation(), equalTo(playerLoc));
|
||||
assertThat(limbo.getGroup(), equalTo(""));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldClearTasksOnAlreadyExistingLimbo() {
|
||||
// given
|
||||
LimboPlayer existingLimbo = mock(LimboPlayer.class);
|
||||
getLimboMap().put("carlos", existingLimbo);
|
||||
Player player = newPlayer("Carlos");
|
||||
|
||||
// when
|
||||
limboService.createLimboPlayer(player, false);
|
||||
|
||||
// then
|
||||
verify(existingLimbo).clearTasks();
|
||||
LimboPlayer newLimbo = limboService.getLimboPlayer("Carlos");
|
||||
assertThat(newLimbo, not(nullValue()));
|
||||
assertThat(newLimbo, not(sameInstance(existingLimbo)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRestoreData() {
|
||||
// given
|
||||
LimboPlayer limbo = Mockito.spy(convertToLimboPlayer(
|
||||
newPlayer("John", true, 0.4f, false, 0.0f), null, ""));
|
||||
getLimboMap().put("john", limbo);
|
||||
Player player = newPlayer("John", false, 0.2f, false, 0.7f);
|
||||
|
||||
given(settings.getProperty(LimboSettings.RESTORE_ALLOW_FLIGHT)).willReturn(AllowFlightRestoreType.ENABLE);
|
||||
given(settings.getProperty(LimboSettings.RESTORE_WALK_SPEED)).willReturn(WalkFlySpeedRestoreType.RESTORE);
|
||||
given(settings.getProperty(LimboSettings.RESTORE_FLY_SPEED)).willReturn(WalkFlySpeedRestoreType.RESTORE_NO_ZERO);
|
||||
|
||||
// when
|
||||
limboService.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player).setOp(true);
|
||||
verify(player).setWalkSpeed(0.4f);
|
||||
verify(player).setAllowFlight(true);
|
||||
verify(player).setFlySpeed(LimboPlayer.DEFAULT_FLY_SPEED);
|
||||
verify(limbo).clearTasks();
|
||||
assertThat(limboService.hasLimboPlayer("John"), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleMissingLimboPlayerWhileRestoring() {
|
||||
// given
|
||||
Player player = newPlayer("Test");
|
||||
|
||||
// when
|
||||
limboService.restoreData(player);
|
||||
|
||||
// then
|
||||
verify(player, only()).getName();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReplaceTasks() {
|
||||
// given
|
||||
LimboPlayer limbo = mock(LimboPlayer.class);
|
||||
getLimboMap().put("jeff", limbo);
|
||||
Player player = newPlayer("JEFF");
|
||||
|
||||
|
||||
// when
|
||||
limboService.replaceTasksAfterRegistration(player);
|
||||
|
||||
// then
|
||||
verify(taskManager).registerTimeoutTask(player, limbo);
|
||||
verify(taskManager).registerMessageTask(player, limbo, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleMissingLimboForReplaceTasks() {
|
||||
// given
|
||||
Player player = newPlayer("ghost");
|
||||
|
||||
// when
|
||||
limboService.replaceTasksAfterRegistration(player);
|
||||
|
||||
// then
|
||||
verifyZeroInteractions(taskManager);
|
||||
}
|
||||
|
||||
private static Player newPlayer(String name) {
|
||||
Player player = mock(Player.class);
|
||||
given(player.getName()).willReturn(name);
|
||||
return player;
|
||||
}
|
||||
|
||||
private static Player newPlayer(String name, boolean isOp, float walkSpeed, boolean canFly, float flySpeed) {
|
||||
Player player = newPlayer(name);
|
||||
given(player.isOp()).willReturn(isOp);
|
||||
given(player.getWalkSpeed()).willReturn(walkSpeed);
|
||||
given(player.getAllowFlight()).willReturn(canFly);
|
||||
given(player.getFlySpeed()).willReturn(flySpeed);
|
||||
return player;
|
||||
}
|
||||
|
||||
private static LimboPlayer convertToLimboPlayer(Player player, Location location, String group) {
|
||||
return new LimboPlayer(location, player.isOp(), group, player.getAllowFlight(),
|
||||
player.getWalkSpeed(), player.getFlySpeed());
|
||||
}
|
||||
|
||||
private Map<String, LimboPlayer> getLimboMap() {
|
||||
return ReflectionTestUtils.getFieldValue(LimboService.class, limboService, "entries");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.junit.runners.Parameterized;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static fr.xephi.authme.data.limbo.LimboPlayer.DEFAULT_FLY_SPEED;
|
||||
import static fr.xephi.authme.data.limbo.LimboPlayer.DEFAULT_WALK_SPEED;
|
||||
import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.DEFAULT;
|
||||
import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.MAX_RESTORE;
|
||||
import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.RESTORE;
|
||||
import static fr.xephi.authme.data.limbo.WalkFlySpeedRestoreType.RESTORE_NO_ZERO;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
|
||||
/**
|
||||
* Test for {@link WalkFlySpeedRestoreType}.
|
||||
*/
|
||||
@RunWith(Parameterized.class)
|
||||
public class WalkFlySpeedRestoreTypeTest {
|
||||
|
||||
private final TestParameters parameters;
|
||||
|
||||
public WalkFlySpeedRestoreTypeTest(TestParameters parameters) {
|
||||
this.parameters = parameters;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRestoreToExpectedValue() {
|
||||
// given
|
||||
LimboPlayer limbo = mock(LimboPlayer.class);
|
||||
given(limbo.getWalkSpeed()).willReturn(parameters.givenLimboWalkSpeed);
|
||||
given(limbo.getFlySpeed()).willReturn(parameters.givenLimboFlySpeed);
|
||||
|
||||
Player player = mock(Player.class);
|
||||
given(player.getWalkSpeed()).willReturn(parameters.givenPlayerWalkSpeed);
|
||||
given(player.getFlySpeed()).willReturn(parameters.givenPlayerFlySpeed);
|
||||
|
||||
// when
|
||||
parameters.testedType.restoreWalkSpeed(player, limbo);
|
||||
parameters.testedType.restoreFlySpeed(player, limbo);
|
||||
|
||||
// then
|
||||
verify(player).setWalkSpeed(parameters.expectedWalkSpeed);
|
||||
verify(player).setFlySpeed(parameters.expectedFlySpeed);
|
||||
}
|
||||
|
||||
@Parameterized.Parameters(name = "{0}")
|
||||
public static List<Object[]> buildParams() {
|
||||
List<TestParameters> parameters = Arrays.asList(
|
||||
create(RESTORE).withLimbo(0.1f, 0.4f).withPlayer(0.3f, 0.9f).expect(0.1f, 0.4f),
|
||||
create(RESTORE).withLimbo(0.9f, 0.2f).withPlayer(0.3f, 0.0f).expect(0.9f, 0.2f),
|
||||
create(MAX_RESTORE).withLimbo(0.3f, 0.8f).withPlayer(0.5f, 0.2f).expect(0.5f, 0.8f),
|
||||
create(MAX_RESTORE).withLimbo(0.4f, 0.2f).withPlayer(0.1f, 0.4f).expect(0.4f, 0.4f),
|
||||
create(RESTORE_NO_ZERO).withLimbo(0.1f, 0.2f).withPlayer(0.5f, 0.1f).expect(0.1f, 0.2f),
|
||||
create(RESTORE_NO_ZERO).withLimbo(0.0f, 0.005f).withPlayer(0.4f, 0.8f).expect(DEFAULT_WALK_SPEED, DEFAULT_FLY_SPEED),
|
||||
create(DEFAULT).withLimbo(0.1f, 0.7f).withPlayer(0.4f, 0.0f).expect(DEFAULT_WALK_SPEED, DEFAULT_FLY_SPEED)
|
||||
);
|
||||
|
||||
// Convert List<TestParameters> to List<Object[]>
|
||||
return parameters.stream().map(p -> new Object[]{p}).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
private static TestParameters create(WalkFlySpeedRestoreType testedType) {
|
||||
TestParameters params = new TestParameters();
|
||||
params.testedType = testedType;
|
||||
return params;
|
||||
}
|
||||
|
||||
private static final class TestParameters {
|
||||
private WalkFlySpeedRestoreType testedType;
|
||||
private float givenLimboWalkSpeed;
|
||||
private float givenLimboFlySpeed;
|
||||
private float givenPlayerWalkSpeed;
|
||||
private float givenPlayerFlySpeed;
|
||||
private float expectedWalkSpeed;
|
||||
private float expectedFlySpeed;
|
||||
|
||||
TestParameters withLimbo(float walkSpeed, float flySpeed) {
|
||||
this.givenLimboWalkSpeed = walkSpeed;
|
||||
this.givenLimboFlySpeed = flySpeed;
|
||||
return this;
|
||||
}
|
||||
|
||||
TestParameters withPlayer(float walkSpeed, float flySpeed) {
|
||||
this.givenPlayerWalkSpeed = walkSpeed;
|
||||
this.givenPlayerFlySpeed = flySpeed;
|
||||
return this;
|
||||
}
|
||||
|
||||
TestParameters expect(float walkSpeed, float flySpeed) {
|
||||
this.expectedWalkSpeed = walkSpeed;
|
||||
this.expectedFlySpeed = flySpeed;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return testedType + " {" + expectedWalkSpeed + ", " + expectedFlySpeed + "}";
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,158 @@
|
||||
package fr.xephi.authme.data.limbo.persistence;
|
||||
|
||||
import ch.jalu.injector.testing.BeforeInjecting;
|
||||
import ch.jalu.injector.testing.DelayedInjectionRunner;
|
||||
import ch.jalu.injector.testing.InjectDelayed;
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.limbo.LimboPlayer;
|
||||
import fr.xephi.authme.initialization.factory.Factory;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.LimboSettings;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.hamcrest.Matcher;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import static org.hamcrest.Matchers.both;
|
||||
import static org.hamcrest.Matchers.containsString;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.instanceOf;
|
||||
import static org.hamcrest.Matchers.not;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.hamcrest.Matchers.sameInstance;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.ArgumentMatchers.eq;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.doThrow;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboPersistence}.
|
||||
*/
|
||||
@RunWith(DelayedInjectionRunner.class)
|
||||
public class LimboPersistenceTest {
|
||||
|
||||
@InjectDelayed
|
||||
private LimboPersistence limboPersistence;
|
||||
|
||||
@Mock
|
||||
private Factory<LimboPersistenceHandler> handlerFactory;
|
||||
|
||||
@Mock
|
||||
private Settings settings;
|
||||
|
||||
@BeforeClass
|
||||
public static void setUpLogger() {
|
||||
TestHelper.setupLogger();
|
||||
}
|
||||
|
||||
@BeforeInjecting
|
||||
@SuppressWarnings("unchecked")
|
||||
public void setUpMocks() {
|
||||
given(settings.getProperty(LimboSettings.LIMBO_PERSISTENCE_TYPE)).willReturn(LimboPersistenceType.DISABLED);
|
||||
given(handlerFactory.newInstance(any(Class.class)))
|
||||
.willAnswer(invocation -> mock(invocation.getArgument(0)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldInitializeProperly() {
|
||||
// given / when / then
|
||||
assertThat(getHandler(), instanceOf(NoOpPersistenceHandler.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldDelegateToHandler() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
LimboPersistenceHandler handler = getHandler();
|
||||
LimboPlayer limbo = mock(LimboPlayer.class);
|
||||
given(handler.getLimboPlayer(player)).willReturn(limbo);
|
||||
|
||||
// when
|
||||
LimboPlayer result = limboPersistence.getLimboPlayer(player);
|
||||
limboPersistence.saveLimboPlayer(player, mock(LimboPlayer.class));
|
||||
limboPersistence.removeLimboPlayer(mock(Player.class));
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(limbo));
|
||||
verify(handler).getLimboPlayer(player);
|
||||
verify(handler).saveLimboPlayer(eq(player), argThat(notNullAndDifferentFrom(limbo)));
|
||||
verify(handler).removeLimboPlayer(argThat(notNullAndDifferentFrom(player)));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReloadProperly() {
|
||||
// given
|
||||
given(settings.getProperty(LimboSettings.LIMBO_PERSISTENCE_TYPE))
|
||||
.willReturn(LimboPersistenceType.INDIVIDUAL_FILES);
|
||||
|
||||
// when
|
||||
limboPersistence.reload(settings);
|
||||
|
||||
// then
|
||||
assertThat(getHandler(), instanceOf(LimboPersistenceType.INDIVIDUAL_FILES.getImplementationClass()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleExceptionWhenGettingLimbo() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
Logger logger = TestHelper.setupLogger();
|
||||
LimboPersistenceHandler handler = getHandler();
|
||||
doThrow(IllegalAccessException.class).when(handler).getLimboPlayer(player);
|
||||
|
||||
// when
|
||||
LimboPlayer result = limboPersistence.getLimboPlayer(player);
|
||||
|
||||
// then
|
||||
assertThat(result, nullValue());
|
||||
verify(logger).warning(argThat(containsString("[IllegalAccessException]")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleExceptionWhenSavingLimbo() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
LimboPlayer limbo = mock(LimboPlayer.class);
|
||||
Logger logger = TestHelper.setupLogger();
|
||||
LimboPersistenceHandler handler = getHandler();
|
||||
doThrow(IllegalStateException.class).when(handler).saveLimboPlayer(player, limbo);
|
||||
|
||||
// when
|
||||
limboPersistence.saveLimboPlayer(player, limbo);
|
||||
|
||||
// then
|
||||
verify(logger).warning(argThat(containsString("[IllegalStateException]")));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleExceptionWhenRemovingLimbo() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
Logger logger = TestHelper.setupLogger();
|
||||
LimboPersistenceHandler handler = getHandler();
|
||||
doThrow(UnsupportedOperationException.class).when(handler).removeLimboPlayer(player);
|
||||
|
||||
// when
|
||||
limboPersistence.removeLimboPlayer(player);
|
||||
|
||||
// then
|
||||
verify(logger).warning(argThat(containsString("[UnsupportedOperationException]")));
|
||||
}
|
||||
|
||||
private LimboPersistenceHandler getHandler() {
|
||||
return ReflectionTestUtils.getFieldValue(LimboPersistence.class, limboPersistence, "handler");
|
||||
}
|
||||
|
||||
private static <T> Matcher<T> notNullAndDifferentFrom(T o) {
|
||||
return both(not(sameInstance(o))).and(not(nullValue()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
package fr.xephi.authme.data.limbo.persistence;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.fail;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboPersistenceType}.
|
||||
*/
|
||||
public class LimboPersistenceTypeTest {
|
||||
|
||||
@Test
|
||||
public void shouldHaveUniqueImplementationClasses() {
|
||||
// given
|
||||
Set<Class<?>> classes = new HashSet<>();
|
||||
|
||||
// when / then
|
||||
for (LimboPersistenceType persistenceType : LimboPersistenceType.values()) {
|
||||
if (!classes.add(persistenceType.getImplementationClass())) {
|
||||
fail("Implementation class '" + persistenceType.getImplementationClass() + "' from '"
|
||||
+ persistenceType + "' already encountered previously");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHaveTypeReturnedFromImplementationClass() {
|
||||
for (LimboPersistenceType persistenceType : LimboPersistenceType.values()) {
|
||||
// given
|
||||
LimboPersistenceHandler implementationMock = mock(persistenceType.getImplementationClass());
|
||||
given(implementationMock.getType()).willCallRealMethod();
|
||||
|
||||
// when
|
||||
LimboPersistenceType returnedType = implementationMock.getType();
|
||||
|
||||
// then
|
||||
assertThat(returnedType, equalTo(persistenceType));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package fr.xephi.authme.data.limbo.persistence;
|
||||
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.greaterThan;
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
/**
|
||||
* Test for {@link SegmentConfiguration}.
|
||||
*/
|
||||
public class SegmentConfigurationTest {
|
||||
|
||||
@Test
|
||||
public void shouldHaveDistributionThatIsPowerOf2() {
|
||||
// given
|
||||
Set<Integer> allowedDistributions = ImmutableSet.of(1, 2, 4, 8, 16);
|
||||
|
||||
// when / then
|
||||
for (SegmentConfiguration entry : SegmentConfiguration.values()) {
|
||||
if (!allowedDistributions.contains(entry.getDistribution())) {
|
||||
fail("Distribution must be a power of 2 and within [1, 16]. Offending item: " + entry);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHaveDifferentSegmentSizes() {
|
||||
// given
|
||||
Set<Integer> segmentTotals = new HashSet<>();
|
||||
|
||||
// when / then
|
||||
for (SegmentConfiguration entry : SegmentConfiguration.values()) {
|
||||
int totalSegments = entry.getTotalSegments();
|
||||
assertThat(entry + " must have a positive segment size",
|
||||
totalSegments, greaterThan(0));
|
||||
|
||||
assertThat(entry + " has a segment total that was already encountered (" + totalSegments + ")",
|
||||
segmentTotals.add(totalSegments), equalTo(true));
|
||||
}
|
||||
}
|
||||
}
|
||||
+205
@@ -0,0 +1,205 @@
|
||||
package fr.xephi.authme.data.limbo.persistence;
|
||||
|
||||
import ch.jalu.injector.testing.BeforeInjecting;
|
||||
import ch.jalu.injector.testing.DelayedInjectionRunner;
|
||||
import ch.jalu.injector.testing.InjectDelayed;
|
||||
import com.google.common.io.Files;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.limbo.LimboPlayer;
|
||||
import fr.xephi.authme.initialization.DataFolder;
|
||||
import fr.xephi.authme.service.BukkitService;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.LimboSettings;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.hamcrest.Matcher;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Rule;
|
||||
import org.junit.Test;
|
||||
import org.junit.rules.TemporaryFolder;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.Mock;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.util.UUID;
|
||||
|
||||
import static fr.xephi.authme.data.limbo.LimboPlayerMatchers.hasLocation;
|
||||
import static fr.xephi.authme.data.limbo.LimboPlayerMatchers.isLimbo;
|
||||
import static java.util.UUID.fromString;
|
||||
import static org.hamcrest.MatcherAssert.assertThat;
|
||||
import static org.hamcrest.Matchers.arrayContainingInAnyOrder;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.nullValue;
|
||||
import static org.mockito.ArgumentMatchers.anyString;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link SegmentFilesPersistenceHolder}.
|
||||
*/
|
||||
@RunWith(DelayedInjectionRunner.class)
|
||||
public class SegmentFilesPersistenceHolderTest {
|
||||
|
||||
/** Player is in seg32-10110 and should be migrated into seg16-f. */
|
||||
private static final UUID MIGRATED_UUID = fromString("f6a97c88-7c8f-c12e-4931-6206d4ca067d");
|
||||
private static final Matcher<LimboPlayer> MIGRATED_LIMBO_MATCHER =
|
||||
isLimbo(false, "noob", true, 0.2f, 0.1f);
|
||||
|
||||
/** Existing player in seg16-f. */
|
||||
private static final UUID UUID_FAB69 = fromString("fab69c88-2cd0-1fed-f00d-dead14ca067d");
|
||||
private static final Matcher<LimboPlayer> FAB69_MATCHER =
|
||||
isLimbo(false, "", false, 0.2f, 0.1f);
|
||||
|
||||
/** Player in seg16-8. */
|
||||
private static final UUID UUID_STAFF = fromString("88897c88-7c8f-c12e-4931-6206d4ca067d");
|
||||
private static final Matcher<LimboPlayer> STAFF_MATCHER =
|
||||
isLimbo(true, "staff", false, 0.3f, 0.1f);
|
||||
|
||||
/** Player in seg16-8. */
|
||||
private static final UUID UUID_8C679 = fromString("8c679491-1234-abcd-9102-1fa6e0cc3f81");
|
||||
private static final Matcher<LimboPlayer> SC679_MATCHER =
|
||||
isLimbo(false, "primary", true, 0.1f, 0.0f);
|
||||
|
||||
/** UUID for which no data is stored (belongs to a segment file that does not exist, seg16-4). */
|
||||
private static final UUID UNKNOWN_UUID = fromString("42d1cc0b-8f12-d04a-e7ba-a067d05cdc39");
|
||||
|
||||
/** UUID for which no data is stored (belongs to an existing segment file: seg16-8). */
|
||||
private static final UUID UNKNOWN_UUID2 = fromString("84d1cc0b-8f12-d04a-e7ba-a067d05cdc39");
|
||||
|
||||
|
||||
@InjectDelayed
|
||||
private SegmentFilesPersistenceHolder persistenceHandler;
|
||||
|
||||
@Mock
|
||||
private Settings settings;
|
||||
@Mock
|
||||
private BukkitService bukkitService;
|
||||
@DataFolder
|
||||
private File dataFolder;
|
||||
private File playerDataFolder;
|
||||
|
||||
@Rule
|
||||
public TemporaryFolder temporaryFolder = new TemporaryFolder();
|
||||
|
||||
@BeforeClass
|
||||
public static void initLogger() {
|
||||
TestHelper.setupLogger();
|
||||
}
|
||||
|
||||
@BeforeInjecting
|
||||
public void setUpClasses() throws IOException {
|
||||
given(settings.getProperty(LimboSettings.SEGMENT_DISTRIBUTION)).willReturn(SegmentConfiguration.SIXTEEN);
|
||||
dataFolder = temporaryFolder.newFolder();
|
||||
playerDataFolder = new File(dataFolder, "playerdata");
|
||||
playerDataFolder.mkdir();
|
||||
|
||||
File limboFilesFolder = new File("src/test/resources/fr/xephi/authme/data/limbo");
|
||||
for (File file : limboFilesFolder.listFiles()) {
|
||||
File from = new File(playerDataFolder, file.getName());
|
||||
Files.copy(file, from);
|
||||
}
|
||||
|
||||
given(bukkitService.getWorld(anyString()))
|
||||
.willAnswer(invocation -> {
|
||||
World world = mock(World.class);
|
||||
given(world.getName()).willReturn(invocation.getArgument(0));
|
||||
return world;
|
||||
});
|
||||
}
|
||||
|
||||
// Note ljacqu 20170314: These tests are a little slow to set up; therefore we sometimes
|
||||
// test things in one test that would traditionally belong into two separate tests
|
||||
|
||||
@Test
|
||||
public void shouldMigrateOldSegmentFilesOnStartup() {
|
||||
// Ensure that only the files of the current segmenting scheme remain
|
||||
assertThat(playerDataFolder.list(), arrayContainingInAnyOrder("seg16-8-limbo.json", "seg16-f-limbo.json"));
|
||||
|
||||
// Check that the expected limbo players can be read
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(MIGRATED_UUID)), MIGRATED_LIMBO_MATCHER);
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_FAB69)), FAB69_MATCHER);
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_STAFF)), STAFF_MATCHER);
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_8C679)), SC679_MATCHER);
|
||||
|
||||
// Check that unknown players are null (whose segment file exists and does not exist)
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UNKNOWN_UUID)), nullValue());
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UNKNOWN_UUID2)), nullValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldRemovePlayer() {
|
||||
// given
|
||||
Player playerToRemove = mockPlayerWithUuid(UUID_STAFF);
|
||||
Player unknownPlayerToRemove = mockPlayerWithUuid(UNKNOWN_UUID);
|
||||
|
||||
// when
|
||||
persistenceHandler.removeLimboPlayer(playerToRemove);
|
||||
persistenceHandler.removeLimboPlayer(unknownPlayerToRemove);
|
||||
|
||||
// then
|
||||
assertThat(persistenceHandler.getLimboPlayer(playerToRemove), nullValue());
|
||||
assertThat(persistenceHandler.getLimboPlayer(unknownPlayerToRemove), nullValue());
|
||||
// Player in same segment should still exist...
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_8C679)), SC679_MATCHER);
|
||||
|
||||
// Check that we didn't create seg16-4 by deleting UNKNOWN_UUID.
|
||||
assertThat(playerDataFolder.list(), arrayContainingInAnyOrder("seg16-8-limbo.json", "seg16-f-limbo.json"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldAddPlayer() {
|
||||
// given
|
||||
Player uuidToAdd1 = mockPlayerWithUuid(UNKNOWN_UUID);
|
||||
Location location1 = new Location(mockWorldWithName("1world"), 120, 60, -80, 0.42345f, 120.32f);
|
||||
LimboPlayer limbo1 = new LimboPlayer(location1, false, "group-1", true, 0.1f, 0.2f);
|
||||
Player uuidToAdd2 = mockPlayerWithUuid(UNKNOWN_UUID2);
|
||||
Location location2 = new Location(mockWorldWithName("2world"), -40, 20, 33, 4.235f, 8.32299f);
|
||||
LimboPlayer limbo2 = new LimboPlayer(location2, true, "", false, 0.0f, 0.25f);
|
||||
|
||||
// when
|
||||
persistenceHandler.saveLimboPlayer(uuidToAdd1, limbo1);
|
||||
persistenceHandler.saveLimboPlayer(uuidToAdd2, limbo2);
|
||||
|
||||
// then
|
||||
LimboPlayer addedPlayer1 = persistenceHandler.getLimboPlayer(uuidToAdd1);
|
||||
assertThat(addedPlayer1, isLimbo(limbo1));
|
||||
assertThat(addedPlayer1, hasLocation(location1));
|
||||
LimboPlayer addedPlayer2 = persistenceHandler.getLimboPlayer(uuidToAdd2);
|
||||
assertThat(addedPlayer2, isLimbo(limbo2));
|
||||
assertThat(addedPlayer2, hasLocation(location2));
|
||||
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(MIGRATED_UUID)), MIGRATED_LIMBO_MATCHER);
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_FAB69)), FAB69_MATCHER);
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_STAFF)), STAFF_MATCHER);
|
||||
assertThat(persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UUID_8C679)), SC679_MATCHER);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHandleReadErrorGracefully() throws IOException {
|
||||
// given
|
||||
// assumption
|
||||
File invalidFile = new File(playerDataFolder, "seg16-4-limbo.json");
|
||||
assertThat(invalidFile.exists(), equalTo(false));
|
||||
Files.write("not valid json".getBytes(), invalidFile);
|
||||
|
||||
// when
|
||||
LimboPlayer result = persistenceHandler.getLimboPlayer(mockPlayerWithUuid(UNKNOWN_UUID));
|
||||
|
||||
// then
|
||||
assertThat(result, nullValue());
|
||||
}
|
||||
|
||||
private static Player mockPlayerWithUuid(UUID uuid) {
|
||||
Player player = mock(Player.class);
|
||||
given(player.getUniqueId()).willReturn(uuid);
|
||||
return player;
|
||||
}
|
||||
|
||||
private static World mockWorldWithName(String name) {
|
||||
World world = mock(World.class);
|
||||
given(world.getName()).willReturn(name);
|
||||
return world;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
package fr.xephi.authme.data.limbo.persistence;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.EIGHT;
|
||||
import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.FOUR;
|
||||
import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.ONE;
|
||||
import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.SIXTEEN;
|
||||
import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.SIXTY_FOUR;
|
||||
import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.THIRTY_TWO;
|
||||
import static fr.xephi.authme.data.limbo.persistence.SegmentConfiguration.TWO_FIFTY;
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.hasSize;
|
||||
import static org.junit.Assert.assertThat;
|
||||
|
||||
/**
|
||||
* Test for {@link SegmentNameBuilder}.
|
||||
*/
|
||||
public class SegmentNameBuilderTest {
|
||||
|
||||
/**
|
||||
* Checks that using a given segment size really produces as many segments as defined.
|
||||
* E.g. if we partition with {@link SegmentConfiguration#EIGHT} we expect eight different buckets.
|
||||
*/
|
||||
@Test
|
||||
public void shouldCreatePromisedSizeOfSegments() {
|
||||
for (SegmentConfiguration part : SegmentConfiguration.values()) {
|
||||
// Perform this check only for `length` <= 5 because the test creates all hex numbers with `length` digits.
|
||||
if (part.getLength() <= 5) {
|
||||
checkTotalSegmentsProduced(part);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void checkTotalSegmentsProduced(SegmentConfiguration part) {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(part);
|
||||
Set<String> encounteredSegments = new HashSet<>();
|
||||
int shift = part.getLength() * 4;
|
||||
// e.g. (1 << 16) - 1 = 0xFFFF. (Number of digits = shift/4, since 16 = 2^4)
|
||||
int max = (1 << shift) - 1;
|
||||
|
||||
// when
|
||||
for (int i = 0; i <= max; ++i) {
|
||||
String uuid = toPaddedHex(i, part.getLength());
|
||||
encounteredSegments.add(nameBuilder.createSegmentName(uuid));
|
||||
}
|
||||
|
||||
// then
|
||||
assertThat(encounteredSegments, hasSize(part.getTotalSegments()));
|
||||
}
|
||||
|
||||
private static String toPaddedHex(int dec, int padLength) {
|
||||
String hexResult = Integer.toString(dec, 16);
|
||||
while (hexResult.length() < padLength) {
|
||||
hexResult = "0" + hexResult;
|
||||
}
|
||||
return hexResult;
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateOneSegment() {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(ONE);
|
||||
|
||||
// when / then
|
||||
assertThat(nameBuilder.createSegmentName("abc"), equalTo("seg1-0"));
|
||||
assertThat(nameBuilder.createSegmentName("f0e"), equalTo("seg1-0"));
|
||||
assertThat(nameBuilder.createSegmentName("329"), equalTo("seg1-0"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateFourSegments() {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(FOUR);
|
||||
|
||||
// when / then
|
||||
assertThat(nameBuilder.createSegmentName("f9cc"), equalTo("seg4-3"));
|
||||
assertThat(nameBuilder.createSegmentName("84c9"), equalTo("seg4-2"));
|
||||
assertThat(nameBuilder.createSegmentName("3799"), equalTo("seg4-0"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateEightSegments() {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(EIGHT);
|
||||
|
||||
// when / then
|
||||
assertThat(nameBuilder.createSegmentName("fc9c"), equalTo("seg8-7"));
|
||||
assertThat(nameBuilder.createSegmentName("90ad"), equalTo("seg8-4"));
|
||||
assertThat(nameBuilder.createSegmentName("35e4"), equalTo("seg8-1"));
|
||||
assertThat(nameBuilder.createSegmentName("a39f"), equalTo("seg8-5"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateSixteenSegments() {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(SIXTEEN);
|
||||
|
||||
// when / then
|
||||
assertThat(nameBuilder.createSegmentName("fc9a054"), equalTo("seg16-f"));
|
||||
assertThat(nameBuilder.createSegmentName("b0a945e"), equalTo("seg16-b"));
|
||||
assertThat(nameBuilder.createSegmentName("7afebab"), equalTo("seg16-7"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateThirtyTwoSegments() {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(THIRTY_TWO);
|
||||
|
||||
// when / then
|
||||
assertThat(nameBuilder.createSegmentName("f890c9"), equalTo("seg32-11101"));
|
||||
assertThat(nameBuilder.createSegmentName("49c39a"), equalTo("seg32-01101"));
|
||||
assertThat(nameBuilder.createSegmentName("b75d09"), equalTo("seg32-10010"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreateSixtyFourSegments() {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(SIXTY_FOUR);
|
||||
|
||||
// when / then
|
||||
assertThat(nameBuilder.createSegmentName("82f"), equalTo("seg64-203"));
|
||||
assertThat(nameBuilder.createSegmentName("9b4"), equalTo("seg64-221"));
|
||||
assertThat(nameBuilder.createSegmentName("068"), equalTo("seg64-012"));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldCreate256Segments() {
|
||||
// given
|
||||
SegmentNameBuilder nameBuilder = new SegmentNameBuilder(TWO_FIFTY);
|
||||
|
||||
// when / then
|
||||
assertThat(nameBuilder.createSegmentName("a813c"), equalTo("seg256-a8"));
|
||||
assertThat(nameBuilder.createSegmentName("b4d01"), equalTo("seg256-b4"));
|
||||
assertThat(nameBuilder.createSegmentName("7122f"), equalTo("seg256-71"));
|
||||
}
|
||||
}
|
||||
+12
-35
@@ -1,13 +1,12 @@
|
||||
package fr.xephi.authme.data.limbo;
|
||||
package fr.xephi.authme.data.limbo.persistence;
|
||||
|
||||
import ch.jalu.injector.testing.BeforeInjecting;
|
||||
import ch.jalu.injector.testing.DelayedInjectionRunner;
|
||||
import ch.jalu.injector.testing.InjectDelayed;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.limbo.LimboPlayer;
|
||||
import fr.xephi.authme.initialization.DataFolder;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
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;
|
||||
@@ -31,26 +30,20 @@ import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link LimboPlayerStorage}.
|
||||
* Test for {@link SeparateFilePersistenceHandler}.
|
||||
*/
|
||||
@RunWith(DelayedInjectionRunner.class)
|
||||
public class LimboPlayerStorageTest {
|
||||
public class SeparateFilePersistenceHandlerTest {
|
||||
|
||||
private static final UUID SAMPLE_UUID = UUID.nameUUIDFromBytes("PlayerDataStorageTest".getBytes());
|
||||
private static final UUID SAMPLE_UUID = UUID.nameUUIDFromBytes("PersistenceTest".getBytes());
|
||||
private static final String SOURCE_FOLDER = TestHelper.PROJECT_ROOT + "data/backup/";
|
||||
|
||||
@InjectDelayed
|
||||
private LimboPlayerStorage limboPlayerStorage;
|
||||
|
||||
@Mock
|
||||
private SpawnLoader spawnLoader;
|
||||
private SeparateFilePersistenceHandler handler;
|
||||
|
||||
@Mock
|
||||
private BukkitService bukkitService;
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
|
||||
@DataFolder
|
||||
private File dataFolder;
|
||||
|
||||
@@ -77,7 +70,7 @@ public class LimboPlayerStorageTest {
|
||||
given(bukkitService.getWorld("nether")).willReturn(world);
|
||||
|
||||
// when
|
||||
LimboPlayer data = limboPlayerStorage.readData(player);
|
||||
LimboPlayer data = handler.getLimboPlayer(player);
|
||||
|
||||
// then
|
||||
assertThat(data, not(nullValue()));
|
||||
@@ -102,44 +95,28 @@ public class LimboPlayerStorageTest {
|
||||
given(player.getUniqueId()).willReturn(UUID.nameUUIDFromBytes("other-player".getBytes()));
|
||||
|
||||
// when
|
||||
LimboPlayer data = limboPlayerStorage.readData(player);
|
||||
LimboPlayer data = handler.getLimboPlayer(player);
|
||||
|
||||
// then
|
||||
assertThat(data, nullValue());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldReturnIfHasData() {
|
||||
// given
|
||||
Player player1 = mock(Player.class);
|
||||
given(player1.getUniqueId()).willReturn(SAMPLE_UUID);
|
||||
Player player2 = mock(Player.class);
|
||||
given(player2.getUniqueId()).willReturn(UUID.nameUUIDFromBytes("not-stored".getBytes()));
|
||||
|
||||
// when / then
|
||||
assertThat(limboPlayerStorage.hasData(player1), equalTo(true));
|
||||
assertThat(limboPlayerStorage.hasData(player2), equalTo(false));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldSavePlayerData() {
|
||||
// given
|
||||
Player player = mock(Player.class);
|
||||
UUID uuid = UUID.nameUUIDFromBytes("New player".getBytes());
|
||||
given(player.getUniqueId()).willReturn(uuid);
|
||||
given(permissionsManager.getPrimaryGroup(player)).willReturn("primary-grp");
|
||||
given(player.isOp()).willReturn(true);
|
||||
given(player.getWalkSpeed()).willReturn(1.2f);
|
||||
given(player.getFlySpeed()).willReturn(0.8f);
|
||||
given(player.getAllowFlight()).willReturn(true);
|
||||
|
||||
|
||||
World world = mock(World.class);
|
||||
given(world.getName()).willReturn("player-world");
|
||||
Location location = new Location(world, 0.2, 102.25, -89.28, 3.02f, 90.13f);
|
||||
given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(location);
|
||||
String group = "primary-grp";
|
||||
LimboPlayer limbo = new LimboPlayer(location, true, group, true, 1.2f, 0.8f);
|
||||
|
||||
// when
|
||||
limboPlayerStorage.saveData(player);
|
||||
handler.saveLimboPlayer(player, limbo);
|
||||
|
||||
// then
|
||||
File playerFile = new File(dataFolder, FileUtils.makePath("playerdata", uuid.toString(), "data.json"));
|
||||
@@ -4,8 +4,10 @@ import ch.jalu.injector.testing.BeforeInjecting;
|
||||
import ch.jalu.injector.testing.DelayedInjectionRunner;
|
||||
import ch.jalu.injector.testing.InjectDelayed;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.output.LogLevel;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.EmailSettings;
|
||||
import fr.xephi.authme.settings.properties.PluginSettings;
|
||||
import org.apache.commons.mail.EmailException;
|
||||
import org.apache.commons.mail.HtmlEmail;
|
||||
import org.junit.BeforeClass;
|
||||
@@ -49,6 +51,7 @@ public class SendMailSSLTest {
|
||||
public void initFields() throws IOException {
|
||||
given(settings.getProperty(EmailSettings.MAIL_ACCOUNT)).willReturn("mail@example.org");
|
||||
given(settings.getProperty(EmailSettings.MAIL_PASSWORD)).willReturn("pass1234");
|
||||
given(settings.getProperty(PluginSettings.LOG_LEVEL)).willReturn(LogLevel.INFO);
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -67,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");
|
||||
|
||||
@@ -3,18 +3,17 @@ package fr.xephi.authme.process.login;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.auth.PlayerAuth;
|
||||
import fr.xephi.authme.data.auth.PlayerCache;
|
||||
import fr.xephi.authme.data.limbo.LimboService;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.events.AuthMeAsyncPreLoginEvent;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.permission.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;
|
||||
import fr.xephi.authme.settings.properties.RestrictionSettings;
|
||||
import fr.xephi.authme.task.LimboPlayerTaskManager;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.BeforeClass;
|
||||
import org.junit.Test;
|
||||
@@ -58,11 +57,9 @@ public class AsynchronousLoginTest {
|
||||
@Mock
|
||||
private CommonService commonService;
|
||||
@Mock
|
||||
private LimboPlayerTaskManager limboPlayerTaskManager;
|
||||
private LimboService limboService;
|
||||
@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();
|
||||
}
|
||||
|
||||
|
||||
@@ -3,9 +3,13 @@ package fr.xephi.authme.process.register;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.auth.PlayerCache;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.initialization.factory.SingletonStore;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.permission.PermissionsManager;
|
||||
import fr.xephi.authme.process.register.executors.PasswordRegisterParams;
|
||||
import fr.xephi.authme.process.register.executors.RegistrationExecutor;
|
||||
import fr.xephi.authme.process.register.executors.RegistrationMethod;
|
||||
import fr.xephi.authme.process.register.executors.TwoFactorRegisterParams;
|
||||
import fr.xephi.authme.service.CommonService;
|
||||
import fr.xephi.authme.settings.properties.RegistrationSettings;
|
||||
import fr.xephi.authme.settings.properties.RestrictionSettings;
|
||||
@@ -16,6 +20,7 @@ import org.mockito.InjectMocks;
|
||||
import org.mockito.Mock;
|
||||
import org.mockito.junit.MockitoJUnitRunner;
|
||||
|
||||
import static org.mockito.ArgumentMatchers.any;
|
||||
import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.only;
|
||||
@@ -39,6 +44,8 @@ public class AsyncRegisterTest {
|
||||
private CommonService commonService;
|
||||
@Mock
|
||||
private DataSource dataSource;
|
||||
@Mock
|
||||
private SingletonStore<RegistrationExecutor> registrationExecutorStore;
|
||||
|
||||
@Test
|
||||
public void shouldDetectAlreadyLoggedInPlayer() {
|
||||
@@ -47,9 +54,10 @@ public class AsyncRegisterTest {
|
||||
Player player = mockPlayerWithName(name);
|
||||
given(playerCache.isAuthenticated(name)).willReturn(true);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
singletonStoreWillReturn(registrationExecutorStore, executor);
|
||||
|
||||
// when
|
||||
asyncRegister.register(player, executor);
|
||||
asyncRegister.register(RegistrationMethod.PASSWORD_REGISTRATION, PasswordRegisterParams.of(player, "abc", null));
|
||||
|
||||
// then
|
||||
verify(commonService).send(player, MessageKey.ALREADY_LOGGED_IN_ERROR);
|
||||
@@ -64,9 +72,10 @@ public class AsyncRegisterTest {
|
||||
given(playerCache.isAuthenticated(name)).willReturn(false);
|
||||
given(commonService.getProperty(RegistrationSettings.IS_ENABLED)).willReturn(false);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
singletonStoreWillReturn(registrationExecutorStore, executor);
|
||||
|
||||
// when
|
||||
asyncRegister.register(player, executor);
|
||||
asyncRegister.register(RegistrationMethod.TWO_FACTOR_REGISTRATION, TwoFactorRegisterParams.of(player));
|
||||
|
||||
// then
|
||||
verify(commonService).send(player, MessageKey.REGISTRATION_DISABLED);
|
||||
@@ -82,9 +91,10 @@ public class AsyncRegisterTest {
|
||||
given(commonService.getProperty(RegistrationSettings.IS_ENABLED)).willReturn(true);
|
||||
given(dataSource.isAuthAvailable(name)).willReturn(true);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
singletonStoreWillReturn(registrationExecutorStore, executor);
|
||||
|
||||
// when
|
||||
asyncRegister.register(player, executor);
|
||||
asyncRegister.register(RegistrationMethod.TWO_FACTOR_REGISTRATION, TwoFactorRegisterParams.of(player));
|
||||
|
||||
// then
|
||||
verify(commonService).send(player, MessageKey.NAME_ALREADY_REGISTERED);
|
||||
@@ -93,6 +103,7 @@ public class AsyncRegisterTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void shouldStopForFailedExecutorCheck() {
|
||||
// given
|
||||
String name = "edbert";
|
||||
@@ -103,14 +114,16 @@ public class AsyncRegisterTest {
|
||||
given(commonService.getProperty(RestrictionSettings.MAX_REGISTRATION_PER_IP)).willReturn(0);
|
||||
given(dataSource.isAuthAvailable(name)).willReturn(false);
|
||||
RegistrationExecutor executor = mock(RegistrationExecutor.class);
|
||||
given(executor.isRegistrationAdmitted()).willReturn(false);
|
||||
TwoFactorRegisterParams params = TwoFactorRegisterParams.of(player);
|
||||
given(executor.isRegistrationAdmitted(params)).willReturn(false);
|
||||
singletonStoreWillReturn(registrationExecutorStore, executor);
|
||||
|
||||
// when
|
||||
asyncRegister.register(player, executor);
|
||||
asyncRegister.register(RegistrationMethod.TWO_FACTOR_REGISTRATION, params);
|
||||
|
||||
// then
|
||||
verify(dataSource, only()).isAuthAvailable(name);
|
||||
verify(executor, only()).isRegistrationAdmitted();
|
||||
verify(executor, only()).isRegistrationAdmitted(params);
|
||||
}
|
||||
|
||||
private static Player mockPlayerWithName(String name) {
|
||||
@@ -118,4 +131,10 @@ public class AsyncRegisterTest {
|
||||
given(player.getName()).willReturn(name);
|
||||
return player;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static void singletonStoreWillReturn(SingletonStore<RegistrationExecutor> store,
|
||||
RegistrationExecutor mock) {
|
||||
given(store.getSingleton(any(Class.class))).willReturn(mock);
|
||||
}
|
||||
}
|
||||
|
||||
+16
-19
@@ -1,6 +1,5 @@
|
||||
package fr.xephi.authme.process.register.executors;
|
||||
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.auth.PlayerAuth;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
@@ -34,13 +33,13 @@ import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
|
||||
/**
|
||||
* Test for {@link EmailRegisterExecutorProvider}.
|
||||
* Test for {@link EmailRegisterExecutor}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class EmailRegisterExecutorProviderTest {
|
||||
|
||||
@InjectMocks
|
||||
private EmailRegisterExecutorProvider emailRegisterExecutorProvider;
|
||||
private EmailRegisterExecutor executor;
|
||||
|
||||
@Mock
|
||||
private PermissionsManager permissionsManager;
|
||||
@@ -62,10 +61,10 @@ public class EmailRegisterExecutorProviderTest {
|
||||
String email = "test@example.com";
|
||||
given(dataSource.countAuthsByEmail(email)).willReturn(4);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, email);
|
||||
EmailRegisterParams params = EmailRegisterParams.of(player, email);
|
||||
|
||||
// when
|
||||
boolean result = executor.isRegistrationAdmitted();
|
||||
boolean result = executor.isRegistrationAdmitted(params);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(false));
|
||||
@@ -80,10 +79,10 @@ public class EmailRegisterExecutorProviderTest {
|
||||
given(commonService.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(3);
|
||||
Player player = mock(Player.class);
|
||||
given(permissionsManager.hasPermission(player, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS)).willReturn(true);
|
||||
RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
|
||||
EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
|
||||
|
||||
// when
|
||||
boolean result = executor.isRegistrationAdmitted();
|
||||
boolean result = executor.isRegistrationAdmitted(params);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(true));
|
||||
@@ -97,10 +96,10 @@ public class EmailRegisterExecutorProviderTest {
|
||||
String email = "test@example.com";
|
||||
given(dataSource.countAuthsByEmail(email)).willReturn(0);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
|
||||
EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
|
||||
|
||||
// when
|
||||
boolean result = executor.isRegistrationAdmitted();
|
||||
boolean result = executor.isRegistrationAdmitted(params);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(true));
|
||||
@@ -120,10 +119,10 @@ public class EmailRegisterExecutorProviderTest {
|
||||
World world = mock(World.class);
|
||||
given(world.getName()).willReturn("someWorld");
|
||||
given(player.getLocation()).willReturn(new Location(world, 48, 96, 144));
|
||||
RegistrationExecutor executor = emailRegisterExecutorProvider.new EmailRegisterExecutor(player, "test@example.com");
|
||||
EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
|
||||
|
||||
// when
|
||||
PlayerAuth auth = executor.buildPlayerAuth();
|
||||
PlayerAuth auth = executor.buildPlayerAuth(params);
|
||||
|
||||
// then
|
||||
assertThat(auth, hasAuthBasicData("veronica", "Veronica", "test@example.com", "123.45.67.89"));
|
||||
@@ -132,18 +131,17 @@ public class EmailRegisterExecutorProviderTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void shouldPerformActionAfterDataSourceSave() {
|
||||
// given
|
||||
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");
|
||||
EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
|
||||
String password = "A892C#@";
|
||||
ReflectionTestUtils.setField((Class) executor.getClass(), executor, "password", password);
|
||||
params.setPassword(password);
|
||||
|
||||
// when
|
||||
executor.executePostPersistAction();
|
||||
executor.executePostPersistAction(params);
|
||||
|
||||
// then
|
||||
verify(emailService).sendPasswordMail("Laleh", "test@example.com", password);
|
||||
@@ -151,18 +149,17 @@ public class EmailRegisterExecutorProviderTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
@SuppressWarnings("unchecked")
|
||||
public void shouldHandleEmailSendingFailure() {
|
||||
// given
|
||||
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");
|
||||
EmailRegisterParams params = EmailRegisterParams.of(player, "test@example.com");
|
||||
String password = "A892C#@";
|
||||
ReflectionTestUtils.setField((Class) executor.getClass(), executor, "password", password);
|
||||
params.setPassword(password);
|
||||
|
||||
// when
|
||||
executor.executePostPersistAction();
|
||||
executor.executePostPersistAction(params);
|
||||
|
||||
// then
|
||||
verify(emailService).sendPasswordMail("Laleh", "test@example.com", password);
|
||||
|
||||
+13
-13
@@ -34,13 +34,13 @@ import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
|
||||
/**
|
||||
* Test for {@link PasswordRegisterExecutorProvider}.
|
||||
* Test for {@link PasswordRegisterExecutor}.
|
||||
*/
|
||||
@RunWith(MockitoJUnitRunner.class)
|
||||
public class PasswordRegisterExecutorProviderTest {
|
||||
public class PasswordRegisterExecutorTest {
|
||||
|
||||
@InjectMocks
|
||||
private PasswordRegisterExecutorProvider passwordRegisterExecutorProvider;
|
||||
private PasswordRegisterExecutor executor;
|
||||
|
||||
@Mock
|
||||
private ValidationService validationService;
|
||||
@@ -62,10 +62,10 @@ public class PasswordRegisterExecutorProviderTest {
|
||||
String name = "player040";
|
||||
given(validationService.validatePassword(password, name)).willReturn(new ValidationResult());
|
||||
Player player = mockPlayerWithName(name);
|
||||
RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, password, null);
|
||||
PasswordRegisterParams params = PasswordRegisterParams.of(player, password, null);
|
||||
|
||||
// when
|
||||
boolean result = executor.isRegistrationAdmitted();
|
||||
boolean result = executor.isRegistrationAdmitted(params);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(true));
|
||||
@@ -80,10 +80,10 @@ public class PasswordRegisterExecutorProviderTest {
|
||||
given(validationService.validatePassword(password, name)).willReturn(
|
||||
new ValidationResult(MessageKey.PASSWORD_CHARACTERS_ERROR, "[a-z]"));
|
||||
Player player = mockPlayerWithName(name);
|
||||
RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, password, null);
|
||||
PasswordRegisterParams params = PasswordRegisterParams.of(player, password, null);
|
||||
|
||||
// when
|
||||
boolean result = executor.isRegistrationAdmitted();
|
||||
boolean result = executor.isRegistrationAdmitted(params);
|
||||
|
||||
// then
|
||||
assertThat(result, equalTo(false));
|
||||
@@ -101,10 +101,10 @@ public class PasswordRegisterExecutorProviderTest {
|
||||
World world = mock(World.class);
|
||||
given(world.getName()).willReturn("someWorld");
|
||||
given(player.getLocation()).willReturn(new Location(world, 48, 96, 144));
|
||||
RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, "pass", "mail@example.org");
|
||||
PasswordRegisterParams params = PasswordRegisterParams.of(player, "pass", "mail@example.org");
|
||||
|
||||
// when
|
||||
PlayerAuth auth = executor.buildPlayerAuth();
|
||||
PlayerAuth auth = executor.buildPlayerAuth(params);
|
||||
|
||||
// then
|
||||
assertThat(auth, hasAuthBasicData("s1m0n", "S1m0N", "mail@example.org", "123.45.67.89"));
|
||||
@@ -118,10 +118,10 @@ public class PasswordRegisterExecutorProviderTest {
|
||||
given(commonService.getProperty(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER)).willReturn(false);
|
||||
given(commonService.getProperty(PluginSettings.USE_ASYNC_TASKS)).willReturn(false);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, "pass", "mail@example.org");
|
||||
PasswordRegisterParams params = PasswordRegisterParams.of(player, "pass", "mail@example.org");
|
||||
|
||||
// when
|
||||
executor.executePostPersistAction();
|
||||
executor.executePostPersistAction(params);
|
||||
|
||||
// then
|
||||
TestHelper.runSyncDelayedTaskWithDelay(bukkitService);
|
||||
@@ -134,10 +134,10 @@ public class PasswordRegisterExecutorProviderTest {
|
||||
// given
|
||||
given(commonService.getProperty(RegistrationSettings.FORCE_LOGIN_AFTER_REGISTER)).willReturn(true);
|
||||
Player player = mock(Player.class);
|
||||
RegistrationExecutor executor = passwordRegisterExecutorProvider.new PasswordRegisterExecutor(player, "pass", "mail@example.org");
|
||||
PasswordRegisterParams params = PasswordRegisterParams.of(player, "pass", "mail@example.org");
|
||||
|
||||
// when
|
||||
executor.executePostPersistAction();
|
||||
executor.executePostPersistAction(params);
|
||||
|
||||
// then
|
||||
verifyZeroInteractions(bukkitService, asynchronousLogin);
|
||||
@@ -3,19 +3,17 @@ package fr.xephi.authme.process.unregister;
|
||||
import fr.xephi.authme.TestHelper;
|
||||
import fr.xephi.authme.data.auth.PlayerAuth;
|
||||
import fr.xephi.authme.data.auth.PlayerCache;
|
||||
import fr.xephi.authme.data.limbo.LimboCache;
|
||||
import fr.xephi.authme.data.limbo.LimboService;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.message.MessageKey;
|
||||
import fr.xephi.authme.permission.AuthGroupHandler;
|
||||
import fr.xephi.authme.permission.AuthGroupType;
|
||||
import fr.xephi.authme.service.CommonService;
|
||||
import fr.xephi.authme.security.PasswordSecurity;
|
||||
import fr.xephi.authme.security.crypts.HashedPassword;
|
||||
import fr.xephi.authme.service.BukkitService;
|
||||
import fr.xephi.authme.service.CommonService;
|
||||
import fr.xephi.authme.service.TeleportationService;
|
||||
import fr.xephi.authme.settings.properties.RegistrationSettings;
|
||||
import fr.xephi.authme.settings.properties.RestrictionSettings;
|
||||
import fr.xephi.authme.task.LimboPlayerTaskManager;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.junit.BeforeClass;
|
||||
@@ -53,9 +51,7 @@ public class AsynchronousUnregisterTest {
|
||||
@Mock
|
||||
private BukkitService bukkitService;
|
||||
@Mock
|
||||
private LimboCache limboCache;
|
||||
@Mock
|
||||
private LimboPlayerTaskManager limboPlayerTaskManager;
|
||||
private LimboService limboService;
|
||||
@Mock
|
||||
private TeleportationService teleportationService;
|
||||
@Mock
|
||||
@@ -85,7 +81,7 @@ public class AsynchronousUnregisterTest {
|
||||
// then
|
||||
verify(service).send(player, MessageKey.WRONG_PASSWORD);
|
||||
verify(passwordSecurity).comparePassword(userPassword, password, name);
|
||||
verifyZeroInteractions(dataSource, limboPlayerTaskManager, limboCache, authGroupHandler, teleportationService);
|
||||
verifyZeroInteractions(dataSource, limboService, authGroupHandler, teleportationService);
|
||||
verify(player, only()).getName();
|
||||
}
|
||||
|
||||
@@ -104,8 +100,6 @@ public class AsynchronousUnregisterTest {
|
||||
given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(true);
|
||||
given(dataSource.removeAuth(name)).willReturn(true);
|
||||
given(service.getProperty(RegistrationSettings.FORCE)).willReturn(true);
|
||||
given(service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)).willReturn(true);
|
||||
given(service.getProperty(RestrictionSettings.TIMEOUT)).willReturn(12);
|
||||
|
||||
// when
|
||||
asynchronousUnregister.unregister(player, userPassword);
|
||||
@@ -117,7 +111,7 @@ public class AsynchronousUnregisterTest {
|
||||
verify(playerCache).removePlayer(name);
|
||||
verify(teleportationService).teleportOnJoin(player);
|
||||
verify(authGroupHandler).setGroup(player, AuthGroupType.UNREGISTERED);
|
||||
verify(bukkitService).runTask(any(Runnable.class));
|
||||
verify(bukkitService).scheduleSyncTaskFromOptionallyAsyncTask(any(Runnable.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -135,8 +129,6 @@ public class AsynchronousUnregisterTest {
|
||||
given(passwordSecurity.comparePassword(userPassword, password, name)).willReturn(true);
|
||||
given(dataSource.removeAuth(name)).willReturn(true);
|
||||
given(service.getProperty(RegistrationSettings.FORCE)).willReturn(true);
|
||||
given(service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)).willReturn(true);
|
||||
given(service.getProperty(RestrictionSettings.TIMEOUT)).willReturn(0);
|
||||
|
||||
// when
|
||||
asynchronousUnregister.unregister(player, userPassword);
|
||||
@@ -148,7 +140,7 @@ public class AsynchronousUnregisterTest {
|
||||
verify(playerCache).removePlayer(name);
|
||||
verify(teleportationService).teleportOnJoin(player);
|
||||
verify(authGroupHandler).setGroup(player, AuthGroupType.UNREGISTERED);
|
||||
verify(bukkitService).runTask(any(Runnable.class));
|
||||
verify(bukkitService).scheduleSyncTaskFromOptionallyAsyncTask(any(Runnable.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -175,7 +167,7 @@ public class AsynchronousUnregisterTest {
|
||||
verify(dataSource).removeAuth(name);
|
||||
verify(playerCache).removePlayer(name);
|
||||
verify(authGroupHandler).setGroup(player, AuthGroupType.UNREGISTERED);
|
||||
verifyZeroInteractions(teleportationService, limboPlayerTaskManager);
|
||||
verifyZeroInteractions(teleportationService, limboService);
|
||||
verify(bukkitService, never()).runTask(any(Runnable.class));
|
||||
}
|
||||
|
||||
@@ -237,8 +229,6 @@ public class AsynchronousUnregisterTest {
|
||||
given(player.isOnline()).willReturn(true);
|
||||
given(dataSource.removeAuth(name)).willReturn(true);
|
||||
given(service.getProperty(RegistrationSettings.FORCE)).willReturn(true);
|
||||
given(service.getProperty(RegistrationSettings.APPLY_BLIND_EFFECT)).willReturn(true);
|
||||
given(service.getProperty(RestrictionSettings.TIMEOUT)).willReturn(12);
|
||||
CommandSender initiator = mock(CommandSender.class);
|
||||
|
||||
// when
|
||||
@@ -251,7 +241,7 @@ public class AsynchronousUnregisterTest {
|
||||
verify(playerCache).removePlayer(name);
|
||||
verify(teleportationService).teleportOnJoin(player);
|
||||
verify(authGroupHandler).setGroup(player, AuthGroupType.UNREGISTERED);
|
||||
verify(bukkitService).runTask(any(Runnable.class));
|
||||
verify(bukkitService).scheduleSyncTaskFromOptionallyAsyncTask(any(Runnable.class));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -9,7 +9,7 @@ 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;
|
||||
import fr.xephi.authme.security.crypts.Joomla;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.HooksSettings;
|
||||
import fr.xephi.authme.settings.properties.SecuritySettings;
|
||||
@@ -231,7 +231,7 @@ public class PasswordSecurityTest {
|
||||
ArgumentCaptor<PasswordEncryptionEvent> captor = ArgumentCaptor.forClass(PasswordEncryptionEvent.class);
|
||||
verify(pluginManager).callEvent(captor.capture());
|
||||
PasswordEncryptionEvent event = captor.getValue();
|
||||
assertThat(JOOMLA.class.equals(caughtClassInEvent), equalTo(true));
|
||||
assertThat(Joomla.class.equals(caughtClassInEvent), equalTo(true));
|
||||
assertThat(event.getPlayerName(), equalTo(usernameLowerCase));
|
||||
}
|
||||
|
||||
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link BCRYPT2Y}.
|
||||
* Test for {@link BCrypt2y}.
|
||||
*/
|
||||
public class BCRYPT2YTest extends AbstractEncryptionMethodTest {
|
||||
public class BCrypt2yTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public BCRYPT2YTest() {
|
||||
super(new BCRYPT2Y(),
|
||||
public BCrypt2yTest() {
|
||||
super(new BCrypt2y(),
|
||||
"$2y$10$da641e404b982edf1c7c0uTU9BcKzfA2vWKV05q6r.dCvm/93wqVK", // password
|
||||
"$2y$10$e52c48a76f5b86f5da899uiK/HYocyPsfQXESNbP278rIz08LKEP2", // PassWord1
|
||||
"$2y$10$be6f11548dc5fb4088410ONdC0dXnJ04y1RHcJh5fVF3XK5d.qgqK", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -7,12 +7,12 @@ import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link BCRYPT}.
|
||||
* Test for {@link BCrypt}.
|
||||
*/
|
||||
public class BcryptTest extends AbstractEncryptionMethodTest {
|
||||
public class BCryptTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public BcryptTest() {
|
||||
super(new BCRYPT(mockSettings()),
|
||||
public BCryptTest() {
|
||||
super(new BCrypt(mockSettings()),
|
||||
"$2a$10$6iATmYgwJVc3YONhVcZFve3Cfb5GnwvKhJ20r.hMjmcNkIT9.Uh9K", // password
|
||||
"$2a$10$LOhUxhEcS0vgDPv/jkXvCurNb7LjP9xUlEolJGk.Uhgikqc6FtIOi", // PassWord1
|
||||
"$2a$10$j9da7SGiaakWhzIms9BtwemLUeIhSEphGUQ3XSlvYgpYsGnGCKRBa", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link CRAZYCRYPT1}.
|
||||
* Test for {@link CrazyCrypt1}.
|
||||
*/
|
||||
public class CRAZYCRYPT1Test extends AbstractEncryptionMethodTest {
|
||||
public class CrazyCrypt1Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public CRAZYCRYPT1Test() {
|
||||
super(new CRAZYCRYPT1(),
|
||||
public CrazyCrypt1Test() {
|
||||
super(new CrazyCrypt1(),
|
||||
"d5c76eb36417d4e97ec62609619e40a9e549a2598d0dab5a7194fd997a9305af78de2b93f958e150d19dd1e7f821043379ddf5f9c7f352bf27df91ae4913f3e8", // password
|
||||
"49c63f827c88196871e344e589bd46cc4fa6db3c27801bbad5374c0d216381977627c1d76f2114667d5dd117e046f7493eb06e4f461f4f848aa08f6f40a3e934", // PassWord1
|
||||
"6fefb0233bab6e6efb9c16f82cb0d8f569488905e2dae0e7c9dde700e7363da67213d37c44bc15f4a05854c9c21e5688389d416413c7309398aa96cb1f341d08", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link DOUBLEMD5}.
|
||||
* Test for {@link DoubleMd5}.
|
||||
*/
|
||||
public class DOUBLEMD5Test extends AbstractEncryptionMethodTest {
|
||||
public class DoubleMd5Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public DOUBLEMD5Test() {
|
||||
super(new DOUBLEMD5(),
|
||||
public DoubleMd5Test() {
|
||||
super(new DoubleMd5(),
|
||||
"696d29e0940a4957748fe3fc9efd22a3", // password
|
||||
"c77aa2024d9fb7233a2872452d601aba", // PassWord1
|
||||
"fbd5790af706ec19f8a7ef161878758b", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link IPB3}.
|
||||
* Test for {@link Ipb3}.
|
||||
*/
|
||||
public class IPB3Test extends AbstractEncryptionMethodTest {
|
||||
public class Ipb3Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public IPB3Test() {
|
||||
super(new IPB3(),
|
||||
public Ipb3Test() {
|
||||
super(new Ipb3(),
|
||||
new HashedPassword("f8ecea1ce42b5babef369ff7692dbe3f", "1715b"), //password
|
||||
new HashedPassword("40a93731a931352e0619cdf09b975040", "ba91c"), //PassWord1
|
||||
new HashedPassword("a77ca982373946d5800430bd2947ba11", "a7725"), //&^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link IPB4}.
|
||||
* Test for {@link Ipb4}.
|
||||
*/
|
||||
public class IPB4Test extends AbstractEncryptionMethodTest {
|
||||
public class Ipb4Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public IPB4Test() {
|
||||
super(new IPB4(),
|
||||
public Ipb4Test() {
|
||||
super(new Ipb4(),
|
||||
new HashedPassword("$2a$13$leEvXu77OIwPwNvtZIJvaeAx8EItGHuR3nIlq8416g0gXeJaQdrr2", "leEvXu77OIwPwNvtZIJval"), //password
|
||||
new HashedPassword("$2a$13$xyTTP9zhQQtRRKIJPv5AuuOGJ6Ni9FLbDhcuIAcPjt3XzCxIWe3Uu", "xyTTP9zhQQtRRKIJPv5Au3"), //PassWord1
|
||||
new HashedPassword("$2a$13$rGBrqErm9DZyzbxIGHlgf.xfA15/4d5Ay/TK.3y9lG3AljcoG9Lsi", "rGBrqErm9DZyzbxIGHlgfN"), //&^%te$t?Pw@_
|
||||
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link JOOMLA}.
|
||||
* Test for {@link Joomla}.
|
||||
*/
|
||||
public class JoomlaTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public JoomlaTest() {
|
||||
super(new JOOMLA(),
|
||||
super(new Joomla(),
|
||||
"b18c99813cd96df3a706652f47177490:377c4aaf92c5ed57711306909e6065ca", // password
|
||||
"c5af71da91a8841d95937ba24a5b7fdb:07068e5850930b794526a614438cafc7", // PassWord1
|
||||
"f5fccd5166af7080833d7c7a6a531295:7cb6eeabcfac67ffe1341ec43375a9e6", // &^%te$t?Pw@_
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link MD5}.
|
||||
* Test for {@link Md5}.
|
||||
*/
|
||||
public class Md5Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public Md5Test() {
|
||||
super(new MD5(),
|
||||
super(new Md5(),
|
||||
"5f4dcc3b5aa765d61d8327deb882cf99", // password
|
||||
"f2126d405f46ed603ff5b2950f062c96", // PassWord1
|
||||
"0833dcd2bc741f90c46bbac5498fd08f", // &^%te$t?Pw@_
|
||||
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link MD5VB}.
|
||||
* Test for {@link Md5vB}.
|
||||
*/
|
||||
public class MD5VBTest extends AbstractEncryptionMethodTest {
|
||||
public class Md5vBTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public MD5VBTest() {
|
||||
super(new MD5VB(),
|
||||
public Md5vBTest() {
|
||||
super(new Md5vB(),
|
||||
"$MD5vb$bd9832fffa287321$5006d371fcb813f2347987f902a024ad", // password
|
||||
"$MD5vb$5e492c1166b5a828$c954fa5ee561700a097826971653b57f", // PassWord1
|
||||
"$MD5vb$3ec43cd46a61d70b$59687c0976f2e327b1245c8063f7008c", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link MYBB}.
|
||||
* Test for {@link MyBB}.
|
||||
*/
|
||||
public class MYBBTest extends AbstractEncryptionMethodTest {
|
||||
public class MyBBTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public MYBBTest() {
|
||||
super(new MYBB(),
|
||||
public MyBBTest() {
|
||||
super(new MyBB(),
|
||||
new HashedPassword("57c7a16d860833db5030738f5a465d2b", "acdc14e6"), //password
|
||||
new HashedPassword("08fbdf721f2c42d9780b7d66df0ba830", "792fd7fb"), //PassWord1
|
||||
new HashedPassword("d602f38fb59ad9e185d5604f5d4ddb36", "4b5534a4"), //&^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link PHPBB}.
|
||||
* Test for {@link PhpBB}.
|
||||
*/
|
||||
public class PHPBBTest extends AbstractEncryptionMethodTest {
|
||||
public class PhpBBTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public PHPBBTest() {
|
||||
super(new PHPBB(),
|
||||
public PhpBBTest() {
|
||||
super(new PhpBB(),
|
||||
"$H$7MaSGQb0xe3Fp/a.Q.Ewpw.UKfCv.t0", // password
|
||||
"$H$7ESfAVjzqajC7fJFcZKZIhyds41MuW.", // PassWord1
|
||||
"$H$7G65SXRPbR69jLg.qZTjtqsw36Ciw7.", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link PHPFUSION}.
|
||||
* Test for {@link PhpFusion}.
|
||||
*/
|
||||
public class PHPFUSIONTest extends AbstractEncryptionMethodTest {
|
||||
public class PhpFusionTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public PHPFUSIONTest() {
|
||||
super(new PHPFUSION(),
|
||||
public PhpFusionTest() {
|
||||
super(new PhpFusion(),
|
||||
new HashedPassword("f7a606c4eb3fcfbc382906476e05b06f21234a77d1a4eacc0f93f503deb69e70", "6cd1c97c55cb"), // password
|
||||
new HashedPassword("8a9b7bb706a3347e5f684a7cb905bfb26b9a0d099358064139ab3ed1a66aeb2b", "d6012370b73f"), // PassWord1
|
||||
new HashedPassword("43f2f23f44c8f89e2dbf06050bc8c77dbcdf71a7b5d28c87ec657d474e63d62d", "f75400a209a4"), // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link ROYALAUTH}.
|
||||
* Test for {@link RoyalAuth}.
|
||||
*/
|
||||
public class ROYALAUTHTest extends AbstractEncryptionMethodTest {
|
||||
public class RoyalAuthTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public ROYALAUTHTest() {
|
||||
super(new ROYALAUTH(),
|
||||
public RoyalAuthTest() {
|
||||
super(new RoyalAuth(),
|
||||
"5d21ef9236896bc4ac508e524e2da8a0def555dac1cdfc7259d62900d1d3f553826210c369870673ae2cf1c41abcf4f92670d76af1db044d33559324f5c2a339", // password
|
||||
"ecc685f4328bc54093c086ced66c5c11855e117ea22940632d5c0f55fff84d94bfdcc74e05f5d95bbdd052823a7057910748bc1c7a07af96b3e86731a4f11794", // PassWord1
|
||||
"2c0b4674f7c2c266db13ae4382cbeee3083167a774f6e73793a6268a0b8b2c3c6b324a99596f4a7958e58c5311c77e25975a3b517ce17adfc4eaece821e3dd19", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -7,12 +7,12 @@ import static org.mockito.BDDMockito.given;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
/**
|
||||
* Test for {@link SALTED2MD5}.
|
||||
* Test for {@link Salted2Md5}.
|
||||
*/
|
||||
public class SALTED2MD5Test extends AbstractEncryptionMethodTest {
|
||||
public class Salted2Md5Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public SALTED2MD5Test() {
|
||||
super(new SALTED2MD5(mockSettings()),
|
||||
public Salted2Md5Test() {
|
||||
super(new Salted2Md5(mockSettings()),
|
||||
new HashedPassword("9f3d13dc01a6fe61fd669954174399f3", "9b5f5749"), // password
|
||||
new HashedPassword("b28c32f624a4eb161d6adc9acb5bfc5b", "f750ba32"), // PassWord1
|
||||
new HashedPassword("38dcb83cc68424afe3cda012700c2bb1", "eb2c3394"), // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link SALTEDSHA512}.
|
||||
* Test for {@link SaltedSha512}.
|
||||
*/
|
||||
public class SALTEDSHA512Test extends AbstractEncryptionMethodTest {
|
||||
public class SaltedSha512Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public SALTEDSHA512Test() {
|
||||
super(new SALTEDSHA512(),
|
||||
public SaltedSha512Test() {
|
||||
super(new SaltedSha512(),
|
||||
new HashedPassword("dea7a37cecf5384ae8e347fd1411efb51364b6ba1b328695de3b354612c1d7010807e8b7051c40f740e498490e1f133e2c2408327d13fbdd68e1b1f6d548e624", "29f8a3c52147f987fee7ba3e0fb311bd"), // password
|
||||
new HashedPassword("7c06225aac574d2dc7c81a2ed306637adf025715f52083e05bdab014faaa234e24a97d0e69ea0108dfa77cc9228e58be319ee677e679b5d1ad168d40e50a42f6", "8ea37b85d020b98f60c0fe9b8ec9296c"), // PassWord1
|
||||
new HashedPassword("55711adbe03c9616f3505f0d57077fdd528c32243eb6f9840c1a6ff9e553940d6b89790750ebd52ebda63ca793fbe9980d54057af40836820c648750fe22d49c", "9f58079631ef21d32b4710694f1f461b"), // &^%te$t?Pw@_
|
||||
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link SHA1}.
|
||||
* Test for {@link Sha1}.
|
||||
*/
|
||||
public class Sha1Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public Sha1Test() {
|
||||
super(new SHA1(),
|
||||
super(new Sha1(),
|
||||
"5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8", // password
|
||||
"285d0c707f9644b75e1a87a62f25d0efb56800f0", // PassWord1
|
||||
"a42ef8e61e890af80461ca5dcded25cbfcf407a4", // &^%te$t?Pw@_
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link SHA256}.
|
||||
* Test for {@link Sha256}.
|
||||
*/
|
||||
public class Sha256Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public Sha256Test() {
|
||||
super(new SHA256(),
|
||||
super(new Sha256(),
|
||||
"$SHA$11aa0706173d7272$dbba96681c2ae4e0bfdf226d70fbbc5e4ee3d8071faa613bc533fe8a64817d10", // password
|
||||
"$SHA$3c72a18a29b08d40$8e50a7a4f69a80f4893dc921eac84bd74b3f9ebfa22908302c9965eac3aa45e5", // PassWord1
|
||||
"$SHA$584cea1cfab90030$adc006330e73d81e463fe02a4fe9b17bdbbcc05955bff72fb27cf2089f0b3859", // &^%te$t?Pw@_
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link SHA512}.
|
||||
* Test for {@link Sha512}.
|
||||
*/
|
||||
public class Sha512Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public Sha512Test() {
|
||||
super(new SHA512(),
|
||||
super(new Sha512(),
|
||||
"b109f3bbbc244eb82441917ed06d618b9008dd09b3befd1b5e07394c706a8bb980b1d7785e5976ec049b46df5f1326af5a2ea6d103fd07c95385ffab0cacbc86", // password
|
||||
"ae9942149995a8171391625b36da134d5e288c721650d7c8d2d464fb49a49f3f551e4916ab1e097d9dd1201b01d69b1dccdefa3d2524a66092fb61b3df6e7e71", // PassWord1
|
||||
"8c4f3df78db191142d819a72c16058b9e1ea41ae9b1649e1184eb89e30344c51c9c71039c483cf2f1b76b51480d8459d7eb3cfbaa24b07f2041d1551af4ead75", // &^%te$t?Pw@_
|
||||
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link SMF}.
|
||||
* Test for {@link Smf}.
|
||||
*/
|
||||
public class SMFTest extends AbstractEncryptionMethodTest {
|
||||
public class SmfTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public SMFTest() {
|
||||
super(new SMF(),
|
||||
public SmfTest() {
|
||||
super(new Smf(),
|
||||
"9b361c66977bb059d460a20d3c21fb3394772df5", // password
|
||||
"31a560bdd095a837945d46add1605108ba87b268", // PassWord1
|
||||
"8d4b84544e0891be8c183fe9b1003cfac18c51a1", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link WBB3}.
|
||||
* Test for {@link Wbb3}.
|
||||
*/
|
||||
public class WBB3Test extends AbstractEncryptionMethodTest {
|
||||
public class Wbb3Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public WBB3Test() {
|
||||
super(new WBB3(),
|
||||
public Wbb3Test() {
|
||||
super(new Wbb3(),
|
||||
new HashedPassword("8df818ef7d56075ab2744f74b98ad68a375ccac4", "b7415b355492ea60314f259a35733a3092c03e3f"), // password
|
||||
new HashedPassword("106da5cf5df92cb845e12cf62cbdb5235b6dc693", "6110f19b2b52910dccf592a19c59126873f42e69"), // PassWord1
|
||||
new HashedPassword("940a9fb7acec0178c6691e8b3c14bd7d789078b1", "f9dd501ff3d1bf74904f9e89649e378429af56e7"), // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link WBB4}.
|
||||
* Test for {@link Wbb4}.
|
||||
*/
|
||||
public class WBB4Test extends AbstractEncryptionMethodTest {
|
||||
public class Wbb4Test extends AbstractEncryptionMethodTest {
|
||||
|
||||
public WBB4Test() {
|
||||
super(new WBB4(),
|
||||
public Wbb4Test() {
|
||||
super(new Wbb4(),
|
||||
"$2a$08$7DGr.wROqEPe0Z3XJS7n5.k.QWehovLHbpI.UkdfRb4ns268WsR6C", // password
|
||||
"$2a$08$yWWVUA4PB4mqW.0wyIvV3OdoH492HuLk5L3iaqUrpRK2.2zn08d/K", // PassWord1
|
||||
"$2a$08$EHXUFt7bTT9Fnsu22KWvF.QDssiosV8YzH8CyWqulB/ckOA7qioJG", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link WHIRLPOOL}.
|
||||
* Test for {@link Whirlpool}.
|
||||
*/
|
||||
public class WHIRLPOOLTest extends AbstractEncryptionMethodTest {
|
||||
public class WhirlpoolTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public WHIRLPOOLTest() {
|
||||
super(new WHIRLPOOL(),
|
||||
public WhirlpoolTest() {
|
||||
super(new Whirlpool(),
|
||||
"74DFC2B27ACFA364DA55F93A5CAEE29CCAD3557247EDA238831B3E9BD931B01D77FE994E4F12B9D4CFA92A124461D2065197D8CF7F33FC88566DA2DB2A4D6EAE", // password
|
||||
"819B4CBD26508E39EA76BFE102DCF2ACC87A446747CAB0BD88522B0822A724583E81B6A4BD2CE255DB694E530B659F47D434EEB50344A02F50B64414C9671583", // PassWord1
|
||||
"71ECB0E5AEAB006F5336348076AA6A8E46075AEC9E010C7055BA1334B57746F2A9D8A8799BDD9B7EB4AB7544A59D25F469C8BCA2067508ACBA62A929260A1E17", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link WORDPRESS}.
|
||||
* Test for {@link Wordpress}.
|
||||
*/
|
||||
public class WORDPRESSTest extends AbstractEncryptionMethodTest {
|
||||
public class WordpressTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public WORDPRESSTest() {
|
||||
super(new WORDPRESS(),
|
||||
public WordpressTest() {
|
||||
super(new Wordpress(),
|
||||
"$P$B9wyjxuU4yrfjnnHNGSzH9ti9CC0Os1", // password
|
||||
"$P$BjzPjjzPjjkRzvGGRTyYu0sNqcz6Ci0", // PassWord1
|
||||
"$P$BjzPjjzPjrAOyB1V0WFdpisgCTFx.N/", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link XAUTH}.
|
||||
* Test for {@link XAuth}.
|
||||
*/
|
||||
public class XAUTHTest extends AbstractEncryptionMethodTest {
|
||||
public class XAuthTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public XAUTHTest() {
|
||||
super(new XAUTH(),
|
||||
public XAuthTest() {
|
||||
super(new XAuth(),
|
||||
"e54d4916577410d26d2f6e9362445463dab9ffdff9a67ed3b74d3f2312bc8fab84f653fcb88ad8338793ef8a6d0a1162105e46ec24f0dcb52355c634e3e6439f45444b09c715", // password
|
||||
"d54489a4fd4732ee03d56810ab92944096e3d49335266adeecfbc12567abb3ff744761b33a1fcc4d04739e377775c788e4baace3caf35c7b9176b82b1fe3472e4cbdc5a43214", // PassWord1
|
||||
"ce6404c1092fb5abf0a72f9c4327bfe8f4cdc4b8dc90ee6ca35c42b8ae9481b89c2559bb60b99ff2b57a102cfced40b8e2f5ef481400c9e6f79445017fc763b1cc27f4c2df36", // &^%te$t?Pw@_
|
||||
+4
-4
@@ -1,12 +1,12 @@
|
||||
package fr.xephi.authme.security.crypts;
|
||||
|
||||
/**
|
||||
* Test for {@link XFBCRYPT}.
|
||||
* Test for {@link XfBCrypt}.
|
||||
*/
|
||||
public class XFBCRYPTTest extends AbstractEncryptionMethodTest {
|
||||
public class XfBCryptTest extends AbstractEncryptionMethodTest {
|
||||
|
||||
public XFBCRYPTTest() {
|
||||
super(new XFBCRYPT(),
|
||||
public XfBCryptTest() {
|
||||
super(new XfBCrypt(),
|
||||
"$2a$10$UtuON/ZG.x8EWG/zQbryB.BHfQVrfxk3H7qykzP.UJQ8YiLjZyfqq", // password
|
||||
"$2a$10$Q.ocUo.YtHTdI4nu3pcpKun6BILcmWHm541ANULucmuU/ps1QKY4K", // PassWord1
|
||||
"$2a$10$yHjm02.K4HP5iFU1F..yLeTeo7PWZVbKAr/QGex5jU4.J3mdq/uuO", // &^%te$t?Pw@_
|
||||
@@ -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
|
||||
|
||||
@@ -5,7 +5,7 @@ import fr.xephi.authme.data.auth.PlayerAuth;
|
||||
import fr.xephi.authme.datasource.DataSource;
|
||||
import fr.xephi.authme.security.HashAlgorithm;
|
||||
import fr.xephi.authme.security.crypts.HashedPassword;
|
||||
import fr.xephi.authme.security.crypts.SHA256;
|
||||
import fr.xephi.authme.security.crypts.Sha256;
|
||||
import fr.xephi.authme.settings.Settings;
|
||||
import fr.xephi.authme.settings.properties.SecuritySettings;
|
||||
import org.junit.BeforeClass;
|
||||
@@ -28,6 +28,7 @@ import static org.mockito.Mockito.times;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
import static org.mockito.hamcrest.MockitoHamcrest.argThat;
|
||||
import static fr.xephi.authme.AuthMeMatchers.equalToHash;
|
||||
|
||||
/**
|
||||
* Test for {@link MigrationService}.
|
||||
@@ -42,7 +43,7 @@ public class MigrationServiceTest {
|
||||
private DataSource dataSource;
|
||||
|
||||
@Mock
|
||||
private SHA256 sha256;
|
||||
private Sha256 sha256;
|
||||
|
||||
@BeforeClass
|
||||
public static void setUpLogger() {
|
||||
@@ -122,7 +123,7 @@ public class MigrationServiceTest {
|
||||
.build();
|
||||
}
|
||||
|
||||
private static void setSha256MockToUppercase(SHA256 sha256) {
|
||||
private static void setSha256MockToUppercase(Sha256 sha256) {
|
||||
given(sha256.computeHash(anyString(), anyString())).willAnswer(new Answer<HashedPassword>() {
|
||||
@Override
|
||||
public HashedPassword answer(InvocationOnMock invocation) {
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -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));
|
||||
|
||||
@@ -1,15 +1,33 @@
|
||||
package fr.xephi.authme.settings;
|
||||
|
||||
import ch.jalu.configme.SectionComments;
|
||||
import ch.jalu.configme.SettingsHolder;
|
||||
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.ClassCollector;
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
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.lang.reflect.Method;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static com.google.common.base.Preconditions.checkArgument;
|
||||
import static fr.xephi.authme.ReflectionTestUtils.getFieldValue;
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
/**
|
||||
@@ -22,6 +40,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 +95,119 @@ public class SettingsConsistencyTest {
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldNotHaveVeryLongSectionCommentLines() {
|
||||
// given
|
||||
List<Method> sectionCommentMethods = getSectionCommentMethods();
|
||||
Set<Method> badMethods = new HashSet<>();
|
||||
|
||||
// when
|
||||
for (Method method : sectionCommentMethods) {
|
||||
boolean hasTooLongLine = getSectionComments(method).stream()
|
||||
.anyMatch(line -> line.length() > MAX_COMMENT_LENGTH);
|
||||
if (hasTooLongLine) {
|
||||
badMethods.add(method);
|
||||
}
|
||||
}
|
||||
|
||||
// then
|
||||
if (!badMethods.isEmpty()) {
|
||||
String methodList = badMethods.stream()
|
||||
.map(m -> m.getName() + " in " + m.getDeclaringClass().getSimpleName())
|
||||
.collect(Collectors.joining("\n- "));
|
||||
fail("Found SectionComments methods with too long comments:\n- " + methodList);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets all {@link SectionComments} methods from {@link SettingsHolder} implementations.
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
private List<Method> getSectionCommentMethods() {
|
||||
// Find all SettingsHolder classes
|
||||
List<Class<? extends SettingsHolder>> settingsClasses =
|
||||
new ClassCollector("src/main/java", "fr/xephi/authme/settings/properties/")
|
||||
.collectClasses(SettingsHolder.class);
|
||||
checkArgument(!settingsClasses.isEmpty(), "Could not find any SettingsHolder classes");
|
||||
|
||||
// Find all @SectionComments methods in these classes
|
||||
return settingsClasses.stream()
|
||||
.map(Class::getDeclaredMethods)
|
||||
.flatMap(Arrays::stream)
|
||||
.filter(method -> method.isAnnotationPresent(SectionComments.class))
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns all comments returned from the given SectionComments method, flattened into one list.
|
||||
*
|
||||
* @param sectionCommentsMethod the method whose comments should be retrieved
|
||||
* @return flattened list of all comments provided by the method
|
||||
*/
|
||||
private static List<String> getSectionComments(Method sectionCommentsMethod) {
|
||||
// @SectionComments methods are static
|
||||
Map<String, String[]> comments = ReflectionTestUtils.invokeMethod(sectionCommentsMethod, null);
|
||||
return comments.values().stream()
|
||||
.flatMap(Arrays::stream)
|
||||
.collect(Collectors.toList());
|
||||
}
|
||||
|
||||
/**
|
||||
* 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
|
||||
}
|
||||
}
|
||||
|
||||
@@ -22,7 +22,7 @@ public class AuthMeSettingsRetrieverTest {
|
||||
// an error margin of 10: this prevents us from having to adjust the test every time the config is changed.
|
||||
// If this test fails, replace the first argument in closeTo() with the new number of properties
|
||||
assertThat((double) configurationData.getProperties().size(),
|
||||
closeTo(150, 10));
|
||||
closeTo(160, 10));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
package fr.xephi.authme.settings.properties;
|
||||
|
||||
import ch.jalu.configme.SettingsHolder;
|
||||
import ch.jalu.configme.configurationdata.ConfigurationData;
|
||||
import ch.jalu.configme.properties.Property;
|
||||
import fr.xephi.authme.ClassCollector;
|
||||
import fr.xephi.authme.ReflectionTestUtils;
|
||||
@@ -10,11 +11,13 @@ import org.junit.Test;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.lang.reflect.Modifier;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import static org.hamcrest.Matchers.equalTo;
|
||||
import static org.hamcrest.Matchers.hasSize;
|
||||
import static org.junit.Assert.assertThat;
|
||||
import static org.junit.Assert.fail;
|
||||
|
||||
@@ -74,6 +77,27 @@ public class SettingsClassConsistencyTest {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks that {@link AuthMeSettingsRetriever} returns a ConfigurationData with all
|
||||
* available SettingsHolder classes.
|
||||
*/
|
||||
@Test
|
||||
public void shouldHaveAllClassesInConfigurationData() {
|
||||
// given
|
||||
long totalProperties = classes.stream()
|
||||
.map(Class::getDeclaredFields)
|
||||
.flatMap(Arrays::stream)
|
||||
.filter(field -> Property.class.isAssignableFrom(field.getType()))
|
||||
.count();
|
||||
|
||||
// when
|
||||
ConfigurationData configData = AuthMeSettingsRetriever.buildConfigurationData();
|
||||
|
||||
// then
|
||||
assertThat("ConfigurationData should have " + totalProperties + " properties (as found manually)",
|
||||
configData.getProperties(), hasSize((int) totalProperties));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void shouldHaveHiddenEmptyConstructorOnly() {
|
||||
for (Class<?> clazz : classes) {
|
||||
|
||||
@@ -95,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));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user