SteamWar/Paper
9
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Paper Plugins

Browse Source 
Co-authored-by: Micah Rao <micah.s.rao@gmail.com>
This commit is contained in:
Owen1212055
2022-07-06 23:00:31 -04:00
parent 329dfdabdc
commit 216388dfdf
103 changed files with 7450 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

146
paper-server/src/test/java/io/papermc/paper/plugin/PaperTestPlugin.java Normal file
View File

@@ -0,0 +1,146 @@
package io.papermc.paper.plugin;
import io.papermc.paper.plugin.configuration.PluginMeta;
import org.bukkit.Server;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.generator.BiomeProvider;
import org.bukkit.generator.ChunkGenerator;
import org.bukkit.plugin.PluginBase;
import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.PluginLoader;
import org.bukkit.plugin.PluginLogger;
import java.io.File;
import java.io.InputStream;
import java.util.List;
public class PaperTestPlugin extends PluginBase {
private final String pluginName;
private boolean enabled = true;
private final PluginMeta configuration;
public PaperTestPlugin(String pluginName) {
this.pluginName = pluginName;
this.configuration = new TestPluginMeta(pluginName);
}
public PaperTestPlugin(PluginMeta configuration) {
this.configuration = configuration;
this.pluginName = configuration.getName();
}
@Override
public File getDataFolder() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public PluginDescriptionFile getDescription() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public PluginMeta getPluginMeta() {
return this.configuration;
}
@Override
public FileConfiguration getConfig() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public InputStream getResource(String filename) {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public void saveConfig() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public void saveDefaultConfig() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public void saveResource(String resourcePath, boolean replace) {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public void reloadConfig() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public PluginLogger getLogger() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public PluginLoader getPluginLoader() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public Server getServer() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
@Override
public void onDisable() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public void onLoad() {
}
@Override
public void onEnable() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public boolean isNaggable() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public void setNaggable(boolean canNag) {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public BiomeProvider getDefaultBiomeProvider(String worldName, String id) {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
throw new UnsupportedOperationException("Not supported.");
}
}

62
paper-server/src/test/java/io/papermc/paper/plugin/PluginDependencyValidationTest.java Normal file
View File

@@ -0,0 +1,62 @@
package io.papermc.paper.plugin;
import io.papermc.paper.plugin.entrypoint.dependency.MetaDependencyTree;
import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree;
import org.bukkit.support.environment.Normal;
import org.junit.jupiter.api.Test;
import java.util.List;
import static org.hamcrest.MatcherAssert.assertThat;
@Normal
public class PluginDependencyValidationTest {
private static final TestPluginMeta MAIN;
private static final TestPluginMeta HARD_DEPENDENCY_1;
private static final TestPluginMeta SOFT_DEPENDENCY_1;
public static final String ROOT_NAME = "main";
public static final String REGISTERED_HARD_DEPEND = "hard1";
public static final String REGISTERED_SOFT_DEPEND = "soft1";
public static final String UNREGISTERED_HARD_DEPEND = "hard2";
public static final String UNREGISTERED_SOFT_DEPEND = "soft2";
static {
MAIN = new TestPluginMeta(ROOT_NAME);
MAIN.setSoftDependencies(List.of(REGISTERED_SOFT_DEPEND, UNREGISTERED_SOFT_DEPEND));
MAIN.setHardDependencies(List.of(REGISTERED_HARD_DEPEND, UNREGISTERED_HARD_DEPEND));
HARD_DEPENDENCY_1 = new TestPluginMeta(REGISTERED_HARD_DEPEND);
SOFT_DEPENDENCY_1 = new TestPluginMeta(REGISTERED_SOFT_DEPEND);
}
@Test
public void testDependencyTree() {
MetaDependencyTree tree = new SimpleMetaDependencyTree();
tree.add(MAIN);
tree.add(HARD_DEPENDENCY_1);
tree.add(SOFT_DEPENDENCY_1);
// Test simple transitive dependencies
assertThat("%s was not a transitive dependency of %s".formatted(ROOT_NAME, REGISTERED_SOFT_DEPEND), tree.isTransitiveDependency(MAIN, SOFT_DEPENDENCY_1));
assertThat("%s was not a transitive dependency of %s".formatted(ROOT_NAME, REGISTERED_HARD_DEPEND), tree.isTransitiveDependency(MAIN, HARD_DEPENDENCY_1));
assertThat("%s was a transitive dependency of %s".formatted(REGISTERED_SOFT_DEPEND, ROOT_NAME), !tree.isTransitiveDependency(SOFT_DEPENDENCY_1, MAIN));
assertThat("%s was a transitive dependency of %s".formatted(REGISTERED_HARD_DEPEND, ROOT_NAME), !tree.isTransitiveDependency(HARD_DEPENDENCY_1, MAIN));
// Test to ensure that registered dependencies exist
assertThat("tree did not contain dependency %s".formatted(ROOT_NAME), tree.hasDependency(ROOT_NAME));
assertThat("tree did not contain dependency %s".formatted(REGISTERED_HARD_DEPEND), tree.hasDependency(REGISTERED_HARD_DEPEND));
assertThat("tree did not contain dependency %s".formatted(REGISTERED_SOFT_DEPEND), tree.hasDependency(REGISTERED_SOFT_DEPEND));
// Test to ensure unregistered dependencies don't exist
assertThat("tree contained dependency %s".formatted(UNREGISTERED_HARD_DEPEND), !tree.hasDependency(UNREGISTERED_HARD_DEPEND));
assertThat("tree contained dependency %s".formatted(UNREGISTERED_SOFT_DEPEND), !tree.hasDependency(UNREGISTERED_SOFT_DEPEND));
// Test removal
tree.remove(HARD_DEPENDENCY_1);
assertThat("tree contained dependency %s".formatted(REGISTERED_HARD_DEPEND), !tree.hasDependency(REGISTERED_HARD_DEPEND));
}
}

150
paper-server/src/test/java/io/papermc/paper/plugin/PluginLoadOrderTest.java Normal file
View File

@@ -0,0 +1,150 @@
package io.papermc.paper.plugin;
import com.google.common.graph.GraphBuilder;
import io.papermc.paper.plugin.entrypoint.dependency.SimpleMetaDependencyTree;
import io.papermc.paper.plugin.provider.entrypoint.DependencyContext;
import io.papermc.paper.plugin.entrypoint.strategy.modern.ModernPluginLoadingStrategy;
import io.papermc.paper.plugin.entrypoint.strategy.ProviderConfiguration;
import io.papermc.paper.plugin.provider.PluginProvider;
import org.bukkit.support.environment.Normal;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
@Normal
public class PluginLoadOrderTest {
private static List<PluginProvider<PaperTestPlugin>> REGISTERED_PROVIDERS = new ArrayList<>();
private static Map<String, Integer> LOAD_ORDER = new HashMap<>();
private static final String[] EMPTY = {};
static {
setup();
}
private static TestJavaPluginProvider setup(String identifier, String[] loadAfter, String[] loadAfterSoft, String[] before) {
TestPluginMeta configuration = new TestPluginMeta(identifier);
configuration.setHardDependencies(List.of(loadAfter));
configuration.setSoftDependencies(List.of(loadAfterSoft));
configuration.setLoadBefore(List.of(before));
TestJavaPluginProvider provider = new TestJavaPluginProvider(configuration);
REGISTERED_PROVIDERS.add(provider);
return provider;
}
/**
* Obfuscated plugin names, this uses a real dependency tree...
*/
private static void setup() {
setup("RedAir", EMPTY, new String[]{"NightShovel", "EmeraldFire"}, new String[]{"GreenShovel", "IronSpork", "BrightBlueShovel", "WireDoor"});
setup("BigGrass", EMPTY, new String[]{"IronEarth", "RedAir"}, new String[]{"BlueFire"});
setup("BlueFire", EMPTY, EMPTY, EMPTY);
setup("BigPaper", EMPTY, new String[]{"BlueFire"}, EMPTY);
setup("EmeraldSpork", EMPTY, EMPTY, new String[]{"GoldPaper", "YellowSnow"});
setup("GreenShovel", EMPTY, EMPTY, EMPTY);
setup("BrightBlueGrass", new String[]{"BigPaper"}, new String[]{"DarkSpork"}, EMPTY);
setup("GoldPaper", EMPTY, new String[]{"BlueFire"}, EMPTY);
setup("GreenGlass", EMPTY, EMPTY, EMPTY);
setup("GoldNeptune", EMPTY, new String[]{"GreenShovel", "GoldNeptuneVersioning"}, EMPTY);
setup("RedPaper", EMPTY, new String[]{"GoldPaper", "GoldFire", "EmeraldGrass", "BlueFire", "CopperSpork", "YellowDoor", "OrangeClam", "BlueSponge", "GoldNeptune", "BrightBlueGrass", "DarkSpoon", "BigShovel", "GreenGlass", "IronGlass"}, new String[]{"IronPaper", "YellowFire"});
setup("YellowGrass", EMPTY, new String[]{"RedAir"}, EMPTY);
setup("WireFire", EMPTY, new String[]{"RedPaper", "WireGrass", "YellowSpork", "NightAir"}, EMPTY);
setup("OrangeNeptune", EMPTY, EMPTY, EMPTY);
setup("BigSpoon", new String[]{"YellowGrass", "GreenShovel"}, new String[]{"RedAir", "GoldNeptune", "BrightBlueGrass", "LightDoor", "LightSpork", "LightEarth", "NightDoor", "OrangeSpoon", "GoldSponge", "GoldDoor", "DarkPaper", "RedPaper", "GreenGlass", "IronGlass", "NightGlass", "BigGrass", "BlueFire", "YellowSpoon", "DiamondGrass", "DiamondShovel", "DarkSnow", "EmeraldGlass", "EmeraldSpoon", "LightFire", "WireGrass", "RedEarth", "WireFire"}, EMPTY);
setup("CopperSnow", EMPTY, new String[]{"RedSnow", "OrangeFire", "WireAir", "GreenGlass", "NightSpork", "EmeraldPaper"}, new String[]{"BlueGrass"});
setup("BrightBluePaper", EMPTY, new String[]{"GoldEarth", "BrightBlueSpoon", "CopperGlass", "LightSporkChat", "DarkAir", "LightEarth", "DiamondDoor", "YellowShovel", "BlueAir", "DarkShovel", "GoldPaper", "BlueFire", "GreenGlass", "YellowSpork", "BigGrass", "OrangePaper", "DarkPaper"}, new String[]{"WireShovel"});
setup("LightSponge", EMPTY, EMPTY, EMPTY);
setup("OrangeShovel", EMPTY, EMPTY, EMPTY);
setup("GoldGrass", EMPTY, new String[]{"GreenGlass", "BlueFire"}, EMPTY);
setup("IronSponge", EMPTY, new String[]{"DiamondEarth"}, EMPTY);
setup("EmeraldSnow", EMPTY, EMPTY, EMPTY);
setup("BlueSpoon", new String[]{"BigGrass"}, new String[]{"GreenGlass", "GoldPaper", "GreenShovel", "YellowClam"}, EMPTY);
setup("BigSpork", EMPTY, new String[]{"BigPaper"}, EMPTY);
setup("BluePaper", EMPTY, new String[]{"BigClam", "RedSpoon", "GreenFire", "WireSnow", "OrangeSnow", "BlueFire", "BrightBlueGrass", "YellowSpork", "GreenGlass"}, EMPTY);
setup("OrangeSpork", EMPTY, EMPTY, EMPTY);
setup("DiamondNeptune", EMPTY, new String[]{"GreenGlass", "GreenShovel", "YellowNeptune"}, EMPTY);
setup("BigFire", EMPTY, new String[]{"BlueFire", "BrightBlueDoor", "GreenGlass"}, EMPTY);
setup("NightNeptune", EMPTY, new String[]{"BlueFire", "DarkGlass", "GoldPaper", "YellowNeptune", "BlueShovel"}, EMPTY);
setup("YellowEarth", new String[]{"RedAir"}, EMPTY, EMPTY);
setup("DiamondClam", EMPTY, EMPTY, EMPTY);
setup("CopperAir", EMPTY, new String[]{"BigPaper"}, EMPTY);
setup("NightSpoon", new String[]{"OrangeNeptune"}, new String[]{"BlueFire", "GreenGlass", "RedSpork", "GoldPaper", "BigShovel", "YellowSponge", "EmeraldSpork"}, EMPTY);
setup("GreenClam", EMPTY, new String[]{"GreenShovel", "BrightBlueEarth", "BigSpoon", "RedPaper", "BlueFire", "GreenGlass", "WireFire", "GreenSnow"}, EMPTY);
setup("YellowPaper", EMPTY, EMPTY, EMPTY);
setup("WireGlass", new String[]{"YellowGrass"}, new String[]{"YellowGlass", "BigSpoon", "CopperSnow", "GreenGlass", "BlueEarth"}, EMPTY);
setup("BlueSpork", EMPTY, new String[]{"BrightBlueGrass"}, EMPTY);
setup("CopperShovel", EMPTY, new String[]{"GreenGlass"}, EMPTY);
setup("RedClam", EMPTY, EMPTY, EMPTY);
setup("EmeraldClam", EMPTY, new String[]{"BlueFire"}, EMPTY);
setup("DarkClam", EMPTY, new String[]{"GoldAir", "LightGlass"}, EMPTY);
setup("WireSpoon", EMPTY, new String[]{"GoldPaper", "LightSnow"}, EMPTY);
setup("CopperNeptune", EMPTY, new String[]{"GreenGlass", "BigGrass"}, EMPTY);
setup("RedNeptune", EMPTY, EMPTY, EMPTY);
setup("GreenAir", EMPTY, EMPTY, EMPTY);
setup("RedFire", new String[]{"BrightBlueGrass", "BigPaper"}, new String[]{"BlueFire", "GreenGlass", "BigGrass"}, EMPTY);
}
@BeforeEach
public void loadProviders() {
AtomicInteger currentLoad = new AtomicInteger();
ModernPluginLoadingStrategy<PaperTestPlugin> modernPluginLoadingStrategy = new ModernPluginLoadingStrategy<>(new ProviderConfiguration<>() {
@Override
public void applyContext(PluginProvider<PaperTestPlugin> provider, DependencyContext dependencyContext) {
}
@Override
public boolean load(PluginProvider<PaperTestPlugin> provider, PaperTestPlugin provided) {
LOAD_ORDER.put(provider.getMeta().getName(), currentLoad.getAndIncrement());
return false;
}
});
modernPluginLoadingStrategy.loadProviders(REGISTERED_PROVIDERS, new SimpleMetaDependencyTree(GraphBuilder.directed().build()));
}
@Test
public void testDependencies() {
for (PluginProvider<PaperTestPlugin> provider : REGISTERED_PROVIDERS) {
TestPluginMeta pluginMeta = (TestPluginMeta) provider.getMeta();
String identifier = pluginMeta.getName();
Assertions.assertTrue(LOAD_ORDER.containsKey(identifier), "Provider wasn't loaded! (%s)".formatted(identifier));
int index = LOAD_ORDER.get(identifier);
// Hard dependencies should be loaded BEFORE
for (String hardDependency : pluginMeta.getPluginDependencies()) {
Assertions.assertTrue(LOAD_ORDER.containsKey(hardDependency), "Plugin (%s) is missing hard dependency (%s)".formatted(identifier, hardDependency));
int dependencyIndex = LOAD_ORDER.get(hardDependency);
Assertions.assertTrue(index > dependencyIndex, "Plugin (%s) was not loaded BEFORE soft dependency. (%s)".formatted(identifier, hardDependency));
}
for (String softDependency : pluginMeta.getPluginSoftDependencies()) {
if (!LOAD_ORDER.containsKey(softDependency)) {
continue;
}
int dependencyIndex = LOAD_ORDER.get(softDependency);
Assertions.assertTrue(index > dependencyIndex, "Plugin (%s) was not loaded BEFORE soft dependency. (%s)".formatted(identifier, softDependency));
}
for (String loadBefore : pluginMeta.getLoadBeforePlugins()) {
if (!LOAD_ORDER.containsKey(loadBefore)) {
continue;
}
int dependencyIndex = LOAD_ORDER.get(loadBefore);
Assertions.assertTrue(index < dependencyIndex, "Plugin (%s) was NOT loaded BEFORE loadbefore dependency. (%s)".formatted(identifier, loadBefore));
}
}
}
}

78
paper-server/src/test/java/io/papermc/paper/plugin/PluginManagerTest.java Normal file
View File

@@ -0,0 +1,78 @@
package io.papermc.paper.plugin;
import org.bukkit.Bukkit;
import org.bukkit.event.Event;
import org.bukkit.permissions.Permission;
import org.bukkit.plugin.PluginManager;
import org.bukkit.support.environment.Normal;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Test;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.empty;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.nullValue;
@Normal
public class PluginManagerTest {
private static final PluginManager pm = Bukkit.getPluginManager();
@Test
public void testSyncSameThread() {
final Event event = new TestEvent(false);
pm.callEvent(event);
}
@Test
public void testRemovePermissionByNameLower() {
this.testRemovePermissionByName("lower");
}
@Test
public void testRemovePermissionByNameUpper() {
this.testRemovePermissionByName("UPPER");
}
@Test
public void testRemovePermissionByNameCamel() {
this.testRemovePermissionByName("CaMeL");
}
@Test
public void testRemovePermissionByPermissionLower() {
this.testRemovePermissionByPermission("lower");
}
@Test
public void testRemovePermissionByPermissionUpper() {
this.testRemovePermissionByPermission("UPPER");
}
@Test
public void testRemovePermissionByPermissionCamel() {
this.testRemovePermissionByPermission("CaMeL");
}
private void testRemovePermissionByName(final String name) {
final Permission perm = new Permission(name);
pm.addPermission(perm);
assertThat("Permission \"" + name + "\" was not added", pm.getPermission(name), is(perm));
pm.removePermission(name);
assertThat("Permission \"" + name + "\" was not removed", pm.getPermission(name), is(nullValue()));
}
private void testRemovePermissionByPermission(final String name) {
final Permission perm = new Permission(name);
pm.addPermission(perm);
assertThat("Permission \"" + name + "\" was not added", pm.getPermission(name), is(perm));
pm.removePermission(perm);
assertThat("Permission \"" + name + "\" was not removed", pm.getPermission(name), is(nullValue()));
}
@AfterEach
public void tearDown() {
pm.clearPlugins();
assertThat(pm.getPermissions(), is(empty()));
}
}

30
paper-server/src/test/java/io/papermc/paper/plugin/PluginNamingTest.java Normal file
View File

@@ -0,0 +1,30 @@
package io.papermc.paper.plugin;
import io.papermc.paper.plugin.provider.configuration.PaperPluginMeta;
import org.bukkit.support.environment.Normal;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@Normal
public class PluginNamingTest {
private static final String TEST_NAME = "Test_Plugin";
private static final String TEST_VERSION = "1.0";
private final PaperPluginMeta pluginMeta;
public PluginNamingTest() {
this.pluginMeta = new PaperPluginMeta();
this.pluginMeta.setName(TEST_NAME);
this.pluginMeta.setVersion(TEST_VERSION);
}
@Test
public void testName() {
Assertions.assertEquals(TEST_NAME, this.pluginMeta.getName());
}
@Test
public void testDisplayName() {
Assertions.assertEquals(TEST_NAME + " v" + TEST_VERSION, this.pluginMeta.getDisplayName());
}
}

44
paper-server/src/test/java/io/papermc/paper/plugin/SyntheticEventTest.java Normal file
View File

@@ -0,0 +1,44 @@
package io.papermc.paper.plugin;
import io.papermc.paper.plugin.manager.PaperPluginManagerImpl;
import org.bukkit.Bukkit;
import org.bukkit.event.Event;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.support.environment.Normal;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
@Normal
public class SyntheticEventTest {
@Test
public void test() {
PaperTestPlugin paperTestPlugin = new PaperTestPlugin("synthetictest");
PaperPluginManagerImpl paperPluginManager = new PaperPluginManagerImpl(Bukkit.getServer(), null, null);
TestEvent event = new TestEvent(false);
Impl impl = new Impl();
paperPluginManager.registerEvents(impl, paperTestPlugin);
paperPluginManager.callEvent(event);
Assertions.assertEquals(1, impl.callCount);
}
public abstract static class Base<E extends Event> implements Listener {
int callCount = 0;
public void accept(E evt) {
callCount++;
}
}
public static class Impl extends Base<TestEvent> {
@Override
@EventHandler
public void accept(TestEvent evt) {
super.accept(evt);
}
}
}

22
paper-server/src/test/java/io/papermc/paper/plugin/TestEvent.java Normal file
View File

@@ -0,0 +1,22 @@
package io.papermc.paper.plugin;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class TestEvent extends Event {
private static final HandlerList handlers = new HandlerList();
public TestEvent(boolean async) {
super(async);
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}

83
paper-server/src/test/java/io/papermc/paper/plugin/TestJavaPluginProvider.java Normal file
View File

@@ -0,0 +1,83 @@
package io.papermc.paper.plugin;
import io.papermc.paper.plugin.configuration.PluginMeta;
import io.papermc.paper.plugin.provider.PluginProvider;
import io.papermc.paper.plugin.provider.configuration.LoadOrderConfiguration;
import io.papermc.paper.plugin.provider.entrypoint.DependencyContext;
import net.kyori.adventure.text.logger.slf4j.ComponentLogger;
import org.jetbrains.annotations.NotNull;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.jar.JarFile;
public class TestJavaPluginProvider implements PluginProvider<PaperTestPlugin> {
private final TestPluginMeta testPluginConfiguration;
public TestJavaPluginProvider(TestPluginMeta testPluginConfiguration) {
this.testPluginConfiguration = testPluginConfiguration;
}
@Override
public @NotNull Path getSource() {
return Path.of("dummy");
}
@Override
public JarFile file() {
throw new UnsupportedOperationException();
}
@Override
public PaperTestPlugin createInstance() {
return new PaperTestPlugin(this.testPluginConfiguration);
}
@Override
public TestPluginMeta getMeta() {
return this.testPluginConfiguration;
}
@Override
public ComponentLogger getLogger() {
return ComponentLogger.logger("TestPlugin");
}
@Override
public LoadOrderConfiguration createConfiguration(@NotNull Map<String, PluginProvider<?>> toLoad) {
return new LoadOrderConfiguration() {
@Override
public @NotNull List<String> getLoadBefore() {
return TestJavaPluginProvider.this.testPluginConfiguration.getLoadBeforePlugins();
}
@Override
public @NotNull List<String> getLoadAfter() {
List<String> loadAfter = new ArrayList<>();
loadAfter.addAll(TestJavaPluginProvider.this.testPluginConfiguration.getPluginDependencies());
loadAfter.addAll(TestJavaPluginProvider.this.testPluginConfiguration.getPluginSoftDependencies());
return loadAfter;
}
@Override
public @NotNull PluginMeta getMeta() {
return TestJavaPluginProvider.this.testPluginConfiguration;
}
};
}
@Override
public List<String> validateDependencies(@NotNull DependencyContext context) {
List<String> missingDependencies = new ArrayList<>();
for (String hardDependency : this.getMeta().getPluginDependencies()) {
if (!context.hasDependency(hardDependency)) {
missingDependencies.add(hardDependency);
}
}
return missingDependencies;
}
}

114
paper-server/src/test/java/io/papermc/paper/plugin/TestPluginMeta.java Normal file
View File

@@ -0,0 +1,114 @@
package io.papermc.paper.plugin;
import io.papermc.paper.plugin.configuration.PluginMeta;
import org.bukkit.permissions.Permission;
import org.bukkit.permissions.PermissionDefault;
import org.bukkit.plugin.PluginLoadOrder;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
public class TestPluginMeta implements PluginMeta {
private final String identifier;
private List<String> hardDependencies = List.of();
private List<String> softDependencies = List.of();
private List<String> loadBefore = List.of();
public TestPluginMeta(String identifier) {
this.identifier = identifier;
}
@Override
public @NotNull String getName() {
return this.identifier;
}
@Override
public @NotNull String getMainClass() {
return "null";
}
@Override
public @NotNull PluginLoadOrder getLoadOrder() {
return PluginLoadOrder.POSTWORLD;
}
@Override
public @NotNull String getVersion() {
return "1.0";
}
@Override
public @Nullable String getLoggerPrefix() {
return this.identifier;
}
public void setHardDependencies(List<String> hardDependencies) {
this.hardDependencies = hardDependencies;
}
@Override
public @NotNull List<String> getPluginDependencies() {
return this.hardDependencies;
}
public void setSoftDependencies(List<String> softDependencies) {
this.softDependencies = softDependencies;
}
@Override
public @NotNull List<String> getPluginSoftDependencies() {
return this.softDependencies;
}
public void setLoadBefore(List<String> loadBefore) {
this.loadBefore = loadBefore;
}
@Override
public @NotNull List<String> getLoadBeforePlugins() {
return this.loadBefore;
}
@Override
public @NotNull List<String> getProvidedPlugins() {
return List.of();
}
@Override
public @NotNull List<String> getAuthors() {
return List.of();
}
@Override
public @NotNull List<String> getContributors() {
return List.of();
}
@Override
public @Nullable String getDescription() {
return "null";
}
@Override
public @Nullable String getWebsite() {
return "null";
}
@Override
public @NotNull List<Permission> getPermissions() {
return List.of();
}
@Override
public @NotNull PermissionDefault getPermissionDefault() {
return PermissionDefault.TRUE;
}
@Override
public @NotNull String getAPIVersion() {
return "null";
}
}

2
paper-server/src/test/java/org/bukkit/support/DummyServerHelper.java
View File

@@ -87,7 +87,7 @@ public final class DummyServerHelper {
// Paper start - testing additions
final Thread currentThread = Thread.currentThread();
when(instance.isPrimaryThread()).thenAnswer(ignored -> Thread.currentThread().equals(currentThread));
final org.bukkit.plugin.PluginManager pluginManager = new org.bukkit.plugin.SimplePluginManager(instance, new org.bukkit.command.SimpleCommandMap(instance));
final org.bukkit.plugin.PluginManager pluginManager = new io.papermc.paper.plugin.manager.PaperPluginManagerImpl(instance, new org.bukkit.command.SimpleCommandMap(instance), null);
when(instance.getPluginManager()).thenReturn(pluginManager);
// Paper end - testing additions