#1034 Create permissions for debug sections

- Add an individual permission for each debug section (including wildcard perm)
- Create test for DebugCommand
- Refactor tests for the enum permission nodes to use the same abstract class
- Update related project files (plugin.yml, permission docs, command docs)

src/test/java/fr/xephi/authme/command/executable/authme/debug/DebugCommandTest.java

@@ -0,0 +1,154 @@
+package fr.xephi.authme.command.executable.authme.debug;
+
+import fr.xephi.authme.initialization.factory.Factory;
+import fr.xephi.authme.permission.DebugSectionPermissions;
+import fr.xephi.authme.permission.PermissionNode;
+import fr.xephi.authme.permission.PermissionsManager;
+import org.bukkit.command.CommandSender;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Collections.emptyList;
+import static org.hamcrest.Matchers.contains;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.Assert.assertThat;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.hamcrest.MockitoHamcrest.argThat;
+
+/**
+ * Test for {@link DebugCommand}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class DebugCommandTest {
+
+    /**
+     * Number we test against if we expect an action to have been performed for each debug section.
+     * This is a minimum number so tests don't fail each time a new debug section is added; however,
+     * it should be close to the total.
+     */
+    private static final int MIN_DEBUG_SECTIONS = 9;
+
+    @InjectMocks
+    private DebugCommand command;
+
+    @Mock
+    private Factory<DebugSection> debugSectionFactory;
+
+    @Mock
+    private PermissionsManager permissionsManager;
+
+    @Before
+    @SuppressWarnings("unchecked")
+    public void initFactory() {
+        given(debugSectionFactory.newInstance(any(Class.class))).willAnswer(
+            invocation -> {
+                Class<?> classArgument = invocation.getArgument(0);
+                checkArgument(DebugSection.class.isAssignableFrom(classArgument));
+                return spy(classArgument);
+            });
+    }
+
+    @Test
+    public void shouldListAllAvailableDebugSections() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(false);
+        given(permissionsManager.hasPermission(sender, DebugSectionPermissions.INPUT_VALIDATOR)).willReturn(true);
+        given(permissionsManager.hasPermission(sender, DebugSectionPermissions.DATA_STATISTICS)).willReturn(true);
+
+        // when
+        command.executeCommand(sender, emptyList());
+
+        // then
+        verify(debugSectionFactory, atLeast(MIN_DEBUG_SECTIONS)).newInstance(any(Class.class));
+        verify(permissionsManager, atLeast(MIN_DEBUG_SECTIONS)).hasPermission(eq(sender), any(DebugSectionPermissions.class));
+
+        ArgumentCaptor<String> strCaptor = ArgumentCaptor.forClass(String.class);
+        verify(sender, times(3)).sendMessage(strCaptor.capture());
+        assertThat(strCaptor.getAllValues(), contains(
+            containsString("Sections available to you"),
+            containsString("stats: Outputs general data statistics"),
+            containsString("valid: Check if email / password is valid")));
+    }
+
+    @Test
+    public void shouldNotListAnyDebugSection() {
+        // given
+        CommandSender sender = mock(CommandSender.class);
+        given(permissionsManager.hasPermission(eq(sender), any(PermissionNode.class))).willReturn(false);
+
+        // when
+        command.executeCommand(sender, emptyList());
+
+        // then
+        verify(debugSectionFactory, atLeast(MIN_DEBUG_SECTIONS)).newInstance(any(Class.class));
+        verify(permissionsManager, atLeast(MIN_DEBUG_SECTIONS)).hasPermission(eq(sender), any(DebugSectionPermissions.class));
+
+        ArgumentCaptor<String> strCaptor = ArgumentCaptor.forClass(String.class);
+        verify(sender, times(2)).sendMessage(strCaptor.capture());
+        assertThat(strCaptor.getAllValues(), contains(
+            equalTo("Sections available to you:"),
+            containsString("You don't have permission to view any debug section")));
+    }
+
+    @Test
+    public void shouldRunSection() {
+        // given
+        DebugSection section = spy(InputValidator.class);
+        doNothing().when(section).execute(any(CommandSender.class), anyList());
+        // Mockito throws a runtime error if below we use the usual "given(factory.newInstance(...)).willReturn(...)"
+        doReturn(section).when(debugSectionFactory).newInstance(InputValidator.class);
+
+        CommandSender sender = mock(CommandSender.class);
+        given(permissionsManager.hasPermission(sender, section.getRequiredPermission())).willReturn(true);
+        List<String> arguments = Arrays.asList(section.getName().toUpperCase(), "test", "toast");
+
+        // when
+        command.executeCommand(sender, arguments);
+
+        // then
+        verify(permissionsManager).hasPermission(sender, section.getRequiredPermission());
+        verify(section).execute(sender, Arrays.asList("test", "toast"));
+    }
+
+    @Test
+    public void shouldNotRunSectionForMissingPermission() {
+        // given
+        DebugSection section = spy(InputValidator.class);
+        // Mockito throws a runtime error if below we use the usual "given(factory.newInstance(...)).willReturn(...)"
+        doReturn(section).when(debugSectionFactory).newInstance(InputValidator.class);
+
+        CommandSender sender = mock(CommandSender.class);
+        given(permissionsManager.hasPermission(sender, section.getRequiredPermission())).willReturn(false);
+        List<String> arguments = Arrays.asList(section.getName().toUpperCase(), "test");
+
+        // when
+        command.executeCommand(sender, arguments);
+
+        // then
+        verify(permissionsManager).hasPermission(sender, section.getRequiredPermission());
+        verify(section, never()).execute(any(CommandSender.class), anyList());
+        verify(sender).sendMessage(argThat(containsString("You don't have permission")));
+    }
+}

