From 3ecdeacaf8538d8474f47730faa7318b1fb371ee Mon Sep 17 00:00:00 2001 From: lucko Date: Thu, 5 Jan 2023 21:32:50 +0000 Subject: [PATCH] Add more unit tests (#3555) --- common/build.gradle | 9 +- .../luckperms/common/util/Paginated.java | 14 + .../calculator/PermissionCalculatorTest.java | 252 +++++++++++++ ...Test.java => ImmutableContextSetTest.java} | 111 +++--- .../dependencies/DependencyChecksumTest.java | 51 +-- .../common/event/EventGeneratorTest.java | 96 +++++ .../common/model/GroupManagerTest.java | 93 +++++ .../common/model/InheritanceTest.java | 138 ++++++++ .../luckperms/common/model/NodeMapTest.java | 331 ++++++++++++++++++ .../common/model/PermissionHolderTest.java | 135 +++++++ .../TrackManagerTest.java} | 47 +-- .../common/model/UserManagerTest.java | 115 ++++++ .../common/node/NodeBuildersTest.java | 70 ++++ .../luckperms/common/node/NodeParseTest.java | 253 +++++++++++++ .../lucko/luckperms/common/node/NodeTest.java | 139 ++++++++ .../common/node/ShorthandParserTest.java | 73 ++++ .../common/storage/SqlStorageTest.java | 246 +++++++++++++ .../luckperms/common/util/DifferenceTest.java | 86 +++++ .../common/util/DurationFormatterTest.java | 116 ++++++ .../common/util/DurationParserTest.java | 167 +++++---- .../luckperms/common/util/EnumNamerTest.java | 2 +- .../luckperms/common/util/IteratorsTest.java | 6 +- .../luckperms/common/util/PaginatedTest.java | 87 +++-- .../common/util/UniqueIdTypeTest.java | 70 ++++ .../common/verbose/BooleanExpressionTest.java | 37 +- .../common/verbose/VerboseFilterTest.java | 139 ++++++++ .../org.mockito.plugins.MockMaker | 1 + 27 files changed, 2641 insertions(+), 243 deletions(-) create mode 100644 common/src/test/java/me/lucko/luckperms/common/calculator/PermissionCalculatorTest.java rename common/src/test/java/me/lucko/luckperms/common/context/{ContextSetTest.java => ImmutableContextSetTest.java} (63%) create mode 100644 common/src/test/java/me/lucko/luckperms/common/event/EventGeneratorTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/model/GroupManagerTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/model/InheritanceTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/model/NodeMapTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/model/PermissionHolderTest.java rename common/src/test/java/me/lucko/luckperms/common/{node/utils/ShorthandParserTest.java => model/TrackManagerTest.java} (53%) create mode 100644 common/src/test/java/me/lucko/luckperms/common/model/UserManagerTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/node/NodeBuildersTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/node/NodeParseTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/node/NodeTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/node/ShorthandParserTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/storage/SqlStorageTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/util/DifferenceTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/util/DurationFormatterTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/util/UniqueIdTypeTest.java create mode 100644 common/src/test/java/me/lucko/luckperms/common/verbose/VerboseFilterTest.java create mode 100644 common/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker diff --git a/common/build.gradle b/common/build.gradle index ec0f719cf..7a36dc6a5 100644 --- a/common/build.gradle +++ b/common/build.gradle @@ -9,8 +9,13 @@ test { } dependencies { - testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0' - testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.7.0' + testImplementation 'org.junit.jupiter:junit-jupiter-api:5.9.1' + testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.9.1' + testImplementation 'org.junit.jupiter:junit-jupiter-params:5.9.1' + testImplementation 'org.mockito:mockito-core:4.11.0' + testImplementation 'org.mockito:mockito-junit-jupiter:4.11.0' + + testImplementation 'com.h2database:h2:2.1.214' api project(':api') api 'org.checkerframework:checker-qual:3.12.0' diff --git a/common/src/main/java/me/lucko/luckperms/common/util/Paginated.java b/common/src/main/java/me/lucko/luckperms/common/util/Paginated.java index dd4dcf81a..7feb91712 100644 --- a/common/src/main/java/me/lucko/luckperms/common/util/Paginated.java +++ b/common/src/main/java/me/lucko/luckperms/common/util/Paginated.java @@ -30,6 +30,7 @@ import com.google.common.collect.ImmutableList; import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.Objects; /** * A simple pagination utility @@ -93,6 +94,19 @@ public class Paginated { public String toString() { return this.position + ": " + this.value; } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (!(o instanceof Entry)) return false; + Entry entry = (Entry) o; + return this.position == entry.position && Objects.equals(this.value, entry.value); + } + + @Override + public int hashCode() { + return Objects.hash(this.position, this.value); + } } } diff --git a/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionCalculatorTest.java b/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionCalculatorTest.java new file mode 100644 index 000000000..1bac3431e --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/calculator/PermissionCalculatorTest.java @@ -0,0 +1,252 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.calculator; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableMap; + +import me.lucko.luckperms.common.cacheddata.CacheMetadata; +import me.lucko.luckperms.common.cacheddata.result.TristateResult; +import me.lucko.luckperms.common.calculator.processor.AbstractOverrideWildcardProcessor; +import me.lucko.luckperms.common.calculator.processor.DirectProcessor; +import me.lucko.luckperms.common.calculator.processor.PermissionProcessor; +import me.lucko.luckperms.common.calculator.processor.RegexProcessor; +import me.lucko.luckperms.common.calculator.processor.SpongeWildcardProcessor; +import me.lucko.luckperms.common.calculator.processor.WildcardProcessor; +import me.lucko.luckperms.common.model.HolderType; +import me.lucko.luckperms.common.node.factory.NodeBuilders; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; +import me.lucko.luckperms.common.query.QueryOptionsImpl; +import me.lucko.luckperms.common.treeview.PermissionRegistry; +import me.lucko.luckperms.common.verbose.VerboseCheckTarget; +import me.lucko.luckperms.common.verbose.VerboseHandler; +import me.lucko.luckperms.common.verbose.event.CheckOrigin; + +import net.luckperms.api.node.Node; +import net.luckperms.api.util.Tristate; + +import org.junit.jupiter.api.BeforeEach; +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.CsvSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.Map; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class PermissionCalculatorTest { + + private static final CacheMetadata MOCK_METADATA = new CacheMetadata( + HolderType.GROUP, + VerboseCheckTarget.of(VerboseCheckTarget.GROUP_TYPE, "test"), + QueryOptionsImpl.DEFAULT_CONTEXTUAL + ); + + private static final Map EXAMPLE_PERMISSIONS = ImmutableMap.builder() + // direct + .put("test.node1", true) + .put("test.node2", false) + + // wildcard + .put("one.two.three.four", true) + .put("one.two.three.*", false) + .put("one.two.three", true) + .put("one.two.*", false) + .put("one.two", true) + .put("one.*", false) + .put("one", true) + .put("*", false) + + // regex + .put("r=hello\\d+", true) + .put("R=rege(x(es)?|xps?)[1-5]", false) + + // override + .put("overridetest.*", true) + + .build().entrySet().stream() + .collect(Collectors.toMap( + Map.Entry::getKey, + e -> NodeBuilders.determineMostApplicable(e.getKey()).value(e.getValue()).build() + )); + + @Mock private LuckPermsPlugin plugin; + + @BeforeEach + public void setupMocks() { + lenient().when(this.plugin.getVerboseHandler()).thenReturn(mock(VerboseHandler.class)); + lenient().when(this.plugin.getPermissionRegistry()).thenReturn(mock(PermissionRegistry.class)); + } + + private PermissionCalculator createCalculator(PermissionProcessor... processors) { + return new PermissionCalculator(this.plugin, MOCK_METADATA, ImmutableList.copyOf(processors)); + } + + @ParameterizedTest + @CsvSource({ + "test, UNDEFINED", + "test.node1, TRUE", + "test.node2, FALSE" + }) + public void testDirect(String node, Tristate expected) { + PermissionCalculator calculator = createCalculator(new DirectProcessor()); + calculator.setSourcePermissions(EXAMPLE_PERMISSIONS); + + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); + assertEquals(expected, result.result()); + assertNull(result.overriddenResult()); + + if (expected != Tristate.UNDEFINED) { + assertNotNull(result.node()); + assertSame(DirectProcessor.class, result.processorClass()); + } else { + assertNull(result.node()); + assertNull(result.processorClass()); + } + } + + @ParameterizedTest + @CsvSource({ + "one.two.three.four, true, direct", + "one.two.three.test, false, wildcard", + "one.two.three.*, false, direct", + "one.two.three, true, direct", + "one.two.test, false, wildcard", + "one.two.*, false, direct", + "one.two, true, direct", + "one.test, false, wildcard", + "one.*, false, direct", + "one, true, direct", + "test, false, wildcard", + "*, false, direct", + }) + public void testWildcard(String node, boolean expected, String type) { + PermissionCalculator calculator = createCalculator(new DirectProcessor(), new WildcardProcessor()); + calculator.setSourcePermissions(EXAMPLE_PERMISSIONS); + + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); + assertEquals(Tristate.of(expected), result.result()); + assertNull(result.overriddenResult()); + assertNotNull(result.node()); + + if (type.equals("direct")) { + assertSame(DirectProcessor.class, result.processorClass()); + } else if (type.equals("wildcard")) { + assertSame(WildcardProcessor.class, result.processorClass()); + } else { + throw new AssertionError(); + } + } + + @ParameterizedTest + @CsvSource({ + "one, true, direct", + "one.test, true, wildcard", + "one.two, true, direct", + "one.two.test, true, wildcard", + }) + public void testSpongeWildcard(String node, boolean expected, String type) { + PermissionCalculator calculator = createCalculator(new DirectProcessor(), new SpongeWildcardProcessor()); + calculator.setSourcePermissions(EXAMPLE_PERMISSIONS); + + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); + assertEquals(Tristate.of(expected), result.result()); + assertNull(result.overriddenResult()); + assertNotNull(result.node()); + + if (type.equals("direct")) { + assertSame(DirectProcessor.class, result.processorClass()); + } else if (type.equals("wildcard")) { + assertSame(SpongeWildcardProcessor.class, result.processorClass()); + } else { + throw new AssertionError(); + } + } + + @ParameterizedTest + @CsvSource({ + "hello, UNDEFINED", + "hello1, TRUE", + "hello123, TRUE", + "helloo, UNDEFINED", + "regex1, FALSE", + "regexes2, FALSE", + "regexp3, FALSE", + "regexps4, FALSE", + }) + public void testRegex(String node, Tristate expected) { + PermissionCalculator calculator = createCalculator(new DirectProcessor(), new RegexProcessor()); + calculator.setSourcePermissions(EXAMPLE_PERMISSIONS); + + TristateResult result = calculator.checkPermission(node, CheckOrigin.INTERNAL); + assertEquals(expected, result.result()); + assertNull(result.overriddenResult()); + + if (expected != Tristate.UNDEFINED) { + assertNotNull(result.node()); + assertSame(RegexProcessor.class, result.processorClass()); + } else { + assertNull(result.node()); + assertNull(result.processorClass()); + } + } + + @Test + public void testOverrideWildcard() { + AbstractOverrideWildcardProcessor overrideProcessor = new AbstractOverrideWildcardProcessor(true) { + @Override + protected TristateResult hasPermission(String permission) { + if (permission.equals("overridetest.test")) { + return new TristateResult.Factory(AbstractOverrideWildcardProcessor.class) + .result(Tristate.FALSE); + } + return TristateResult.UNDEFINED; + } + }; + + PermissionCalculator calculator = createCalculator(new DirectProcessor(), new WildcardProcessor(), overrideProcessor); + calculator.setSourcePermissions(EXAMPLE_PERMISSIONS); + + TristateResult result = calculator.checkPermission("overridetest.test", CheckOrigin.INTERNAL); + assertEquals(Tristate.FALSE, result.result()); + assertSame(AbstractOverrideWildcardProcessor.class, result.processorClass()); + + TristateResult overriddenResult = result.overriddenResult(); + assertNotNull(overriddenResult); + assertSame(WildcardProcessor.class, overriddenResult.processorClass()); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/context/ContextSetTest.java b/common/src/test/java/me/lucko/luckperms/common/context/ImmutableContextSetTest.java similarity index 63% rename from common/src/test/java/me/lucko/luckperms/common/context/ContextSetTest.java rename to common/src/test/java/me/lucko/luckperms/common/context/ImmutableContextSetTest.java index d23dfd21b..e73756792 100644 --- a/common/src/test/java/me/lucko/luckperms/common/context/ContextSetTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/context/ImmutableContextSetTest.java @@ -25,7 +25,6 @@ package me.lucko.luckperms.common.context; -import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableSet; import net.luckperms.api.context.Context; @@ -33,19 +32,20 @@ import net.luckperms.api.context.ContextSatisfyMode; import net.luckperms.api.context.ImmutableContextSet; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; -import java.util.List; import java.util.function.Consumer; +import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; -public class ContextSetTest { +public class ImmutableContextSetTest { - @Test - public void testImmutableBuilder() { - List> tests = ImmutableList.of( + private static Stream> testBuilder() { + return Stream.of( builder -> { builder.add("test", "a"); builder.add("test", "b"); @@ -73,29 +73,31 @@ public class ContextSetTest { builder.add("test", "c"); } ); + } - for (Consumer action : tests) { - ImmutableContextSet.Builder builder = new ImmutableContextSetImpl.BuilderImpl(); - action.accept(builder); - ImmutableContextSet set = builder.build(); + @ParameterizedTest + @MethodSource + public void testBuilder(Consumer action) { + ImmutableContextSet.Builder builder = new ImmutableContextSetImpl.BuilderImpl(); + action.accept(builder); + ImmutableContextSet set = builder.build(); - ImmutableSet expected = ImmutableSet.of( - new ContextImpl("test", "a"), - new ContextImpl("test", "b"), - new ContextImpl("test", "c") - ); + ImmutableSet expected = ImmutableSet.of( + new ContextImpl("test", "a"), + new ContextImpl("test", "b"), + new ContextImpl("test", "c") + ); - assertEquals(expected, set.toSet()); - assertEquals(3, set.size()); + assertEquals(expected, set.toSet()); + assertEquals(3, set.size()); - assertTrue(set.contains("test", "a")); - assertTrue(set.contains("test", "b")); - assertTrue(set.contains("test", "c")); - } + assertTrue(set.contains("test", "a")); + assertTrue(set.contains("test", "b")); + assertTrue(set.contains("test", "c")); } @Test - public void testImmutableContains() { + public void testContains() { ImmutableContextSet set = new ImmutableContextSetImpl.BuilderImpl() .add("test", "a") .add("test", "a") @@ -111,8 +113,18 @@ public class ContextSetTest { assertFalse(set.containsKey("aaa")); } - @Test - public void testImmutableContainsAll() { + private static Stream> testContainsAllTrue() { + return Stream.of( + builder -> builder.add("aaa", "a").add("bbb", "a"), + builder -> builder.add("aaa", "b").add("bbb", "a"), + builder -> builder.add("aaa", "c").add("bbb", "a"), + builder -> builder.add("aaa", "c").add("bbb", "b") + ); + } + + @ParameterizedTest + @MethodSource + public void testContainsAllTrue(Consumer setup) { ImmutableContextSetImpl set = (ImmutableContextSetImpl) new ImmutableContextSetImpl.BuilderImpl() .add("aaa", "a") .add("aaa", "b") @@ -121,38 +133,43 @@ public class ContextSetTest { .add("bbb", "b") .build(); - List> trueTests = ImmutableList.of( - builder -> builder.add("aaa", "a").add("bbb", "a"), - builder -> builder.add("aaa", "b").add("bbb", "a"), - builder -> builder.add("aaa", "c").add("bbb", "a"), - builder -> builder.add("aaa", "c").add("bbb", "b") + ImmutableContextSet.Builder builder = new ImmutableContextSetImpl.BuilderImpl(); + setup.accept(builder); + + assertTrue(set.otherContainsAll( + builder.build(), + ContextSatisfyMode.AT_LEAST_ONE_VALUE_PER_KEY) ); + } - for (Consumer test : trueTests) { - ImmutableContextSet.Builder builder = new ImmutableContextSetImpl.BuilderImpl(); - test.accept(builder); - assertTrue(set.otherContainsAll( - builder.build(), - ContextSatisfyMode.AT_LEAST_ONE_VALUE_PER_KEY) - ); - } - - List> falseTests = ImmutableList.of( + private static Stream> testContainsAllFalse() { + return Stream.of( builder -> builder.add("aaa", "a").add("bbb", "z"), builder -> builder.add("aaa", "b").add("bbb", "z"), builder -> builder.add("aaa", "b"), builder -> builder.add("aaa", "c"), builder -> {} ); + } - for (Consumer test : falseTests) { - ImmutableContextSet.Builder builder = new ImmutableContextSetImpl.BuilderImpl(); - test.accept(builder); - assertFalse(set.otherContainsAll( - builder.build(), - ContextSatisfyMode.AT_LEAST_ONE_VALUE_PER_KEY) - ); - } + @ParameterizedTest + @MethodSource + public void testContainsAllFalse(Consumer setup) { + ImmutableContextSetImpl set = (ImmutableContextSetImpl) new ImmutableContextSetImpl.BuilderImpl() + .add("aaa", "a") + .add("aaa", "b") + .add("aaa", "c") + .add("bbb", "a") + .add("bbb", "b") + .build(); + + ImmutableContextSet.Builder builder = new ImmutableContextSetImpl.BuilderImpl(); + setup.accept(builder); + + assertFalse(set.otherContainsAll( + builder.build(), + ContextSatisfyMode.AT_LEAST_ONE_VALUE_PER_KEY) + ); } } diff --git a/common/src/test/java/me/lucko/luckperms/common/dependencies/DependencyChecksumTest.java b/common/src/test/java/me/lucko/luckperms/common/dependencies/DependencyChecksumTest.java index a73380455..b22a73c6f 100644 --- a/common/src/test/java/me/lucko/luckperms/common/dependencies/DependencyChecksumTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/dependencies/DependencyChecksumTest.java @@ -25,54 +25,23 @@ package me.lucko.luckperms.common.dependencies; -import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Tag; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import java.util.Base64; -import java.util.concurrent.ExecutorService; -import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.atomic.AtomicBoolean; + +import static org.junit.jupiter.api.Assertions.assertTrue; public class DependencyChecksumTest { - @Test + @ParameterizedTest + @EnumSource @Tag("dependency_checksum") - public void check() { - Dependency[] dependencies = Dependency.values(); - DependencyRepository[] repos = DependencyRepository.values(); - ExecutorService pool = Executors.newCachedThreadPool(); - - AtomicBoolean failed = new AtomicBoolean(false); - - for (Dependency dependency : dependencies) { - for (DependencyRepository repo : repos) { - pool.submit(() -> { - try { - byte[] hash = Dependency.createDigest().digest(repo.downloadRaw(dependency)); - if (!dependency.checksumMatches(hash)) { - System.out.println("NO MATCH - " + repo.name() + " - " + dependency.name() + ": " + Base64.getEncoder().encodeToString(hash)); - failed.set(true); - } else { - System.out.println("OK - " + repo.name() + " - " + dependency.name()); - } - } catch (Exception e) { - e.printStackTrace(); - } - }); - } - } - - pool.shutdown(); - try { - pool.awaitTermination(1, TimeUnit.HOURS); - } catch (InterruptedException e) { - e.printStackTrace(); - } - - if (failed.get()) { - Assertions.fail("Some dependency checksums did not match"); + public void checksumMatches(Dependency dependency) throws DependencyDownloadException { + for (DependencyRepository repo : DependencyRepository.values()) { + byte[] hash = Dependency.createDigest().digest(repo.downloadRaw(dependency)); + assertTrue(dependency.checksumMatches(hash), "Dependency " + dependency.name() + " has hash " + Base64.getEncoder().encodeToString(hash)); } } diff --git a/common/src/test/java/me/lucko/luckperms/common/event/EventGeneratorTest.java b/common/src/test/java/me/lucko/luckperms/common/event/EventGeneratorTest.java new file mode 100644 index 000000000..acbab2fb4 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/event/EventGeneratorTest.java @@ -0,0 +1,96 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.event; + +import me.lucko.luckperms.common.event.gen.GeneratedEventClass; + +import net.luckperms.api.LuckPerms; +import net.luckperms.api.event.LuckPermsEvent; +import net.luckperms.api.event.player.PlayerDataSaveEvent; +import net.luckperms.api.event.sync.PreSyncEvent; +import net.luckperms.api.model.PlayerSaveResult; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.UUID; +import java.util.concurrent.atomic.AtomicBoolean; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class EventGeneratorTest { + + @Mock public LuckPerms luckPermsApi; + + @Test + public void testGenerateAll() { + GeneratedEventClass.preGenerate(); + } + + @Test + public void testSimple() throws Throwable { + UUID randomUniqueId = UUID.randomUUID(); + String randomUsername = "random"; + PlayerSaveResult mockResult = mock(PlayerSaveResult.class); + + GeneratedEventClass eventClass = GeneratedEventClass.generate(PlayerDataSaveEvent.class); + LuckPermsEvent rawEvent = eventClass.newInstance(this.luckPermsApi, randomUniqueId, randomUsername, mockResult); + + assertTrue(rawEvent instanceof PlayerDataSaveEvent); + PlayerDataSaveEvent event = (PlayerDataSaveEvent) rawEvent; + + assertEquals(PlayerDataSaveEvent.class, event.getEventType()); + assertSame(randomUniqueId, event.getUniqueId()); + assertSame(randomUsername, event.getUsername()); + assertSame(mockResult, event.getResult()); + assertSame(this.luckPermsApi, event.getLuckPerms()); + } + + @Test + public void testDefaultMethods() throws Throwable { + AtomicBoolean state = new AtomicBoolean(false); + GeneratedEventClass eventClass = GeneratedEventClass.generate(PreSyncEvent.class); + PreSyncEvent event = (PreSyncEvent) eventClass.newInstance(this.luckPermsApi, state); + + assertFalse(event.isCancelled()); + assertTrue(event.isNotCancelled()); + assertEquals("PreSyncEvent{cancellationState=false}", event.toString()); + + assertFalse(event.setCancelled(true)); + + assertTrue(event.isCancelled()); + assertFalse(event.isNotCancelled()); + assertEquals("PreSyncEvent{cancellationState=true}", event.toString()); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/model/GroupManagerTest.java b/common/src/test/java/me/lucko/luckperms/common/model/GroupManagerTest.java new file mode 100644 index 000000000..a01f7c26d --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/model/GroupManagerTest.java @@ -0,0 +1,93 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.model; + +import com.google.common.collect.ImmutableSet; + +import me.lucko.luckperms.common.model.manager.group.StandardGroupManager; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class GroupManagerTest { + + @Mock private LuckPermsPlugin plugin; + + @Test + public void testSanitizeIdentifier() { + StandardGroupManager manager = new StandardGroupManager(this.plugin) { + @Override + public Group apply(String name) { + Group group = mock(Group.class); + when(group.getName()).thenReturn(name); + return group; + } + }; + + Group group = manager.getOrMake("DEFAULT"); + assertEquals("default", group.getName()); + assertEquals(ImmutableSet.of("default"), manager.getAll().keySet()); + } + + @Test + public void testGetByDisplayName() { + StandardGroupManager manager = new StandardGroupManager(this.plugin) { + @Override + public Group apply(String name) { + return mock(Group.class); + } + }; + + Group defaultGroup = manager.getOrMake("default"); + when(defaultGroup.getDisplayName()).thenReturn(Optional.of("member")); + + assertSame(defaultGroup, manager.getByDisplayName("default")); + assertSame(defaultGroup, manager.getByDisplayName("Default")); + assertSame(defaultGroup, manager.getByDisplayName("member")); + assertSame(defaultGroup, manager.getByDisplayName("Member")); + assertNull(manager.getByDisplayName("test")); + + Group memberGroup = manager.getOrMake("member"); + + assertSame(defaultGroup, manager.getByDisplayName("default")); + assertSame(defaultGroup, manager.getByDisplayName("Default")); + assertSame(memberGroup, manager.getByDisplayName("member")); + assertSame(memberGroup, manager.getByDisplayName("Member")); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/model/InheritanceTest.java b/common/src/test/java/me/lucko/luckperms/common/model/InheritanceTest.java new file mode 100644 index 000000000..572ea6018 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/model/InheritanceTest.java @@ -0,0 +1,138 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.model; + +import me.lucko.luckperms.common.config.ConfigKeys; +import me.lucko.luckperms.common.config.LuckPermsConfiguration; +import me.lucko.luckperms.common.event.EventDispatcher; +import me.lucko.luckperms.common.graph.TraversalAlgorithm; +import me.lucko.luckperms.common.inheritance.InheritanceGraphFactory; +import me.lucko.luckperms.common.model.manager.group.GroupManager; +import me.lucko.luckperms.common.model.manager.group.StandardGroupManager; +import me.lucko.luckperms.common.node.types.Inheritance; +import me.lucko.luckperms.common.node.types.Weight; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; +import me.lucko.luckperms.common.query.QueryOptionsImpl; + +import net.luckperms.api.context.ContextSatisfyMode; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.stream.Collectors; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class InheritanceTest { + + @Mock private LuckPermsPlugin plugin; + @Mock private LuckPermsConfiguration configuration; + + private StandardGroupManager groupManager; + + @BeforeEach + public void setupMocks() { + this.groupManager = new StandardGroupManager(this.plugin); + + //noinspection unchecked,rawtypes + lenient().when(this.plugin.getGroupManager()).thenReturn((GroupManager) this.groupManager); + lenient().when(this.plugin.getInheritanceGraphFactory()).thenReturn(new InheritanceGraphFactory(this.plugin)); + lenient().when(this.plugin.getConfiguration()).thenReturn(this.configuration); + lenient().when(this.plugin.getEventDispatcher()).thenReturn(mock(EventDispatcher.class)); + lenient().when(this.configuration.get(ConfigKeys.CONTEXT_SATISFY_MODE)).thenReturn(ContextSatisfyMode.AT_LEAST_ONE_VALUE_PER_KEY); + lenient().when(this.configuration.get(ConfigKeys.GROUP_WEIGHTS)).thenReturn(Collections.emptyMap()); + } + + /* + * Given the following inheritance setup: + * (value in brackets is the group weight) + * + * test user + * │ + * ├── owner (13) + * │ └── admin (12) + * │ └── mod (11) + * │ └── helper (10) + * │ └── member (0) + * └── vip+ (6) + * └── vip (5) + * └── member (0) + * + * This test checks if the resolved inheritance order is correct :) + */ + @ParameterizedTest(name = "[{index}] {0}, {1}") + @CsvSource({ + "DEPTH_FIRST_PRE_ORDER, false, 'owner -> admin -> mod -> helper -> member -> vip+ -> vip'", + "BREADTH_FIRST, false, 'owner -> vip+ -> admin -> vip -> mod -> member -> helper'", + "DEPTH_FIRST_POST_ORDER, false, 'member -> helper -> mod -> admin -> owner -> vip -> vip+'", + "DEPTH_FIRST_PRE_ORDER, true, 'owner -> admin -> mod -> helper -> vip+ -> vip -> member'", + "BREADTH_FIRST, true, 'owner -> admin -> mod -> helper -> vip+ -> vip -> member'", + "DEPTH_FIRST_POST_ORDER, true, 'owner -> admin -> mod -> helper -> vip+ -> vip -> member'" + }) + public void testInheritanceTree(TraversalAlgorithm traversalAlgorithm, boolean postTraversalSort, String expected) { + when(this.configuration.get(ConfigKeys.INHERITANCE_TRAVERSAL_ALGORITHM)).thenReturn(traversalAlgorithm); + when(this.configuration.get(ConfigKeys.POST_TRAVERSAL_INHERITANCE_SORT)).thenReturn(postTraversalSort); + + Group member = this.groupManager.getOrMake("member"); + + Group helper = createGroup("helper", 10, member); + Group mod = createGroup("mod", 11, helper); + Group admin = createGroup("admin", 12, mod); + Group owner = createGroup("owner", 13, admin); + + Group vip = createGroup("vip", 5, member); + Group vipPlus = createGroup("vip+", 6, vip); + + PermissionHolder testHolder = this.groupManager.getOrMake("test"); + testHolder.normalData().add(Inheritance.builder().group(owner.getName()).build()); + testHolder.normalData().add(Inheritance.builder().group(vipPlus.getName()).build()); + + List groups = testHolder.resolveInheritanceTree(QueryOptionsImpl.DEFAULT_CONTEXTUAL) + .stream().map(Group::getName).collect(Collectors.toList()); + + List expectedList = Arrays.stream(expected.split(" -> ")).collect(Collectors.toList()); + assertEquals(expectedList, groups); + } + + private Group createGroup(String name, int weight, Group parent) { + Group group = this.groupManager.getOrMake(name); + group.normalData().add(Inheritance.builder().group(parent.getName()).build()); + group.normalData().add(Weight.builder().weight(weight).build()); + return group; + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/model/NodeMapTest.java b/common/src/test/java/me/lucko/luckperms/common/model/NodeMapTest.java new file mode 100644 index 000000000..0da67e4a3 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/model/NodeMapTest.java @@ -0,0 +1,331 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.model; + +import com.google.common.base.Splitter; +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; + +import me.lucko.luckperms.common.context.ImmutableContextSetImpl; +import me.lucko.luckperms.common.model.nodemap.NodeMapMutable; +import me.lucko.luckperms.common.node.factory.NodeBuilders; +import me.lucko.luckperms.common.query.QueryOptionsBuilderImpl; +import me.lucko.luckperms.common.util.Difference; + +import net.luckperms.api.context.ContextSatisfyMode; +import net.luckperms.api.context.ImmutableContextSet; +import net.luckperms.api.model.data.DataType; +import net.luckperms.api.node.Node; +import net.luckperms.api.node.NodeType; +import net.luckperms.api.node.metadata.types.InheritanceOriginMetadata; +import net.luckperms.api.node.types.InheritanceNode; +import net.luckperms.api.query.Flag; +import net.luckperms.api.query.QueryMode; +import net.luckperms.api.query.QueryOptions; + +import org.junit.jupiter.api.BeforeEach; +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.CsvSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.time.Duration; +import java.util.EnumSet; +import java.util.HashSet; +import java.util.List; +import java.util.Set; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class NodeMapTest { + + private static final PermissionHolderIdentifier ORIGIN = new PermissionHolderIdentifier(HolderType.GROUP, "test"); + + @Mock private PermissionHolder mockHolder; + + @BeforeEach + public void setupMocks() { + when(this.mockHolder.getIdentifier()).thenReturn(ORIGIN); + } + + private static Node makeNode(String key) { + return NodeBuilders.determineMostApplicable(key).build(); + } + + @Test + public void testSimpleAddAndRemove() { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL); + assertEquals(0, map.size()); + + Node node = makeNode("test"); + + Difference r1 = map.add(node); + assertEquals(ImmutableSet.of(node), r1.getAdded()); + assertEquals(ImmutableSet.of(), r1.getRemoved()); + assertEquals(1, map.size()); + + Difference r2 = map.remove(node); + assertEquals(ImmutableSet.of(), r2.getAdded()); + assertEquals(ImmutableSet.of(node), r2.getRemoved()); + assertEquals(0, map.size()); + } + + @Test + public void testInheritanceOrigin() { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL); + Node node = makeNode("test"); + + map.add(node); + + List nodes = map.asList(); + assertEquals(ImmutableList.of(node), map.asList()); + + InheritanceOriginMetadata origin = nodes.get(0).metadata(InheritanceOriginMetadata.KEY); + assertEquals(ORIGIN, origin.getOrigin()); + assertEquals(DataType.NORMAL, origin.getDataType()); + } + + @ParameterizedTest + @CsvSource({ + "test, true, false", + "test, false, true", + "group.test, true, false", + "group.test, false, true" + }) + public void testRemoveMatchingButNotSameValue(String nodeKey, boolean firstValue, boolean secondValue) { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL); + + Node first = makeNode(nodeKey).toBuilder().value(firstValue).build(); + Node second = makeNode(nodeKey).toBuilder().value(secondValue).build(); + + map.add(first); + + Difference diff = map.add(second); + assertEquals(ImmutableSet.of(first), diff.getRemoved()); + assertEquals(ImmutableSet.of(second), diff.getAdded()); + assertEquals(ImmutableList.of(second), map.asList()); + + if (second.getType() == NodeType.INHERITANCE && second.getValue()) { + assertEquals(ImmutableList.of(second), map.inheritanceAsList()); + } else { + assertEquals(ImmutableList.of(), map.inheritanceAsList()); + } + } + + @ParameterizedTest + @CsvSource({ + "test, 1, 5", + "test, 5, 1", + "group.test, 1, 5", + "group.test, 5, 1" + }) + public void testRemoveMatchingButNotSameExpiry(String nodeKey, int firstDuration, int secondDuration) { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL); + + Node first = makeNode(nodeKey).toBuilder() + .expiry(firstDuration == 0 ? null : Duration.ofDays(firstDuration)) + .build(); + Node second = makeNode(nodeKey).toBuilder() + .expiry(secondDuration == 0 ? null : Duration.ofDays(secondDuration)) + .build(); + + map.add(first); + + Difference diff = map.add(second); + assertEquals(ImmutableSet.of(first), diff.getRemoved()); + assertEquals(ImmutableSet.of(second), diff.getAdded()); + assertEquals(ImmutableList.of(second), map.asList()); + + if (second.getType() == NodeType.INHERITANCE) { + assertEquals(ImmutableList.of(second), map.inheritanceAsList()); + } else { + assertEquals(ImmutableList.of(), map.inheritanceAsList()); + } + } + + @Test + public void testRemove() { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL); + map.add(makeNode("test1")); + map.add(makeNode("test2").toBuilder().value(false).build()); + map.add(makeNode("test3").toBuilder().expiry(1, TimeUnit.HOURS).build()); + map.add(makeNode("test4").toBuilder().withContext("hello", "world").build()); + + assertEquals(4, map.size()); + + map.remove(makeNode("test1").toBuilder().withContext("hello", "world").build()); + map.remove(makeNode("test3")); + map.remove(makeNode("test4")); + map.remove(makeNode("test4").toBuilder().withContext("hello", "world").withContext("aaa", "bbb").build()); + map.remove(makeNode("test5")); + + assertEquals(4, map.size()); + + map.remove(makeNode("test1")); + map.remove(makeNode("test2").toBuilder().value(true).build()); + map.remove(makeNode("test3").toBuilder().expiry(2, TimeUnit.HOURS).build()); + map.remove(makeNode("test4").toBuilder().withContext("hello", "world").build()); + + assertEquals(0, map.size()); + } + + @Test + public void testRemoveExact() { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL); + map.add(makeNode("test1")); + map.add(makeNode("test2").toBuilder().value(false).build()); + map.add(makeNode("test3").toBuilder().expiry(1, TimeUnit.HOURS).build()); + map.add(makeNode("test4").toBuilder().withContext("hello", "world").build()); + + assertEquals(4, map.size()); + + map.removeExact(makeNode("test1").toBuilder().withContext("hello", "world").build()); + map.removeExact(makeNode("test3")); + map.removeExact(makeNode("test4")); + map.removeExact(makeNode("test4").toBuilder().withContext("hello", "world").withContext("aaa", "bbb").build()); + map.removeExact(makeNode("test5")); + + assertEquals(4, map.size()); + + map.removeExact(makeNode("test2").toBuilder().value(true).build()); + map.removeExact(makeNode("test3").toBuilder().expiry(2, TimeUnit.HOURS).build()); + map.removeExact(makeNode("test4").toBuilder().withContext("hello", "world").withContext("aaa", "bbb").build()); + + assertEquals(4, map.size()); + + map.removeExact(makeNode("test1")); + map.removeExact(makeNode("test2").toBuilder().value(false).build()); + map.removeExact(makeNode("test3").toBuilder().expiry(1, TimeUnit.HOURS).build()); + map.removeExact(makeNode("test4").toBuilder().withContext("hello", "world").build()); + + assertEquals(0, map.size()); + } + + @ParameterizedTest(name = "s={0} w={1} is={2} iw={3}") + @CsvSource({ + "true, true, true, true, 8, 4", + "true, true, false, false, 8, 1", + "false, true, true, true, 6, 4", + "true, false, true, true, 6, 4", + "false, false, true, true, 5, 4", + "false, true, false, true, 4, 2", + "true, false, true, false, 4, 2", + "false, false, false, false, 2, 1" + }) + public void testFlagsFiltering(boolean includeServer, boolean includeWorld, boolean inheritanceIncludeServer, boolean inheritanceIncludeWorld, int expected, int expectedInheritance) { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL) { + @Override + protected ContextSatisfyMode defaultSatisfyMode() { + return ContextSatisfyMode.AT_LEAST_ONE_VALUE_PER_KEY; + } + }; + + map.add(makeNode("test1")); + map.add(makeNode("test2").toBuilder().withContext("server", "test").build()); + map.add(makeNode("test3").toBuilder().withContext("world", "test").build()); + map.add(makeNode("test4").toBuilder().withContext("server", "test").withContext("world", "test").build()); + map.add(makeNode("group.test1")); + map.add(makeNode("group.test2").toBuilder().withContext("server", "test").build()); + map.add(makeNode("group.test3").toBuilder().withContext("world", "test").build()); + map.add(makeNode("group.test4").toBuilder().withContext("server", "test").withContext("world", "test").build()); + + Set flags = EnumSet.noneOf(Flag.class); + if (includeServer) flags.add(Flag.INCLUDE_NODES_WITHOUT_SERVER_CONTEXT); + if (includeWorld) flags.add(Flag.INCLUDE_NODES_WITHOUT_WORLD_CONTEXT); + if (inheritanceIncludeServer) flags.add(Flag.APPLY_INHERITANCE_NODES_WITHOUT_SERVER_CONTEXT); + if (inheritanceIncludeWorld) flags.add(Flag.APPLY_INHERITANCE_NODES_WITHOUT_WORLD_CONTEXT); + + QueryOptions options = new QueryOptionsBuilderImpl(QueryMode.NON_CONTEXTUAL) + .flags(flags) + .build(); + + Set output = new HashSet<>(); + map.copyTo(output, options); + assertEquals(expected, output.size()); + + output.clear(); + map.forEach(options, output::add); + assertEquals(expected, output.size()); + + Set inheritanceOutput = new HashSet<>(); + map.copyInheritanceNodesTo(inheritanceOutput, options); + assertEquals(expectedInheritance, inheritanceOutput.size()); + } + + @ParameterizedTest + @CsvSource({ + "'', 2, 1", + "server=test, 4, 2", + "world=test, 4, 2", + "server=test|world=test, 8, 4", + "server=test|world=test|test=test, 8, 4", + }) + public void testContextFiltering(String context, int expected, int expectedInheritance) { + NodeMapMutable map = new NodeMapMutable(this.mockHolder, DataType.NORMAL) { + @Override + protected ContextSatisfyMode defaultSatisfyMode() { + return ContextSatisfyMode.AT_LEAST_ONE_VALUE_PER_KEY; + } + }; + + map.add(makeNode("test1")); + map.add(makeNode("test2").toBuilder().withContext("server", "test").build()); + map.add(makeNode("test3").toBuilder().withContext("world", "test").build()); + map.add(makeNode("test4").toBuilder().withContext("server", "test").withContext("world", "test").build()); + map.add(makeNode("group.test1")); + map.add(makeNode("group.test2").toBuilder().withContext("server", "test").build()); + map.add(makeNode("group.test3").toBuilder().withContext("world", "test").build()); + map.add(makeNode("group.test4").toBuilder().withContext("server", "test").withContext("world", "test").build()); + + ImmutableContextSet.Builder builder = new ImmutableContextSetImpl.BuilderImpl(); + if (!context.isEmpty()) { + Splitter.on('|').withKeyValueSeparator('=').split(context).forEach(builder::add); + } + + QueryOptions options = new QueryOptionsBuilderImpl(QueryMode.CONTEXTUAL) + .context(builder.build()) + .build(); + + Set output = new HashSet<>(); + map.copyTo(output, options); + assertEquals(expected, output.size()); + + output.clear(); + map.forEach(options, output::add); + assertEquals(expected, output.size()); + + Set inheritanceOutput = new HashSet<>(); + map.copyInheritanceNodesTo(inheritanceOutput, options); + assertEquals(expectedInheritance, inheritanceOutput.size()); + } + + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/model/PermissionHolderTest.java b/common/src/test/java/me/lucko/luckperms/common/model/PermissionHolderTest.java new file mode 100644 index 000000000..95416023e --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/model/PermissionHolderTest.java @@ -0,0 +1,135 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.model; + +import com.google.common.collect.ImmutableList; + +import me.lucko.luckperms.common.event.EventDispatcher; +import me.lucko.luckperms.common.node.types.Permission; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; + +import net.luckperms.api.model.data.DataMutateResult; +import net.luckperms.api.model.data.DataType; +import net.luckperms.api.model.data.TemporaryNodeMergeStrategy; +import net.luckperms.api.node.types.PermissionNode; + +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 java.time.Duration; +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class PermissionHolderTest { + + @Mock private LuckPermsPlugin plugin; + + @BeforeEach + public void setupMocks() { + when(this.plugin.getEventDispatcher()).thenReturn(mock(EventDispatcher.class)); + } + + @Test + public void testTemporaryMergeNone() { + PermissionHolder holder = new Group("test", this.plugin); + + PermissionNode node1 = Permission.builder().permission("test").expiry(1, TimeUnit.HOURS).build(); + PermissionNode node2 = Permission.builder().permission("test").expiry(2, TimeUnit.HOURS).build(); + + TemporaryNodeMergeStrategy strategy = TemporaryNodeMergeStrategy.NONE; + + DataMutateResult.WithMergedNode r1 = holder.setNode(DataType.NORMAL, node1, strategy); + assertEquals(DataMutateResult.SUCCESS, r1.getResult()); + assertEquals(ImmutableList.of(node1), holder.normalData().asList()); + + DataMutateResult.WithMergedNode r2 = holder.setNode(DataType.NORMAL, node2, strategy); + assertEquals(DataMutateResult.FAIL_ALREADY_HAS, r2.getResult()); + assertEquals(ImmutableList.of(node1), holder.normalData().asList()); + } + + @Test + public void testTemporaryMergeReplaceIfLonger() { + PermissionHolder holder = new Group("test", this.plugin); + + PermissionNode node1 = Permission.builder().permission("test").expiry(1, TimeUnit.HOURS).build(); + PermissionNode node2 = Permission.builder().permission("test").expiry(2, TimeUnit.HOURS).build(); + + TemporaryNodeMergeStrategy strategy = TemporaryNodeMergeStrategy.REPLACE_EXISTING_IF_DURATION_LONGER; + + DataMutateResult.WithMergedNode r1 = holder.setNode(DataType.NORMAL, node1, strategy); + assertEquals(DataMutateResult.SUCCESS, r1.getResult()); + assertEquals(ImmutableList.of(node1), holder.normalData().asList()); + + DataMutateResult.WithMergedNode r2 = holder.setNode(DataType.NORMAL, node2, strategy); + assertEquals(DataMutateResult.SUCCESS, r2.getResult()); + assertEquals(ImmutableList.of(node2), holder.normalData().asList()); + assertEquals(node2, r2.getMergedNode()); + + DataMutateResult.WithMergedNode r3 = holder.setNode(DataType.NORMAL, node1, strategy); + assertEquals(DataMutateResult.FAIL_ALREADY_HAS, r3.getResult()); + assertEquals(ImmutableList.of(node2), holder.normalData().asList()); + } + + @Test + public void testTemporaryMergeAddDurations() { + PermissionHolder holder = new Group("test", this.plugin); + + PermissionNode node1 = Permission.builder().permission("test").expiry(2, TimeUnit.HOURS).build(); + PermissionNode node2 = Permission.builder().permission("test").expiry(1, TimeUnit.HOURS).build(); + + TemporaryNodeMergeStrategy strategy = TemporaryNodeMergeStrategy.ADD_NEW_DURATION_TO_EXISTING; + + DataMutateResult.WithMergedNode r1 = holder.setNode(DataType.NORMAL, node1, strategy); + assertEquals(DataMutateResult.SUCCESS, r1.getResult()); + assertEquals(ImmutableList.of(node1), holder.normalData().asList()); + + DataMutateResult.WithMergedNode r2 = holder.setNode(DataType.NORMAL, node2, strategy); + assertEquals(DataMutateResult.SUCCESS, r2.getResult()); + + Instant originalExpiry = node1.getExpiry(); + assertNotNull(originalExpiry); + + Instant newExpiry = r2.getMergedNode().getExpiry(); + assertNotNull(newExpiry); + + Instant expectedExpiry = node1.getExpiry().plus(1, ChronoUnit.HOURS); + + // uses wall-clock time, so allow for the tests to run slowly + assertTrue(Duration.between(newExpiry, expectedExpiry).abs().getSeconds() < 5); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/node/utils/ShorthandParserTest.java b/common/src/test/java/me/lucko/luckperms/common/model/TrackManagerTest.java similarity index 53% rename from common/src/test/java/me/lucko/luckperms/common/node/utils/ShorthandParserTest.java rename to common/src/test/java/me/lucko/luckperms/common/model/TrackManagerTest.java index 2cdbc5bc2..b9e6f4a7d 100644 --- a/common/src/test/java/me/lucko/luckperms/common/node/utils/ShorthandParserTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/model/TrackManagerTest.java @@ -23,48 +23,31 @@ * SOFTWARE. */ -package me.lucko.luckperms.common.node.utils; +package me.lucko.luckperms.common.model; import com.google.common.collect.ImmutableSet; +import me.lucko.luckperms.common.model.manager.track.StandardTrackManager; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; + 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 org.junit.jupiter.api.Assertions.assertEquals; -public class ShorthandParserTest { +@ExtendWith(MockitoExtension.class) +public class TrackManagerTest { - private static void test(String shorthand, String... expected) { - assertEquals(ImmutableSet.copyOf(expected), ShorthandParser.expandShorthand(shorthand)); - } + @Mock private LuckPermsPlugin plugin; @Test - void testNumericRange() { - test("{2-4}", "2", "3", "4"); - } - - @Test - void testCharacterRange() { - test("{a-d}", "a", "b", "c", "d"); - test("{A-D}", "A", "B", "C", "D"); - } - - @Test - void testList() { - test("{aa,bb,cc}", "aa", "bb", "cc"); - test("{aa|bb|cc}", "aa", "bb", "cc"); - test("{aa,bb|cc}", "aa", "bb", "cc"); - } - - @Test - void testGroups() { - test("he{y|llo} {1-2}", "hey 1", "hey 2", "hello 1", "hello 2"); - test("my.permission.{test,hi}", "my.permission.test", "my.permission.hi"); - test("my.permission.{a-c}", "my.permission.a", "my.permission.b", "my.permission.c"); - - // use ( ) instead - test("he(y|llo) (1-2)", "hey 1", "hey 2", "hello 1", "hello 2"); - test("my.permission.(test,hi)", "my.permission.test", "my.permission.hi"); - test("my.permission.(a-c)", "my.permission.a", "my.permission.b", "my.permission.c"); + public void testSanitizeIdentifier() { + StandardTrackManager manager = new StandardTrackManager(this.plugin); + Track track = manager.getOrMake("TEST"); + assertEquals("test", track.getName()); + assertEquals(ImmutableSet.of("test"), manager.getAll().keySet()); } } diff --git a/common/src/test/java/me/lucko/luckperms/common/model/UserManagerTest.java b/common/src/test/java/me/lucko/luckperms/common/model/UserManagerTest.java new file mode 100644 index 000000000..2d58a0382 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/model/UserManagerTest.java @@ -0,0 +1,115 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.model; + +import com.google.common.collect.ImmutableList; + +import me.lucko.luckperms.common.config.ConfigKeys; +import me.lucko.luckperms.common.config.LuckPermsConfiguration; +import me.lucko.luckperms.common.event.EventDispatcher; +import me.lucko.luckperms.common.model.manager.user.StandardUserManager; +import me.lucko.luckperms.common.node.types.Inheritance; +import me.lucko.luckperms.common.node.types.Permission; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; +import me.lucko.luckperms.common.plugin.bootstrap.LuckPermsBootstrap; +import me.lucko.luckperms.common.plugin.scheduler.SchedulerAdapter; + +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 java.util.UUID; +import java.util.concurrent.TimeUnit; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.mock; + +@ExtendWith(MockitoExtension.class) +public class UserManagerTest { + + @Mock private LuckPermsPlugin plugin; + @Mock private LuckPermsBootstrap bootstrap; + @Mock private LuckPermsConfiguration configuration; + + @BeforeEach + public void setupMocks() { + lenient().when(this.plugin.getBootstrap()).thenReturn(this.bootstrap); + lenient().when(this.plugin.getConfiguration()).thenReturn(this.configuration); + lenient().when(this.plugin.getEventDispatcher()).thenReturn(mock(EventDispatcher.class)); + lenient().when(this.bootstrap.getScheduler()).thenReturn(mock(SchedulerAdapter.class)); + lenient().when(this.configuration.get(ConfigKeys.PRIMARY_GROUP_CALCULATION)).thenReturn(PrimaryGroupHolder.AllParentsByWeight::new); + lenient().when(this.configuration.get(ConfigKeys.PRIMARY_GROUP_CALCULATION_METHOD)).thenReturn("parents-by-weight"); + } + + @Test + public void testGiveDefaultIfNeeded() { + StandardUserManager manager = new StandardUserManager(this.plugin); + + User user = manager.getOrMake(UUID.randomUUID()); + assertEquals(ImmutableList.of(), user.normalData().asList()); + + boolean changed = manager.giveDefaultIfNeeded(user); + assertTrue(changed); + + Inheritance defaultNode = Inheritance.builder("default").build(); + assertEquals(ImmutableList.of(defaultNode), user.normalData().asList()); + + changed = manager.giveDefaultIfNeeded(user); + assertFalse(changed); + } + + @Test + public void testIsNonDefaultUser() { + StandardUserManager manager = new StandardUserManager(this.plugin); + User user = manager.getOrMake(UUID.randomUUID()); + manager.giveDefaultIfNeeded(user); + + assertFalse(manager.isNonDefaultUser(user)); + + user.normalData().add(Permission.builder().permission("test").build()); + assertTrue(manager.isNonDefaultUser(user)); + } + + @Test + public void testIsDefaultNode() { + StandardUserManager manager = new StandardUserManager(this.plugin); + + assertTrue(manager.isDefaultNode(Inheritance.builder().group("default").build())); + assertTrue(manager.isDefaultNode(Inheritance.builder().group("Default").build())); + + assertFalse(manager.isDefaultNode(Inheritance.builder().group("default").value(false).build())); + assertFalse(manager.isDefaultNode(Inheritance.builder().group("default").withContext("server", "test").build())); + assertFalse(manager.isDefaultNode(Inheritance.builder().group("default").expiry(1, TimeUnit.DAYS).build())); + assertFalse(manager.isDefaultNode(Inheritance.builder().group("test").build())); + assertFalse(manager.isDefaultNode(Permission.builder().permission("hello").build())); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/node/NodeBuildersTest.java b/common/src/test/java/me/lucko/luckperms/common/node/NodeBuildersTest.java new file mode 100644 index 000000000..95850ac31 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/node/NodeBuildersTest.java @@ -0,0 +1,70 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.node; + +import me.lucko.luckperms.common.node.factory.NodeBuilders; +import me.lucko.luckperms.common.node.types.Permission; + +import net.luckperms.api.node.Node; +import net.luckperms.api.node.NodeBuilder; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class NodeBuildersTest { + + @ParameterizedTest + @CsvSource({ + "luckperms.user.info, Permission$Builder, PERMISSION", + "group.default, Inheritance$Builder, INHERITANCE", + "meta.key.value, Meta$Builder, META", + "prefix.100.hello, Prefix$Builder, PREFIX", + "suffix.100.hello, Suffix$Builder, SUFFIX", + "displayname.hello, DisplayName$Builder, DISPLAY_NAME", + "weight.10, Weight$Builder, WEIGHT", + "r=hello, RegexPermission$Builder, REGEX_PERMISSION", + "R=hello, RegexPermission$Builder, REGEX_PERMISSION" + }) + public void testDetermineMostApplicableType(String key, String expectedBuilderClass, String expectedType) { + NodeBuilder builder = NodeBuilders.determineMostApplicable(key); + assertTrue(builder.getClass().getName().endsWith(expectedBuilderClass)); + + Node node = builder.build(); + assertEquals(expectedType, node.getType().name()); + } + + @Test + public void testNonSpecificNodeBuild() { + Permission.Builder builder = Permission.builder().permission("group.default"); + assertThrows(IllegalArgumentException.class, builder::build); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/node/NodeParseTest.java b/common/src/test/java/me/lucko/luckperms/common/node/NodeParseTest.java new file mode 100644 index 000000000..2590535c3 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/node/NodeParseTest.java @@ -0,0 +1,253 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.node; + +import me.lucko.luckperms.common.node.types.DisplayName; +import me.lucko.luckperms.common.node.types.Inheritance; +import me.lucko.luckperms.common.node.types.Meta; +import me.lucko.luckperms.common.node.types.Prefix; +import me.lucko.luckperms.common.node.types.RegexPermission; +import me.lucko.luckperms.common.node.types.Suffix; +import me.lucko.luckperms.common.node.types.Weight; + +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.ValueSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; + +public class NodeParseTest { + + @ParameterizedTest + @CsvSource({ + "group.test, test", + "group.TEST, test", + "group.hello world, hello world" + }) + public void testInheritance(String key, String expectedGroupName) { + Inheritance.Builder builder = Inheritance.parse(key); + assertNotNull(builder); + + Inheritance node = builder.build(); + assertEquals(expectedGroupName, node.getGroupName()); + } + + @ParameterizedTest + @ValueSource(strings = { + "", + "aaaa" + }) + public void testInheritanceFail(String key) { + Inheritance.Builder builder = Inheritance.parse(key); + assertNull(builder); + } + + @ParameterizedTest + @CsvSource({ + "displayname.test, test", + "displayname.TEST, TEST", + "displayname.hello world, hello world" + }) + public void testDisplayName(String key, String expectedDisplayName) { + DisplayName.Builder builder = DisplayName.parse(key); + assertNotNull(builder); + + DisplayName node = builder.build(); + assertEquals(expectedDisplayName, node.getDisplayName()); + } + + @ParameterizedTest + @ValueSource(strings = { + "", + "aaaa" + }) + public void testDisplayNameFail(String key) { + DisplayName.Builder builder = DisplayName.parse(key); + assertNull(builder); + } + + @ParameterizedTest + @CsvSource({ + "weight.100, 100", + "weight.-100, -100", + "weight.0, 0" + }) + public void testWeight(String key, int expectedWeight) { + Weight.Builder builder = Weight.parse(key); + assertNotNull(builder); + + Weight node = builder.build(); + assertEquals(expectedWeight, node.getWeight()); + } + + @ParameterizedTest + @ValueSource(strings = { + "", + "aaaa", + "weight.", + "weight.hello" + }) + public void testWeightFail(String key) { + Weight.Builder builder = Weight.parse(key); + assertNull(builder); + } + + @ParameterizedTest + @CsvSource({ + "prefix.100.hello, 100, hello", + "prefix.-100.hello, -100, hello", + "prefix.0.hello, 0, hello", + "prefix.100.hello world, 100, hello world", + "prefix.100.HELLO world &123, 100, HELLO world &123", + "prefix.100., 100, ''" + }) + public void testPrefix(String key, int expectedPriority, String expectedValue) { + Prefix.Builder builder = Prefix.parse(key); + assertNotNull(builder); + + Prefix node = builder.build(); + assertEquals(expectedPriority, node.getPriority()); + assertEquals(expectedValue, node.getMetaValue()); + } + + @ParameterizedTest + @ValueSource(strings = { + "", + "aaaa", + "prefix.", + "prefix.hello", + "prefix.100", + "prefix.hello.hello" + }) + public void testPrefixFail(String key) { + Prefix.Builder builder = Prefix.parse(key); + assertNull(builder); + } + + @ParameterizedTest + @CsvSource({ + "suffix.100.hello, 100, hello", + "suffix.-100.hello, -100, hello", + "suffix.0.hello, 0, hello", + "suffix.100.hello world, 100, hello world", + "suffix.100.HELLO world &123, 100, HELLO world &123", + "suffix.100., 100, ''" + }) + public void testSuffix(String key, int expectedPriority, String expectedValue) { + Suffix.Builder builder = Suffix.parse(key); + assertNotNull(builder); + + Suffix node = builder.build(); + assertEquals(expectedPriority, node.getPriority()); + assertEquals(expectedValue, node.getMetaValue()); + } + + @ParameterizedTest + @ValueSource(strings = { + "", + "aaaa", + "suffix.", + "suffix.hello", + "suffix.100", + "suffix.hello.hello" + }) + public void testSuffixFail(String key) { + Suffix.Builder builder = Suffix.parse(key); + assertNull(builder); + } + + @ParameterizedTest + @CsvSource({ + "meta.k.v, k, v", + "meta.hello.world, hello, world", + "meta.hello., hello, ''" + }) + public void testMeta(String key, String expectedKey, String expectedValue) { + Meta.Builder builder = Meta.parse(key); + assertNotNull(builder); + + Meta node = builder.build(); + assertEquals(expectedKey, node.getMetaKey()); + assertEquals(expectedValue, node.getMetaValue()); + } + + @ParameterizedTest + @ValueSource(strings = { + "", + "aaaa", + "meta.", + "meta.hello", + }) + public void testMetaFail(String key) { + Meta.Builder builder = Meta.parse(key); + assertNull(builder); + } + + @ParameterizedTest + @ValueSource(strings = { + "meta.." + }) + public void testMetaFailThrows(String key) { + assertThrows(IllegalArgumentException.class, () -> Meta.parse(key)); + } + + @ParameterizedTest + @CsvSource({ + "r=hello, hello", + "R=hello, hello", + "r=.*&^12 3[], .*&^12 3[]" + }) + public void testRegexPermission(String key, String expectedPattern) { + RegexPermission.Builder builder = RegexPermission.parse(key); + assertNotNull(builder); + + RegexPermission node = builder.build(); + assertEquals(expectedPattern, node.getPatternString()); + } + + @ParameterizedTest + @ValueSource(strings = { + "", + "aaaa" + }) + public void testRegexPermissionFail(String key) { + RegexPermission.Builder builder = RegexPermission.parse(key); + assertNull(builder); + } + + @ParameterizedTest + @ValueSource(strings = { + "r=", + "R=" + }) + public void testRegexPermissionFailThrows(String key) { + assertThrows(IllegalArgumentException.class, () -> RegexPermission.parse(key)); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/node/NodeTest.java b/common/src/test/java/me/lucko/luckperms/common/node/NodeTest.java new file mode 100644 index 000000000..d20bdc3e8 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/node/NodeTest.java @@ -0,0 +1,139 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.node; + +import me.lucko.luckperms.common.context.ImmutableContextSetImpl; +import me.lucko.luckperms.common.node.types.Permission; + +import net.luckperms.api.context.ImmutableContextSet; +import net.luckperms.api.node.Node; +import net.luckperms.api.node.metadata.NodeMetadataKey; + +import org.junit.jupiter.api.Test; + +import java.time.Instant; +import java.time.temporal.ChronoUnit; +import java.util.Optional; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class NodeTest { + + @Test + public void testBasic() { + Node node = Permission.builder() + .permission("hello.world") + .build(); + + assertEquals("hello.world", node.getKey()); + assertTrue(node.getValue()); + assertNull(node.getExpiry()); + assertNull(node.getExpiryDuration()); + assertFalse(node.hasExpired()); + assertFalse(node.hasExpiry()); + } + + @Test + public void testExpiry() { + Instant instant = Instant.now() + .plusSeconds(60) + .truncatedTo(ChronoUnit.SECONDS); + + Node node = Permission.builder() + .permission("hello.world") + .expiry(instant) + .build(); + + assertEquals("hello.world", node.getKey()); + assertTrue(node.getValue()); + assertEquals(instant, node.getExpiry()); + assertNotNull(node.getExpiryDuration()); + assertFalse(node.hasExpired()); + assertTrue(node.hasExpiry()); + } + + @Test + public void testContext() { + Node node = Permission.builder() + .permission("hello.world") + .withContext("hello", "123") + .withContext("world", "456") + .build(); + + ImmutableContextSet contexts = node.getContexts(); + ImmutableContextSet expected = new ImmutableContextSetImpl.BuilderImpl() + .add("hello", "123") + .add("world", "456") + .build(); + + assertEquals(expected, contexts); + } + + @Test + public void testMetadata() { + NodeMetadataKey key = NodeMetadataKey.of("test2", UUID.class); + UUID randomUniqueId = UUID.randomUUID(); + + Node node = Permission.builder() + .permission("hello.world") + .withMetadata(key, randomUniqueId) + .build(); + + assertEquals(Optional.of(randomUniqueId), node.getMetadata(key)); + assertEquals(randomUniqueId, node.metadata(key)); + } + + @Test + public void testMetadataFails() { + NodeMetadataKey key1 = NodeMetadataKey.of("test1", String.class); + NodeMetadataKey key2 = NodeMetadataKey.of("test2", UUID.class); + NodeMetadataKey key3 = NodeMetadataKey.of("test2", UUID.class); + NodeMetadataKey key4 = NodeMetadataKey.of("test2", String.class); + UUID randomUniqueId = UUID.randomUUID(); + + Node node = Permission.builder() + .permission("hello.world") + .withMetadata(key2, randomUniqueId) + .build(); + + assertEquals(Optional.of(randomUniqueId), node.getMetadata(key2)); + assertEquals(Optional.of(randomUniqueId), node.getMetadata(key3)); + assertEquals(randomUniqueId, node.metadata(key2)); + assertEquals(randomUniqueId, node.metadata(key3)); + + assertEquals(Optional.empty(), node.getMetadata(key1)); + assertEquals(Optional.empty(), node.getMetadata(key4)); + assertThrows(IllegalStateException.class, () -> node.metadata(key1)); + assertThrows(IllegalStateException.class, () -> node.metadata(key4)); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/node/ShorthandParserTest.java b/common/src/test/java/me/lucko/luckperms/common/node/ShorthandParserTest.java new file mode 100644 index 000000000..33a62de7d --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/node/ShorthandParserTest.java @@ -0,0 +1,73 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.node; + +import com.google.common.collect.ImmutableSet; + +import me.lucko.luckperms.common.node.utils.ShorthandParser; + +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.util.stream.Stream; + +public class ShorthandParserTest { + + private static Stream testParse() { + return Stream.of( + // numeric range + Arguments.of("{2-4}", new String[]{"2", "3", "4"}), + + // character range + Arguments.of("{a-d}", new String[]{"a", "b", "c", "d"}), + Arguments.of("{A-D}", new String[]{"A", "B", "C", "D"}), + + // list + Arguments.of("{aa,bb,cc}", new String[]{"aa", "bb", "cc"}), + Arguments.of("{aa|bb|cc}", new String[]{"aa", "bb", "cc"}), + Arguments.of("{aa,bb|cc}", new String[]{"aa", "bb", "cc"}), + + // groups + Arguments.of("he{y|llo} {1-2}", new String[]{"hey 1", "hey 2", "hello 1", "hello 2"}), + Arguments.of("my.permission.{test,hi}", new String[]{"my.permission.test", "my.permission.hi"}), + Arguments.of("my.permission.{a-c}", new String[]{"my.permission.a", "my.permission.b", "my.permission.c"}), + + // groups - using () instead + Arguments.of("he(y|llo) (1-2)", new String[]{"hey 1", "hey 2", "hello 1", "hello 2"}), + Arguments.of("my.permission.(test,hi)", new String[]{"my.permission.test", "my.permission.hi"}), + Arguments.of("my.permission.(a-c)", new String[]{"my.permission.a", "my.permission.b", "my.permission.c"}) + ); + } + + @ParameterizedTest + @MethodSource + public void testParse(String shorthand, String[] expected) { + Assertions.assertEquals(ImmutableSet.copyOf(expected), ShorthandParser.expandShorthand(shorthand)); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/storage/SqlStorageTest.java b/common/src/test/java/me/lucko/luckperms/common/storage/SqlStorageTest.java new file mode 100644 index 000000000..98bbd0cc9 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/storage/SqlStorageTest.java @@ -0,0 +1,246 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.storage; + +import com.google.common.collect.ImmutableSet; + +import me.lucko.luckperms.common.actionlog.Log; +import me.lucko.luckperms.common.actionlog.LoggedAction; +import me.lucko.luckperms.common.event.EventDispatcher; +import me.lucko.luckperms.common.model.Group; +import me.lucko.luckperms.common.model.manager.group.GroupManager; +import me.lucko.luckperms.common.model.manager.group.StandardGroupManager; +import me.lucko.luckperms.common.node.types.Permission; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; +import me.lucko.luckperms.common.plugin.bootstrap.LuckPermsBootstrap; +import me.lucko.luckperms.common.storage.implementation.sql.SqlStorage; +import me.lucko.luckperms.common.storage.implementation.sql.connection.ConnectionFactory; +import me.lucko.luckperms.common.storage.implementation.sql.connection.file.NonClosableConnection; + +import net.luckperms.api.actionlog.Action; +import net.luckperms.api.model.PlayerSaveResult; +import net.luckperms.api.model.PlayerSaveResult.Outcome; +import net.luckperms.api.node.Node; +import net.luckperms.api.node.types.PermissionNode; + +import org.junit.jupiter.api.AfterEach; +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 java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.Collections; +import java.util.LinkedHashSet; +import java.util.Optional; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.TimeUnit; +import java.util.function.Function; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.AdditionalAnswers.answer; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.lenient; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class SqlStorageTest { + + @Mock private LuckPermsPlugin plugin; + @Mock private LuckPermsBootstrap bootstrap; + + private SqlStorage storage; + + @BeforeEach + public void setupMocksAndDatabase() throws Exception { + lenient().when(this.plugin.getBootstrap()).thenReturn(this.bootstrap); + lenient().when(this.bootstrap.getResourceStream(anyString())) + .then(answer((String path) -> SqlStorageTest.class.getClassLoader().getResourceAsStream(path))); + lenient().when(this.plugin.getEventDispatcher()).thenReturn(mock(EventDispatcher.class)); + + this.storage = new SqlStorage(this.plugin, new TestH2ConnectionFactory(), "luckperms_"); + this.storage.init(); + } + + @AfterEach + public void shutdownDatabase() { + this.storage.shutdown(); + } + + @Test + public void testActionLog() throws Exception { + LoggedAction action = LoggedAction.build() + .source(UUID.randomUUID()) + .sourceName("Test Source") + .targetType(Action.Target.Type.USER) + .target(UUID.randomUUID()) + .targetName("Test Target") + .description("hello 123 hello 123") + .build(); + + this.storage.logAction(action); + + Log log = this.storage.getLog(); + assertEquals(1, log.getContent().size()); + assertEquals(action, log.getContent().first()); + } + + @Test + public void testSavePlayerData() throws Exception { + UUID uniqueId = UUID.randomUUID(); + + // clean insert + PlayerSaveResult r1 = this.storage.savePlayerData(uniqueId, "Player1"); + assertEquals(ImmutableSet.of(Outcome.CLEAN_INSERT), r1.getOutcomes()); + assertNull(r1.getOtherUniqueIds()); + assertNull(r1.getPreviousUsername()); + + // no change expected + PlayerSaveResult r2 = this.storage.savePlayerData(uniqueId, "Player1"); + assertEquals(ImmutableSet.of(Outcome.NO_CHANGE), r2.getOutcomes()); + assertNull(r2.getOtherUniqueIds()); + assertNull(r2.getPreviousUsername()); + + // changed username + PlayerSaveResult r3 = this.storage.savePlayerData(uniqueId, "Player2"); + assertEquals(ImmutableSet.of(Outcome.USERNAME_UPDATED), r3.getOutcomes()); + assertNull(r3.getOtherUniqueIds()); + assertTrue("Player1".equalsIgnoreCase(r3.getPreviousUsername())); + + // changed uuid + UUID newUniqueId = UUID.randomUUID(); + PlayerSaveResult r4 = this.storage.savePlayerData(newUniqueId, "Player2"); + assertEquals(ImmutableSet.of(Outcome.CLEAN_INSERT, Outcome.OTHER_UNIQUE_IDS_PRESENT_FOR_USERNAME), r4.getOutcomes()); + assertNotNull(r4.getOtherUniqueIds()); + assertEquals(ImmutableSet.of(uniqueId), r4.getOtherUniqueIds()); + assertNull(r2.getPreviousUsername()); + } + + @Test + public void testGetPlayerUniqueIdAndName() throws Exception { + UUID uniqueId = UUID.randomUUID(); + String username = "Player1"; + + this.storage.savePlayerData(uniqueId, username); + + assertEquals(uniqueId, this.storage.getPlayerUniqueId("Player1")); + assertTrue(username.equalsIgnoreCase(this.storage.getPlayerName(uniqueId))); + } + + @Test + public void testGetPlayerUniqueIdAndNameNull() throws Exception { + assertNull(this.storage.getPlayerUniqueId("Player1")); + assertNull(this.storage.getPlayerName(UUID.randomUUID())); + } + + @Test + public void testSaveAndLoadGroup() throws Exception { + StandardGroupManager groupManager = new StandardGroupManager(this.plugin); + + //noinspection unchecked,rawtypes + lenient().when(this.plugin.getGroupManager()).thenReturn((GroupManager) groupManager); + + Group group = this.storage.createAndLoadGroup("test"); + + group.normalData().add(Permission.builder() + .permission("test.1") + .withContext("server", "test") + .build() + ); + group.normalData().add(Permission.builder() + .permission("test.2") + .withContext("world", "test") + .build() + ); + group.normalData().add(Permission.builder() + .permission("test.3") + .expiry(1, TimeUnit.HOURS) + .withContext("server", "test") + .withContext("world", "test") + .withContext("hello", "test") + .build() + ); + + Set nodes = group.normalData().asSet(); + assertEquals(3, nodes.size()); + + this.storage.saveGroup(group); + groupManager.unload("test"); + + Group loaded = this.storage.loadGroup("test").orElse(null); + assertNotNull(loaded); + assertNotSame(group, loaded); + assertEquals(nodes, loaded.normalData().asSet()); + } + + private static class TestH2ConnectionFactory implements ConnectionFactory { + private final NonClosableConnection connection; + + TestH2ConnectionFactory() throws SQLException { + this.connection = new NonClosableConnection( + DriverManager.getConnection("jdbc:h2:mem:test") + ); + } + + @Override + public Connection getConnection() { + return this.connection; + } + + @Override + public String getImplementationName() { + return "H2"; + } + + @Override + public void init(LuckPermsPlugin plugin) { + + } + + @Override + public Function getStatementProcessor() { + return s -> s.replace('\'', '`') + .replace("LIKE", "ILIKE") + .replace("value", "`value`") + .replace("``value``", "`value`"); + } + + @Override + public void shutdown() throws Exception { + this.connection.shutdown(); + } + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/util/DifferenceTest.java b/common/src/test/java/me/lucko/luckperms/common/util/DifferenceTest.java new file mode 100644 index 000000000..c42659de6 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/util/DifferenceTest.java @@ -0,0 +1,86 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.util; + +import com.google.common.collect.ImmutableSet; + +import me.lucko.luckperms.common.util.Difference.ChangeType; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class DifferenceTest { + + @Test + public void testSimple() { + Difference diff = new Difference<>(); + assertTrue(diff.isEmpty()); + + diff.recordChange(ChangeType.ADD, "test1"); + diff.recordChange(ChangeType.REMOVE, "test2"); + diff.recordChange(ChangeType.ADD, "test3"); + + assertEquals(ImmutableSet.of("test1", "test3"), diff.getAdded()); + assertEquals(ImmutableSet.of("test2"), diff.getRemoved()); + + assertFalse(diff.isEmpty()); + assertEquals(3, diff.getChanges().size()); + } + + @Test + public void testOverride() { + Difference diff = new Difference<>(); + assertTrue(diff.isEmpty()); + + diff.recordChange(ChangeType.ADD, "test1"); + diff.recordChange(ChangeType.REMOVE, "test1"); + + assertTrue(diff.isEmpty()); + } + + @Test + public void testMerge() { + Difference diff = new Difference<>(); + diff.recordChange(ChangeType.ADD, "test1"); + + Difference diff2 = new Difference<>(); + diff2.recordChange(ChangeType.REMOVE, "test1"); + + assertEquals(1, diff.getChanges().size()); + assertEquals(1, diff2.getChanges().size()); + + Difference returnedDiff = diff.mergeFrom(diff2); + assertSame(diff, returnedDiff); + + assertEquals(0, diff.getChanges().size()); + assertEquals(1, diff2.getChanges().size()); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/util/DurationFormatterTest.java b/common/src/test/java/me/lucko/luckperms/common/util/DurationFormatterTest.java new file mode 100644 index 000000000..a7d7b8079 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/util/DurationFormatterTest.java @@ -0,0 +1,116 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.util; + +import net.kyori.adventure.key.Key; +import net.kyori.adventure.text.Component; +import net.kyori.adventure.text.renderer.TranslatableComponentRenderer; +import net.kyori.adventure.text.serializer.plain.PlainTextComponentSerializer; +import net.kyori.adventure.translation.TranslationRegistry; +import net.kyori.adventure.util.UTF8ResourceBundleControl; + +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.time.Duration; +import java.time.temporal.ChronoUnit; +import java.util.Locale; +import java.util.ResourceBundle; +import java.util.stream.Stream; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class DurationFormatterTest { + + private static TranslatableComponentRenderer renderer; + + @BeforeAll + public static void setupRenderer() { + TranslationRegistry registry = TranslationRegistry.create(Key.key("luckperms", "test")); + + ResourceBundle bundle = ResourceBundle.getBundle("luckperms", Locale.ENGLISH, UTF8ResourceBundleControl.get()); + registry.registerAll(Locale.ENGLISH, bundle, false); + + renderer = TranslatableComponentRenderer.usingTranslationSource(registry); + } + + private static String render(Component component) { + return PlainTextComponentSerializer.plainText().serialize(renderer.render(component, Locale.ENGLISH)); + } + + private static Stream testSimple() { + Duration years = ChronoUnit.YEARS.getDuration(); + Duration months = ChronoUnit.MONTHS.getDuration(); + + return Stream.of( + Arguments.of("1 year", years.multipliedBy(1)), + Arguments.of("2 years", years.multipliedBy(2)), + Arguments.of("3 years", years.multipliedBy(3)), + Arguments.of("15 years", years.multipliedBy(15)), + Arguments.of("1 month", months.multipliedBy(1)), + Arguments.of("2 months", months.multipliedBy(2)), + Arguments.of("1 week", Duration.ofDays(7)), + Arguments.of("2 weeks", Duration.ofDays(7 * 2)), + Arguments.of("1 day", Duration.ofDays(1)), + Arguments.of("2 days", Duration.ofDays(2)), + Arguments.of("1 hour", Duration.ofHours(1)), + Arguments.of("2 hours", Duration.ofHours(2)), + Arguments.of("15 hours", Duration.ofHours(15)), + Arguments.of("1 minute", Duration.ofMinutes(1)), + Arguments.of("2 minutes", Duration.ofMinutes(2)), + Arguments.of("15 minutes", Duration.ofMinutes(15)), + Arguments.of("1 second", Duration.ofSeconds(1)), + Arguments.of("2 seconds", Duration.ofSeconds(2)), + Arguments.of("15 seconds", Duration.ofSeconds(15)), + Arguments.of("0 seconds", Duration.ZERO) + ); + } + + @ParameterizedTest + @MethodSource + public void testSimple(String expected, Duration input) { + assertEquals(expected, render(DurationFormatter.LONG.format(input))); + } + + @Test + public void testFormats() { + Duration duration = ChronoUnit.YEARS.getDuration().multipliedBy(5) + .plus(ChronoUnit.MONTHS.getDuration().multipliedBy(4)) + .plus(ChronoUnit.WEEKS.getDuration().multipliedBy(3)) + .plusDays(2) + .plusHours(1) + .plusMinutes(6) + .plusSeconds(7); + + assertEquals("5y 4mo 3w 2d 1h 6m 7s", render(DurationFormatter.CONCISE.format(duration))); + assertEquals("5y 4mo 3w", render(DurationFormatter.CONCISE_LOW_ACCURACY.format(duration))); + assertEquals("5 years 4 months 3 weeks 2 days 1 hour 6 minutes 7 seconds", render(DurationFormatter.LONG.format(duration))); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/util/DurationParserTest.java b/common/src/test/java/me/lucko/luckperms/common/util/DurationParserTest.java index a96d7fd40..5b6e28c15 100644 --- a/common/src/test/java/me/lucko/luckperms/common/util/DurationParserTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/util/DurationParserTest.java @@ -25,82 +25,100 @@ package me.lucko.luckperms.common.util; -import org.junit.jupiter.api.Test; +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 java.time.Duration; import java.time.temporal.ChronoUnit; +import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; public class DurationParserTest { - private static void test(Duration expected, String input) { + private static Stream testSimple() { + Duration years = ChronoUnit.YEARS.getDuration(); + Duration months = ChronoUnit.MONTHS.getDuration(); + + return Stream.of( + Arguments.of("2y", years.multipliedBy(2)), + Arguments.of("3year", years.multipliedBy(3)), + Arguments.of("4years", years.multipliedBy(4)), + Arguments.of("2 y", years.multipliedBy(2)), + Arguments.of("3 year", years.multipliedBy(3)), + Arguments.of("4 years", years.multipliedBy(4)), + + Arguments.of("2mo", months.multipliedBy(2)), + Arguments.of("3month", months.multipliedBy(3)), + Arguments.of("4months", months.multipliedBy(4)), + Arguments.of("2 mo", months.multipliedBy(2)), + Arguments.of("3 month", months.multipliedBy(3)), + Arguments.of("4 months", months.multipliedBy(4)), + + Arguments.of("2w", Duration.ofDays(7 * 2)), + Arguments.of("3week", Duration.ofDays(7 * 3)), + Arguments.of("4weeks", Duration.ofDays(7 * 4)), + Arguments.of("2 w", Duration.ofDays(7 * 2)), + Arguments.of("3 week", Duration.ofDays(7 * 3)), + Arguments.of("4 weeks", Duration.ofDays(7 * 4)), + + Arguments.of("2d", Duration.ofDays(2)), + Arguments.of("3day", Duration.ofDays(3)), + Arguments.of("4days", Duration.ofDays(4)), + Arguments.of("2 d", Duration.ofDays(2)), + Arguments.of("3 day", Duration.ofDays(3)), + Arguments.of("4 days", Duration.ofDays(4)), + + Arguments.of("2h", Duration.ofHours(2)), + Arguments.of("3hour", Duration.ofHours(3)), + Arguments.of("4hours", Duration.ofHours(4)), + Arguments.of("2 h", Duration.ofHours(2)), + Arguments.of("3 hour", Duration.ofHours(3)), + Arguments.of("4 hours", Duration.ofHours(4)), + + Arguments.of("2m", Duration.ofMinutes(2)), + Arguments.of("3min", Duration.ofMinutes(3)), + Arguments.of("4mins", Duration.ofMinutes(4)), + Arguments.of("5minute", Duration.ofMinutes(5)), + Arguments.of("6minutes", Duration.ofMinutes(6)), + Arguments.of("2 m", Duration.ofMinutes(2)), + Arguments.of("3 min", Duration.ofMinutes(3)), + Arguments.of("4 mins", Duration.ofMinutes(4)), + Arguments.of("5 minute", Duration.ofMinutes(5)), + Arguments.of("6 minutes", Duration.ofMinutes(6)), + + Arguments.of("2s", Duration.ofSeconds(2)), + Arguments.of("3sec", Duration.ofSeconds(3)), + Arguments.of("4secs", Duration.ofSeconds(4)), + Arguments.of("5second", Duration.ofSeconds(5)), + Arguments.of("6seconds", Duration.ofSeconds(6)), + Arguments.of("2 s", Duration.ofSeconds(2)), + Arguments.of("3 sec", Duration.ofSeconds(3)), + Arguments.of("4 secs", Duration.ofSeconds(4)), + Arguments.of("5 second", Duration.ofSeconds(5)), + Arguments.of("6 seconds", Duration.ofSeconds(6)) + ); + } + + @ParameterizedTest + @MethodSource + public void testSimple(String input, Duration expected) { assertEquals(expected, DurationParser.parseDuration(input)); } - @Test - void testSimple() { - test(ChronoUnit.YEARS.getDuration().multipliedBy(2), "2y"); - test(ChronoUnit.YEARS.getDuration().multipliedBy(3), "3year"); - test(ChronoUnit.YEARS.getDuration().multipliedBy(4), "4years"); - test(ChronoUnit.YEARS.getDuration().multipliedBy(2), "2 y"); - test(ChronoUnit.YEARS.getDuration().multipliedBy(3), "3 year"); - test(ChronoUnit.YEARS.getDuration().multipliedBy(4), "4 years"); - - test(ChronoUnit.MONTHS.getDuration().multipliedBy(2), "2mo"); - test(ChronoUnit.MONTHS.getDuration().multipliedBy(3), "3month"); - test(ChronoUnit.MONTHS.getDuration().multipliedBy(4), "4months"); - test(ChronoUnit.MONTHS.getDuration().multipliedBy(2), "2 mo"); - test(ChronoUnit.MONTHS.getDuration().multipliedBy(3), "3 month"); - test(ChronoUnit.MONTHS.getDuration().multipliedBy(4), "4 months"); - - test(Duration.ofDays(7 * 2), "2w"); - test(Duration.ofDays(7 * 3), "3week"); - test(Duration.ofDays(7 * 4), "4weeks"); - test(Duration.ofDays(7 * 2), "2 w"); - test(Duration.ofDays(7 * 3), "3 week"); - test(Duration.ofDays(7 * 4), "4 weeks"); - - test(Duration.ofDays(2), "2d"); - test(Duration.ofDays(3), "3day"); - test(Duration.ofDays(4), "4days"); - test(Duration.ofDays(2), "2 d"); - test(Duration.ofDays(3), "3 day"); - test(Duration.ofDays(4), "4 days"); - - test(Duration.ofHours(2), "2h"); - test(Duration.ofHours(3), "3hour"); - test(Duration.ofHours(4), "4hours"); - test(Duration.ofHours(2), "2 h"); - test(Duration.ofHours(3), "3 hour"); - test(Duration.ofHours(4), "4 hours"); - - test(Duration.ofMinutes(2), "2m"); - test(Duration.ofMinutes(3), "3min"); - test(Duration.ofMinutes(4), "4mins"); - test(Duration.ofMinutes(5), "5minute"); - test(Duration.ofMinutes(6), "6minutes"); - test(Duration.ofMinutes(2), "2 m"); - test(Duration.ofMinutes(3), "3 min"); - test(Duration.ofMinutes(4), "4 mins"); - test(Duration.ofMinutes(5), "5 minute"); - test(Duration.ofMinutes(6), "6 minutes"); - - test(Duration.ofSeconds(2), "2s"); - test(Duration.ofSeconds(3), "3sec"); - test(Duration.ofSeconds(4), "4secs"); - test(Duration.ofSeconds(5), "5second"); - test(Duration.ofSeconds(6), "6seconds"); - test(Duration.ofSeconds(2), "2 s"); - test(Duration.ofSeconds(3), "3 sec"); - test(Duration.ofSeconds(4), "4 secs"); - test(Duration.ofSeconds(5), "5 second"); - test(Duration.ofSeconds(6), "6 seconds"); - } - - @Test - void testCombined() { + @ParameterizedTest + @ValueSource(strings = { + "5y 4mo 3w 2d 1h 6m 7s", + "5y4mo3w2d1h6m7s", + "5 years 4 months 3 weeks 2 days 1 hour 6 minutes 7 seconds", + "5y, 4mo, 3w, 2d, 1h, 6m, 7s", + "5y,4mo,3w,2d,1h,6m,7s", + "5 years, 4 months, 3 weeks, 2 days, 1 hour, 6 minutes, 7 seconds" + }) + public void testCombined(String input) { Duration expected = ChronoUnit.YEARS.getDuration().multipliedBy(5) .plus(ChronoUnit.MONTHS.getDuration().multipliedBy(4)) .plus(ChronoUnit.WEEKS.getDuration().multipliedBy(3)) @@ -109,20 +127,17 @@ public class DurationParserTest { .plusMinutes(6) .plusSeconds(7); - test(expected, "5y 4mo 3w 2d 1h 6m 7s"); - test(expected, "5y4mo3w2d1h6m7s"); - test(expected, "5 years 4 months 3 weeks 2 days 1 hour 6 minutes 7 seconds"); - - test(expected, "5y, 4mo, 3w, 2d, 1h, 6m, 7s"); - test(expected, "5y,4mo,3w,2d,1h,6m,7s"); - test(expected, "5 years, 4 months, 3 weeks, 2 days, 1 hour, 6 minutes, 7 seconds"); + assertEquals(expected, DurationParser.parseDuration(input)); } - @Test - void testFail() { - assertThrows(IllegalArgumentException.class, () -> DurationParser.parseDuration("definitely not a duration")); - assertThrows(IllegalArgumentException.class, () -> DurationParser.parseDuration("still 1 not a duration")); - assertThrows(IllegalArgumentException.class, () -> DurationParser.parseDuration("still 1s not a duration")); + @ParameterizedTest + @ValueSource(strings = { + "definitely not a duration", + "still 1 not a duration", + "still 1s not a duration" + }) + public void testFail(String input) { + assertThrows(IllegalArgumentException.class, () -> DurationParser.parseDuration(input)); } } diff --git a/common/src/test/java/me/lucko/luckperms/common/util/EnumNamerTest.java b/common/src/test/java/me/lucko/luckperms/common/util/EnumNamerTest.java index d2d36e327..c7d1c9411 100644 --- a/common/src/test/java/me/lucko/luckperms/common/util/EnumNamerTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/util/EnumNamerTest.java @@ -36,7 +36,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; public class EnumNamerTest { @Test - void testSimple() { + public void testSimple() { EnumNamer namer = new EnumNamer<>( TestEnum.class, ImmutableMap.of(TestEnum.THING, "hi"), diff --git a/common/src/test/java/me/lucko/luckperms/common/util/IteratorsTest.java b/common/src/test/java/me/lucko/luckperms/common/util/IteratorsTest.java index af30c6375..8ae550b94 100644 --- a/common/src/test/java/me/lucko/luckperms/common/util/IteratorsTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/util/IteratorsTest.java @@ -36,12 +36,12 @@ import static org.junit.jupiter.api.Assertions.assertEquals; public class IteratorsTest { @Test - void testDivideEmpty() { + public void testDivideEmpty() { assertEquals(ImmutableList.of(), Iterators.divideIterable(ImmutableList.of(), 2)); } @Test - void testDivideSimple() { + public void testDivideSimple() { List> expected = ImmutableList.of( ImmutableList.of("one", "two"), ImmutableList.of("three", "four"), @@ -57,7 +57,7 @@ public class IteratorsTest { } @Test - void testDivideBoundary() { + public void testDivideBoundary() { List> expected = ImmutableList.of( ImmutableList.of("one", "two"), ImmutableList.of("three", "four") diff --git a/common/src/test/java/me/lucko/luckperms/common/util/PaginatedTest.java b/common/src/test/java/me/lucko/luckperms/common/util/PaginatedTest.java index 8865db349..360d317b1 100644 --- a/common/src/test/java/me/lucko/luckperms/common/util/PaginatedTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/util/PaginatedTest.java @@ -27,44 +27,79 @@ package me.lucko.luckperms.common.util; import com.google.common.collect.ImmutableList; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.CsvSource; +import org.junit.jupiter.params.provider.MethodSource; import java.util.List; +import java.util.stream.Stream; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertThrows; public class PaginatedTest { - @Test - void testSimple() { - Paginated paginated = new Paginated<>(ImmutableList.of("one", "two", "three", "four", "five")); - assertEquals(3, paginated.getMaxPages(2)); - assertEquals(1, paginated.getMaxPages(5)); - assertEquals(1, paginated.getMaxPages(6)); + private static final Paginated EXAMPLE_PAGE = new Paginated<>(ImmutableList.of("one", "two", "three", "four", "five")); - List> page1 = paginated.getPage(1, 2); - assertEquals(2, page1.size()); - assertEquals("one", page1.get(0).value()); - assertEquals(1, page1.get(0).position()); - assertEquals("two", page1.get(1).value()); - assertEquals(2, page1.get(1).position()); + @ParameterizedTest + @CsvSource({ + "3, 2", + "1, 5", + "1, 6" + }) + public void testMaxPages(int expected, int entriesPerPage) { + assertEquals(expected, EXAMPLE_PAGE.getMaxPages(entriesPerPage)); + } - List> page2 = paginated.getPage(2, 2); - assertEquals(2, page2.size()); - assertEquals("three", page2.get(0).value()); - assertEquals(3, page2.get(0).position()); - assertEquals("four", page2.get(1).value()); - assertEquals(4, page2.get(1).position()); + @ParameterizedTest + @CsvSource({ + "1, 2", + "2, 2", + "3, 1" + }) + public void testPageSize(int pageNo, int expectedSize) { + List> page = EXAMPLE_PAGE.getPage(pageNo, 2); + assertEquals(expectedSize, page.size()); + } - List> page3 = paginated.getPage(3, 2); - assertEquals(1, page3.size()); - assertEquals("five", page3.get(0).value()); - assertEquals(5, page3.get(0).position()); + private static Stream testPageContent() { + return Stream.of( + Arguments.of(1, ImmutableList.of( + new Paginated.Entry<>(1, "one"), + new Paginated.Entry<>(2, "two") + )), + Arguments.of(2, ImmutableList.of( + new Paginated.Entry<>(3, "three"), + new Paginated.Entry<>(4, "four") + )), + Arguments.of(3, ImmutableList.of( + new Paginated.Entry<>(5, "five") + )) + ); + } - assertThrows(IllegalStateException.class, () -> paginated.getPage(4, 2)); - assertThrows(IllegalArgumentException.class, () -> paginated.getPage(0, 2)); - assertThrows(IllegalArgumentException.class, () -> paginated.getPage(-1, 2)); + @ParameterizedTest + @MethodSource + public void testPageContent(int pageNo, List> expectedContent) { + assertEquals(expectedContent, EXAMPLE_PAGE.getPage(pageNo, 2)); + } + + @ParameterizedTest + @CsvSource({ + "4, 2", + }) + public void testFailState(int pageNo, int pageSize) { + assertThrows(IllegalStateException.class, () -> EXAMPLE_PAGE.getPage(pageNo, pageSize)); + } + + @ParameterizedTest + @CsvSource({ + "0, 2", + "-1, 2" + }) + public void testFailArgument(int pageNo, int pageSize) { + assertThrows(IllegalArgumentException.class, () -> EXAMPLE_PAGE.getPage(pageNo, pageSize)); } } diff --git a/common/src/test/java/me/lucko/luckperms/common/util/UniqueIdTypeTest.java b/common/src/test/java/me/lucko/luckperms/common/util/UniqueIdTypeTest.java new file mode 100644 index 000000000..0515f4606 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/util/UniqueIdTypeTest.java @@ -0,0 +1,70 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.util; + +import me.lucko.luckperms.common.event.EventDispatcher; +import me.lucko.luckperms.common.plugin.LuckPermsPlugin; + +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.extension.ExtendWith; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; +import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoExtension; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.mockito.AdditionalAnswers.returnsSecondArg; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.when; + +@ExtendWith(MockitoExtension.class) +public class UniqueIdTypeTest { + + @Mock private LuckPermsPlugin plugin; + @Mock private EventDispatcher dispatcher; + + @BeforeEach + public void setupMocks() { + when(this.plugin.getEventDispatcher()).thenReturn(this.dispatcher); + when(this.dispatcher.dispatchUniqueIdDetermineType(any(), anyString())).then(returnsSecondArg()); + } + + @ParameterizedTest + @CsvSource({ + "797a99ba-c040-4f04-8cfc-6b01a4890d2f, authenticated", + "5d41402a-bc4b-3a76-b971-9d911017c592, unauthenticated", + "cfa4fcb1-a786-23fc-b956-33914c7bb373, npc", + "00000000-0000-0000-0000-000000000000, unknown" + }) + public void testParse(UUID uuid, String expectedType) { + UniqueIdType uniqueIdType = UniqueIdType.determineType(uuid, this.plugin); + assertEquals(expectedType, uniqueIdType.getType()); + } + +} diff --git a/common/src/test/java/me/lucko/luckperms/common/verbose/BooleanExpressionTest.java b/common/src/test/java/me/lucko/luckperms/common/verbose/BooleanExpressionTest.java index 904914c6e..584e8978a 100644 --- a/common/src/test/java/me/lucko/luckperms/common/verbose/BooleanExpressionTest.java +++ b/common/src/test/java/me/lucko/luckperms/common/verbose/BooleanExpressionTest.java @@ -26,28 +26,35 @@ package me.lucko.luckperms.common.verbose; import me.lucko.luckperms.common.verbose.expression.BooleanExpressionCompiler; +import me.lucko.luckperms.common.verbose.expression.BooleanExpressionCompiler.VariableEvaluator; -import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; -import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; public class BooleanExpressionTest { - private static void test(String expression, boolean expected) { - assertEquals( - expected, - BooleanExpressionCompiler.compile(expression).eval(var -> var.equals("true")), - expression + " is not " + expected - ); + private static final VariableEvaluator STRING_EVAL = var -> var.equals("true"); + + @ParameterizedTest + @ValueSource(strings = { + "false & false | true", + "true | false & false", + "(true & ((true | false) & !(true & false)))" + }) + public void testEvaluatesTrue(String expression) { + assertTrue(BooleanExpressionCompiler.compile(expression).eval(STRING_EVAL)); } - @Test - void testBrackets() { - test("false & false | true", true); - test("false & (false | true)", false); - test("true | false & false", true); - test("(true | false) & false", false); - test("(true & ((true | false) & !(true & false)))", true); + @ParameterizedTest + @ValueSource(strings = { + "false & (false | true)", + "(true | false) & false" + }) + public void testEvaluatesFalse(String expression) { + assertFalse(BooleanExpressionCompiler.compile(expression).eval(STRING_EVAL)); } } diff --git a/common/src/test/java/me/lucko/luckperms/common/verbose/VerboseFilterTest.java b/common/src/test/java/me/lucko/luckperms/common/verbose/VerboseFilterTest.java new file mode 100644 index 000000000..5001ece74 --- /dev/null +++ b/common/src/test/java/me/lucko/luckperms/common/verbose/VerboseFilterTest.java @@ -0,0 +1,139 @@ +/* + * This file is part of LuckPerms, licensed under the MIT License. + * + * Copyright (c) lucko (Luck) + * Copyright (c) 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 me.lucko.luckperms.common.verbose; + +import me.lucko.luckperms.common.cacheddata.result.StringResult; +import me.lucko.luckperms.common.cacheddata.result.TristateResult; +import me.lucko.luckperms.common.query.QueryOptionsImpl; +import me.lucko.luckperms.common.verbose.event.CheckOrigin; +import me.lucko.luckperms.common.verbose.event.MetaCheckEvent; +import me.lucko.luckperms.common.verbose.event.PermissionCheckEvent; + +import net.luckperms.api.util.Tristate; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.CsvSource; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +public class VerboseFilterTest { + + @Test + public void testAcceptAll() { + VerboseFilter filter = VerboseFilter.acceptAll(); + assertTrue(filter.isBlank()); + } + + @ParameterizedTest + @CsvSource({ + "luckperms, true", + "luckperms.user, true", + "luckperms.group, false", + "Player1, true", + "Player2, false", + "luckperms & Player1, true", + "permission & luckperms & Player1, true", + "permission & luckperms & Player1 & true, true", + "luckperms & Player2, false", + "luckperms | test, true" + }) + public void testPermissionEvent(String expression, boolean expected) throws InvalidFilterException { + VerboseFilter filter = VerboseFilter.compile(expression); + assertFalse(filter.isBlank()); + + PermissionCheckEvent relevantEvent = new PermissionCheckEvent( + CheckOrigin.INTERNAL, + VerboseCheckTarget.of(VerboseCheckTarget.USER_TYPE, "Player1"), + QueryOptionsImpl.DEFAULT_CONTEXTUAL, + System.currentTimeMillis(), + new Throwable(), + "test", + "luckperms.user.parent.info", + TristateResult.forMonitoredResult(Tristate.TRUE) + ); + + PermissionCheckEvent nonRelevantEvent = new PermissionCheckEvent( + CheckOrigin.INTERNAL, + VerboseCheckTarget.of(VerboseCheckTarget.USER_TYPE, "aaaaaaa"), + QueryOptionsImpl.DEFAULT_CONTEXTUAL, + System.currentTimeMillis(), + new Throwable(), + "test", + "aaaaaaaaa", + TristateResult.forMonitoredResult(Tristate.FALSE) + ); + + assertEquals(expected, filter.evaluate(relevantEvent)); + assertFalse(filter.evaluate(nonRelevantEvent)); + } + + @ParameterizedTest + @CsvSource({ + "nametags, true", + "nametags.nametag, true", + "nametags.other, false", + "Player1, true", + "Player2, false", + "nametags & Player1, true", + "meta & nametags & Player1, true", + "meta & nametags & Player1 & admin, true", + "nametags & Player2, false", + "nametags | test, true" + }) + public void testMetaEvent(String expression, boolean expected) throws InvalidFilterException { + VerboseFilter filter = VerboseFilter.compile(expression); + assertFalse(filter.isBlank()); + + MetaCheckEvent relevantEvent = new MetaCheckEvent( + CheckOrigin.INTERNAL, + VerboseCheckTarget.of(VerboseCheckTarget.USER_TYPE, "Player1"), + QueryOptionsImpl.DEFAULT_CONTEXTUAL, + System.currentTimeMillis(), + new Throwable(), + "test", + "nametags.nametag", + StringResult.of("ADMIN") + ); + + MetaCheckEvent nonRelevantEvent = new MetaCheckEvent( + CheckOrigin.INTERNAL, + VerboseCheckTarget.of(VerboseCheckTarget.USER_TYPE, "aaaaaaa"), + QueryOptionsImpl.DEFAULT_CONTEXTUAL, + System.currentTimeMillis(), + new Throwable(), + "test", + "aaaaaaaaa", + StringResult.of("aaaaaa") + ); + + assertEquals(expected, filter.evaluate(relevantEvent)); + assertFalse(filter.evaluate(nonRelevantEvent)); + } + +} diff --git a/common/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/common/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker new file mode 100644 index 000000000..ca6ee9cea --- /dev/null +++ b/common/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker @@ -0,0 +1 @@ +mock-maker-inline \ No newline at end of file