#674 Create tests for purge commands and purge service

src/test/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommandTest.java

@@ -0,0 +1,74 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.task.PurgeService;
+import fr.xephi.authme.util.BukkitService;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import static com.google.common.collect.Sets.newHashSet;
+import static org.hamcrest.Matchers.arrayContainingInAnyOrder;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+/**
+ * Test for {@link PurgeBannedPlayersCommand}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PurgeBannedPlayersCommandTest {
+
+    @InjectMocks
+    private PurgeBannedPlayersCommand command;
+
+    @Mock
+    private PurgeService purgeService;
+
+    @Mock
+    private BukkitService bukkitService;
+
+    @Test
+    public void shouldForwardRequestToService() {
+        // given
+        String[] names = {"bannedPlayer", "other_banned", "evilplayer", "Someone"};
+        OfflinePlayer[] players = offlinePlayersWithNames(names);
+        given(bukkitService.getBannedPlayers()).willReturn(newHashSet(players));
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Collections.<String>emptyList());
+
+        // then
+        verify(bukkitService).getBannedPlayers();
+        verify(purgeService).purgePlayers(eq(sender), eq(asLowerCaseSet(names)),
+            argThat(arrayContainingInAnyOrder(players)));
+    }
+
+    private static OfflinePlayer[] offlinePlayersWithNames(String... names) {
+        OfflinePlayer[] players = new OfflinePlayer[names.length];
+        for (int i = 0; i < names.length; ++i) {
+            OfflinePlayer player = mock(OfflinePlayer.class);
+            given(player.getName()).willReturn(names[i]);
+            players[i] = player;
+        }
+        return players;
+    }
+
+    private static Set<String> asLowerCaseSet(String... items) {
+        Set<String> result = new HashSet<>(items.length);
+        for (String item : items) {
+            result.add(item.toLowerCase());
+        }
+        return result;
+    }
+}

src/test/java/fr/xephi/authme/command/executable/authme/PurgeCommandTest.java

@@ -0,0 +1,89 @@
+package fr.xephi.authme.command.executable.authme;
+
+import fr.xephi.authme.task.PurgeService;
+import org.bukkit.command.CommandSender;
+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.Calendar;
+import java.util.Collections;
+
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.not;
+import static org.junit.Assert.assertThat;
+import static org.mockito.Matchers.argThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
+/**
+ * Test for {@link PurgeCommand}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PurgeCommandTest {
+
+    @InjectMocks
+    private PurgeCommand command;
+
+    @Mock
+    private PurgeService purgeService;
+
+    @Test
+    public void shouldHandleInvalidNumber() {
+        // given
+        String interval = "invalid";
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(interval));
+
+        // then
+        verify(sender).sendMessage(argThat(containsString("The value you've entered is invalid")));
+        verifyZeroInteractions(purgeService);
+    }
+
+    @Test
+    public void shouldRejectTooSmallInterval() {
+        // given
+        String interval = "29";
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(interval));
+
+        // then
+        verify(sender).sendMessage(argThat(containsString("You can only purge data older than 30 days")));
+        verifyZeroInteractions(purgeService);
+    }
+
+    @Test
+    public void shouldForwardToService() {
+        // given
+        String interval = "45";
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Collections.singletonList(interval));
+
+        // then
+        ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
+        verify(purgeService).runPurge(eq(sender), captor.capture());
+
+        // Check the timestamp with a certain tolerance
+        int toleranceMillis = 100;
+        Calendar calendar = Calendar.getInstance();
+        calendar.add(Calendar.DATE, -Integer.valueOf(interval));
+        assertIsCloseTo(captor.getValue(), calendar.getTimeInMillis(), toleranceMillis);
+    }
+
+    private static void assertIsCloseTo(long value1, long value2, long tolerance) {
+        assertThat(Math.abs(value1 - value2), not(greaterThan(tolerance)));
+    }
+
+}