src/test/java/fr/xephi/authme/command/executable/authme/debug/HasPermissionCheckerTest.java

@@ -20,9 +20,9 @@ import java.util.stream.Collectors;
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
+import static org.hamcrest.Matchers.containsInAnyOrder;
 import static org.hamcrest.Matchers.containsString;
 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.atLeast;
@@ -55,8 +55,7 @@ public class HasPermissionCheckerTest {
                 .collect(Collectors.toList());
 
         // when / then
-        assertThat(HasPermissionChecker.PERMISSION_NODE_CLASSES.containsAll(permissionClasses), equalTo(true));
-        assertThat(HasPermissionChecker.PERMISSION_NODE_CLASSES, hasSize(permissionClasses.size()));
+        assertThat(HasPermissionChecker.PERMISSION_NODE_CLASSES, containsInAnyOrder(permissionClasses.toArray()));
     }
 
     @Test

src/test/java/fr/xephi/authme/permission/AbstractPermissionsEnumTest.java

@@ -0,0 +1,52 @@
+package fr.xephi.authme.permission;
+
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import static org.junit.Assert.fail;
+
+/**
+ * Has common tests for enums implementing {@link PermissionNode}.
+ */
+public abstract class AbstractPermissionsEnumTest {
+
+    @Test
+    public void shouldAllStartWitRequiredPrefix() {
+        // given
+        String requiredPrefix = getRequiredPrefix();
+
+        // when/then
+        for (PermissionNode permission : getPermissionNodes()) {
+            if (!permission.getNode().startsWith(requiredPrefix)) {
+                fail("The permission '" + permission + "' does not start with the required prefix '"
+                    + requiredPrefix + "'");
+            }
+        }
+    }
+
+    @Test
+    public void shouldHaveUniqueNodes() {
+        // given
+        Set<String> nodes = new HashSet<>();
+
+        // when/then
+        for (PermissionNode permission : getPermissionNodes()) {
+            if (!nodes.add(permission.getNode())) {
+                fail("More than one enum value defines the node '" + permission.getNode() + "'");
+            }
+        }
+    }
+
+    /**
+     * @return the permission nodes to test
+     */
+    protected abstract PermissionNode[] getPermissionNodes();
+
+    /**
+     * @return text with which all permission nodes must start with
+     */
+    protected abstract String getRequiredPrefix();
+
+}

src/test/java/fr/xephi/authme/permission/AdminPermissionTest.java

@@ -1,42 +1,18 @@
 package fr.xephi.authme.permission;
 
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.junit.Assert.fail;
-
 /**
  * Test for {@link AdminPermission}.
  */
