#886 Do not include players with lastlogin = 0 in autopurge or default purge

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

@@ -9,6 +9,7 @@ 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;
 
@@ -73,7 +74,7 @@ public class PurgeCommandTest {
 
         // then
         ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
-        verify(purgeService).runPurge(eq(sender), captor.capture());
+        verify(purgeService).runPurge(eq(sender), captor.capture(), eq(false));
 
         // Check the timestamp with a certain tolerance
         int toleranceMillis = 100;
@@ -82,6 +83,41 @@ public class PurgeCommandTest {
         assertIsCloseTo(captor.getValue(), calendar.getTimeInMillis(), toleranceMillis);
     }
 
+    @Test
+    public void shouldProcessCommandWithAllParameter() {
+        // given
+        String interval = "32";
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Arrays.asList(interval, "all"));
+
+        // then
+        ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
+        verify(purgeService).runPurge(eq(sender), captor.capture(), eq(true));
+
+        // 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);
+    }
+
+    @Test
+    public void shouldRejectCommandWithInvalidSecondParameter() {
+        // given
+        String interval = "80";
+        CommandSender sender = mock(CommandSender.class);
+
+        // when
+        command.executeCommand(sender, Arrays.asList(interval, "bogus"));
+
+        // then
+        verify(sender).sendMessage(
+            argThat(containsString("Purge process aborted; use '/authme purge " + interval + " all'")));
+        verifyZeroInteractions(purgeService);
+    }
+
     private static void assertIsCloseTo(long value1, long value2, long tolerance) {
         assertThat(Math.abs(value1 - value2), not(greaterThan(tolerance)));
     }

src/test/java/fr/xephi/authme/datasource/AbstractDataSourceIntegrationTest.java

@@ -328,14 +328,16 @@ public abstract class AbstractDataSourceIntegrationTest {
     public void shouldGetRecordsToPurge() {
         // given
         DataSource dataSource = getDataSource();
-        // 1453242857 -> user, 1449136800 -> bobby
+        PlayerAuth auth = PlayerAuth.builder().name("potato").lastLogin(0).build();
+        dataSource.saveAuth(auth);
+        // 1453242857 -> user, 1449136800 -> bobby, 0 -> potato
 
         // when
-        Set<String> records1 = dataSource.getRecordsToPurge(1450000000);
-        Set<String> records2 = dataSource.getRecordsToPurge(1460000000);
+        Set<String> records1 = dataSource.getRecordsToPurge(1450000000, true);
+        Set<String> records2 = dataSource.getRecordsToPurge(1460000000, false);
 
         // then
-        assertThat(records1, contains("bobby"));
+        assertThat(records1, containsInAnyOrder("bobby", "potato"));
         assertThat(records2, containsInAnyOrder("bobby", "user"));
         // check that the entry was not deleted because of running this command
         assertThat(dataSource.isAuthAvailable("bobby"), equalTo(true));

src/test/java/fr/xephi/authme/datasource/AbstractResourceClosingTest.java

@@ -241,6 +241,7 @@ public abstract class AbstractResourceClosingTest {
             .put(String.class, "test")
             .put(int.class, 3)
             .put(long.class, 102L)
+            .put(boolean.class, true)
             .put(PlayerAuth.class, PlayerAuth.builder().name("test").realName("test").password(hash).build())
             .put(HashedPassword.class, hash)
             .build();

src/test/java/fr/xephi/authme/task/purge/PurgeServiceTest.java

@@ -10,7 +10,6 @@ import fr.xephi.authme.util.BukkitService;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
-import org.hamcrest.Matchers;
 import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -100,7 +99,7 @@ public class PurgeServiceTest {
         given(settings.getProperty(PurgeSettings.USE_AUTO_PURGE)).willReturn(true);
         given(settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER)).willReturn(60);
         Set<String> playerNames = newHashSet("alpha", "bravo", "charlie", "delta");
-        given(dataSource.getRecordsToPurge(anyLong())).willReturn(playerNames);
+        given(dataSource.getRecordsToPurge(anyLong(), eq(false))).willReturn(playerNames);
         mockReturnedOfflinePlayers();
 
         // when
@@ -108,7 +107,7 @@ public class PurgeServiceTest {
 
         // then
         ArgumentCaptor<Long> captor = ArgumentCaptor.forClass(Long.class);
-        verify(dataSource).getRecordsToPurge(captor.capture());
+        verify(dataSource).getRecordsToPurge(captor.capture(), eq(false));
         assertCorrectPurgeTimestamp(captor.getValue(), 60);
         assertThat(Boolean.TRUE, equalTo(
             ReflectionTestUtils.getFieldValue(PurgeService.class, purgeService, "isPurging")));
@@ -118,15 +117,16 @@ public class PurgeServiceTest {
     @Test
     public void shouldRecognizeNoPlayersToPurge() {
         // given
-        long delay = 123012301L;
-        given(dataSource.getRecordsToPurge(delay)).willReturn(Collections.<String>emptySet());
+        final long delay = 123012301L;
+        final boolean includeLastLoginZeroEntries = true;
+        given(dataSource.getRecordsToPurge(delay, includeLastLoginZeroEntries)).willReturn(Collections.<String>emptySet());
         CommandSender sender = mock(CommandSender.class);
 
         // when
-        purgeService.runPurge(sender, delay);
+        purgeService.runPurge(sender, delay, includeLastLoginZeroEntries);
 
         // then
-        verify(dataSource).getRecordsToPurge(delay);
+        verify(dataSource).getRecordsToPurge(delay, includeLastLoginZeroEntries);
         verify(dataSource, never()).purgeRecords(anyCollectionOf(String.class));
         verify(sender).sendMessage("No players to purge");
         verifyZeroInteractions(bukkitService, permissionsManager);
@@ -135,19 +135,20 @@ public class PurgeServiceTest {
     @Test
     public void shouldRunPurge() {
         // given
-        long delay = 1809714L;
+        final long delay = 1809714L;
+        final boolean includeLastLoginZeroEntries = false;
         Set<String> playerNames = newHashSet("charlie", "delta", "echo", "foxtrot");
-        given(dataSource.getRecordsToPurge(delay)).willReturn(playerNames);
+        given(dataSource.getRecordsToPurge(delay, includeLastLoginZeroEntries)).willReturn(playerNames);
         mockReturnedOfflinePlayers();
         Player sender = mock(Player.class);
         UUID uuid = UUID.randomUUID();
         given(sender.getUniqueId()).willReturn(uuid);
 
         // when
-        purgeService.runPurge(sender, delay);
+        purgeService.runPurge(sender, delay, includeLastLoginZeroEntries);
 
         // then
-        verify(dataSource).getRecordsToPurge(delay);
+        verify(dataSource).getRecordsToPurge(delay, includeLastLoginZeroEntries);
         verifyScheduledPurgeTask(uuid, playerNames);
     }
 
@@ -214,7 +215,7 @@ public class PurgeServiceTest {
 
         Object senderInTask = ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "sender");
         Set<String> namesInTask = ReflectionTestUtils.getFieldValue(PurgeTask.class, task, "toPurge");
-        assertThat(senderInTask, Matchers.<Object>equalTo(senderUuid));
+        assertThat(senderInTask, equalTo(senderUuid));
         assertThat(namesInTask, containsInAnyOrder(names.toArray()));
     }
 }