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

Merge branch '784-purgeservice-architecture' of https://github.com/AuthMe-Team/AuthMeReloaded

Browse Source
This commit is contained in:
ljacqu
2016-07-20 21:31:25 +02:00
parent b671c94e0b 57f90fe410
commit 8fcb651ebb
28 changed files with 553 additions and 292 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/test/java/fr/xephi/authme/AuthMeInitializationTest.java
+2 -2
View File
@@ -13,7 +13,7 @@ import fr.xephi.authme.process.Management;
import fr.xephi.authme.process.login.ProcessSyncPlayerLogin;
import fr.xephi.authme.security.PasswordSecurity;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.task.PurgeService;
import fr.xephi.authme.task.purge.PurgeService;
import org.bukkit.Bukkit;
import org.bukkit.Server;
import org.bukkit.plugin.PluginDescriptionFile;
@@ -94,7 +94,7 @@ public class AuthMeInitializationTest {
// given
NewSetting settings = new NewSetting(settingsFile, dataFolder, getAllPropertyFields(), alwaysFulfilled());
// TODO ljacqu 20160619: At some point setting the "plugin" field should not longer be necessary
// TODO ljacqu 20160619: At some point setting the "plugin" field should no longer be necessary
// We only require it right now because of usages of AuthMe#getInstance()
ReflectionTestUtils.setField(AuthMe.class, null, "plugin", authMe);
src/test/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommandTest.java
+1 -1
View File
@@ -1,6 +1,6 @@
package fr.xephi.authme.command.executable.authme;
import fr.xephi.authme.task.PurgeService;
import fr.xephi.authme.task.purge.PurgeService;
import fr.xephi.authme.util.BukkitService;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
src/test/java/fr/xephi/authme/command/executable/authme/PurgeCommandTest.java
+1 -1
View File
@@ -1,6 +1,6 @@
package fr.xephi.authme.command.executable.authme;
import fr.xephi.authme.task.PurgeService;
import fr.xephi.authme.task.purge.PurgeService;
import org.bukkit.command.CommandSender;
import org.junit.Test;
import org.junit.runner.RunWith;
src/test/java/fr/xephi/authme/datasource/AbstractDataSourceIntegrationTest.java
+13
View File
@@ -369,4 +369,17 @@ public abstract class AbstractDataSourceIntegrationTest {
assertThat(dataSource.getLoggedPlayers(), empty());
}
@Test
public void shouldPerformPurgeOperation() {
// given
List<String> names = Arrays.asList("Bobby", "USER", "DoesnotExist");
DataSource dataSource = getDataSource();
// when
dataSource.purgeRecords(names);
// then
assertThat(dataSource.getAllAuths(), empty());
}
}
src/test/java/fr/xephi/authme/datasource/AbstractResourceClosingTest.java
+6 -1
View File
@@ -219,7 +219,7 @@ public abstract class AbstractResourceClosingTest {
Object element = PARAM_VALUES.get(genericType);
Preconditions.checkNotNull(element, "No sample element for list of generic type " + genericType);
if (List.class == parameterizedType.getRawType()) {
if (isAssignableFrom(parameterizedType.getRawType(), List.class)) {
return Arrays.asList(element, element, element);
} else if (Set.class == parameterizedType.getRawType()) {
return new HashSet<>(Arrays.asList(element, element, element));
@@ -229,6 +229,11 @@ public abstract class AbstractResourceClosingTest {
throw new IllegalStateException("Cannot build list for unexpected Type: " + type);
}
private static boolean isAssignableFrom(Type type, Class<?> fromType) {
return (type instanceof Class<?>)
&& ((Class<?>) type).isAssignableFrom(fromType);
}
/* Initialize the map of test values to pass to methods to satisfy their signature. */
private static Map<Class<?>, Object> getDefaultParameters() {
HashedPassword hash = new HashedPassword("test", "test");
src/test/java/fr/xephi/authme/task/PurgeServiceTest.java → src/test/java/fr/xephi/authme/task/purge/PurgeServiceTest.java
+36 -48
View File
@@ -1,19 +1,13 @@
package fr.xephi.authme.task;
package fr.xephi.authme.task.purge;
import ch.jalu.injector.testing.BeforeInjecting;
import ch.jalu.injector.testing.DelayedInjectionRunner;
import ch.jalu.injector.testing.InjectDelayed;
import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.datasource.DataSource;
import fr.xephi.authme.hooks.PluginHooks;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PlayerStatePermission;
import fr.xephi.authme.settings.NewSetting;
import fr.xephi.authme.settings.properties.PurgeSettings;
import fr.xephi.authme.util.BukkitService;
import org.bukkit.OfflinePlayer;
import org.bukkit.Server;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.hamcrest.Matchers;
@@ -21,10 +15,14 @@ import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.UUID;
@@ -32,7 +30,6 @@ import static com.google.common.collect.Sets.newHashSet;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.equalToIgnoringCase;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.not;
import static org.junit.Assert.assertThat;
@@ -49,10 +46,10 @@ import static org.mockito.Mockito.verifyZeroInteractions;
/**
* Test for {@link PurgeService}.
*/
@RunWith(DelayedInjectionRunner.class)
@RunWith(MockitoJUnitRunner.class)
public class PurgeServiceTest {
@InjectDelayed
@InjectMocks
private PurgeService purgeService;
@Mock
@@ -64,24 +61,18 @@ public class PurgeServiceTest {
@Mock
private PermissionsManager permissionsManager;
@Mock
private PluginHooks pluginHooks;
@Mock
private Server server;
private PurgeExecutor executor;
@BeforeClass
public static void initLogger() {
TestHelper.setupLogger();
}
@BeforeInjecting
public void initSettingDefaults() {
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
}
@Test
public void shouldNotRunAutoPurge() {
// given
given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(false);
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
// when
purgeService.runAutoPurge();
@@ -95,7 +86,6 @@ public class PurgeServiceTest {
// given
given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(true);
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(0);
purgeService.reload();
// when
purgeService.runAutoPurge();
@@ -109,10 +99,9 @@ public class PurgeServiceTest {
// given
given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(true);
given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
String[] playerNames = {"alpha", "bravo", "charlie", "delta"};
given(dataSource.getRecordsToPurge(anyLong())).willReturn(newHashSet(playerNames));
Set<String> playerNames = newHashSet("alpha", "bravo", "charlie", "delta");
given(dataSource.getRecordsToPurge(anyLong())).willReturn(playerNames);
mockReturnedOfflinePlayers();
mockHasBypassPurgePermission("bravo", "delta");
// when
purgeService.runAutoPurge();
@@ -121,13 +110,13 @@ public class PurgeServiceTest {
ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
verify(dataSource).getRecordsToPurge(captor.capture());
assertCorrectPurgeTimestamp(captor.getValue(), 60);
verify(dataSource).purgeRecords(newHashSet("alpha", "charlie"));
assertThat(purgeService.isPurging(), equalTo(true));
verifyScheduledPurgeTask(null, "alpha", "charlie");
assertThat(Boolean.TRUE, equalTo(
ReflectionTestUtils.getFieldValue(PurgeService.class, purgeService, "isPurging")));
verifyScheduledPurgeTask(null, playerNames);
}
@SuppressWarnings("unchecked")
@Test
@SuppressWarnings("unchecked")
public void shouldRecognizeNoPlayersToPurge() {
// given
long delay = 123012301L;
@@ -148,9 +137,9 @@ public class PurgeServiceTest {
public void shouldRunPurge() {
// given
long delay = 1809714L;
given(dataSource.getRecordsToPurge(delay)).willReturn(newHashSet("charlie", "delta", "echo", "foxtrot"));
Set<String> playerNames = newHashSet("charlie", "delta", "echo", "foxtrot");
given(dataSource.getRecordsToPurge(delay)).willReturn(playerNames);
mockReturnedOfflinePlayers();
mockHasBypassPurgePermission("echo");
Player sender = mock(Player.class);
UUID uuid = UUID.randomUUID();
given(sender.getUniqueId()).willReturn(uuid);
@@ -160,13 +149,11 @@ public class PurgeServiceTest {
// then
verify(dataSource).getRecordsToPurge(delay);
verify(dataSource).purgeRecords(newHashSet("charlie", "delta", "foxtrot"));
verify(sender).sendMessage(argThat(containsString("Deleted 3 user accounts")));
verifyScheduledPurgeTask(uuid, "charlie", "delta", "foxtrot");
verifyScheduledPurgeTask(uuid, playerNames);
}
@Test
public void shouldRunPurgeIfProcessIsAlreadyRunning() {
public void shouldNotRunPurgeIfProcessIsAlreadyRunning() {
// given
purgeService.setPurging(true);
CommandSender sender = mock(CommandSender.class);
@@ -180,6 +167,19 @@ public class PurgeServiceTest {
verifyZeroInteractions(bukkitService, dataSource, permissionsManager);
}
@Test
public void shouldExecutePurgeActions() {
// given
List<OfflinePlayer> players = Arrays.asList(mockReturnedOfflinePlayers());
List<String> names = Arrays.asList("alpha", "bravo", "foxtrot");
// when
purgeService.executePurge(players, names);
// then
verify(executor).executePurge(players, names);
}
/**
* Returns mock OfflinePlayer objects with names corresponding to A - G of the NATO phonetic alphabet,
* in various casing.
@@ -198,18 +198,6 @@ public class PurgeServiceTest {
return players;
}
/**
* Mocks the permission manager to say that the given names have the bypass purge permission.
*
* @param names the names
*/
private void mockHasBypassPurgePermission(String... names) {
for (String name : names) {
given(permissionsManager.hasPermissionOffline(
argThat(equalToIgnoringCase(name)), eq(PlayerStatePermission.BYPASS_PURGE))).willReturn(true);
}
}
private void assertCorrectPurgeTimestamp(long timestamp, int configuredDays) {
final long toleranceMillis = 100L;
Calendar cal = Calendar.getInstance();
@@ -221,14 +209,14 @@ public class PurgeServiceTest {
}
@SuppressWarnings("unchecked")
private void verifyScheduledPurgeTask(UUID uuid, String... names) {
private void verifyScheduledPurgeTask(UUID senderUuid, Set<String> names) {
ArgumentCaptor<PurgeTask> captor = ArgumentCaptor.forClass(PurgeTask.class);
verify(bukkitService).runTaskAsynchronously(captor.capture());
verify(bukkitService).runTaskTimer(captor.capture(), eq(0L), eq(1L));
PurgeTask task = captor.getValue();
Object senderInTask = ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "sender");
Set<String> namesInTask = (Set<String>) ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "toPurge");
assertThat(senderInTask, Matchers.<Object>equalTo(uuid));
assertThat(namesInTask, containsInAnyOrder(names));
assertThat(senderInTask, Matchers.<Object>equalTo(senderUuid));
assertThat(namesInTask, containsInAnyOrder(names.toArray()));
}
}
src/test/java/fr/xephi/authme/task/purge/PurgeTaskTest.java
+221
View File
@@ -0,0 +1,221 @@
package fr.xephi.authme.task.purge;
import fr.xephi.authme.ReflectionTestUtils;
import fr.xephi.authme.TestHelper;
import fr.xephi.authme.permission.PermissionNode;
import fr.xephi.authme.permission.PermissionsManager;
import fr.xephi.authme.permission.PlayerStatePermission;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.Server;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitScheduler;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.runners.MockitoJUnitRunner;
import org.mockito.stubbing.Answer;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import static com.google.common.collect.Sets.newHashSet;
import static org.hamcrest.Matchers.containsInAnyOrder;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.empty;
import static org.junit.Assert.assertThat;
import static org.mockito.BDDMockito.given;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
/**
* Test for {@link PurgeTask}.
*/
@RunWith(MockitoJUnitRunner.class)
public class PurgeTaskTest {
private static final PermissionNode BYPASS_NODE = PlayerStatePermission.BYPASS_PURGE;
private Map<OfflinePlayer, Boolean> playerBypassAssignments = new HashMap<>();
@Mock
private PermissionsManager permissionsManager;
@Mock
private PurgeService purgeService;
@Captor
private ArgumentCaptor<Collection<OfflinePlayer>> playerCaptor;
@Captor
private ArgumentCaptor<Collection<String>> namesCaptor;
@BeforeClass
public static void initLogger() {
TestHelper.setupLogger();
}
@Test
public void shouldRunTask() {
// given
Set<String> names =
newHashSet("alpha", "bravo", "charlie", "delta", "echo", "foxtrot", "golf", "hotel", "india");
// alpha and echo have bypass permission
// Foxtrot and india are not present as OfflinePlayer
// Additionally, BOGUS and 123456 are not present in the names list
OfflinePlayer[] players = asArray(
mockOfflinePlayer("Alpha", true), mockOfflinePlayer("BOGUS", false), mockOfflinePlayer("charlie", false),
mockOfflinePlayer("Delta", false), mockOfflinePlayer("BRAVO", false), mockOfflinePlayer("Echo", true),
mockOfflinePlayer("Golf", false), mockOfflinePlayer("123456", false), mockOfflinePlayer("HOTEL", false));
reset(purgeService, permissionsManager);
setPermissionsBehavior();
PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, players);
// when (1 - first run, 5 players per run)
task.run();
// then (1)
// In the first run, Alpha to BRAVO (see players list above) went through. One of those players is not present
// in the names list, so expect the permission manager to have been called four times
verify(permissionsManager, times(4)).hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE));
// Alpha has the bypass permission, so we expect charlie, Delta and BRAVO to be purged
assertRanPurgeWithPlayers(players[2], players[3], players[4]);
// when (2)
reset(purgeService, permissionsManager);
setPermissionsBehavior();
task.run();
// then (2)
// Echo, Golf, HOTEL
verify(permissionsManager, times(3)).hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE));
assertRanPurgeWithPlayers(players[6], players[8]);
// given (3)
// Third round: no more OfflinePlayer objects, but some names remain
reset(purgeService, permissionsManager);
given(permissionsManager.hasPermissionOffline("india", BYPASS_NODE)).willReturn(true);
// when (3)
task.run();
// then (3)
// We no longer have any OfflinePlayers, so lookup of permissions was done with the names
verify(permissionsManager, times(2)).hasPermissionOffline(anyString(), eq(BYPASS_NODE));
verify(permissionsManager, never()).hasPermissionOffline(any(OfflinePlayer.class), any(PermissionNode.class));
assertRanPurgeWithNames("foxtrot");
}
@Test
public void shouldStopTaskAndInformSenderUponCompletion() {
// given
Set<String> names = newHashSet("name1", "name2");
Player sender = mock(Player.class);
UUID uuid = UUID.randomUUID();
given(sender.getUniqueId()).willReturn(uuid);
PurgeTask task = new PurgeTask(purgeService, permissionsManager, sender, names, new OfflinePlayer[0]);
ReflectionTestUtils.setField(BukkitRunnable.class, task, "taskId", 10049);
Server server = mock(Server.class);
BukkitScheduler scheduler = mock(BukkitScheduler.class);
given(server.getScheduler()).willReturn(scheduler);
ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
given(server.getPlayer(uuid)).willReturn(sender);
task.run(); // Run for the first time -> results in empty names list
// when
task.run();
// then
verify(scheduler).cancelTask(task.getTaskId());
verify(sender).sendMessage(argThat(containsString("Database has been purged successfully")));
}
@Test
public void shouldStopTaskAndInformConsoleUser() {
// given
Set<String> names = newHashSet("name1", "name2");
PurgeTask task = new PurgeTask(purgeService, permissionsManager, null, names, new OfflinePlayer[0]);
ReflectionTestUtils.setField(BukkitRunnable.class, task, "taskId", 10049);
Server server = mock(Server.class);
BukkitScheduler scheduler = mock(BukkitScheduler.class);
given(server.getScheduler()).willReturn(scheduler);
ReflectionTestUtils.setField(Bukkit.class, null, "server", server);
ConsoleCommandSender consoleSender = mock(ConsoleCommandSender.class);
given(server.getConsoleSender()).willReturn(consoleSender);
task.run(); // Run for the first time -> results in empty names list
// when
task.run();
// then
verify(scheduler).cancelTask(task.getTaskId());
verify(consoleSender).sendMessage(argThat(containsString("Database has been purged successfully")));
}
private OfflinePlayer mockOfflinePlayer(String name, boolean hasBypassPermission) {
OfflinePlayer player = mock(OfflinePlayer.class);
given(player.getName()).willReturn(name);
playerBypassAssignments.put(player, hasBypassPermission);
return player;
}
private OfflinePlayer[] asArray(OfflinePlayer... players) {
return players;
}
private void setPermissionsBehavior() {
given(permissionsManager.hasPermissionOffline(any(OfflinePlayer.class), eq(BYPASS_NODE)))
.willAnswer(new Answer<Boolean>() {
@Override
public Boolean answer(InvocationOnMock invocationOnMock) throws Throwable {
OfflinePlayer player = (OfflinePlayer) invocationOnMock.getArguments()[0];
Boolean hasPermission = playerBypassAssignments.get(player);
if (hasPermission == null) {
throw new IllegalStateException("Unexpected check of '" + BYPASS_NODE
+ "' with player = " + player);
}
return hasPermission;
}
});
}
private void assertRanPurgeWithPlayers(OfflinePlayer... players) {
List<String> names = new ArrayList<>(players.length);
for (OfflinePlayer player : players) {
names.add(player.getName());
}
verify(purgeService).executePurge(playerCaptor.capture(), namesCaptor.capture());
assertThat(namesCaptor.getValue(), containsInAnyOrder(names.toArray()));
assertThat(playerCaptor.getValue(), containsInAnyOrder(players));
}
private void assertRanPurgeWithNames(String... names) {
verify(purgeService).executePurge(playerCaptor.capture(), namesCaptor.capture());
assertThat(namesCaptor.getValue(), containsInAnyOrder(names));
assertThat(playerCaptor.getValue(), empty());
}
}