-public class AdminPermissionTest {
+public class AdminPermissionTest extends AbstractPermissionsEnumTest {
 
-    @Test
-    public void shouldStartWithAuthMeAdminPrefix() {
-        // given
-        String requiredPrefix = "authme.admin.";
-
-        // when/then
-        for (AdminPermission permission : AdminPermission.values()) {
-            if (!permission.getNode().startsWith(requiredPrefix)) {
-                fail("The permission '" + permission + "' does not start with the required prefix '"
-                    + requiredPrefix + "'");
-            }
-        }
+    @Override
+    protected PermissionNode[] getPermissionNodes() {
+        return AdminPermission.values();
     }
 
-    @Test
-    public void shouldHaveUniqueNodes() {
-        // given
-        Set<String> nodes = new HashSet<>();
-
-        // when/then
-        for (AdminPermission permission : AdminPermission.values()) {
-            if (!nodes.add(permission.getNode())) {
-                fail("More than one enum value defines the node '" + permission.getNode() + "'");
-            }
-        }
+    @Override
+    protected String getRequiredPrefix() {
+        return "authme.admin.";
     }
 
 }

src/test/java/fr/xephi/authme/permission/DebugSectionPermissionsTest.java

@@ -0,0 +1,17 @@
+package fr.xephi.authme.permission;
+
+/**
+ * Test for {@link DebugSectionPermissions}.
+ */
+public class DebugSectionPermissionsTest extends AbstractPermissionsEnumTest {
+
+    @Override
+    protected PermissionNode[] getPermissionNodes() {
+        return DebugSectionPermissions.values();
+    }
+
+    @Override
+    protected String getRequiredPrefix() {
+        return "authme.debug.";
+    }
+}

src/test/java/fr/xephi/authme/permission/PermissionConsistencyTest.java

@@ -31,7 +31,7 @@ public class PermissionConsistencyTest {
 
     /** Wildcard permissions (present in plugin.yml but not in the codebase). */
     private static final Set<String> PLUGIN_YML_PERMISSIONS_WILDCARDS =
-        ImmutableSet.of("authme.admin.*", "authme.player.*", "authme.player.email");
+        ImmutableSet.of("authme.admin.*", "authme.player.*", "authme.player.email", "authme.debug");
 
     /** Name of the fields that make up a permission entry in plugin.yml. */
     private static final Set<String> PERMISSION_FIELDS = ImmutableSet.of("description", "default", "children");

src/test/java/fr/xephi/authme/permission/PlayerPermissionTest.java

@@ -1,41 +1,17 @@
 package fr.xephi.authme.permission;
 
-import org.junit.Test;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import static org.junit.Assert.fail;
-
 /**
  * Test for {@link PlayerPermission}.
  */
-public class PlayerPermissionTest {
+public class PlayerPermissionTest extends AbstractPermissionsEnumTest {
 
-    @Test
-    public void shouldStartWithPlayerPrefix() {
-        // given
-        String playerBranch = "authme.player.";
-
-        // when/then
-        for (PlayerPermission permission : PlayerPermission.values()) {
-            if (!permission.getNode().startsWith(playerBranch)) {
-                fail("The permission '" + permission + "' should use a node with the player-specific branch '"
-                    + playerBranch + "'");
-            }
-        }
+    @Override
+    protected PermissionNode[] getPermissionNodes() {
+        return PlayerPermission.values();
     }
 
-    @Test
-    public void shouldHaveUniqueNodes() {
-        // given
-        Set<String> nodes = new HashSet<>();
-
-        // when/then
-        for (PlayerPermission permission : PlayerPermission.values()) {
-            if (!nodes.add(permission.getNode())) {
-                fail("More than one enum value defines the node '" + permission.getNode() + "'");
-            }
-        }
+    @Override
+    protected String getRequiredPrefix() {
+        return "authme.player.";
     }
 }

src/test/java/fr/xephi/authme/permission/PlayerStatePermissionTest.java

@@ -2,7 +2,7 @@ package fr.xephi.authme.permission;
 
 import org.junit.Test;
 
-import java.util.HashSet;
+import java.util.Collection;
 import java.util.Set;
 
 import static com.google.common.collect.Sets.newHashSet;
@@ -11,39 +11,32 @@ import static org.junit.Assert.fail;
 /**
  * Test for {@link PlayerStatePermission}.
  */
-public class PlayerStatePermissionTest {
+public class PlayerStatePermissionTest extends AbstractPermissionsEnumTest {
 
     @Test
-    public void shouldStartWithAuthMeAdminPrefix() {
+    public void shouldNotStartWithOtherPrefixes() {
         // given
-        String requiredPrefix = "authme.";
-        Set<String> forbiddenPrefixes = newHashSet("authme.player", "authme.admin");
+        Set<String> forbiddenPrefixes = newHashSet("authme.player", "authme.admin", "authme.debug");
 
         // when/then
         for (PlayerStatePermission permission : PlayerStatePermission.values()) {
-            if (!permission.getNode().startsWith(requiredPrefix)) {
-                fail("The permission '" + permission + "' does not start with the required prefix '"
-                    + requiredPrefix + "'");
-            } else if (hasAnyPrefix(permission.getNode(), forbiddenPrefixes)) {
+            if (startsWithAny(permission.getNode(), forbiddenPrefixes)) {
                 fail("The permission '" + permission + "' should not start with any of " + forbiddenPrefixes);
             }
         }
     }
 
-    @Test
-    public void shouldHaveUniqueNodes() {
-        // given
-        Set<String> nodes = new HashSet<>();
-
-        // when/then
-        for (PlayerStatePermission permission : PlayerStatePermission.values()) {
-            if (!nodes.add(permission.getNode())) {
-                fail("More than one enum value defines the node '" + permission.getNode() + "'");
-            }
-        }
+    @Override
+    protected PermissionNode[] getPermissionNodes() {
+        return PlayerStatePermission.values();
     }
 
-    private static boolean hasAnyPrefix(String node, Set<String> prefixes) {
+    @Override
+    protected String getRequiredPrefix() {
+        return "authme.";
+    }
+
+    private static boolean startsWithAny(String node, Collection<String> prefixes) {
         for (String prefix : prefixes) {
             if (node.startsWith(prefix)) {
                 return true;
@@ -51,5 +44,4 @@ public class PlayerStatePermissionTest {
         }
         return false;
     }
-
 }