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

src/main/java/fr/xephi/authme/AuthMe.java

@@ -48,7 +48,7 @@ import fr.xephi.authme.settings.properties.RestrictionSettings;
 import fr.xephi.authme.settings.properties.SecuritySettings;
 import fr.xephi.authme.settings.properties.SettingsFieldRetriever;
 import fr.xephi.authme.settings.propertymap.PropertyMap;
-import fr.xephi.authme.task.PurgeService;
+import fr.xephi.authme.task.purge.PurgeService;
 import fr.xephi.authme.util.BukkitService;
 import fr.xephi.authme.util.FileUtils;
 import fr.xephi.authme.util.GeoLiteAPI;

src/main/java/fr/xephi/authme/command/executable/authme/PurgeBannedPlayersCommand.java

@@ -1,7 +1,7 @@
 package fr.xephi.authme.command.executable.authme;
 
 import fr.xephi.authme.command.ExecutableCommand;
-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/main/java/fr/xephi/authme/command/executable/authme/PurgeCommand.java

@@ -1,7 +1,7 @@
 package fr.xephi.authme.command.executable.authme;
 
 import fr.xephi.authme.command.ExecutableCommand;
-import fr.xephi.authme.task.PurgeService;
+import fr.xephi.authme.task.purge.PurgeService;
 import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
 

src/main/java/fr/xephi/authme/datasource/CacheDataSource.java

@@ -15,6 +15,7 @@ import fr.xephi.authme.cache.auth.PlayerCache;
 import fr.xephi.authme.security.crypts.HashedPassword;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Callable;
@@ -184,7 +185,7 @@ public class CacheDataSource implements DataSource {
     }
 
     @Override
