Files
purpur-fantasy-stick/src/nativeTest/java/games/dmg/fantasystick/EquipmentAdminCommandNativeTest.java
T
dmg 40e41d6b7a
Release / release (push) Successful in 7m58s
CI / build (push) Successful in 4m6s
feat(sessions): add configurable Adventure-mode sessions
2026-09-18 23:36:03 -04:00

209 lines
14 KiB
Java

package games.dmg.fantasystick;
import static org.junit.jupiter.api.Assertions.*;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.bukkit.command.CommandSender;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
/** Actual packaged PluginCommand permission/dispatch; only the absent console is a port. */
class EquipmentAdminCommandNativeTest {
@TempDir Path data;
@BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
@Test void adventureConfigurationCommandReadsValidatesPersistsAndReopensWithoutTouchingPlayers() throws Exception {
try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
f.plugin.setEnabled(true);
var sender = new Sender();
f.command.execute(sender.port, "fantasystick", new String[]{"config", "adventure-mode"});
assertTrue(sender.messages.getLast().contains("adventure-mode=true"));
sender.messages.clear();
for (String value : List.of("yes", "1", "TRUE", "")) {
f.command.execute(sender.port, "fantasystick", new String[]{"config", "adventure-mode", value});
assertTrue(sender.messages.getLast().contains("true|false"));
}
assertTrue(f.tasks.isEmpty());
assertFalse(Files.exists(data.resolve("config.yml")));
sender.allowed = false;
f.command.getExecutor().onCommand(sender.port, f.command, "fantasystick", new String[]{"config", "adventure-mode", "false"});
assertFalse(Files.exists(data.resolve("config.yml")));
sender.allowed = true; sender.messages.clear();
f.command.execute(sender.port, "fantasystick", new String[]{"config", "adventure-mode", "false"});
assertTrue(sender.messages.isEmpty(), "Do not report success before acknowledgment");
var reply = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(reply); reply.run();
assertTrue(sender.messages.getLast().contains("adventure-mode=false"));
assertTrue(sender.messages.getLast().contains("new sessions"));
assertEquals(0, f.playerLookups);
f.plugin.setEnabled(false); f.plugin.setEnabled(true);
f.command.execute(sender.port, "fantasystick", new String[]{"config", "adventure-mode"});
assertTrue(sender.messages.getLast().contains("adventure-mode=false"));
}
}
@Test void reenableWaitsOffThreadForAcceptedConfigurationWritesBeforeReadingNewPolicy() throws Exception {
try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
f.plugin.setEnabled(true);
var old = FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "adventureSettings");
var worker = (java.util.concurrent.ExecutorService) FantasyStickLifecycleNativeTest.Fixture.field(old, "worker");
var entered = new java.util.concurrent.CountDownLatch(1);
var release = new java.util.concurrent.CountDownLatch(1);
worker.execute(() -> {
entered.countDown();
try { release.await(5, java.util.concurrent.TimeUnit.SECONDS); }
catch (InterruptedException error) { Thread.currentThread().interrupt(); }
});
try {
assertTrue(entered.await(5, java.util.concurrent.TimeUnit.SECONDS));
var sender = new Sender();
f.command.execute(sender.port, "fantasystick", new String[]{"config", "adventure-mode", "false"});
f.plugin.setEnabled(false); f.plugin.setEnabled(true);
assertNull(FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions"), "Do not activate from a stale config snapshot");
release.countDown();
f.tick();
assertNotNull(FantasyStickLifecycleNativeTest.Fixture.field(f.plugin, "sessions"));
f.command.execute(sender.port, "fantasystick", new String[]{"config", "adventure-mode"});
assertTrue(sender.messages.getLast().contains("adventure-mode=false"));
} finally { release.countDown(); }
}
}
@Test void permissionAndStrictShapeRejectBeforePersistenceOrNativeLookup() throws Exception {
try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
f.plugin.setEnabled(true);
assertNotNull(f.command, "Packaged descriptor must install the actual command");
var sender = new Sender();
sender.allowed = false;
assertTrue(f.command.execute(sender.port, "fantasystick", new String[]{"inspect", UUID.randomUUID().toString()}));
// Executor must also defend direct dispatch, not rely solely on PluginCommand.
assertTrue(f.command.getExecutor().onCommand(sender.port, f.command, "fantasystick",
new String[]{"recover", UUID.randomUUID().toString()}));
sender.allowed = true;
for (String[] args : List.of(new String[]{}, new String[]{"inspect"},
new String[]{"reset", UUID.randomUUID().toString()}, new String[]{"inspect", "1-1-1-1-1"},
new String[]{"recover", "not-a-uuid"}, new String[]{"inspect", UUID.randomUUID().toString(), "extra"})) {
assertTrue(f.command.execute(sender.port, "fantasystick", args));
}
assertFalse(Files.exists(data.resolve("sessions")));
assertTrue(f.tasks.isEmpty());
assertEquals(0, f.playerLookups, "Rejected commands must not inspect native players");
assertFalse(sender.messages.isEmpty());
}
assertFalse(Files.exists(data.resolve("sessions")), "No queued IO after worker drain either");
}
@Test void inspectIsDeferredSanitizedAndReturnsToMainThreadAndCloseDropsResponses() throws Exception {
try (var receipts = new games.dmg.fantasystick.persistence.EquipmentSessionStore(data, java.time.Clock.systemUTC());
var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
UUID owner = UUID.randomUUID(), session = UUID.randomUUID(), character = UUID.randomUUID();
receipts.prepare(owner, session, character).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS);
receipts.recordExit(owner, session, java.time.Duration.ofSeconds(900)).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS);
f.plugin.setEnabled(true);
var sender = new Sender();
assertNotNull(f.command);
assertTrue(f.command.execute(sender.port, "fantasystick", new String[]{"inspect", owner.toString()}));
assertTrue(sender.messages.isEmpty(), "No response until the server callback");
var response = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(response);
response.run();
String text = String.join("\n", sender.messages);
assertTrue(text.contains(owner.toString()), text);
assertTrue(text.contains(session.toString()), text);
assertTrue(text.contains(character.toString()), text);
assertTrue(text.contains("pending") && text.contains("deadline") && text.contains("exit"), text);
assertFalse(text.contains("schema-version") || text.contains(data.toString()), text);
sender.messages.clear();
f.command.execute(sender.port, "fantasystick", new String[]{"inspect", owner.toString()});
var stale = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(stale);
f.plugin.setEnabled(false);
f.plugin.setEnabled(true);
stale.run();
assertTrue(sender.messages.isEmpty(), "Previous lifetime must not reply after re-enable");
}
}
@Test void onlineRecoveryUsesNativeProofAndReportsOnlyARequestAndOfflineNeverQueuesIO() throws Exception {
try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
f.plugin.setEnabled(true);
var sender = new Sender(); UUID offline = UUID.randomUUID();
f.command.execute(sender.port, "fantasystick", new String[]{"recover", offline.toString()});
assertTrue(sender.messages.getLast().contains("must be online"));
assertFalse(Files.exists(data.resolve("sessions"))); assertTrue(f.tasks.isEmpty());
var a = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(a.core.id, a.player);
var original = a.core.snapshot(); UUID session = UUID.randomUUID();
f.receipts().prepare(a.core.id, session, a.core.record.id()).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS);
assertEquals(games.dmg.fantasystick.items.EquipmentStorage.PackResult.PACKED,
new games.dmg.fantasystick.items.EquipmentStorage().pack(a.core.inventory, a.core.id, session));
a.core.marker(session, "PACKED"); var packed = a.core.snapshot();
sender.messages.clear();
f.command.execute(sender.port, "fantasystick", new String[]{"recover", a.core.id.toString()});
assertEquals(1, sender.messages.size());
assertTrue(sender.messages.getFirst().contains("requested") && sender.messages.getFirst().contains("not confirmation"));
assertArrayEquals(packed, a.core.snapshot(), "Request is not premature success");
f.tick();
assertArrayEquals(original, a.core.snapshot()); assertTrue(a.core.marker().endsWith("|RESTORED"));
assertNull(f.receipts().find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow().pending());
f.command.execute(sender.port, "fantasystick", new String[]{"recover", a.core.id.toString()}); f.tick();
assertArrayEquals(original, a.core.snapshot());
}
}
@Test void ambiguousRecoveryRetainsEveryItemAndReceiptAndInspectionNeverPrintsRawMarker() throws Exception {
try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
f.plugin.setEnabled(true);
var a = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(a.core.id, a.player);
UUID session = UUID.randomUUID();
var saved = f.receipts().prepare(a.core.id, session, a.core.record.id()).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS);
new games.dmg.fantasystick.items.EquipmentStorage().pack(a.core.inventory, a.core.id, session);
a.core.pdc.set(new org.bukkit.NamespacedKey("fantasystick", "equipment_session"),
org.bukkit.persistence.PersistentDataType.STRING, "secret-not-a-valid-marker");
var before = a.core.snapshot(); var marker = a.core.pdc.serializeToBytes();
var sender = new Sender();
f.command.execute(sender.port, "fantasystick", new String[]{"recover", a.core.id.toString()}); f.tick();
assertArrayEquals(before, a.core.snapshot()); assertArrayEquals(marker, a.core.pdc.serializeToBytes());
assertEquals(saved, f.receipts().find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow());
f.command.execute(sender.port, "fantasystick", new String[]{"inspect", a.core.id.toString()}); f.tick();
var text = String.join("\n", sender.messages);
assertTrue(text.contains("malformed (retained)")); assertTrue(text.contains("active=none"));
assertFalse(text.contains("secret-not-a-valid-marker"));
}
}
@Test void inspectObservesCurrentOnlineActiveStateAndPermissionRevocationDropsDeferredResponse() throws Exception {
try (var f = new FantasyStickLifecycleNativeTest.Fixture(data)) {
f.plugin.setEnabled(true);
var a = new FantasyStickLifecycleNativeTest.Actor(data); f.players.put(a.core.id, a.player); f.activate(a);
var sender = new Sender();
f.command.execute(sender.port, "fantasystick", new String[]{"inspect", a.core.id.toString()}); f.tick();
assertTrue(sender.messages.stream().anyMatch(message -> message.contains("active=session=")));
assertTrue(sender.messages.stream().anyMatch(message -> message.contains("phase=PACKED")));
sender.messages.clear();
f.command.execute(sender.port, "fantasystick", new String[]{"inspect", a.core.id.toString()});
var pending = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(pending);
sender.allowed = false; pending.run(); assertTrue(sender.messages.isEmpty());
sender.allowed = true;
f.command.execute(sender.port, "fantasystick", new String[]{"inspect", a.core.id.toString()});
pending = f.tasks.poll(5, java.util.concurrent.TimeUnit.SECONDS); assertNotNull(pending);
((AutoCloseable) f.command.getExecutor()).close(); pending.run(); assertTrue(sender.messages.isEmpty());
}
}
static final class Sender {
final Thread main = Thread.currentThread();
final List<String> messages = new ArrayList<>();
boolean allowed = true;
final CommandSender port = FantasyStickLifecycleNativeTest.port(CommandSender.class, (name, args) -> {
assertSame(main, Thread.currentThread(), "Worker accessed command sender: " + name);
return switch (name) {
case "hasPermission" -> { assertEquals("fantasystick.admin", args[0]); yield allowed; }
case "sendMessage" -> { messages.add(String.valueOf(args[0])); yield null; }
default -> throw new AssertionError("Unexpected sender call " + name);
};
});
}
}