diff --git a/build.gradle b/build.gradle index 83af930..01a701f 100644 --- a/build.gradle +++ b/build.gradle @@ -44,7 +44,6 @@ import cpw.mods.fml.relauncher.SideOnly; apply plugin: 'java' -apply plugin: 'groovy' apply plugin: 'maven-publish' apply plugin: 'eclipse' @@ -130,13 +129,6 @@ runtime 'net.openhft:koloboke-impl-jdk8:0.6.8' runtime 'mysql:mysql-connector-java:5.1.31' - - testCompile "org.codehaus.groovy:groovy-all:2.3.0" - testCompile "org.spockframework:spock-core:1.0-groovy-2.0-SNAPSHOT" - testCompile 'junit:junit:4.5' - - testRuntime "cglib:cglib-nodep:2.2.2" - testRuntime "org.objenesis:objenesis:1.2" } task processServerResources(type: ProcessResources) { diff --git a/src/test/groovy/org/ultramine/commands/syntax/ArgumentsPatternParserTest.groovy b/src/test/groovy/org/ultramine/commands/syntax/ArgumentsPatternParserTest.groovy deleted file mode 100644 index 31f43c4..0000000 --- a/src/test/groovy/org/ultramine/commands/syntax/ArgumentsPatternParserTest.groovy +++ /dev/null @@ -1,121 +0,0 @@ -package org.ultramine.commands.syntax - -import spock.lang.Specification - -class ArgumentsPatternParserTest extends Specification { - - def parser = new ArgumentsPatternParser() - - def "Test single handler"() { - setup: - def argumentHandler = Mock(IArgumentCompletionHandler) - parser.registerHandler("test", argumentHandler) - def commandHandler = parser.parse("") - - when: "Get completion" - commandHandler.getCompletionOptions("first") - - then: "Argument handler is called" - 1 * argumentHandler.handleCompletion("first", "par1", "par2") - } - - def "Test not registered handler"() { - setup: - def argumentHandler = Mock(IArgumentCompletionHandler) - parser.registerHandler("test", argumentHandler) - def commandHandler = parser.parse("") - - when: "Get completion" - commandHandler.getCompletionOptions("first") - - then: "Argument handler is not called" - 0 * argumentHandler._ - } - - def "Test action argument"() { - setup: - def commandHandler = parser.parse("[ add remove ]") - - expect: "Action is parsed" - commandHandler.getCompletionOptions("a") == ["add"] - commandHandler.resolveActionName("add") == "add" - } - - def "Test several arguments"() { - setup: - def playerHandler = Mock(IArgumentCompletionHandler) - def itemHandler = Mock(IArgumentCompletionHandler) - parser.registerHandler("player", playerHandler) - parser.registerHandler("item", itemHandler) - def commadHandler = parser.parse(string) - - when: "Get completions" - commadHandler.getCompletionOptions("first") - commadHandler.getCompletionOptions("first", "second") - commadHandler.getCompletionOptions("first", "second", "third") - commadHandler.getCompletionOptions("first", "second", "third", "fourth") - - then: "Argument handles called correctly" - 1 * playerHandler.handleCompletion("first") - 1 * itemHandler.handleCompletion("third", "first") - 0 * playerHandler._ - 0 * itemHandler._ - - where: - string << [" <> ", " < player> < > < item &0 >"] - } - - def "Test infinite"() { - setup: - def argumentHandler = Mock(IArgumentCompletionHandler) - parser.registerHandler("test", argumentHandler) - def commandHandler = parser.parse("<> ...") - - when: "Get completion" - commandHandler.getCompletionOptions("first", "second", "third") - - then: "Argument handler is called" - 1 * argumentHandler.handleCompletion("third", "par1", "par2") - } - - def "Test naming"() { - setup: - parser.registerHandler("test", Mock(IArgumentCompletionHandler)) - def commandHandler = parser.parse(" [add remove] <%p3>") - - expect: "Names are correct" - commandHandler.getArgumentsNames() == ["p1", "test", null, "p2", "p3"] - } - - def "Test integration"() { - setup: - def commnadHander = parser.parse(" ") - parser.registerHandlers(TestHandlers) - - expect: - commnadHander.getCompletionOptions("B") == ["Bob", "Barny"] - commnadHander.getCompletionOptions("Bob", "ki") == ["kick", "kill"] - commnadHander.match("Jenifer", "aza") - commnadHander.isUsernameIndex(0) - } - - public static class TestHandlers { - @ArgumentCompleter(value = "player", isUsername = true) - public static List player(String val, String[] args) - { - return ["Bob", "Jenifer", "Barny"].findAll { it.startsWith(val) } - } - - @ArgumentCompleter("list") - public static List list(String val, String[] args) - { - return args.findAll { it.startsWith(val) } - } - - @ArgumentValidator("player") - public static boolean player_v(String val, String[] args) - { - return ["Bob", "Jenifer", "Barny"].contains(val) - } - } -} diff --git a/src/test/groovy/org/ultramine/commands/syntax/ArgumentsPatternTest.groovy b/src/test/groovy/org/ultramine/commands/syntax/ArgumentsPatternTest.groovy deleted file mode 100644 index 1b29a06..0000000 --- a/src/test/groovy/org/ultramine/commands/syntax/ArgumentsPatternTest.groovy +++ /dev/null @@ -1,190 +0,0 @@ -package org.ultramine.commands.syntax - -import spock.lang.Specification - -import static org.ultramine.commands.syntax.ArgumentsPattern.MatchResult.* - -class ArgumentsPatternTest extends Specification { - - def builder = new ArgumentsPattern.Builder() - def pattern = builder.build(); - - def "Test completion"() { - setup: "Pattern with argument" - def argument = Mock(IArgument) - builder.addArgument("name", argument); - - when: "Get completion for first argument" - pattern.getCompletionOptions("first") - - then: "Argument handler is called" - 1 * argument.getCompletionOptions("first") - } - - def "Test action completion"() { - setup: "Pattern with action" - builder.addAction("add", "adopt", "remove") - - expect: - pattern.getCompletionOptions("ad") == ["add", "adopt"] - } - - def "Test action name"() { - setup: "Pattern without action" - builder.addArgument("name", Mock(IArgument)) - - expect: "Action name is blank" - pattern.resolveActionName("name") == "" - - when: "With one action" - builder.addAction("add", "get") - - then: "Action name is correct" - pattern.resolveActionName("name", "add") == "add" - - when: "With two actions" - builder.addAction("make") - - then: "Space is separator between actions" - pattern.resolveActionName("name", "get", "make") == "get make" - } - - def "Test infinite handler"() { - setup: - def argument = Mock(IArgument) - builder.addArgument("name", argument) - - when: "Get completion for second argument" - def result = pattern.getCompletionOptions("first", "second") - - then: "Argument handler is not called" - 0 * argument._ - - and: "Result is null" - result == null - - when: "Make command handler infinite" - builder.makeInfinite() - - and: "Get completion for second and third argument" - pattern.getCompletionOptions("first", "second") - pattern.getCompletionOptions("first", "second", "third") - - then: "Argument handler is called" - 1 * argument.getCompletionOptions("first", "second") - 1 * argument.getCompletionOptions("first", "second", "third") - } - - def "Test username argument"() { - setup: "Command completion with username argument" - builder.addArgument("name", Mock(IArgument)) - builder.addArgument("name", Mock(IArgument) { - isUsername() >> true - }) - builder.addArgument("name", Mock(IArgument)) - - expect: "Username argument is detected correctly" - !pattern.isUsernameIndex(0) - pattern.isUsernameIndex(1) - !pattern.isUsernameIndex(2) - - when: "Add another username argument" - builder.addArgument("name", Mock(IArgument) { - isUsername() >> true - }) - - then: "Both arguments are detected" - !pattern.isUsernameIndex(0) - pattern.isUsernameIndex(1) - !pattern.isUsernameIndex(2) - pattern.isUsernameIndex(3) - } - - def "Test blank handler"() { - expect: "Always return null" - pattern.getCompletionOptions("first") == null - pattern.getCompletionOptions("first", "second") == null - } - - def "Test matching"() { - setup: - builder.addArgument("name", Mock(IArgument)) - builder.addAction("add") - builder.addArgument("name", Mock(IArgument)) - - expect: "Matching is correct" - !pattern.match("arg1") - !pattern.match("arg1", "add") - pattern.match("arg1", "add", "arg2") - !pattern.match("arg1", "add2", "arg2") - !pattern.match("arg1", "add", "arg2", "arg3") - - when: "Make handler infinite" - builder.makeInfinite() - - then: "Matching is correct" - !pattern.match("arg1") - !pattern.match("arg1", "add") - pattern.match("arg1", "add", "arg2") - !pattern.match("arg1", "ad", "arg2") - pattern.match("arg1", "add", "arg2", "arg3") - } - - def "Test partial matching"() - { - setup: - builder.addArgument("name", Mock(IArgument)) - builder.addAction("add") - builder.addArgument("name", Mock(IArgument)) - - expect: "Partial matching is correct" - pattern.partialMatch("arg1") == POSSIBLY - pattern.partialMatch("arg1", "add") == FULLY - pattern.partialMatch("arg1", "add", "arg2") == FULLY - pattern.partialMatch("arg1", "add2", "arg2") == NOT - pattern.partialMatch("arg1", "add", "arg2", "arg3") == NOT - - when: "Make handler infinite" - builder.makeInfinite() - - then: "Partial matching is correct" - pattern.partialMatch("arg1") == POSSIBLY - pattern.partialMatch("arg1", "add") == FULLY - pattern.partialMatch("arg1", "add", "arg2") == FULLY - pattern.partialMatch("arg1", "ad", "arg2") == NOT - pattern.partialMatch("arg1", "add", "arg2", "arg3") == FULLY - } - - def "Test names"() { - setup: - builder.addArgument("ignored", Mock(IArgument)) - builder.addAction("add") - builder.addArgument("name", Mock(IArgument)) - - expect: "Names are correct" - pattern.getArgumentsNames() == ["ignored", null, "name"] - } - - def "Test integration"() { - setup: - builder.addArgument("name", Mock(IArgument)) - IArgument argument = new HandlerBasedArgument("name", "boom", "bod", "&0"); - argument.setCompletionHandler(new IArgumentCompletionHandler() { - @Override - List handleCompletion(String val, String[] params) { - return params.findAll { it.startsWith(val) } - } - - @Override - boolean isUsername() { - return false - } - }) - builder.addArgument("name", argument) - - expect: "Completions are correct" - pattern.getCompletionOptions("ara", "bo") == ["boom", "bod"] - pattern.getCompletionOptions("zava", "za") == ["zava"] - pattern.getCompletionOptions("b", "va", "vaka") == null - } -} diff --git a/src/test/groovy/org/ultramine/commands/syntax/HandlerBasedArgumentTest.groovy b/src/test/groovy/org/ultramine/commands/syntax/HandlerBasedArgumentTest.groovy deleted file mode 100644 index f66183e..0000000 --- a/src/test/groovy/org/ultramine/commands/syntax/HandlerBasedArgumentTest.groovy +++ /dev/null @@ -1,46 +0,0 @@ -package org.ultramine.commands.syntax - -import spock.lang.Specification - -class HandlerBasedArgumentTest extends Specification { - - - def "Test argument replacement"() { - setup: - def argument = new HandlerBasedArgument("name", "p1", "&0", "p3") - def handler = Mock(IArgumentCompletionHandler) - argument.setCompletionHandler(handler) - - when: "Get completion for argument" - argument.getCompletionOptions("first", "second") - - then: "Argument handler is called with right params" - 1 * handler.handleCompletion("second", "p1", "first", "p3") - } - - def "Test argument replacement: out if bound index"() { - setup: - def argument = new HandlerBasedArgument("name", "p1", "&5", "p3") - def handler = Mock(IArgumentCompletionHandler) - argument.setCompletionHandler(handler) - - when: "Get completion for argument" - argument.getCompletionOptions("first", "second") - - then: "Argument handler is called with right params" - 1 * handler.handleCompletion("second", "p1", "", "p3") - } - - def "Test argument replacement: not number"() { - setup: - def argument = new HandlerBasedArgument("name", "p1", "&aza", "p3") - def handler = Mock(IArgumentCompletionHandler) - argument.setCompletionHandler(handler) - - when: "Get completion for argument" - argument.getCompletionOptions("first", "second") - - then: "Argument handler is called with right params" - 1 * handler.handleCompletion("second", "p1", "&aza", "p3") - } -}