From 09044b9c1b7d18d18e0a4655e173f91ec17e2fff Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alexander=20S=C3=B6derberg?= <4096670+Citymonstret@users.noreply.github.com> Date: Sat, 28 May 2022 14:23:37 +0200 Subject: [PATCH] feat(core): add unit tests for the standard parsers (#362) * feat(core): add BooleanParser unit tests * feat(core): add ByteParser unit tests * feat(core): add IntegerParser, LongParser & ShortParser unit tests * feat(core): add EnumParser unit tests * feat(core): add CharacterParser unit tests * feat(core): add DoubleParser & FloatParser unit tests * feat(core): add UUIDParser & StringArrayParser unit tests --- .../kotlin/cloud.base-conventions.gradle.kts | 1 + .../arguments/standard/BooleanArgument.java | 24 ++- .../arguments/standard/ByteArgument.java | 18 ++ .../arguments/standard/CharArgument.java | 18 ++ .../arguments/standard/DoubleArgument.java | 18 ++ .../arguments/standard/EnumArgument.java | 18 ++ .../arguments/standard/FloatArgument.java | 18 ++ .../arguments/standard/IntegerArgument.java | 18 ++ .../arguments/standard/LongArgument.java | 18 ++ .../arguments/standard/ShortArgument.java | 18 ++ .../arguments/standard/UUIDArgument.java | 18 ++ .../context/CommandContext.java | 2 +- .../standard/ArgumentTestHelper.java | 37 ++++ .../arguments/standard/BooleanParserTest.java | 155 +++++++++++++++ .../arguments/standard/ByteParserTest.java | 185 ++++++++++++++++++ .../standard/CharacterParserTest.java | 88 +++++++++ .../arguments/standard/DoubleParserTest.java | 137 +++++++++++++ .../arguments/standard/EnumParserTest.java | 113 +++++++++++ .../arguments/standard/FloatParserTest.java | 139 +++++++++++++ .../arguments/standard/IntegerParserTest.java | 185 ++++++++++++++++++ .../arguments/standard/LongParserTest.java | 185 ++++++++++++++++++ .../arguments/standard/ShortParserTest.java | 185 ++++++++++++++++++ .../standard/StringArrayParserTest.java | 81 ++++++++ .../arguments/standard/UUIDParserTest.java | 90 +++++++++ gradle/libs.versions.yml | 4 + 25 files changed, 1769 insertions(+), 4 deletions(-) create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/ArgumentTestHelper.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/BooleanParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/ByteParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/CharacterParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/DoubleParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/EnumParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/FloatParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/IntegerParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/LongParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/ShortParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/StringArrayParserTest.java create mode 100644 cloud-core/src/test/java/cloud/commandframework/arguments/standard/UUIDParserTest.java diff --git a/build-logic/src/main/kotlin/cloud.base-conventions.gradle.kts b/build-logic/src/main/kotlin/cloud.base-conventions.gradle.kts index bb256373..874d048b 100644 --- a/build-logic/src/main/kotlin/cloud.base-conventions.gradle.kts +++ b/build-logic/src/main/kotlin/cloud.base-conventions.gradle.kts @@ -111,6 +111,7 @@ repositories { dependencies { compileOnlyApi(libs.checkerQual) testImplementation(libs.jupiterEngine) + testImplementation(libs.jupiterParams) testImplementation(libs.mockitoCore) testImplementation(libs.mockitoKotlin) testImplementation(libs.mockitoJupiter) diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/BooleanArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/BooleanArgument.java index 7049c6d4..947af4bc 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/BooleanArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/BooleanArgument.java @@ -34,6 +34,7 @@ import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.ParserException; import java.util.Arrays; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import org.checkerframework.checker.nullness.qual.NonNull; @@ -163,7 +164,7 @@ public final class BooleanArgument extends CommandArgument { /** * Construct a new boolean parser * - * @param liberal Whether or not it'll accept boolean-esque strings, or just booleans + * @param liberal Whether it'll accept boolean-esque strings, or just booleans */ public BooleanParser(final boolean liberal) { this.liberal = liberal; @@ -244,7 +245,7 @@ public final class BooleanArgument extends CommandArgument { * Construct a new boolean parse exception * * @param input Input - * @param liberal Whether or not the parser allows truthy and falsy values, or strictly true/false + * @param liberal Whether the parser allows truthy and falsy values, or strictly true/false * @param context Command context */ public BooleanParseException( @@ -268,7 +269,7 @@ public final class BooleanArgument extends CommandArgument { * * @return String value */ - public String getInput() { + public @NonNull String getInput() { return this.input; } @@ -281,6 +282,23 @@ public final class BooleanArgument extends CommandArgument { return this.liberal; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final BooleanParseException that = (BooleanParseException) o; + return this.liberal == that.liberal && this.input.equals(that.input); + } + + @Override + public int hashCode() { + return Objects.hash(this.input, this.liberal); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ByteArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ByteArgument.java index fd45fef3..86ba5389 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ByteArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ByteArgument.java @@ -31,6 +31,7 @@ import cloud.commandframework.context.CommandContext; import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.NumberParseException; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import org.checkerframework.checker.nullness.qual.NonNull; @@ -348,6 +349,23 @@ public final class ByteArgument extends CommandArgument { return "byte"; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final ByteParseException that = (ByteParseException) o; + return this.parser.equals(that.parser); + } + + @Override + public int hashCode() { + return Objects.hash(this.parser); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/CharArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/CharArgument.java index 55715f52..09828ac8 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/CharArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/CharArgument.java @@ -33,6 +33,7 @@ import cloud.commandframework.context.CommandContext; import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.ParserException; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import org.checkerframework.checker.nullness.qual.NonNull; @@ -186,6 +187,23 @@ public final class CharArgument extends CommandArgument { return this.input; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final CharParseException that = (CharParseException) o; + return this.input.equals(that.input); + } + + @Override + public int hashCode() { + return Objects.hash(this.input); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/DoubleArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/DoubleArgument.java index f95a59ff..d4fc4a47 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/DoubleArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/DoubleArgument.java @@ -31,6 +31,7 @@ import cloud.commandframework.context.CommandContext; import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.NumberParseException; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import org.checkerframework.checker.nullness.qual.NonNull; @@ -337,6 +338,23 @@ public final class DoubleArgument extends CommandArgument { return "double"; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final DoubleParseException that = (DoubleParseException) o; + return this.parser.equals(that.parser); + } + + @Override + public int hashCode() { + return Objects.hash(this.parser); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/EnumArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/EnumArgument.java index 4436a3c6..7c3bdd81 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/EnumArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/EnumArgument.java @@ -34,6 +34,7 @@ import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.ParserException; import java.util.EnumSet; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import java.util.stream.Collectors; @@ -256,6 +257,23 @@ public class EnumArgument> extends CommandArgument { return this.enumClass; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final EnumParseException that = (EnumParseException) o; + return this.input.equals(that.input) && this.enumClass.equals(that.enumClass); + } + + @Override + public int hashCode() { + return Objects.hash(this.input, this.enumClass); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/FloatArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/FloatArgument.java index 08742c8f..516b6162 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/FloatArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/FloatArgument.java @@ -31,6 +31,7 @@ import cloud.commandframework.context.CommandContext; import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.NumberParseException; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import org.checkerframework.checker.nullness.qual.NonNull; @@ -332,6 +333,23 @@ public final class FloatArgument extends CommandArgument { return "float"; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final FloatParseException that = (FloatParseException) o; + return this.parser.equals(that.parser); + } + + @Override + public int hashCode() { + return Objects.hash(this.parser); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/IntegerArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/IntegerArgument.java index 65f4b38d..e14f0976 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/IntegerArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/IntegerArgument.java @@ -33,6 +33,7 @@ import cloud.commandframework.exceptions.parsing.NumberParseException; import java.util.Collections; import java.util.LinkedList; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.Set; import java.util.TreeSet; @@ -395,6 +396,23 @@ public final class IntegerArgument extends CommandArgument { return "integer"; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final IntegerParseException that = (IntegerParseException) o; + return this.parser.equals(that.parser); + } + + @Override + public int hashCode() { + return Objects.hash(this.parser); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/LongArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/LongArgument.java index 717c25dd..d67c6acb 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/LongArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/LongArgument.java @@ -31,6 +31,7 @@ import cloud.commandframework.context.CommandContext; import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.NumberParseException; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import org.checkerframework.checker.nullness.qual.NonNull; @@ -340,6 +341,23 @@ public final class LongArgument extends CommandArgument { return "long"; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final LongParseException that = (LongParseException) o; + return this.parser.equals(that.parser); + } + + @Override + public int hashCode() { + return Objects.hash(this.parser); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ShortArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ShortArgument.java index e8eee7dc..a7cc3a0b 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ShortArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/ShortArgument.java @@ -31,6 +31,7 @@ import cloud.commandframework.context.CommandContext; import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.NumberParseException; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.function.BiFunction; import org.checkerframework.checker.nullness.qual.NonNull; @@ -337,6 +338,23 @@ public final class ShortArgument extends CommandArgument { return "short"; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null || this.getClass() != o.getClass()) { + return false; + } + final ShortParseException that = (ShortParseException) o; + return this.parser.equals(that.parser); + } + + @Override + public int hashCode() { + return Objects.hash(this.parser); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/UUIDArgument.java b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/UUIDArgument.java index 6671d9ca..9bd28fa2 100644 --- a/cloud-core/src/main/java/cloud/commandframework/arguments/standard/UUIDArgument.java +++ b/cloud-core/src/main/java/cloud/commandframework/arguments/standard/UUIDArgument.java @@ -33,6 +33,7 @@ import cloud.commandframework.context.CommandContext; import cloud.commandframework.exceptions.parsing.NoInputProvidedException; import cloud.commandframework.exceptions.parsing.ParserException; import java.util.List; +import java.util.Objects; import java.util.Queue; import java.util.UUID; import java.util.function.BiFunction; @@ -192,6 +193,23 @@ public final class UUIDArgument extends CommandArgument { return this.input; } + @Override + public boolean equals(final Object o) { + if (this == o) { + return true; + } + if (o == null ||this.getClass() != o.getClass()) { + return false; + } + final UUIDParseException that = (UUIDParseException) o; + return this.input.equals(that.input); + } + + @Override + public int hashCode() { + return Objects.hash(this.input); + } + } } diff --git a/cloud-core/src/main/java/cloud/commandframework/context/CommandContext.java b/cloud-core/src/main/java/cloud/commandframework/context/CommandContext.java index 3b4a0de2..e284e850 100644 --- a/cloud-core/src/main/java/cloud/commandframework/context/CommandContext.java +++ b/cloud-core/src/main/java/cloud/commandframework/context/CommandContext.java @@ -50,7 +50,7 @@ import org.checkerframework.checker.nullness.qual.Nullable; * * @param Command sender type */ -public final class CommandContext { +public class CommandContext { private final CaptionVariableReplacementHandler captionVariableReplacementHandler; private final Map, ArgumentTiming> argumentTimings = new HashMap<>(); diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ArgumentTestHelper.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ArgumentTestHelper.java new file mode 100644 index 00000000..9c831a11 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ArgumentTestHelper.java @@ -0,0 +1,37 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import java.util.Arrays; +import java.util.LinkedList; +import org.checkerframework.checker.nullness.qual.NonNull; + +final class ArgumentTestHelper { + + static @NonNull LinkedList<@NonNull String> linkedListOf( + final @NonNull String... strings + ) { + return new LinkedList<>(Arrays.asList(strings)); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/BooleanParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/BooleanParserTest.java new file mode 100644 index 00000000..3fb63e6f --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/BooleanParserTest.java @@ -0,0 +1,155 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.List; +import java.util.Locale; +import java.util.Queue; +import java.util.stream.Stream; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.ValueSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class BooleanParserTest { + + @Mock + private CommandContext context; + + @ParameterizedTest + @MethodSource("Parse_NonLiberal_ValidInputs_SuccessfulParse_Source") + void Parse_NonLiberal_ValidInputs_SuccessfulParse( + final Queue input, + final boolean expectedResult + ) { + // Arrange + final BooleanArgument.BooleanParser parser = new BooleanArgument.BooleanParser<>(false /* liberal */); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(expectedResult); + + assertThat(input).isEmpty(); + } + + static Stream Parse_NonLiberal_ValidInputs_SuccessfulParse_Source() { + return Stream.of( + Arguments.arguments(ArgumentTestHelper.linkedListOf("true"), true), + Arguments.arguments(ArgumentTestHelper.linkedListOf("false"), false) + ); + } + + @ParameterizedTest + @MethodSource("Parse_Liberal_ValidInputs_SuccessfulParse_Source") + void Parse_Liberal_ValidInputs_SuccessfulParse( + final Queue input, + final boolean expectedResult + ) { + // Arrange + final BooleanArgument.BooleanParser parser = new BooleanArgument.BooleanParser<>(true /* liberal */); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(expectedResult); + + assertThat(input).isEmpty(); + } + + static Stream Parse_Liberal_ValidInputs_SuccessfulParse_Source() { + return Stream.concat( + Stream.of("true", "yes", "on") + .flatMap(input -> Stream.of(input, input.toUpperCase(Locale.ROOT))) + .map(input -> Arguments.arguments(ArgumentTestHelper.linkedListOf(input), true)), + Stream.of("false", "no", "off") + .flatMap(input -> Stream.of(input, input.toUpperCase(Locale.ROOT))) + .map(input -> Arguments.arguments(ArgumentTestHelper.linkedListOf(input), false)) + ); + } + + @ParameterizedTest + @ValueSource(booleans = { true, false }) + void Parse_NonBooleanInput_FailedParse(final boolean liberal) { + // Arrange + final BooleanArgument.BooleanParser parser = new BooleanArgument.BooleanParser<>(liberal); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("not-a-boolean") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new BooleanArgument.BooleanParseException( + "not-a-boolean", + liberal, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @ParameterizedTest + @MethodSource("Suggestions_ExpectedSuggestions_Source") + void Suggestions_ExpectedSuggestions(final boolean liberal, final List expectedSuggestions) { + // Arrange + final BooleanArgument.BooleanParser parser = new BooleanArgument.BooleanParser<>(liberal); + + // Act + final List suggestions = parser.suggestions( + this.context, + "" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } + + static Stream Suggestions_ExpectedSuggestions_Source() { + return Stream.of( + Arguments.arguments(false, ArgumentTestHelper.linkedListOf("TRUE", "FALSE")), + Arguments.arguments(true, ArgumentTestHelper.linkedListOf("TRUE", "YES", "ON", "FALSE", "NO", "OFF")) + ); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ByteParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ByteParserTest.java new file mode 100644 index 00000000..51d76a36 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ByteParserTest.java @@ -0,0 +1,185 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class ByteParserTest { + + @Mock + private CommandContext context; + + @Test + void Parse_NoMinMax_SuccessfulParse() { + // Arrange + final ByteArgument.ByteParser parser = new ByteArgument.ByteParser<>( + ByteArgument.ByteParser.DEFAULT_MINIMUM, + ByteArgument.ByteParser.DEFAULT_MAXIMUM + ); + + final byte byteInput = (byte) ThreadLocalRandom.current().nextInt(Byte.MAX_VALUE); + final LinkedList input = ArgumentTestHelper.linkedListOf(Byte.toString(byteInput)); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(byteInput); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_ValueBelowMin_FailedParse() { + // Arrange + final ByteArgument.ByteParser parser = new ByteArgument.ByteParser<>( + (byte) 5 /* min */, + ByteArgument.ByteParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("4") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new ByteArgument.ByteParseException( + "4", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_ValueAboveMax_FailedParse() { + // Arrange + final ByteArgument.ByteParser parser = new ByteArgument.ByteParser<>( + ByteArgument.ByteParser.DEFAULT_MINIMUM, + (byte) 5 /* max */ + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("6") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new ByteArgument.ByteParseException( + "6", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_NonByteInput_FailedParse() { + // Arrange + final ByteArgument.ByteParser parser = new ByteArgument.ByteParser<>( + ByteArgument.ByteParser.DEFAULT_MINIMUM, + ByteArgument.ByteParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("cow") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new ByteArgument.ByteParseException( + "cow", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Suggestions_EmptyInput_ExpectedSuggestions() { + // Arrange + final ByteArgument.ByteParser parser = new ByteArgument.ByteParser<>( + ByteArgument.ByteParser.DEFAULT_MINIMUM, + ByteArgument.ByteParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Byte.toString((byte) i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } + + @Test + void Suggestions_NegativeSignInput_ExpectedSuggestions() { + // Arrange + final ByteArgument.ByteParser parser = new ByteArgument.ByteParser<>( + ByteArgument.ByteParser.DEFAULT_MINIMUM, + ByteArgument.ByteParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Byte.toString((byte) -i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "-" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/CharacterParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/CharacterParserTest.java new file mode 100644 index 00000000..d1b35ef8 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/CharacterParserTest.java @@ -0,0 +1,88 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.LinkedList; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class CharacterParserTest { + + private CharArgument.CharacterParser parser; + + @Mock + private CommandContext context; + + @BeforeEach + void setup() { + this.parser = new CharArgument.CharacterParser<>(); + } + + @Test + void Parse_ValidChar_SuccessfulParse() { + // Arrange + final LinkedList input = ArgumentTestHelper.linkedListOf("a"); + + // Act + final ArgumentParseResult result = this.parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue('a'); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_TooLongString_FailedParse() { + // Arrange + final LinkedList input = ArgumentTestHelper.linkedListOf("aa"); + + // Act + final ArgumentParseResult result = this.parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).hasValue(new CharArgument.CharParseException( + "aa", + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DoubleParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DoubleParserTest.java new file mode 100644 index 00000000..29af2d77 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/DoubleParserTest.java @@ -0,0 +1,137 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.LinkedList; +import java.util.concurrent.ThreadLocalRandom; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class DoubleParserTest { + + @Mock + private CommandContext context; + + @Test + void Parse_NoMinMax_SuccessfulParse() { + // Arrange + final DoubleArgument.DoubleParser parser = new DoubleArgument.DoubleParser<>( + DoubleArgument.DoubleParser.DEFAULT_MINIMUM, + DoubleArgument.DoubleParser.DEFAULT_MAXIMUM + ); + + final double doubleInput = ThreadLocalRandom.current().nextDouble(); + final LinkedList input = ArgumentTestHelper.linkedListOf(Double.toString(doubleInput)); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(doubleInput); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_ValueBelowMin_FailedParse() { + // Arrange + final DoubleArgument.DoubleParser parser = new DoubleArgument.DoubleParser<>( + 5 /* min */, + DoubleArgument.DoubleParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("4.0") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new DoubleArgument.DoubleParseException( + "4.0", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_ValueAboveMax_FailedParse() { + // Arrange + final DoubleArgument.DoubleParser parser = new DoubleArgument.DoubleParser<>( + DoubleArgument.DoubleParser.DEFAULT_MINIMUM, + 5.0D /* max */ + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("6.0") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new DoubleArgument.DoubleParseException( + "6.0", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_NonDoubleInput_FailedParse() { + // Arrange + final DoubleArgument.DoubleParser parser = new DoubleArgument.DoubleParser<>( + DoubleArgument.DoubleParser.DEFAULT_MINIMUM, + DoubleArgument.DoubleParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("cow") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new DoubleArgument.DoubleParseException( + "cow", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/EnumParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/EnumParserTest.java new file mode 100644 index 00000000..cb08ed1e --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/EnumParserTest.java @@ -0,0 +1,113 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.LinkedList; +import java.util.List; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class EnumParserTest { + + @Mock + private CommandContext context; + + @ParameterizedTest + @EnumSource(TestEnum.class) + void Parse_EnumValues_SuccessfulParse(final TestEnum value) { + // Arrange + final EnumArgument.EnumParser parser = new EnumArgument.EnumParser<>( + TestEnum.class + ); + + final LinkedList input = ArgumentTestHelper.linkedListOf(value.name()); + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(value); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_NonEnumValue_FailedParse() { + // Arrange + final EnumArgument.EnumParser parser = new EnumArgument.EnumParser<>( + TestEnum.class + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("not-an-enum-value") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new EnumArgument.EnumParseException( + "not-an-enum-value", + TestEnum.class, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Suggestions_ExpectedSuggestions() { + // Arrange + final EnumArgument.EnumParser parser = new EnumArgument.EnumParser<>( + TestEnum.class + ); + + // Act + final List suggestions = parser.suggestions( + this.context, + "" + ); + + // Assert + assertThat(suggestions).containsExactly("aaa", "bbb", "ccc"); + } + + enum TestEnum { + AAA, + BBB, + CCC + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/FloatParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/FloatParserTest.java new file mode 100644 index 00000000..1970a23e --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/FloatParserTest.java @@ -0,0 +1,139 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class FloatParserTest { + + @Mock + private CommandContext context; + + @Test + void Parse_NoMinMax_SuccessfulParse() { + // Arrange + final FloatArgument.FloatParser parser = new FloatArgument.FloatParser<>( + FloatArgument.FloatParser.DEFAULT_MINIMUM, + FloatArgument.FloatParser.DEFAULT_MAXIMUM + ); + + final float floatInput = ThreadLocalRandom.current().nextFloat(); + final LinkedList input = ArgumentTestHelper.linkedListOf(Float.toString(floatInput)); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(floatInput); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_ValueBelowMin_FailedParse() { + // Arrange + final FloatArgument.FloatParser parser = new FloatArgument.FloatParser<>( + 5 /* min */, + FloatArgument.FloatParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("4.0") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new FloatArgument.FloatParseException( + "4.0", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_ValueAboveMax_FailedParse() { + // Arrange + final FloatArgument.FloatParser parser = new FloatArgument.FloatParser<>( + FloatArgument.FloatParser.DEFAULT_MINIMUM, + 5.0f /* max */ + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("6.0") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new FloatArgument.FloatParseException( + "6.0", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_NonFloatInput_FailedParse() { + // Arrange + final FloatArgument.FloatParser parser = new FloatArgument.FloatParser<>( + FloatArgument.FloatParser.DEFAULT_MINIMUM, + FloatArgument.FloatParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("cow") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new FloatArgument.FloatParseException( + "cow", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/IntegerParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/IntegerParserTest.java new file mode 100644 index 00000000..de466f5a --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/IntegerParserTest.java @@ -0,0 +1,185 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class IntegerParserTest { + + @Mock + private CommandContext context; + + @Test + void Parse_NoMinMax_SuccessfulParse() { + // Arrange + final IntegerArgument.IntegerParser parser = new IntegerArgument.IntegerParser<>( + IntegerArgument.IntegerParser.DEFAULT_MINIMUM, + IntegerArgument.IntegerParser.DEFAULT_MAXIMUM + ); + + final int intInput = ThreadLocalRandom.current().nextInt(); + final LinkedList input = ArgumentTestHelper.linkedListOf(Integer.toString(intInput)); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(intInput); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_ValueBelowMin_FailedParse() { + // Arrange + final IntegerArgument.IntegerParser parser = new IntegerArgument.IntegerParser<>( + 5 /* min */, + IntegerArgument.IntegerParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("4") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new IntegerArgument.IntegerParseException( + "4", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_ValueAboveMax_FailedParse() { + // Arrange + final IntegerArgument.IntegerParser parser = new IntegerArgument.IntegerParser<>( + IntegerArgument.IntegerParser.DEFAULT_MINIMUM, + 5 /* max */ + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("6") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new IntegerArgument.IntegerParseException( + "6", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_NonIntegerInput_FailedParse() { + // Arrange + final IntegerArgument.IntegerParser parser = new IntegerArgument.IntegerParser<>( + IntegerArgument.IntegerParser.DEFAULT_MINIMUM, + IntegerArgument.IntegerParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("cow") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new IntegerArgument.IntegerParseException( + "cow", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Suggestions_EmptyInput_ExpectedSuggestions() { + // Arrange + final IntegerArgument.IntegerParser parser = new IntegerArgument.IntegerParser<>( + IntegerArgument.IntegerParser.DEFAULT_MINIMUM, + IntegerArgument.IntegerParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Integer.toString(i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } + + @Test + void Suggestions_NegativeSignInput_ExpectedSuggestions() { + // Arrange + final IntegerArgument.IntegerParser parser = new IntegerArgument.IntegerParser<>( + IntegerArgument.IntegerParser.DEFAULT_MINIMUM, + IntegerArgument.IntegerParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Integer.toString(-i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "-" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/LongParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/LongParserTest.java new file mode 100644 index 00000000..a280da33 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/LongParserTest.java @@ -0,0 +1,185 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class LongParserTest { + + @Mock + private CommandContext context; + + @Test + void Parse_NoMinMax_SuccessfulParse() { + // Arrange + final LongArgument.LongParser parser = new LongArgument.LongParser<>( + LongArgument.LongParser.DEFAULT_MINIMUM, + LongArgument.LongParser.DEFAULT_MAXIMUM + ); + + final long longInput = ThreadLocalRandom.current().nextLong(); + final LinkedList input = ArgumentTestHelper.linkedListOf(Long.toString(longInput)); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(longInput); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_ValueBelowMin_FailedParse() { + // Arrange + final LongArgument.LongParser parser = new LongArgument.LongParser<>( + 5L /* min */, + LongArgument.LongParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("4") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new LongArgument.LongParseException( + "4", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_ValueAboveMax_FailedParse() { + // Arrange + final LongArgument.LongParser parser = new LongArgument.LongParser<>( + LongArgument.LongParser.DEFAULT_MINIMUM, + 5L /* max */ + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("6") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new LongArgument.LongParseException( + "6", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_NonLongInput_FailedParse() { + // Arrange + final LongArgument.LongParser parser = new LongArgument.LongParser<>( + LongArgument.LongParser.DEFAULT_MINIMUM, + LongArgument.LongParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("cow") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new LongArgument.LongParseException( + "cow", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Suggestions_EmptyInput_ExpectedSuggestions() { + // Arrange + final LongArgument.LongParser parser = new LongArgument.LongParser<>( + LongArgument.LongParser.DEFAULT_MINIMUM, + LongArgument.LongParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Long.toString((long) i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } + + @Test + void Suggestions_NegativeSignInput_ExpectedSuggestions() { + // Arrange + final LongArgument.LongParser parser = new LongArgument.LongParser<>( + LongArgument.LongParser.DEFAULT_MINIMUM, + LongArgument.LongParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Long.toString((long) -i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "-" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ShortParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ShortParserTest.java new file mode 100644 index 00000000..2150c894 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/ShortParserTest.java @@ -0,0 +1,185 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.ArrayList; +import java.util.LinkedList; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class ShortParserTest { + + @Mock + private CommandContext context; + + @Test + void Parse_NoMinMax_SuccessfulParse() { + // Arrange + final ShortArgument.ShortParser parser = new ShortArgument.ShortParser<>( + ShortArgument.ShortParser.DEFAULT_MINIMUM, + ShortArgument.ShortParser.DEFAULT_MAXIMUM + ); + + final short shortInput = (short) ThreadLocalRandom.current().nextInt(Short.MAX_VALUE); + final LinkedList input = ArgumentTestHelper.linkedListOf(Short.toString(shortInput)); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(shortInput); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_ValueBelowMin_FailedParse() { + // Arrange + final ShortArgument.ShortParser parser = new ShortArgument.ShortParser<>( + (short) 5 /* min */, + ShortArgument.ShortParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("4") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new ShortArgument.ShortParseException( + "4", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_ValueAboveMax_FailedParse() { + // Arrange + final ShortArgument.ShortParser parser = new ShortArgument.ShortParser<>( + ShortArgument.ShortParser.DEFAULT_MINIMUM, + (short) 5 /* max */ + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("6") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new ShortArgument.ShortParseException( + "6", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Parse_NonShortInput_FailedParse() { + // Arrange + final ShortArgument.ShortParser parser = new ShortArgument.ShortParser<>( + ShortArgument.ShortParser.DEFAULT_MINIMUM, + ShortArgument.ShortParser.DEFAULT_MAXIMUM + ); + + // Act + final ArgumentParseResult result = parser.parse( + this.context, + ArgumentTestHelper.linkedListOf("cow") + ); + + // Assert + assertThat(result.getFailure()).hasValue(new ShortArgument.ShortParseException( + "cow", + parser, + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } + + @Test + void Suggestions_EmptyInput_ExpectedSuggestions() { + // Arrange + final ShortArgument.ShortParser parser = new ShortArgument.ShortParser<>( + ShortArgument.ShortParser.DEFAULT_MINIMUM, + ShortArgument.ShortParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Short.toString((short) i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } + + @Test + void Suggestions_NegativeSignInput_ExpectedSuggestions() { + // Arrange + final ShortArgument.ShortParser parser = new ShortArgument.ShortParser<>( + ShortArgument.ShortParser.DEFAULT_MINIMUM, + ShortArgument.ShortParser.DEFAULT_MAXIMUM + ); + + final List expectedSuggestions = new ArrayList<>(); + for (int i = 0; i <= 9; i++) { + expectedSuggestions.add(Short.toString((short) -i)); + } + + // Act + final List suggestions = parser.suggestions( + this.context, + "-" + ); + + // Assert + assertThat(suggestions).containsExactlyElementsIn(expectedSuggestions); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/StringArrayParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/StringArrayParserTest.java new file mode 100644 index 00000000..27dfd0c9 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/StringArrayParserTest.java @@ -0,0 +1,81 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.LinkedList; +import java.util.concurrent.ThreadLocalRandom; +import java.util.stream.Collectors; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class StringArrayParserTest { + + private StringArrayArgument.StringArrayParser parser; + + @Mock + private CommandContext context; + + @BeforeEach + void setup() { + this.parser = new StringArrayArgument.StringArrayParser<>(); + } + + @Test + void Parse_RandomInput_CapturesAll() { + // Arrange + final LinkedList input = new LinkedList<>(); + for (int i = 0; i < 10; i++) { + input.add( + ThreadLocalRandom.current() + .ints() + .mapToObj(Integer::toString) + .limit(32) + .collect(Collectors.joining()) + ); + } + final LinkedList inputCopy = new LinkedList<>(input); + + // Act + final ArgumentParseResult result = this.parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(inputCopy.toArray(new String[0])); + + assertThat(input).isEmpty(); + } +} diff --git a/cloud-core/src/test/java/cloud/commandframework/arguments/standard/UUIDParserTest.java b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/UUIDParserTest.java new file mode 100644 index 00000000..ab0db4b5 --- /dev/null +++ b/cloud-core/src/test/java/cloud/commandframework/arguments/standard/UUIDParserTest.java @@ -0,0 +1,90 @@ +// +// MIT License +// +// Copyright (c) 2021 Alexander Söderberg & Contributors +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. +// +package cloud.commandframework.arguments.standard; + +import cloud.commandframework.TestCommandSender; +import cloud.commandframework.arguments.parser.ArgumentParseResult; +import cloud.commandframework.context.CommandContext; +import java.util.LinkedList; +import java.util.UUID; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import static com.google.common.truth.Truth.assertThat; +import static com.google.common.truth.Truth8.assertThat; + +@ExtendWith(MockitoExtension.class) +class UUIDParserTest { + + private UUIDArgument.UUIDParser parser; + + @Mock + private CommandContext context; + + @BeforeEach + void setup() { + this.parser = new UUIDArgument.UUIDParser<>(); + } + + @Test + void Parse_ValidUUID_SuccessfulParse() { + // Arrange + final UUID inputUUID = UUID.randomUUID(); + final LinkedList input = ArgumentTestHelper.linkedListOf(inputUUID.toString()); + + // Act + final ArgumentParseResult result = this.parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).isEmpty(); + assertThat(result.getParsedValue()).hasValue(inputUUID); + + assertThat(input).isEmpty(); + } + + @Test + void Parse_NonUUID_FailedParse() { + // Arrange + final LinkedList input = ArgumentTestHelper.linkedListOf("non-uuid"); + + // Act + final ArgumentParseResult result = this.parser.parse( + this.context, + input + ); + + // Assert + assertThat(result.getFailure()).hasValue(new UUIDArgument.UUIDParseException( + "non-uuid", + this.context + )); + assertThat(result.getParsedValue()).isEmpty(); + } +} diff --git a/gradle/libs.versions.yml b/gradle/libs.versions.yml index 9ad07c8d..1b276222 100644 --- a/gradle/libs.versions.yml +++ b/gradle/libs.versions.yml @@ -199,6 +199,10 @@ dependencies: group: org.junit.jupiter name: junit-jupiter-engine version: { ref: jupiterEngine } + jupiterParams: + group: org.junit.jupiter + name: junit-jupiter-params + version: { ref: jupiterEngine } mockitoCore: group: org.mockito name: mockito-core