-    public void purgeRecords(final Set<String> banned) {
+    public void purgeRecords(final Collection<String> banned) {
         source.purgeRecords(banned);
         cachedAuths.invalidateAll(banned);
     }

src/main/java/fr/xephi/authme/datasource/DataSource.java

@@ -4,6 +4,7 @@ import fr.xephi.authme.cache.auth.PlayerAuth;
 import fr.xephi.authme.initialization.Reloadable;
 import fr.xephi.authme.security.crypts.HashedPassword;
 
+import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 
@@ -82,7 +83,7 @@ public interface DataSource extends Reloadable {
      *
      * @param toPurge The players to purge
      */
-    void purgeRecords(Set<String> toPurge);
+    void purgeRecords(Collection<String> toPurge);
 
     /**
      * Remove a user record from the database.

src/main/java/fr/xephi/authme/datasource/FlatFile.java

@@ -17,6 +17,7 @@ import java.io.FileReader;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -256,35 +257,8 @@ public class FlatFile implements DataSource {
     }
 
     @Override
-    public void purgeRecords(Set<String> toPurge) {
+    public void purgeRecords(Collection<String> toPurge) {
-        BufferedReader br = null;
+        throw new UnsupportedOperationException("Flat file no longer supported");
-        BufferedWriter bw = null;
-        ArrayList<String> lines = new ArrayList<>();
-
-        try {
-            br = new BufferedReader(new FileReader(source));
-            bw = new BufferedWriter(new FileWriter(source));
-            String line;
-            while ((line = br.readLine()) != null) {
-                String[] args = line.split(":");
-                if (args.length >= 4) {
-                    if (toPurge.contains(args[0])) {
-                        lines.add(line);
-                        continue;
-                    }
-                }
-            }
-
-            for (String l : lines) {
-                bw.write(l + "\n");
-            }
-        } catch (IOException ex) {
-            ConsoleLogger.warning(ex.getMessage());
-            return;
-        } finally {
-            silentClose(br);
-            silentClose(bw);
-        }
     }
 
     @Override

src/main/java/fr/xephi/authme/datasource/MySQL.java

@@ -23,6 +23,7 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.sql.Types;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -693,11 +694,11 @@ public class MySQL implements DataSource {
     }
 
     @Override
-    public void purgeRecords(Set<String> toPurge) {
+    public void purgeRecords(Collection<String> toPurge) {
         String sql = "DELETE FROM " + tableName + " WHERE " + col.NAME + "=?;";
         try (Connection con = getConnection(); PreparedStatement pst = con.prepareStatement(sql)) {
             for (String name : toPurge) {
-                pst.setString(1, name);
+                pst.setString(1, name.toLowerCase());
                 pst.executeUpdate();
             }
         } catch (SQLException ex) {

src/main/java/fr/xephi/authme/datasource/SQLite.java

@@ -16,6 +16,7 @@ import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -317,11 +318,11 @@ public class SQLite implements DataSource {
     }
 
     @Override
-    public void purgeRecords(Set<String> toPurge) {
+    public void purgeRecords(Collection<String> toPurge) {
         String delete = "DELETE FROM " + tableName + " WHERE " + col.NAME + "=?;";
         try (PreparedStatement deletePst = con.prepareStatement(delete)) {
             for (String name : toPurge) {
-                deletePst.setString(1, name);
+                deletePst.setString(1, name.toLowerCase());
                 deletePst.executeUpdate();
             }
         } catch (SQLException ex) {

src/main/java/fr/xephi/authme/permission/DefaultPermission.java

@@ -1,6 +1,6 @@
 package fr.xephi.authme.permission;
 
-import org.bukkit.command.CommandSender;
+import org.bukkit.permissions.ServerOperator;
 
 /**
  * The default permission to fall back to if there is no support for permission nodes.
@@ -10,12 +10,7 @@ public enum DefaultPermission {
     /** No one has permission. */
     NOT_ALLOWED("No permission") {
         @Override
-        public boolean evaluate(CommandSender sender) {
+        public boolean evaluate(ServerOperator sender) {
-            return false;
-        }
-
-        @Override
-        public boolean evaluateOffline(String name) {
             return false;
         }
     },
@@ -23,26 +18,15 @@ public enum DefaultPermission {
     /** Only players with OP status have permission. */
     OP_ONLY("OP's only") {
         @Override
-        public boolean evaluate(CommandSender sender) {
+        public boolean evaluate(ServerOperator sender) {
-            return sender.isOp();
+            return sender != null && sender.isOp();
-        }
-
-        @Override
-        public boolean evaluateOffline(String name) {
-            // TODO #784: Check if there is an elegant way to evaluate OP status
-            return false;
         }
     },
 
     /** Everyone is granted permission. */
     ALLOWED("Everyone allowed") {
         @Override
-        public boolean evaluate(CommandSender sender) {
+        public boolean evaluate(ServerOperator sender) {
-            return true;
-        }
-
-        @Override
-        public boolean evaluateOffline(String name) {
             return true;
         }
     };
@@ -64,15 +48,7 @@ public enum DefaultPermission {
      * @param sender the sender to process
      * @return true if the sender has permission, false otherwise
      */
-    public abstract boolean evaluate(CommandSender sender);
+    public abstract boolean evaluate(ServerOperator sender);
-
-    /**
-     * Evaluate whether permission is granted to an offline user.
-     *
-     * @param name The name to check
-     * @return True if the user has permission, false otherwise
-     */
-    public abstract boolean evaluateOffline(String name);
 
     /**
      * Return the textual representation.

src/main/java/fr/xephi/authme/permission/PermissionsManager.java

@@ -12,6 +12,7 @@ import fr.xephi.authme.permission.handlers.VaultHandler;
 import fr.xephi.authme.permission.handlers.ZPermissionsHandler;
 import fr.xephi.authme.util.StringUtils;
 import org.anjocaido.groupmanager.GroupManager;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.Server;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
@@ -210,22 +211,33 @@ public class PermissionsManager implements Reloadable {
      * Check if a player has permission for the given permission node. This is for offline player checks. If no permissions
      * system is used, then the player will not have permission.
      *
-     * @param name           The name of the player.
+     * @param player         The offline player
-     * @param permissionNode The permission node to verify.
+     * @param permissionNode The permission node to verify
      *
-     * @return
+     * @return true if the player has permission, false otherwise
      */
-    public boolean hasPermissionOffline(String name, PermissionNode permissionNode) {
+    public boolean hasPermissionOffline(OfflinePlayer player, PermissionNode permissionNode) {
         // Check if the permission node is null
         if (permissionNode == null) {
             return true;
         }
 
         if (!isEnabled()) {
-            return permissionNode.getDefaultPermission().evaluateOffline(name);
+            return permissionNode.getDefaultPermission().evaluate(player);
         }
 
-        return handler.hasPermission(name, permissionNode);
+        return handler.hasPermissionOffline(player.getName(), permissionNode);
+    }
+
+    public boolean hasPermissionOffline(String name, PermissionNode permissionNode) {
+        if (permissionNode == null) {
+            return true;
+        }
+        if (!isEnabled()) {
+            return permissionNode.getDefaultPermission().evaluate(null);
+        }
+
+        return handler.hasPermissionOffline(name, permissionNode);
     }
 
     /**

src/main/java/fr/xephi/authme/permission/handlers/BPermissionsHandler.java

@@ -28,7 +28,7 @@ public class BPermissionsHandler implements PermissionHandler {
     }
 
     @Override
-    public boolean hasPermission(String name, PermissionNode node) {
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
         return ApiLayer.hasPermission(null, CalculableType.USER, name, node.getNode());
     }
 

src/main/java/fr/xephi/authme/permission/handlers/GroupManagerHandler.java

@@ -36,7 +36,7 @@ public class GroupManagerHandler implements PermissionHandler {
     }
 
     @Override
-    public boolean hasPermission(String name, PermissionNode node) {
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
         final AnjoPermissionsHandler handler = groupManager.getWorldsHolder().getWorldPermissionsByPlayerName(name);
         List<String> perms = handler.getAllPlayersPermissions(name);
         return perms.contains(node.getNode());

src/main/java/fr/xephi/authme/permission/handlers/PermissionHandler.java

@@ -47,7 +47,7 @@ public interface PermissionHandler {
      *
      * @return True if the player has permission.
      */
-    boolean hasPermission(String name, PermissionNode node);
+    boolean hasPermissionOffline(String name, PermissionNode node);
 
     /**
      * Check whether the player is in the specified group.

src/main/java/fr/xephi/authme/permission/handlers/PermissionsBukkitHandler.java

@@ -26,7 +26,7 @@ public class PermissionsBukkitHandler implements PermissionHandler {
     }
 
     @Override
-    public boolean hasPermission(String name, PermissionNode node) {
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
         return false;
     }
 

src/main/java/fr/xephi/authme/permission/handlers/PermissionsExHandler.java

@@ -44,7 +44,7 @@ public class PermissionsExHandler implements PermissionHandler {
     }
 
     @Override
-    public boolean hasPermission(String name, PermissionNode node) {
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
         PermissionUser user = permissionManager.getUser(name);
         return user.has(node.getNode());
     }

src/main/java/fr/xephi/authme/permission/handlers/VaultHandler.java

@@ -50,7 +50,7 @@ public class VaultHandler implements PermissionHandler {
     }
 
     @Override
-    public boolean hasPermission(String name, PermissionNode node) {
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
         return vaultProvider.has("", name, node.getNode());
     }
 

src/main/java/fr/xephi/authme/permission/handlers/ZPermissionsHandler.java

@@ -43,7 +43,7 @@ public class ZPermissionsHandler implements PermissionHandler {
     }
 
     @Override
-    public boolean hasPermission(String name, PermissionNode node) {
+    public boolean hasPermissionOffline(String name, PermissionNode node) {
         Map<String, Boolean> perms = zPermissionsService.getPlayerPermissions(null, null, name);
         if (perms.containsKey(node.getNode()))
             return perms.get(node.getNode());

src/main/java/fr/xephi/authme/task/purge/PurgeExecutor.java

@@ -1,155 +1,67 @@
-package fr.xephi.authme.task;
+package fr.xephi.authme.task.purge;
 
 import fr.xephi.authme.ConsoleLogger;
 import fr.xephi.authme.datasource.DataSource;
 import fr.xephi.authme.hooks.PluginHooks;
-import fr.xephi.authme.initialization.Reloadable;
 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 fr.xephi.authme.util.CollectionUtils;
 import fr.xephi.authme.util.Utils;
 import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
 import org.bukkit.Server;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.ConsoleCommandSender;
 
-import javax.annotation.PostConstruct;
 import javax.inject.Inject;
 import java.io.File;
-import java.util.Calendar;
+import java.util.Collection;
-import java.util.HashSet;
-import java.util.Set;
 
 import static fr.xephi.authme.util.StringUtils.makePath;
 
-public class PurgeService implements Reloadable {
+/**
-
+ * Executes the purge operations.
-    @Inject
+ */
-    private BukkitService bukkitService;
+class PurgeExecutor {
-
-    @Inject
-    private DataSource dataSource;
 
     @Inject
     private NewSetting settings;
 
+    @Inject
+    private DataSource dataSource;
+
     @Inject
     private PermissionsManager permissionsManager;
 
     @Inject
     private PluginHooks pluginHooks;
 
+    @Inject
+    private BukkitService bukkitService;
+
     @Inject
     private Server server;
 
-    private boolean isPurging = false;
+    PurgeExecutor() {
-
-    // Settings
-    private int daysBeforePurge;
-
-    /**
-     * Return whether a purge is in progress.
-     *
-     * @return True if purging.
-     */
-    public boolean isPurging() {
-        return this.isPurging;
     }
 
     /**
-     * Set if a purge is currently in progress.
+     * Performs the purge operations, i.e. deletes data and removes the files associated with the given
+     * players and names.
      *
-     * @param purging True if purging.
+     * @param players the players to purge
+     * @param names names to purge
      */
-    void setPurging(boolean purging) {
+    public void executePurge(Collection<OfflinePlayer> players, Collection<String> names) {
-        this.isPurging = purging;
+        // Purge other data
+        purgeFromAuthMe(names);
+        purgeEssentials(players);
+        purgeDat(players);
+        purgeLimitedCreative(names);
+        purgeAntiXray(names);
+        purgePermissions(players);
     }
 
-    /**
+    synchronized void purgeAntiXray(Collection<String> cleared) {
-     * Purges players from the database. Run on startup if enabled.
-     */
-    public void runAutoPurge() {
-        if (!settings.getProperty(PurgeSettings.USE_AUTO_PURGE)) {
-            return;
-        } else if (daysBeforePurge <= 0) {
-            ConsoleLogger.warning("Did not run auto purge: configured days before purging must be positive");
-            return;
-        }
-
-        ConsoleLogger.info("Automatically purging the database...");
-        Calendar calendar = Calendar.getInstance();
-        calendar.add(Calendar.DATE, -daysBeforePurge);
-        long until = calendar.getTimeInMillis();
-
-        runPurge(null, until);
-    }
-
-    /**
-     * Run a purge with a specified time.
-     *
-     * @param sender Sender running the command.
-     * @param until The minimum last login.
-     */
-    public void runPurge(CommandSender sender, long until) {
-        //todo: note this should may run async because it may executes a SQL-Query
-        Set<String> initialPurge = dataSource.getRecordsToPurge(until);
-        if (CollectionUtils.isEmpty(initialPurge)) {
-            logAndSendMessage(sender, "No players to purge");
-            return;
-        }
-
-        Set<String> toPurge = getFinalPurgeList(initialPurge);
-        purgePlayers(sender, toPurge, bukkitService.getOfflinePlayers());
-    }
-
-    /**
-     * Purges the given list of player names.
-     *
-     * @param sender Sender running the command.
-     * @param names The names to remove.
-     * @param players Collection of OfflinePlayers (including those with the given names).
-     */
-    public void purgePlayers(CommandSender sender, Set<String> names, OfflinePlayer[] players) {
-        //todo: note this should may run async because it may executes a SQL-Query
-        if (isPurging) {
-            logAndSendMessage(sender, "Purge is already in progress! Aborting purge request");
-            return;
-        }
-
-        dataSource.purgeRecords(names);
-        logAndSendMessage(sender, ChatColor.GOLD + "Deleted " + names.size() + " user accounts");
-        logAndSendMessage(sender, ChatColor.GOLD + "Purging user accounts...");
-
-        isPurging = true;
-        PurgeTask purgeTask = new PurgeTask(this, sender, names, players);
-        bukkitService.runTaskAsynchronously(purgeTask);
-    }
-
-    /**
-     * Check each name in the initial purge findings to remove any player from the purge list
-     * that has the bypass permission.
-     *
-     * @param initial The initial list of players to purge.
-     *
-     * @return The list of players to purge after permission check.
-     */
-    private Set<String> getFinalPurgeList(Set<String> initial) {
-        Set<String> toPurge = new HashSet<>();
-
-        for (String name : initial) {
-            if (!permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_PURGE)) {
-                toPurge.add(name);
-            }
-        }
-
-        return toPurge;
-    }
-
-    synchronized void purgeAntiXray(Set<String> cleared) {
         if (!settings.getProperty(PurgeSettings.REMOVE_ANTI_XRAY_FILE)) {
             return;
         }
@@ -173,7 +85,18 @@ public class PurgeService implements Reloadable {
         ConsoleLogger.info("AutoPurge: Removed " + i + " AntiXRayData Files");
     }
 
-    synchronized void purgeLimitedCreative(Set<String> cleared) {
+    /**
+     * Deletes the given accounts from AuthMe.
+     *
+     * @param names the name of the accounts to delete
+     */
+    synchronized void purgeFromAuthMe(Collection<String> names) {
+        dataSource.purgeRecords(names);
+        // TODO ljacqu 20160717: We shouldn't output namedBanned.size() but the actual total that was deleted
+        ConsoleLogger.info(ChatColor.GOLD + "Deleted " + names.size() + " user accounts");
+    }
+
+    synchronized void purgeLimitedCreative(Collection<String> cleared) {
         if (!settings.getProperty(PurgeSettings.REMOVE_LIMITED_CREATIVE_INVENTORIES)) {
             return;
         }
@@ -214,7 +137,12 @@ public class PurgeService implements Reloadable {
         ConsoleLogger.info("AutoPurge: Removed " + i + " LimitedCreative Survival, Creative and Adventure files");
     }
 
-    synchronized void purgeDat(Set<OfflinePlayer> cleared) {
+    /**
+     * Removes the .dat file of the given players.
+     *
+     * @param cleared list of players to clear
+     */
+    synchronized void purgeDat(Collection<OfflinePlayer> cleared) {
         if (!settings.getProperty(PurgeSettings.REMOVE_PLAYER_DAT)) {
             return;
         }
@@ -234,11 +162,11 @@ public class PurgeService implements Reloadable {
     }
 
     /**
-     * Method purgeEssentials.
+     * Removes the Essentials userdata file of each given player.
      *
-     * @param cleared List of String
+     * @param cleared list of players to clear
      */
-    synchronized void purgeEssentials(Set<OfflinePlayer> cleared) {
+    synchronized void purgeEssentials(Collection<OfflinePlayer> cleared) {
         if (!settings.getProperty(PurgeSettings.REMOVE_ESSENTIALS_FILES)) {
             return;
         }
@@ -267,7 +195,7 @@ public class PurgeService implements Reloadable {
 
     // TODO: What is this method for? Is it correct?
     // TODO: Make it work with OfflinePlayers group data.
-    synchronized void purgePermissions(Set<OfflinePlayer> cleared) {
+    synchronized void purgePermissions(Collection<OfflinePlayer> cleared) {
         if (!settings.getProperty(PurgeSettings.REMOVE_PERMISSIONS)) {
             return;
         }
@@ -280,17 +208,4 @@ public class PurgeService implements Reloadable {
         ConsoleLogger.info("AutoPurge: Removed permissions from " + cleared.size() + " player(s).");
     }
     
-    private static void logAndSendMessage(CommandSender sender, String message) {
-        ConsoleLogger.info(message);
-        // Make sure sender is not console user, which will see the message from ConsoleLogger already
-        if (sender != null && !(sender instanceof ConsoleCommandSender)) {
-            sender.sendMessage(message);
-        }
-    }
-
-    @PostConstruct
-    @Override
-    public void reload() {
-        this.daysBeforePurge = settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER);
-    }
 }

src/main/java/fr/xephi/authme/task/purge/PurgeService.java

@@ -0,0 +1,123 @@
+package fr.xephi.authme.task.purge;
+
+import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.datasource.DataSource;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.settings.NewSetting;
+import fr.xephi.authme.settings.properties.PurgeSettings;
+import fr.xephi.authme.util.BukkitService;
+import fr.xephi.authme.util.CollectionUtils;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.ConsoleCommandSender;
+
+import javax.inject.Inject;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Set;
+
+public class PurgeService {
+
+    @Inject
+    private BukkitService bukkitService;
+
+    @Inject
+    private DataSource dataSource;
+
+    @Inject
+    private NewSetting settings;
+
+    @Inject
+    private PermissionsManager permissionsManager;
+
+    @Inject
+    private PurgeExecutor purgeExecutor;
+
+    private boolean isPurging = false;
+
+    PurgeService() {
+    }
+
+    /**
+     * Purges players from the database. Runs on startup if enabled.
+     */
+    public void runAutoPurge() {
+        int daysBeforePurge = settings.getProperty(PurgeSettings.DAYS_BEFORE_REMOVE_PLAYER);
+        if (!settings.getProperty(PurgeSettings.USE_AUTO_PURGE)) {
+            return;
+        } else if (daysBeforePurge <= 0) {
+            ConsoleLogger.warning("Did not run auto purge: configured days before purging must be positive");
+            return;
+        }
+
+        ConsoleLogger.info("Automatically purging the database...");
+        Calendar calendar = Calendar.getInstance();
+        calendar.add(Calendar.DATE, -daysBeforePurge);
+        long until = calendar.getTimeInMillis();
+
+        runPurge(null, until);
+    }
+
+    /**
+     * Runs a purge with a specified last login threshold. Players who haven't logged in since the threshold
+     * will be purged.
+     *
+     * @param sender Sender running the command
+     * @param until The last login threshold in milliseconds
+     */
+    public void runPurge(CommandSender sender, long until) {
+        //todo: note this should may run async because it may executes a SQL-Query
+        Set<String> toPurge = dataSource.getRecordsToPurge(until);
+        if (CollectionUtils.isEmpty(toPurge)) {
+            logAndSendMessage(sender, "No players to purge");
+            return;
+        }
+
+        purgePlayers(sender, toPurge, bukkitService.getOfflinePlayers());
+    }
+
+    /**
+     * Purges the given list of player names.
+     *
+     * @param sender Sender running the command
+     * @param names The names to remove
+     * @param players Collection of OfflinePlayers (including those with the given names)
+     */
+    public void purgePlayers(CommandSender sender, Set<String> names, OfflinePlayer[] players) {
+        if (isPurging) {
+            logAndSendMessage(sender, "Purge is already in progress! Aborting purge request");
+            return;
+        }
+
+        isPurging = true;
+        PurgeTask purgeTask = new PurgeTask(this, permissionsManager, sender, names, players);
+        bukkitService.runTaskTimer(purgeTask, 0, 1);
+    }
+
+    /**
+     * Set if a purge is currently in progress.
+     *
+     * @param purging True if purging.
+     */
+    void setPurging(boolean purging) {
+        this.isPurging = purging;
+    }
+
+    /**
+     * Perform purge operations for the given players and names.
+     *
+     * @param players the players (associated with the names)
+     * @param names the lowercase names
+     */
+    void executePurge(Collection<OfflinePlayer> players, Collection<String> names) {
+        purgeExecutor.executePurge(players, names);
+    }
+
+    private static void logAndSendMessage(CommandSender sender, String message) {
+        ConsoleLogger.info(message);
+        // Make sure sender is not console user, which will see the message from ConsoleLogger already
+        if (sender != null && !(sender instanceof ConsoleCommandSender)) {
+            sender.sendMessage(message);
+        }
+    }
+}

src/main/java/fr/xephi/authme/task/purge/PurgeTask.java

@@ -1,6 +1,8 @@
-package fr.xephi.authme.task;
+package fr.xephi.authme.task.purge;
 
 import fr.xephi.authme.ConsoleLogger;
+import fr.xephi.authme.permission.PermissionsManager;
+import fr.xephi.authme.permission.PlayerStatePermission;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.OfflinePlayer;
@@ -12,12 +14,13 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.UUID;
 
-public class PurgeTask extends BukkitRunnable {
+class PurgeTask extends BukkitRunnable {
 
     //how many players we should check for each tick
-    private static final int INTERVALL_CHECK = 5;
+    private static final int INTERVAL_CHECK = 5;
 
     private final PurgeService purgeService;
+    private final PermissionsManager permissionsManager;
     private final UUID sender;
     private final Set<String> toPurge;
 
@@ -26,8 +29,20 @@ public class PurgeTask extends BukkitRunnable {
 
     private int currentPage = 0;
 
-    public PurgeTask(PurgeService service, CommandSender sender, Set<String> toPurge, OfflinePlayer[] offlinePlayers) {
+    /**
+     * Constructor.
+     *
+     * @param service the purge service
+     * @param permissionsManager the permissions manager
+     * @param sender the sender who initiated the purge, or null
+     * @param toPurge lowercase names to purge
+     * @param offlinePlayers offline players to map to the names
+     */
+    PurgeTask(PurgeService service, PermissionsManager permissionsManager, CommandSender sender,
+              Set<String> toPurge, OfflinePlayer[] offlinePlayers) {
         this.purgeService = service;
+        this.permissionsManager = permissionsManager;
+
         if (sender instanceof Player) {
             this.sender = ((Player) sender).getUniqueId();
         } else {
@@ -47,20 +62,21 @@ public class PurgeTask extends BukkitRunnable {
             return;
         }
 
-        Set<OfflinePlayer> playerPortion = new HashSet<OfflinePlayer>(INTERVALL_CHECK);
+        Set<OfflinePlayer> playerPortion = new HashSet<>(INTERVAL_CHECK);
-        Set<String> namePortion = new HashSet<String>(INTERVALL_CHECK);
+        Set<String> namePortion = new HashSet<>(INTERVAL_CHECK);
-        for (int i = 0; i < INTERVALL_CHECK; i++) {
+        for (int i = 0; i < INTERVAL_CHECK; i++) {
-            int nextPosition = (currentPage * INTERVALL_CHECK) + i;
+            int nextPosition = (currentPage * INTERVAL_CHECK) + i;
             if (offlinePlayers.length <= nextPosition) {
                 //no more offline players on this page
                 break;
             }
 
             OfflinePlayer offlinePlayer = offlinePlayers[nextPosition];
-            //remove to speed up later lookups
             if (toPurge.remove(offlinePlayer.getName().toLowerCase())) {
-                playerPortion.add(offlinePlayer);
+                if (!permissionsManager.hasPermissionOffline(offlinePlayer, PlayerStatePermission.BYPASS_PURGE)) {
-                namePortion.add(offlinePlayer.getName());
+                    playerPortion.add(offlinePlayer);
+                    namePortion.add(offlinePlayer.getName());
+                }
             }
         }
 
@@ -68,34 +84,29 @@ public class PurgeTask extends BukkitRunnable {
             ConsoleLogger.info("Finished lookup up offlinePlayers. Begin looking purging player names only");
 
             //we went through all offlineplayers but there are still names remaining
-            namePortion.addAll(toPurge);
+            for (String name : toPurge) {
+                if (!permissionsManager.hasPermissionOffline(name, PlayerStatePermission.BYPASS_PURGE)) {
+                    namePortion.add(name);
+                }
+            }
             toPurge.clear();
         }
 
         currentPage++;
-        purgeData(playerPortion, namePortion);
+        purgeService.executePurge(playerPortion, namePortion);
         if (currentPage % 20 == 0) {
             int completed = totalPurgeCount - toPurge.size();
             sendMessage("[AuthMe] Purge progress " + completed + '/' + totalPurgeCount);
         }
     }
 
-    private void purgeData(Set<OfflinePlayer> playerPortion, Set<String> namePortion) {
-        // Purge other data
-        purgeService.purgeEssentials(playerPortion);
-        purgeService.purgeDat(playerPortion);
-        purgeService.purgeLimitedCreative(namePortion);
-        purgeService.purgeAntiXray(namePortion);
-        purgeService.purgePermissions(playerPortion);
-    }
-
     private void finish() {
         cancel();
 
         // Show a status message
-        sendMessage(ChatColor.GREEN + "[AuthMe] Database has been purged correctly");
+        sendMessage(ChatColor.GREEN + "[AuthMe] Database has been purged successfully");
 
-        ConsoleLogger.info("Purge Finished!");
+        ConsoleLogger.info("Purge finished!");
         purgeService.setPurging(false);
     }
 

src/main/java/fr/xephi/authme/util/BukkitService.java

@@ -9,6 +9,9 @@ import org.bukkit.OfflinePlayer;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Event;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitScheduler;
 import org.bukkit.scheduler.BukkitTask;
 
 import javax.inject.Inject;
@@ -123,6 +126,22 @@ public class BukkitService {
         return Bukkit.getScheduler().runTaskLaterAsynchronously(authMe, task, delay);
     }
 
+    /**
+     * Schedules the given task to repeatedly run until cancelled, starting after the
+     * specified number of server ticks.
+     *
+     * @param task the task to schedule
+     * @param delay the ticks to wait before running the task
+     * @param period the ticks to wait between runs
+     * @return a BukkitTask that contains the id number
+     * @throws IllegalArgumentException if plugin is null
+     * @throws IllegalStateException if this was already scheduled
+     * @see BukkitScheduler#runTaskTimer(Plugin, Runnable, long, long)
+     */
+    public BukkitTask runTaskTimer(BukkitRunnable task, long delay, long period) {
+        return task.runTaskTimer(authMe, period, delay);
+    }
+
     /**
      * Broadcast a message to all players.
      *

src/test/java/fr/xephi/authme/AuthMeInitializationTest.java

@@ -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,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,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

@@ -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

@@ -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/purge/PurgeServiceTest.java

@@ -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;
+    private PurgeExecutor executor;
-    @Mock
-    private Server server;
 
     @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"};
+        Set<String> playerNames = newHashSet("alpha", "bravo", "charlie", "delta");
-        given(dataSource.getRecordsToPurge(anyLong())).willReturn(newHashSet(playerNames));
+        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(Boolean.TRUE, equalTo(
-        assertThat(purgeService.isPurging(), equalTo(true));
+            ReflectionTestUtils.getFieldValue(PurgeService.class, purgeService, "isPurging")));
-        verifyScheduledPurgeTask(null, "alpha", "charlie");
+        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"));
+        verifyScheduledPurgeTask(uuid, playerNames);
-        verify(sender).sendMessage(argThat(containsString("Deleted 3 user accounts")));
-        verifyScheduledPurgeTask(uuid, "charlie", "delta", "foxtrot");
     }
 
     @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(senderInTask, Matchers.<Object>equalTo(senderUuid));
-        assertThat(namesInTask, containsInAnyOrder(names));
+        assertThat(namesInTask, containsInAnyOrder(names.toArray()));
     }
 }

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

@@ -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());
+    }
+
+}