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

#567 Move email validation logic to validation service

Browse Source
This commit is contained in:
ljacqu
2016-04-03 20:44:13 +02:00
parent b6ccb3e632
commit 9ea75c502c
19 changed files with 402 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/test/java/fr/xephi/authme/command/CommandServiceTest.java
+31
View File
@@ -246,4 +246,35 @@ public class CommandServiceTest {
assertThat(result, equalTo(MessageKey.INVALID_PASSWORD_LENGTH));
verify(validationService).validatePassword(password, user);
}
@Test
public void shouldValidateEmail() {
// given
String email = "test@example.tld";
given(validationService.validateEmail(email)).willReturn(true);
// when
boolean result = commandService.validateEmail(email);
// then
assertThat(result, equalTo(true));
verify(validationService).validateEmail(email);
}
@Test
public void shouldCheckIfEmailCanBeUsed() {
// given
String email = "mail@example.com";
CommandSender sender = mock(CommandSender.class);
given(validationService.isEmailFreeForRegistration(email, sender))
.willReturn(true);
// when
boolean result = commandService.isEmailFreeForRegistration(email, sender);
// then
assertThat(result, equalTo(true));
verify(validationService).isEmailFreeForRegistration(email, sender);
}
}
src/test/java/fr/xephi/authme/command/executable/email/AddEmailCommandTest.java
+29 -15
View File
@@ -1,14 +1,15 @@
package fr.xephi.authme.command.executable.email;
import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.settings.NewSetting;
import org.bukkit.command.BlockCommandSender;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.ArrayList;
import java.util.Arrays;
@@ -21,19 +22,16 @@ import static org.mockito.Mockito.verify;
/**
* Test for {@link AddEmailCommand}.
*/
@RunWith(MockitoJUnitRunner.class)
public class AddEmailCommandTest {
@Mock
private CommandService commandService;
@Before
public void setUpMocks() {
commandService = mock(CommandService.class);
}
@Test
public void shouldRejectNonPlayerSender() {
// given
CommandSender sender = Mockito.mock(BlockCommandSender.class);
CommandSender sender = mock(BlockCommandSender.class);
AddEmailCommand command = new AddEmailCommand();
// when
@@ -46,18 +44,34 @@ public class AddEmailCommandTest {
@Test
public void shouldForwardData() {
// given
Player sender = Mockito.mock(Player.class);
AddEmailCommand command = new AddEmailCommand();
Player sender = mock(Player.class);
String email = "mail@example";
given(commandService.validateEmail(email)).willReturn(true);
Management management = mock(Management.class);
given(commandService.getManagement()).willReturn(management);
NewSetting settings = mock(NewSetting.class);
given(commandService.getSettings()).willReturn(settings);
AddEmailCommand command = new AddEmailCommand();
// when
command.executeCommand(sender, Arrays.asList("mail@example", "mail@example"), commandService);
command.executeCommand(sender, Arrays.asList(email, email), commandService);
// then
verify(management).performAddEmail(sender, "mail@example");
verify(management).performAddEmail(sender, email);
}
@Test
public void shouldFailForConfirmationMismatch() {
// given
Player sender = mock(Player.class);
String email = "asdfasdf@example.com";
given(commandService.validateEmail(email)).willReturn(true);
AddEmailCommand command = new AddEmailCommand();
// when
command.executeCommand(sender, Arrays.asList(email, "wrongConf"), commandService);
// then
verify(commandService, never()).getManagement();
verify(commandService).send(sender, MessageKey.CONFIRM_EMAIL_MESSAGE);
}
}
src/test/java/fr/xephi/authme/command/executable/register/RegisterCommandTest.java
+4 -2
View File
@@ -3,7 +3,7 @@ package fr.xephi.authme.command.executable.register;
import fr.xephi.authme.command.CommandService;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.process.Management;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import fr.xephi.authme.util.WrapperMock;
import org.bukkit.command.BlockCommandSender;
import org.bukkit.command.CommandSender;
@@ -14,6 +14,7 @@ import org.junit.Test;
import java.util.ArrayList;
import java.util.Collections;
import static fr.xephi.authme.settings.properties.RestrictionSettings.ENABLE_PASSWORD_CONFIRMATION;
import static org.hamcrest.Matchers.containsString;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.argThat;
@@ -31,7 +32,6 @@ public class RegisterCommandTest {
@Before
public void initializeAuthMeMock() {
WrapperMock.createInstance();
Settings.captchaLength = 10;
commandService = mock(CommandService.class);
}
@@ -70,6 +70,8 @@ public class RegisterCommandTest {
RegisterCommand command = new RegisterCommand();
Management management = mock(Management.class);
given(commandService.getManagement()).willReturn(management);
given(commandService.getProperty(ENABLE_PASSWORD_CONFIRMATION)).willReturn(false);
given(commandService.getProperty(RegistrationSettings.USE_EMAIL_REGISTRATION)).willReturn(false);
// when
command.executeCommand(sender, Collections.singletonList("password"), commandService);
src/test/java/fr/xephi/authme/process/ProcessServiceTest.java
+62 -37
View File
@@ -15,9 +15,9 @@ import fr.xephi.authme.util.ValidationService;
import org.bukkit.command.CommandSender;
import org.junit.Before;
import org.junit.Test;
import java.util.HashMap;
import java.util.Map;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import static org.hamcrest.Matchers.equalTo;
import static org.junit.Assert.assertThat;
@@ -28,23 +28,38 @@ import static org.mockito.Mockito.verify;
/**
* Test for {@link ProcessService}.
*/
@RunWith(MockitoJUnitRunner.class)
public class ProcessServiceTest {
private ProcessService processService;
private Map<Class<?>, Object> mocks;
@Mock
private ValidationService validationService;
@Mock
private NewSetting settings;
@Mock
private Messages messages;
@Mock
private IpAddressManager ipAddressManager;
@Mock
private PasswordSecurity passwordSecurity;
@Mock
private AuthMe authMe;
@Mock
private DataSource dataSource;
@Mock
private SpawnLoader spawnLoader;
@Mock
private PluginHooks pluginHooks;
@Before
public void setUpService() {
mocks = new HashMap<>();
processService = new ProcessService(newMock(NewSetting.class), newMock(Messages.class), newMock(AuthMe.class),
newMock(DataSource.class), newMock(IpAddressManager.class), newMock(PasswordSecurity.class),
newMock(PluginHooks.class), newMock(SpawnLoader.class), newMock(ValidationService.class));
processService = new ProcessService(settings, messages, authMe, dataSource, ipAddressManager, passwordSecurity,
pluginHooks, spawnLoader, validationService);
}
@Test
public void shouldGetProperty() {
// given
NewSetting settings = getMock(NewSetting.class);
given(settings.getProperty(SecuritySettings.CAPTCHA_LENGTH)).willReturn(8);
// when
@@ -58,16 +73,15 @@ public class ProcessServiceTest {
@Test
public void shouldReturnSettings() {
// given/when
NewSetting settings = processService.getSettings();
NewSetting result = processService.getSettings();
// then
assertThat(settings, equalTo(getMock(NewSetting.class)));
assertThat(result, equalTo(settings));
}
@Test
public void shouldSendMessageToPlayer() {
// given
Messages messages = getMock(Messages.class);
CommandSender sender = mock(CommandSender.class);
MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
@@ -81,7 +95,6 @@ public class ProcessServiceTest {
@Test
public void shouldSendMessageWithReplacements() {
// given
Messages messages = getMock(Messages.class);
CommandSender sender = mock(CommandSender.class);
MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
String[] replacements = new String[]{"test", "toast"};
@@ -96,7 +109,6 @@ public class ProcessServiceTest {
@Test
public void shouldRetrieveMessage() {
// given
Messages messages = getMock(Messages.class);
MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
String[] lines = new String[]{"First message line", "second line"};
given(messages.retrieve(key)).willReturn(lines);
@@ -112,7 +124,6 @@ public class ProcessServiceTest {
@Test
public void shouldRetrieveSingleMessage() {
// given
Messages messages = getMock(Messages.class);
MessageKey key = MessageKey.ACCOUNT_NOT_ACTIVATED;
String text = "Test text";
given(messages.retrieveSingle(key)).willReturn(text);
@@ -128,52 +139,51 @@ public class ProcessServiceTest {
@Test
public void shouldReturnAuthMeInstance() {
// given / when
AuthMe authMe = processService.getAuthMe();
AuthMe result = processService.getAuthMe();
// then
assertThat(authMe, equalTo(getMock(AuthMe.class)));
assertThat(result, equalTo(authMe));
}
@Test
public void shouldReturnPluginHooks() {
// given / when
PluginHooks pluginHooks = processService.getPluginHooks();
PluginHooks result = processService.getPluginHooks();
// then
assertThat(pluginHooks, equalTo(getMock(PluginHooks.class)));
assertThat(result, equalTo(pluginHooks));
}
@Test
public void shouldReturnIpAddressManager() {
// given / when
IpAddressManager ipAddressManager = processService.getIpAddressManager();
IpAddressManager result = processService.getIpAddressManager();
// then
assertThat(ipAddressManager, equalTo(getMock(IpAddressManager.class)));
assertThat(result, equalTo(ipAddressManager));
}
@Test
public void shouldReturnSpawnLoader() {
// given / when
SpawnLoader spawnLoader = processService.getSpawnLoader();
SpawnLoader result = processService.getSpawnLoader();
// then
assertThat(spawnLoader, equalTo(getMock(SpawnLoader.class)));
assertThat(result, equalTo(spawnLoader));
}
@Test
public void shouldReturnDatasource() {
// given / when
DataSource dataSource = processService.getDataSource();
DataSource result = processService.getDataSource();
// then
assertThat(dataSource, equalTo(getMock(DataSource.class)));
assertThat(result, equalTo(dataSource));
}
@Test
public void shouldComputeHash() {
// given
PasswordSecurity passwordSecurity = getMock(PasswordSecurity.class);
String password = "test123";
String username = "Username";
HashedPassword hashedPassword = new HashedPassword("hashedResult", "salt12342");
@@ -192,7 +202,6 @@ public class ProcessServiceTest {
// given
String user = "test-user";
String password = "passw0rd";
ValidationService validationService = getMock(ValidationService.class);
given(validationService.validatePassword(password, user)).willReturn(MessageKey.PASSWORD_MATCH_ERROR);
// when
@@ -203,17 +212,33 @@ public class ProcessServiceTest {
verify(validationService).validatePassword(password, user);
}
private <T> T newMock(Class<T> clazz) {
T mock = mock(clazz);
mocks.put(clazz, mock);
return mock;
@Test
public void shouldValidateEmail() {
// given
String email = "test@example.tld";
given(validationService.validateEmail(email)).willReturn(true);
// when
boolean result = processService.validateEmail(email);
// then
assertThat(result, equalTo(true));
verify(validationService).validateEmail(email);
}
private <T> T getMock(Class<T> clazz) {
Object mock = mocks.get(clazz);
if (mock == null) {
throw new IllegalArgumentException("No mock of type " + clazz);
}
return clazz.cast(mock);
@Test
public void shouldCheckIfEmailCanBeUsed() {
// given
String email = "mail@example.com";
CommandSender sender = mock(CommandSender.class);
given(validationService.isEmailFreeForRegistration(email, sender))
.willReturn(true);
// when
boolean result = processService.isEmailFreeForRegistration(email, sender);
// then
assertThat(result, equalTo(true));
verify(validationService).isEmailFreeForRegistration(email, sender);
}
}
src/test/java/fr/xephi/authme/process/email/AsyncAddEmailTest.java
+18 -17
View File
@@ -6,8 +6,6 @@ import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import org.bukkit.entity.Player;
import org.junit.BeforeClass;
@@ -21,7 +19,6 @@ import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
/**
* Test for {@link AsyncAddEmail}.
@@ -46,14 +43,16 @@ public class AsyncAddEmailTest {
@Test
public void shouldAddEmail() {
// given
AsyncAddEmail process = createProcess("my.mail@example.org");
String email = "my.mail@example.org";
AsyncAddEmail process = createProcess(email);
given(player.getName()).willReturn("testEr");
given(playerCache.isAuthenticated("tester")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn(null);
given(playerCache.getAuth("tester")).willReturn(auth);
given(dataSource.countAuthsByEmail("my.mail@example.org")).willReturn(1);
given(dataSource.updateEmail(any(PlayerAuth.class))).willReturn(true);
given(service.validateEmail(email)).willReturn(true);
given(service.isEmailFreeForRegistration(email, player)).willReturn(true);
// when
process.run();
@@ -61,21 +60,24 @@ public class AsyncAddEmailTest {
// then
verify(dataSource).updateEmail(auth);
verify(service).send(player, MessageKey.EMAIL_ADDED_SUCCESS);
verify(auth).setEmail("my.mail@example.org");
verify(auth).setEmail(email);
verify(playerCache).updatePlayer(auth);
}
@Test
public void shouldReturnErrorWhenMailCannotBeSaved() {
// given
AsyncAddEmail process = createProcess("my.mail@example.org");
String email = "my.mail@example.org";
AsyncAddEmail process = createProcess(email);
given(player.getName()).willReturn("testEr");
given(playerCache.isAuthenticated("tester")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn(null);
given(playerCache.getAuth("tester")).willReturn(auth);
given(dataSource.countAuthsByEmail("my.mail@example.org")).willReturn(0);
given(dataSource.countAuthsByEmail(email)).willReturn(0);
given(dataSource.updateEmail(any(PlayerAuth.class))).willReturn(false);
given(service.validateEmail(email)).willReturn(true);
given(service.isEmailFreeForRegistration(email, player)).willReturn(true);
// when
process.run();
@@ -94,7 +96,6 @@ public class AsyncAddEmailTest {
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn("another@mail.tld");
given(playerCache.getAuth("my_player")).willReturn(auth);
given(dataSource.countAuthsByEmail("some.mail@example.org")).willReturn(0);
// when
process.run();
@@ -107,13 +108,14 @@ public class AsyncAddEmailTest {
@Test
public void shouldNotAddMailIfItIsInvalid() {
// given
AsyncAddEmail process = createProcess("invalid_mail");
String email = "invalid_mail";
AsyncAddEmail process = createProcess(email);
given(player.getName()).willReturn("my_Player");
given(playerCache.isAuthenticated("my_player")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn(null);
given(playerCache.getAuth("my_player")).willReturn(auth);
given(dataSource.countAuthsByEmail("invalid_mail")).willReturn(0);
given(service.validateEmail(email)).willReturn(false);
// when
process.run();
@@ -126,13 +128,15 @@ public class AsyncAddEmailTest {
@Test
public void shouldNotAddMailIfAlreadyUsed() {
// given
AsyncAddEmail process = createProcess("player@mail.tld");
String email = "player@mail.tld";
AsyncAddEmail process = createProcess(email);
given(player.getName()).willReturn("TestName");
given(playerCache.isAuthenticated("testname")).willReturn(true);
PlayerAuth auth = mock(PlayerAuth.class);
given(auth.getEmail()).willReturn(null);
given(playerCache.getAuth("testname")).willReturn(auth);
given(dataSource.countAuthsByEmail("player@mail.tld")).willReturn(2);
given(service.validateEmail(email)).willReturn(true);
given(service.isEmailFreeForRegistration(email, player)).willReturn(false);
// when
process.run();
@@ -193,15 +197,12 @@ public class AsyncAddEmailTest {
}
/**
* Create an instance of {@link AsyncAddEmail} and save the mocks to this class' fields.
* Create an instance of {@link AsyncAddEmail} with the class' mocks.
*
* @param email The email to use
* @return The created process
*/
private AsyncAddEmail createProcess(String email) {
NewSetting settings = mock(NewSetting.class);
when(service.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).thenReturn(2);
when(service.getSettings()).thenReturn(settings);
return new AsyncAddEmail(player, email, dataSource, playerCache, service);
}
src/test/java/fr/xephi/authme/process/email/AsyncChangeEmailTest.java
+20 -10
View File
@@ -5,7 +5,6 @@ import fr.xephi.authme.cache.auth.PlayerCache;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.process.ProcessService;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.settings.properties.RegistrationSettings;
import org.bukkit.entity.Player;
@@ -35,18 +34,19 @@ public class AsyncChangeEmailTest {
private DataSource dataSource;
@Mock
private ProcessService service;
@Mock
private NewSetting settings;
@Test
public void shouldAddEmail() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
String newEmail = "new@mail.tld";
AsyncChangeEmail process = createProcess("old@mail.tld", newEmail);
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("old@mail.tld");
given(playerCache.getAuth("bobby")).willReturn(auth);
given(dataSource.updateEmail(auth)).willReturn(true);
given(service.validateEmail(newEmail)).willReturn(true);
given(service.isEmailFreeForRegistration(newEmail, player)).willReturn(true);
// when
process.run();
@@ -60,12 +60,15 @@ public class AsyncChangeEmailTest {
@Test
public void shouldShowErrorIfSaveFails() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
String newEmail = "new@mail.tld";
AsyncChangeEmail process = createProcess("old@mail.tld", newEmail);
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("old@mail.tld");
given(playerCache.getAuth("bobby")).willReturn(auth);
given(dataSource.updateEmail(auth)).willReturn(false);
given(service.validateEmail(newEmail)).willReturn(true);
given(service.isEmailFreeForRegistration(newEmail, player)).willReturn(true);
// when
process.run();
@@ -97,11 +100,13 @@ public class AsyncChangeEmailTest {
@Test
public void shouldRejectInvalidNewMail() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "bogus");
String newEmail = "bogus";
AsyncChangeEmail process = createProcess("old@mail.tld", newEmail);
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("old@mail.tld");
given(playerCache.getAuth("bobby")).willReturn(auth);
given(service.validateEmail(newEmail)).willReturn(false);
// when
process.run();
@@ -115,11 +120,15 @@ public class AsyncChangeEmailTest {
@Test
public void shouldRejectInvalidOldEmail() {
// given
AsyncChangeEmail process = createProcess("old@mail.tld", "new@mail.tld");
String newEmail = "new@mail.tld";
AsyncChangeEmail process = createProcess("old@mail.tld", newEmail);
given(player.getName()).willReturn("Bobby");
given(playerCache.isAuthenticated("bobby")).willReturn(true);
PlayerAuth auth = authWithMail("other@address.email");
given(playerCache.getAuth("bobby")).willReturn(auth);
given(service.validateEmail(newEmail)).willReturn(true);
given(service.isEmailFreeForRegistration(newEmail, player)).willReturn(true);
// when
process.run();
@@ -133,12 +142,14 @@ public class AsyncChangeEmailTest {
@Test
public void shouldRejectAlreadyUsedEmail() {
// given
AsyncChangeEmail process = createProcess("old@example.com", "new@example.com");
String newEmail = "new@example.com";
AsyncChangeEmail process = createProcess("old@example.com", newEmail);
given(player.getName()).willReturn("Username");
given(playerCache.isAuthenticated("username")).willReturn(true);
PlayerAuth auth = authWithMail("old@example.com");
given(playerCache.getAuth("username")).willReturn(auth);
given(dataSource.countAuthsByEmail("new@example.com")).willReturn(5);
given(service.validateEmail(newEmail)).willReturn(true);
given(service.isEmailFreeForRegistration(newEmail, player)).willReturn(false);
// when
process.run();
@@ -210,7 +221,6 @@ public class AsyncChangeEmailTest {
private AsyncChangeEmail createProcess(String oldEmail, String newEmail) {
given(service.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(5);
given(service.getSettings()).willReturn(settings);
return new AsyncChangeEmail(player, oldEmail, newEmail, dataSource, playerCache, service);
}
}
src/test/java/fr/xephi/authme/util/UtilsTest.java
+4 -100
View File
@@ -3,26 +3,23 @@ package fr.xephi.authme.util;
import fr.xephi.authme.AuthMe;
import fr.xephi.authme.ConsoleLoggerTestInitializer;
import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.Settings;
import fr.xephi.authme.settings.properties.EmailSettings;
import org.bukkit.entity.Player;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
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.*;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.verify;
/**
* Test for the {@link Utils} class.
@@ -30,7 +27,6 @@ import static org.mockito.Mockito.*;
public class UtilsTest {
private static AuthMe authMeMock;
private PermissionsManager permissionsManagerMock;
/**
* The Utils class initializes its fields in a {@code static} block which is only executed once during the JUnit
@@ -51,9 +47,6 @@ public class UtilsTest {
// before every test -- this is OK because it is retrieved via authMeMock. It is just crucial that authMeMock
// remain the same object.
reset(authMeMock);
permissionsManagerMock = mock(PermissionsManager.class);
when(authMeMock.getPermissionsManager()).thenReturn(permissionsManagerMock);
}
@Test
@@ -103,95 +96,6 @@ public class UtilsTest {
assertThat(players, hasSize(2));
}
// ----------------
// Tests for Utils#isEmailCorrect()
// ----------------
@Test
public void shouldAcceptEmailWithEmptyLists() {
// given
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String> emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String> emptyList());
// when
boolean result = Utils.isEmailCorrect("test@example.org", settings);
// then
assertThat(result, equalTo(true));
}
@Test
public void shouldAcceptEmailWithWhitelist() {
// given
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
.willReturn(Arrays.asList("domain.tld", "example.com"));
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String> emptyList());
// when
boolean result = Utils.isEmailCorrect("TesT@Example.com", settings);
// then
assertThat(result, equalTo(true));
}
@Test
public void shouldRejectEmailNotInWhitelist() {
// given
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
.willReturn(Arrays.asList("domain.tld", "example.com"));
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String> emptyList());
// when
boolean result = Utils.isEmailCorrect("email@other-domain.abc", settings);
// then
assertThat(result, equalTo(false));
}
@Test
public void shouldAcceptEmailNotInBlacklist() {
// given
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String> emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
.willReturn(Arrays.asList("Example.org", "a-test-name.tld"));
// when
boolean result = Utils.isEmailCorrect("sample@valid-name.tld", settings);
// then
assertThat(result, equalTo(true));
}
@Test
public void shouldRejectEmailInBlacklist() {
// given
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String> emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
.willReturn(Arrays.asList("Example.org", "a-test-name.tld"));
// when
boolean result = Utils.isEmailCorrect("sample@a-Test-name.tld", settings);
// then
assertThat(result, equalTo(false));
}
@Test
public void shouldRejectInvalidEmail() {
// given/when/then
assertThat(Utils.isEmailCorrect("invalidinput", mock(NewSetting.class)), equalTo(false));
}
@Test
public void shouldRejectDefaultEmail() {
// given/when/then
assertThat(Utils.isEmailCorrect("your@email.com", mock(NewSetting.class)), equalTo(false));
}
// Note: This method is used through reflections
public static Player[] onlinePlayersImpl() {
return new Player[]{
src/test/java/fr/xephi/authme/util/ValidationServiceTest.java
+143 -2
View File
@@ -1,14 +1,23 @@
package fr.xephi.authme.util;
import com.google.common.base.Strings;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.output.MessageKey;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PlayerStatePermission;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.EmailSettings;
import fr.xephi.authme.settings.properties.RestrictionSettings;
import fr.xephi.authme.settings.properties.SecuritySettings;
import org.bukkit.command.CommandSender;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.Collections;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.nullValue;
@@ -19,19 +28,26 @@ import static org.mockito.Mockito.mock;
/**
* Test for {@link ValidationService}.
*/
@RunWith(MockitoJUnitRunner.class)
public class ValidationServiceTest {
private ValidationService validationService;
@Mock
private NewSetting settings;
@Mock
private DataSource dataSource;
@Mock
private PermissionsManager permissionsManager;
@Before
public void createService() {
NewSetting settings = mock(NewSetting.class);
given(settings.getProperty(RestrictionSettings.ALLOWED_PASSWORD_REGEX)).willReturn("[a-zA-Z]+");
given(settings.getProperty(SecuritySettings.MIN_PASSWORD_LENGTH)).willReturn(3);
given(settings.getProperty(SecuritySettings.MAX_PASSWORD_LENGTH)).willReturn(20);
given(settings.getProperty(SecuritySettings.UNSAFE_PASSWORDS))
.willReturn(Arrays.asList("unsafe", "other-unsafe"));
validationService = new ValidationService(settings);
given(settings.getProperty(EmailSettings.MAX_REG_PER_EMAIL)).willReturn(3);
validationService = new ValidationService(settings, dataSource, permissionsManager);
}
@Test
@@ -89,4 +105,129 @@ public class ValidationServiceTest {
assertThat(error, nullValue());
}
@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());
// when
boolean result = validationService.validateEmail("test@example.org");
// then
assertThat(result, equalTo(true));
}
@Test
public void shouldAcceptEmailWithWhitelist() {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
.willReturn(Arrays.asList("domain.tld", "example.com"));
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String>emptyList());
// when
boolean result = validationService.validateEmail("TesT@Example.com");
// then
assertThat(result, equalTo(true));
}
@Test
public void shouldRejectEmailNotInWhitelist() {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST))
.willReturn(Arrays.asList("domain.tld", "example.com"));
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST)).willReturn(Collections.<String>emptyList());
// when
boolean result = validationService.validateEmail("email@other-domain.abc");
// then
assertThat(result, equalTo(false));
}
@Test
public void shouldAcceptEmailNotInBlacklist() {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
.willReturn(Arrays.asList("Example.org", "a-test-name.tld"));
// when
boolean result = validationService.validateEmail("sample@valid-name.tld");
// then
assertThat(result, equalTo(true));
}
@Test
public void shouldRejectEmailInBlacklist() {
// given
given(settings.getProperty(EmailSettings.DOMAIN_WHITELIST)).willReturn(Collections.<String>emptyList());
given(settings.getProperty(EmailSettings.DOMAIN_BLACKLIST))
.willReturn(Arrays.asList("Example.org", "a-test-name.tld"));
// when
boolean result = validationService.validateEmail("sample@a-Test-name.tld");
// then
assertThat(result, equalTo(false));
}
@Test
public void shouldRejectInvalidEmail() {
// given/when/then
assertThat(validationService.validateEmail("invalidinput"), equalTo(false));
}
@Test
public void shouldRejectDefaultEmail() {
// given/when/then
assertThat(validationService.validateEmail("your@email.com"), equalTo(false));
}
public void shouldAllowRegistration() {
// given
CommandSender sender = mock(CommandSender.class);
String email = "my.address@example.org";
given(permissionsManager.hasPermission(sender, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS))
.willReturn(false);
given(dataSource.countAuthsByEmail(email)).willReturn(2);
// when
boolean result = validationService.isEmailFreeForRegistration(email, sender);
// then
assertThat(result, equalTo(true));
}
public void shouldRejectEmailWithTooManyAccounts() {
// given
CommandSender sender = mock(CommandSender.class);
String email = "mail@example.org";
given(permissionsManager.hasPermission(sender, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS))
.willReturn(false);
given(dataSource.countAuthsByEmail(email)).willReturn(5);
// when
boolean result = validationService.isEmailFreeForRegistration(email, sender);
// then
assertThat(result, equalTo(false));
}
public void shouldAllowBypassForPresentPermission() {
// given
CommandSender sender = mock(CommandSender.class);
String email = "mail-address@example.com";
given(permissionsManager.hasPermission(sender, PlayerStatePermission.ALLOW_MULTIPLE_ACCOUNTS))
.willReturn(true);
given(dataSource.countAuthsByEmail(email)).willReturn(7);
// when
boolean result = validationService.isEmailFreeForRegistration(email, sender);
// then
assertThat(result, equalTo(true));
}
}