270 lines
11 KiB
Java
270 lines
11 KiB
Java
package fr.xephi.authme.command;
|
|
|
|
import fr.xephi.authme.util.StringUtils;
|
|
import org.junit.BeforeClass;
|
|
import org.junit.Test;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Set;
|
|
|
|
import static org.hamcrest.Matchers.equalTo;
|
|
import static org.hamcrest.Matchers.not;
|
|
import static org.hamcrest.Matchers.nullValue;
|
|
import static org.junit.Assert.assertThat;
|
|
import static org.junit.Assert.fail;
|
|
|
|
/**
|
|
* Test for {@link CommandManager}, especially to guarantee the integrity of the defined commands.
|
|
*/
|
|
public class CommandManagerTest {
|
|
|
|
/**
|
|
* Defines the maximum allowed depths for nesting CommandDescription instances.
|
|
* Note that the depth starts at 0 (e.g. /authme), so a depth of 2 is something like /authme hello world
|
|
*/
|
|
private static int MAX_ALLOWED_DEPTH = 1;
|
|
|
|
private static CommandManager manager;
|
|
|
|
@BeforeClass
|
|
public static void initializeCommandManager() {
|
|
manager = new CommandManager(true);
|
|
}
|
|
|
|
@Test
|
|
public void shouldInitializeCommands() {
|
|
// given/when
|
|
int commandCount = manager.getCommandDescriptionCount();
|
|
List<CommandDescription> commands = manager.getCommandDescriptions();
|
|
|
|
// then
|
|
// It obviously doesn't make sense to test much of the concrete data
|
|
// that is being initialized; we just want to guarantee with this test
|
|
// that data is indeed being initialized and we take a few "probes"
|
|
assertThat(commandCount, equalTo(9));
|
|
assertThat(commandsIncludeLabel(commands, "authme"), equalTo(true));
|
|
assertThat(commandsIncludeLabel(commands, "register"), equalTo(true));
|
|
assertThat(commandsIncludeLabel(commands, "help"), equalTo(false));
|
|
}
|
|
|
|
@Test
|
|
public void shouldNotBeNestedExcessively() {
|
|
// given
|
|
BiConsumer descriptionTester = new BiConsumer() {
|
|
@Override
|
|
public void accept(CommandDescription command, int depth) {
|
|
assertThat(depth <= MAX_ALLOWED_DEPTH, equalTo(true));
|
|
}
|
|
};
|
|
|
|
// when/then
|
|
walkThroughCommands(manager.getCommandDescriptions(), descriptionTester);
|
|
}
|
|
|
|
/** Ensure that all children of a command stored the parent. */
|
|
@Test
|
|
public void shouldHaveConnectionBetweenParentAndChild() {
|
|
// given
|
|
BiConsumer connectionTester = new BiConsumer() {
|
|
@Override
|
|
public void accept(CommandDescription command, int depth) {
|
|
if (command.hasChildren()) {
|
|
for (CommandDescription child : command.getChildren()) {
|
|
assertThat(command.equals(child.getParent()), equalTo(true));
|
|
}
|
|
}
|
|
// Checking that the parent has the current command as child is redundant as this is how we can traverse
|
|
// the "command tree" in the first place - if we're here, it's that the parent definitely has the
|
|
// command as child.
|
|
}
|
|
};
|
|
|
|
// when/then
|
|
walkThroughCommands(manager.getCommandDescriptions(), connectionTester);
|
|
}
|
|
|
|
@Test
|
|
public void shouldNotDefineSameLabelTwice() {
|
|
// given
|
|
final Set<String> commandMappings = new HashSet<>();
|
|
BiConsumer uniqueMappingTester = new BiConsumer() {
|
|
@Override
|
|
public void accept(CommandDescription command, int depth) {
|
|
int initialSize = commandMappings.size();
|
|
List<String> newMappings = getAbsoluteLabels(command);
|
|
commandMappings.addAll(newMappings);
|
|
// Set only contains unique entries, so we just check after adding all new mappings that the size
|
|
// of the Set corresponds to our expectation
|
|
assertThat("All bindings are unique for command with bindings '" + newMappings + "'",
|
|
commandMappings.size() == initialSize + newMappings.size(), equalTo(true));
|
|
}
|
|
};
|
|
|
|
// when/then
|
|
walkThroughCommands(manager.getCommandDescriptions(), uniqueMappingTester);
|
|
}
|
|
|
|
/**
|
|
* The description should provide a very short description of the command and shouldn't end in a ".", whereas the
|
|
* detailed description should be longer and end with a period.
|
|
*/
|
|
@Test
|
|
public void shouldHaveProperDescription() {
|
|
// given
|
|
BiConsumer descriptionTester = new BiConsumer() {
|
|
@Override
|
|
public void accept(CommandDescription command, int depth) {
|
|
String forCommandText = " for command with labels '" + command.getLabels() + "'";
|
|
|
|
assertThat("has description" + forCommandText,
|
|
StringUtils.isEmpty(command.getDescription()), equalTo(false));
|
|
assertThat("short description doesn't end in '.'" + forCommandText,
|
|
command.getDescription().endsWith("."), equalTo(false));
|
|
assertThat("has detailed description" + forCommandText,
|
|
StringUtils.isEmpty(command.getDetailedDescription()), equalTo(false));
|
|
assertThat("detailed description ends in '.'" + forCommandText,
|
|
command.getDetailedDescription().endsWith("."), equalTo(true));
|
|
}
|
|
};
|
|
|
|
// when/then
|
|
walkThroughCommands(manager.getCommandDescriptions(), descriptionTester);
|
|
}
|
|
|
|
/**
|
|
* Check that the implementation of {@link ExecutableCommand} a command points to is the same for each type:
|
|
* it is inefficient to instantiate the same type multiple times.
|
|
*/
|
|
@Test
|
|
public void shouldNotHaveMultipleInstancesOfSameExecutableCommandSubType() {
|
|
// given
|
|
final Map<Class<? extends ExecutableCommand>, ExecutableCommand> implementations = new HashMap<>();
|
|
CommandManager manager = new CommandManager(true);
|
|
BiConsumer descriptionTester = new BiConsumer() {
|
|
@Override
|
|
public void accept(CommandDescription command, int depth) {
|
|
assertThat(command.getExecutableCommand(), not(nullValue()));
|
|
ExecutableCommand commandExec = command.getExecutableCommand();
|
|
ExecutableCommand storedExec = implementations.get(command.getExecutableCommand().getClass());
|
|
if (storedExec != null) {
|
|
assertThat("has same implementation of '" + storedExec.getClass().getName() + "' for command with "
|
|
+ "parent " + (command.getParent() == null ? "null" : command.getParent().getLabels()),
|
|
storedExec == commandExec, equalTo(true));
|
|
} else {
|
|
implementations.put(commandExec.getClass(), commandExec);
|
|
}
|
|
}
|
|
};
|
|
|
|
// when
|
|
List<CommandDescription> commands = manager.getCommandDescriptions();
|
|
|
|
// then
|
|
walkThroughCommands(commands, descriptionTester);
|
|
}
|
|
|
|
@Test
|
|
public void shouldHaveOptionalArgumentsAfterMandatoryOnes() {
|
|
// given
|
|
BiConsumer argumentOrderTester = new BiConsumer() {
|
|
@Override
|
|
public void accept(CommandDescription command, int depth) {
|
|
boolean encounteredOptionalArg = false;
|
|
for (CommandArgumentDescription argument : command.getArguments()) {
|
|
if (argument.isOptional()) {
|
|
encounteredOptionalArg = true;
|
|
} else if (!argument.isOptional() && encounteredOptionalArg) {
|
|
fail("Mandatory arguments should come before optional ones for command with labels '"
|
|
+ command.getLabels() + "'");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// when/then
|
|
walkThroughCommands(manager.getCommandDescriptions(), argumentOrderTester);
|
|
}
|
|
|
|
/**
|
|
* Ensure that a command with children (i.e. a base command) doesn't define any arguments. This might otherwise
|
|
* clash with the label of the child.
|
|
*/
|
|
@Test
|
|
public void shouldNotHaveArgumentsIfCommandHasChildren() {
|
|
// given
|
|
BiConsumer noArgumentForParentChecker = new BiConsumer() {
|
|
@Override
|
|
public void accept(CommandDescription command, int depth) {
|
|
// Fail if the command has children and has arguments at the same time
|
|
// Exception: If the parent only has one child defining the help label, it is acceptable
|
|
if (command.hasChildren() && command.hasArguments()
|
|
&& (command.getChildren().size() != 1 || !command.getChildren().get(0).hasLabel("help"))) {
|
|
fail("Parent command (labels='" + command.getLabels() + "') should not have any arguments");
|
|
}
|
|
}
|
|
};
|
|
|
|
// when/then
|
|
walkThroughCommands(manager.getCommandDescriptions(), noArgumentForParentChecker);
|
|
}
|
|
|
|
|
|
// ------------
|
|
// Helper methods
|
|
// ------------
|
|
private static void walkThroughCommands(List<CommandDescription> commands, BiConsumer consumer) {
|
|
walkThroughCommands(commands, consumer, 0);
|
|
}
|
|
|
|
private static void walkThroughCommands(List<CommandDescription> commands, BiConsumer consumer, int depth) {
|
|
for (CommandDescription command : commands) {
|
|
consumer.accept(command, depth);
|
|
if (command.hasChildren()) {
|
|
walkThroughCommands(command.getChildren(), consumer, depth + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static boolean commandsIncludeLabel(Iterable<CommandDescription> commands, String label) {
|
|
for (CommandDescription command : commands) {
|
|
if (command.getLabels().contains(label)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private interface BiConsumer {
|
|
void accept(CommandDescription command, int depth);
|
|
}
|
|
|
|
/**
|
|
* Get the absolute label that a command defines. Note: Assumes that only the passed command might have
|
|
* multiple labels; only considering the first label for all of the command's parents.
|
|
*
|
|
* @param command The command to verify
|
|
*
|
|
* @return The full command binding
|
|
*/
|
|
private static List<String> getAbsoluteLabels(CommandDescription command) {
|
|
String parentPath = "";
|
|
CommandDescription elem = command.getParent();
|
|
while (elem != null) {
|
|
parentPath = elem.getLabels().get(0) + " " + parentPath;
|
|
elem = elem.getParent();
|
|
}
|
|
parentPath = parentPath.trim();
|
|
|
|
List<String> bindings = new ArrayList<>(command.getLabels().size());
|
|
for (String label : command.getLabels()) {
|
|
bindings.add(StringUtils.join(" ", parentPath, label));
|
|
}
|
|
return bindings;
|
|
}
|
|
|
|
}
|