fix(sessions): complete character-switch delay behavior
Release / release (push) Successful in 6m16s
CI / build (push) Successful in 3m16s

This commit is contained in:
dmg committed 2026-09-18 19:11:18 -04:00
1 parent f7d01381ec
commit 3d045ff99b
5 files changed
+384 -10

No files matched your search

@@ -626,7 +626,9 @@ class EquipmentSessionEventsNativeTest {
assertTrue(dead.dead()); assertEquals("Newest name", dead.name());
assertEquals(dead.deathId(), new games.dmg.fantasystick.items.TailBooks().identify(book).orElseThrow().deathId());
assertEquals(1, a.teleports); assertEquals(0, f.world.creates);
assertNull(f.core.state(a).pending());
var exited = f.core.state(a);
assertNull(exited.pending()); assertEquals(a.record.id(), exited.lastExit().characterId());
assertEquals(java.time.Duration.ofSeconds(900), java.time.Duration.between(exited.lastExit().exitedAt(), exited.lastExit().deadline()));
assertTrue(f.core.notices.stream().anyMatch(n -> n.code().equals("DEFEAT")));
}
}
@@ -1536,16 +1538,51 @@ class EquipmentSessionEventsNativeTest {
}
}
@Test void defeatStartsPlayerDelayButLegitimateBackendRevivalCanResumeTheSameIdentity() throws Exception {
try (var f = new Fixture()) {
var a = f.actor; var copiedSheet = a.inventory.getItemInOffHand().clone();
f.core.activate(a); f.changed();
var active = f.core.sessions.active(a.id).orElseThrow();
f.dispatcher.accept(f.death(org.bukkit.damage.DamageType.GENERIC));
var exit = f.core.state(a).lastExit();
assertEquals(active.session(), exit.sessionId()); assertEquals(a.record.id(), exit.characterId());
assertEquals(java.time.Duration.ofSeconds(900), java.time.Duration.between(exit.exitedAt(), exit.deadline()));
f.core.tick(); // Confirm Tail delivery and release the defeat's claim.
assertEquals(Material.WRITTEN_BOOK, a.inventory.getItemInOffHand().getType());
a.inventory.setItemInOffHand(copiedSheet); f.changed();
// The bridge observed the original ID before defeat; join explicitly requests saved-state eligibility.
f.dispatcher.accept(new org.bukkit.event.player.PlayerJoinEvent(a.player, (net.kyori.adventure.text.Component) null));
f.core.tick(); f.core.tick();
assertEquals("UNAVAILABLE_CHARACTER", f.core.notices.getLast().code());
assertEquals(exit, f.core.state(a).lastExit());
var other = f.core.actor(); a.inventory.setItemInOffHand(other.inventory.getItemInOffHand()); f.changed();
f.ticks.remove().run(); f.core.tick();
assertEquals("COOLDOWN", f.core.notices.getLast().code());
var dead = f.core.characters.find(a.record.id()).get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow();
var live = f.core.characters.restoreDeathRecord(dead.id(), dead.deathId()).get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow();
a.inventory.setItemInOffHand(new games.dmg.fantasystick.items.CharacterSheets().create(live)); f.changed();
f.ticks.remove().run(); f.core.tick(); f.core.tick();
assertEquals(live.id(), f.core.sessions.active(a.id).orElseThrow().character());
assertEquals(exit, f.core.state(a).lastExit());
}
}
@Test void replacingCharacterExitsFirstAndCoordinatorEnforcesDifferentIdCooldownWithoutExtendingIt() throws Exception {
try (var f = new Fixture()) {
var a = f.actor; f.core.activate(a); f.changed();
var other = f.core.actor();
a.inventory.setItemInOffHand(other.inventory.getItemInOffHand().clone());
var sameName = f.core.characters.renameCharacter(other.record.id(), a.record.name())
.get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow();
a.inventory.setItemInOffHand(new games.dmg.fantasystick.items.CharacterSheets().create(sameName));
f.changed();
assertTrue(f.core.sessions.active(a.id).isEmpty());
assertEquals(Material.DIAMOND_SWORD, a.inventory.getItem(0).getType(), "Replacement exits and restores before its new entry");
assertEquals(Material.DIAMOND_HELMET, a.inventory.getHelmet().getType());
var restored = a.snapshot(); var cursor = a.cursor.clone();
var exited = f.core.state(a).lastExit(); // IO barrier, not a tick-thread production wait.
f.ticks.remove().run(); f.core.tick();
assertEquals("COOLDOWN", f.core.notices.getLast().code());
assertArrayEquals(restored, a.snapshot()); assertEquals(cursor, a.cursor);
assertEquals(exited, f.core.state(a).lastExit());
a.inventory.setItemInOffHand(new ItemStack(Material.AIR)); f.changed();
a.inventory.setItemInOffHand(new games.dmg.fantasystick.items.CharacterSheets().create(a.record)); f.changed();
@@ -849,6 +849,247 @@ class EquipmentSessionsNativeTest {
}
}
@Test void reopenedCoordinatorCountsOfflineTimeAtExactExpiryAndNewExitsUseCurrentDuration() throws Exception {
for (long configured : new long[]{1, 900, 3600}) try (var f = new Fixture(Duration.ofSeconds(900), new MutableClock())) {
var clock = (MutableClock) f.clock;
var actor = f.actor(); var other = f.actor(); f.activate(actor); f.sessions.exit(actor.player);
var exited = f.state(actor); var deadline = exited.lastExit().deadline();
clock.now = deadline.minusNanos(1);
actor = f.reopen(actor, Duration.ofSeconds(configured));
actor.inventory.setItemInOffHand(other.inventory.getItemInOffHand().clone());
var before = actor.snapshot();
f.sessions.arrive(actor.player); f.tick(); f.tick();
assertEquals("COOLDOWN", f.notices.getLast().code());
assertTrue(f.notices.getLast().message().startsWith("Wait 1 seconds"));
assertEquals(exited, f.state(actor)); assertArrayEquals(before, actor.snapshot());
clock.now = deadline; // Inclusive expiry, even with a longer/shorter newly configured duration.
f.sessions.arrive(actor.player); f.tick(); f.tick(); f.tick();
assertEquals(other.record.id(), f.sessions.active(actor.id).orElseThrow().character());
assertEquals(exited.lastExit(), f.state(actor).lastExit());
clock.advance(Duration.ofSeconds(5)); f.sessions.exit(actor.player);
var next = f.state(actor).lastExit();
assertNotEquals(exited.lastExit().sessionId(), next.sessionId());
assertEquals(other.record.id(), next.characterId());
assertEquals(clock.now, next.exitedAt()); assertEquals(clock.now.plusSeconds(configured), next.deadline());
}
}
@Test void sameIdFailedEquipmentPreflightPreservesExistingDeadlineAndAllItems() throws Exception {
for (boolean full : new boolean[]{false, true}) {
var clock = new MutableClock();
try (var f = new Fixture(Duration.ofSeconds(900), clock)) {
var actor = f.actor(); f.activate(actor); f.sessions.exit(actor.player);
var exited = f.state(actor); clock.advance(Duration.ofSeconds(60));
if (full) for (int slot = 9; slot < 36; slot++) actor.inventory.setItem(slot, new ItemStack(Material.STONE, 64));
else actor.inventory.setItem(0, new ItemStack(Material.SHULKER_BOX));
var before = actor.snapshot(); var marker = actor.marker();
f.sessions.enter(actor.player); f.tick();
assertTrue(f.sessions.active(actor.id).isEmpty());
assertFalse(f.notices.isEmpty()); assertNotEquals("COOLDOWN", f.notices.getLast().code());
assertArrayEquals(before, actor.snapshot()); assertEquals(marker, actor.marker());
assertEquals(exited, f.state(actor), "Failed packing preflight is not an actual exit or a timer reset");
}
}
}
@Test void zeroBypassesSavedDeadlineAfterRestartWithoutSkippingAuthoritativeEligibility() throws Exception {
var clock = new MutableClock();
try (var f = new Fixture(Duration.ofSeconds(900), clock)) {
var actor = f.actor(); var other = f.actor(); f.activate(actor); f.sessions.exit(actor.player);
var exited = f.state(actor); clock.advance(Duration.ofSeconds(100));
actor = f.reopen(actor, Duration.ZERO);
actor.inventory.setItemInOffHand(other.inventory.getItemInOffHand().clone());
var dead = f.characters.recordDeath(other.record.id()).get(5, TimeUnit.SECONDS).orElseThrow();
var before = actor.snapshot(); f.sessions.enter(actor.player); f.tick();
assertEquals("UNAVAILABLE_CHARACTER", f.notices.getLast().code());
assertArrayEquals(before, actor.snapshot()); assertEquals(exited, f.state(actor));
var live = f.characters.restoreDeathRecord(dead.id(), dead.deathId()).get(5, TimeUnit.SECONDS).orElseThrow();
actor.inventory.setItemInOffHand(new CharacterSheets().create(live)); f.activate(actor);
assertEquals(exited.lastExit(), f.state(actor).lastExit(), "Zero bypass does not rewrite the old absolute deadline");
f.sessions.exit(actor.player);
var next = f.state(actor).lastExit();
assertEquals(clock.now, next.exitedAt()); assertEquals(clock.now, next.deadline());
assertEquals(live.id(), next.characterId());
actor = f.reopen(actor, Duration.ofSeconds(900));
actor.inventory.setItemInOffHand(new CharacterSheets().create(actor.record)); f.activate(actor);
assertEquals(next, f.state(actor).lastExit(), "Re-enabling delay cannot retroactively stretch a zero-duration exit");
}
}
@Test void sameCharacterReentryDoesNotResetDelayButItsNextActualExitDoes() throws Exception {
var clock = new MutableClock();
try (var f = new Fixture(Duration.ofSeconds(900), clock)) {
var actor = f.actor(); var other = f.actor(); f.activate(actor); f.sessions.exit(actor.player);
var first = f.state(actor).lastExit(); clock.advance(Duration.ofSeconds(30));
f.activate(actor); assertEquals(first, f.state(actor).lastExit());
clock.advance(Duration.ofSeconds(20)); f.sessions.exit(actor.player);
var second = f.state(actor).lastExit();
assertNotEquals(first.sessionId(), second.sessionId()); assertEquals(first.characterId(), second.characterId());
assertEquals(clock.now, second.exitedAt()); assertEquals(first.deadline().plusSeconds(50), second.deadline());
clock.now = first.deadline(); actor.inventory.setItemInOffHand(other.inventory.getItemInOffHand());
var before = actor.snapshot(); f.sessions.enter(actor.player); f.tick();
assertEquals("COOLDOWN", f.notices.getLast().code());
assertTrue(f.notices.getLast().message().startsWith("Wait 50 seconds")); assertArrayEquals(before, actor.snapshot());
assertEquals(second, f.state(actor).lastExit());
clock.now = second.deadline().plusNanos(1); f.activate(actor);
}
}
@Test void repeatedRecoveryAfterRestartAndDurationChangeNeverExtendsTheActualExit() throws Exception {
var clock = new MutableClock();
try (var f = new Fixture(Duration.ofSeconds(900), clock)) {
var actor = f.actor(); f.activate(actor); var control = actor.inventory.getItem(0).clone();
actor.inventory.setItem(0, new ItemStack(Material.EMERALD));
assertEquals(EquipmentStorage.RestoreResult.OCCUPIED_SLOT, f.sessions.exit(actor.player));
var exit = f.state(actor).lastExit();
clock.advance(Duration.ofSeconds(200)); actor = f.reopen(actor, Duration.ofSeconds(3600));
var before = actor.snapshot(); f.sessions.recover(actor.player); f.tick();
assertArrayEquals(before, actor.snapshot()); assertEquals(exit, f.state(actor).lastExit());
actor.inventory.setItem(0, control); f.sessions.recover(actor.player); f.tick();
assertNull(f.state(actor).pending()); assertEquals(exit, f.state(actor).lastExit());
var restored = actor.snapshot();
for (int retry = 0; retry < 2; retry++) {
clock.advance(Duration.ofSeconds(100)); f.sessions.recover(actor.player); f.tick();
assertArrayEquals(restored, actor.snapshot()); assertEquals(exit, f.state(actor).lastExit());
assertEquals("NO_RECEIPT", f.notices.getLast().code());
}
}
}
@Test void actualNativeExitStartsAtRequestNotDelayedReceiptWorkerExecution() throws Exception {
for (boolean restored : new boolean[]{false, true}) {
var clock = new MutableClock();
var entered = new java.util.concurrent.CountDownLatch(1);
var release = new java.util.concurrent.CountDownLatch(1);
var block = new java.util.concurrent.atomic.AtomicBoolean();
try (var f = new Fixture((source, target) -> {
if (block.compareAndSet(true, false)) { entered.countDown(); gate(release); }
move(source, target);
}, Duration.ofSeconds(900), EquipmentSessionsNativeTest::move, clock)) {
var actor = f.actor(); f.activate(actor);
if (!restored) actor.inventory.setItem(0, new ItemStack(Material.EMERALD));
var before = actor.snapshot();
block.set(true);
var blocker = f.receipts.prepare(UUID.randomUUID(), UUID.randomUUID(), UUID.randomUUID());
java.time.Instant requested;
try {
assertTrue(entered.await(5, TimeUnit.SECONDS));
clock.advance(Duration.ofSeconds(2)); requested = clock.now;
assertEquals(restored ? EquipmentStorage.RestoreResult.RESTORED : EquipmentStorage.RestoreResult.OCCUPIED_SLOT,
f.sessions.exit(actor.player));
assertTrue(f.sessions.active(actor.id).isEmpty());
if (restored) assertEquals(Material.DIAMOND_SWORD, actor.inventory.getItem(0).getType());
else assertArrayEquals(before, actor.snapshot());
clock.advance(Duration.ofHours(1));
} finally { release.countDown(); }
blocker.toCompletableFuture().get(5, TimeUnit.SECONDS);
var state = f.state(actor);
assertEquals(requested, state.lastExit().exitedAt());
assertEquals(requested.plusSeconds(900), state.lastExit().deadline());
assertEquals(restored, state.pending() == null);
}
}
}
@Test void sameStableIdReentersThroughLiveRenamedSerializedCopiedAndBackendRevivedReferences() throws Exception {
for (int kind = 0; kind < 4; kind++) try (var f = new Fixture()) {
var actor = f.actor(); f.activate(actor);
f.sessions.exit(actor.player); var exited = f.state(actor);
var record = actor.record;
if (kind == 1) record = f.characters.renameCharacter(record.id(), "Renamed adventurer").get(5, TimeUnit.SECONDS).orElseThrow();
if (kind == 3) {
var dead = f.characters.recordDeath(record.id()).get(5, TimeUnit.SECONDS).orElseThrow();
var before = actor.snapshot();
f.sessions.enter(actor.player); f.tick();
assertEquals("UNAVAILABLE_CHARACTER", f.notices.getLast().code());
assertArrayEquals(before, actor.snapshot()); assertEquals(exited, f.state(actor));
assertTrue(f.characters.restoreDeathRecord(dead.id(), UUID.randomUUID()).get(5, TimeUnit.SECONDS).isEmpty());
record = f.characters.restoreDeathRecord(dead.id(), dead.deathId()).get(5, TimeUnit.SECONDS).orElseThrow();
assertEquals(actor.record.id(), record.id()); assertFalse(record.dead());
// Real consume-once backend + native reference factory; not a claim of a Revive spell/UI.
assertTrue(f.characters.restoreDeathRecord(dead.id(), dead.deathId()).get(5, TimeUnit.SECONDS).isEmpty());
}
var sheet = new CharacterSheets().create(record);
if (kind == 2) sheet.setAmount(3);
actor.inventory.setItemInOffHand(sheet.clone());
actor = actor.reload(); // Real native item codec + player PDC, not the original item object.
f.activate(actor);
assertEquals(exited.lastExit(), f.state(actor).lastExit(), "Reentry itself does not start a delay");
assertEquals(record.id(), f.sessions.active(actor.id).orElseThrow().character());
assertNotEquals(exited.lastExit().sessionId(), f.sessions.active(actor.id).orElseThrow().session());
assertEquals(record, f.characters.find(record.id()).get(5, TimeUnit.SECONDS).orElseThrow(),
"Session delay does not rewrite character progress or ability cooldowns");
}
}
@Test void missingFakeAndDifferentIdSameNameCannotUseTheSameCharacterException() throws Exception {
for (int kind = 0; kind < 3; kind++) try (var f = new Fixture()) {
var actor = f.actor(); f.activate(actor); f.sessions.exit(actor.player);
var exited = f.state(actor);
if (kind == 0) java.nio.file.Files.delete(data.resolve("characters").resolve(actor.record.id() + ".yml"));
if (kind == 1) {
var fake = new ItemStack(Material.PAPER); fake.setItemMeta(actor.inventory.getItemInOffHand().getItemMeta());
var meta = fake.getItemMeta();
meta.getPersistentDataContainer().remove(new org.bukkit.NamespacedKey("fantasystick", "character_id"));
fake.setItemMeta(meta); actor.inventory.setItemInOffHand(fake);
}
if (kind == 2) {
var other = f.actor();
var sameName = f.characters.renameCharacter(other.record.id(), actor.record.name()).get(5, TimeUnit.SECONDS).orElseThrow();
actor.inventory.setItemInOffHand(new CharacterSheets().create(sameName));
}
var before = actor.snapshot(); var marker = actor.marker();
f.sessions.enter(actor.player); if (kind != 1) f.tick();
assertEquals(kind == 0 ? "UNAVAILABLE_CHARACTER" : kind == 1 ? "INVALID_SHEET" : "COOLDOWN", f.notices.getLast().code());
assertTrue(f.sessions.active(actor.id).isEmpty()); assertArrayEquals(before, actor.snapshot());
assertEquals(marker, actor.marker()); assertEquals(exited, f.state(actor));
}
}
@Test void sheetTransferDoesNotInheritOrResetEitherPlayersExistingSwitchDeadline() throws Exception {
try (var f = new Fixture()) {
var first = f.actor(); var second = f.actor(); var freshHolder = f.actor(first.record);
f.activate(first); f.activate(second);
f.sessions.exit(first.player); f.sessions.exit(second.player);
var firstExit = f.state(first); var secondExit = f.state(second);
var renamed = f.characters.renameCharacter(first.record.id(), "Transferred identity").get(5, TimeUnit.SECONDS).orElseThrow();
var transferred = new CharacterSheets().create(renamed);
first.inventory.setItemInOffHand(new CharacterSheets().create(second.record));
second.inventory.setItemInOffHand(transferred.clone());
for (var holder : java.util.List.of(first, second)) {
var before = holder.snapshot(); f.sessions.enter(holder.player); f.tick();
assertEquals("COOLDOWN", f.notices.getLast().code()); assertArrayEquals(before, holder.snapshot());
}
freshHolder.inventory.setItemInOffHand(transferred.clone()); f.activate(freshHolder);
assertNull(f.state(freshHolder).lastExit(), "The new holder does not inherit the sender's delay");
assertEquals(firstExit, f.state(first)); assertEquals(secondExit, f.state(second));
}
}
@Test void cooldownExplainsRemainingSecondsAndSameCharacterBeforeEquipmentPreflight() throws Exception {
try (var f = new Fixture()) {
var actor = f.actor(); f.activate(actor);
f.sessions.exit(actor.player);
var exited = f.state(actor);
var other = f.actor();
actor.inventory.setItemInOffHand(other.inventory.getItemInOffHand().clone());
// Both equipment checks would refuse too, but the switch explanation must win.
for (int slot = 9; slot < 36; slot++) actor.inventory.setItem(slot, new ItemStack(Material.STONE, 64));
actor.inventory.setItem(0, new ItemStack(Material.SHULKER_BOX));
actor.cursor = new ItemStack(Material.EMERALD);
var before = actor.snapshot(); var cursor = actor.cursor.clone(); var marker = actor.marker();
for (int retry = 0; retry < 2; retry++) {
f.sessions.enter(actor.player); f.tick();
var notice = f.notices.getLast();
assertEquals("COOLDOWN", notice.code());
assertTrue(notice.message().matches("(?s).*Wait [1-9][0-9]* seconds.*"), notice::message);
assertTrue(notice.message().contains("same character may be resumed now"), notice::message);
assertArrayEquals(before, actor.snapshot()); assertEquals(cursor, actor.cursor);
assertEquals(marker, actor.marker()); assertEquals(exited, f.state(actor));
}
}
}
@Test void zeroHealthLiveRecordCannotEnterAndNoReceiptIsInvented() throws Exception {
try (var f = new Fixture()) {
var actor = f.actor(); var old = actor.record;
@@ -1107,7 +1348,8 @@ class EquipmentSessionsNativeTest {
final CopyOnWriteArrayList<EquipmentSessions.Failure> failures = new CopyOnWriteArrayList<>();
final ArrayList<EquipmentSessions.Notice> notices = new ArrayList<>();
final CharacterStorage characters;
final EquipmentSessionStore receipts;
EquipmentSessionStore receipts;
final Clock clock;
EquipmentSessions sessions;
volatile boolean rejectSchedule;
boolean receiptClosed;
@@ -1119,22 +1361,29 @@ class EquipmentSessionsNativeTest {
Fixture(DiskMove move) throws Exception { this(move, Duration.ofSeconds(900)); }
Fixture(DiskMove move, Duration delay) throws Exception { this(move, delay, EquipmentSessionsNativeTest::move); }
Fixture(DiskMove move, Duration delay, DiskMove characterMove) throws Exception {
this(move, delay, characterMove, Clock.systemUTC());
}
Fixture(Duration delay, Clock clock) throws Exception {
this(EquipmentSessionsNativeTest::move, delay, EquipmentSessionsNativeTest::move, clock);
}
Fixture(DiskMove move, Duration delay, DiskMove characterMove, Clock clock) throws Exception {
this.clock = clock;
var characterSeam = Class.forName("games.dmg.fantasystick.persistence.YamlCharacterRepository$Replacement");
var characterConstructor = YamlCharacterRepository.class.getDeclaredConstructor(Path.class, characterSeam);
characterConstructor.setAccessible(true);
Object characterReplacement = Proxy.newProxyInstance(characterSeam.getClassLoader(), new Class<?>[]{characterSeam},
(proxy, method, args) -> { characterMove.move((Path) args[0], (Path) args[1]); return null; });
characters = new CharacterStorage(characterConstructor.newInstance(data, characterReplacement), Clock.systemUTC());
characters = new CharacterStorage(characterConstructor.newInstance(data, characterReplacement), clock);
var seam = Class.forName("games.dmg.fantasystick.persistence.EquipmentSessionStore$Replacement");
var constructor = EquipmentSessionStore.class.getDeclaredConstructor(Path.class, Clock.class, seam);
constructor.setAccessible(true);
Object replacement = Proxy.newProxyInstance(seam.getClassLoader(), new Class<?>[]{seam},
(proxy, method, args) -> { move.move((Path) args[0], (Path) args[1]); return null; });
receipts = constructor.newInstance(data, Clock.systemUTC(), replacement);
receipts = constructor.newInstance(data, clock, replacement);
sessions = coordinator(delay);
}
EquipmentSessions coordinator(Duration delay) {
return new EquipmentSessions(characters, receipts, delay, task -> {
return new EquipmentSessions(characters, receipts, delay, clock, task -> {
if (rejectSchedule) throw new java.util.concurrent.RejectedExecutionException("test scheduler stopped");
tasks.add(task);
}, notice -> {
@@ -1151,6 +1400,14 @@ class EquipmentSessionsNativeTest {
sessions = coordinator(Duration.ofSeconds(900));
return actor.reload();
}
Actor reopen(Actor actor, Duration delay) throws Exception {
sessions.close(); sessions.drained().toCompletableFuture().get(5, TimeUnit.SECONDS);
state(actor); receipts.close();
assertTrue(tasks.isEmpty());
receipts = new EquipmentSessionStore(data, clock);
sessions = coordinator(delay);
return actor.reload();
}
Actor actor() throws Exception {
var record = new CharacterFactory().create(ProgressionRules.defaults());
characters.create(record).get(5, TimeUnit.SECONDS);
@@ -1186,6 +1443,15 @@ class EquipmentSessionsNativeTest {
}
}
static final class MutableClock extends Clock {
// Synthetic clock for exact boundaries, not a document/event timestamp.
volatile java.time.Instant now = java.time.Instant.parse("2000-01-01T00:00:00.123456789Z");
@Override public java.time.ZoneId getZone() { return java.time.ZoneOffset.UTC; }
@Override public Clock withZone(java.time.ZoneId zone) { return this; }
@Override public java.time.Instant instant() { return now; }
void advance(Duration elapsed) { now = now.plus(elapsed); }
}
@FunctionalInterface interface DiskMove { void move(Path source, Path target) throws java.io.IOException; }
static void move(Path source, Path target) throws java.io.IOException {
java.nio.file.Files.move(source, target, java.nio.file.StandardCopyOption.ATOMIC_MOVE, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
@@ -378,6 +378,8 @@ class FantasyStickLifecycleNativeTest {
f.plugin.setEnabled(true);
var a = new Actor(data.resolve(route)); f.players.put(a.core.id, a.player); f.activate(a);
var receipts = f.receipts();
var session = receipts.find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow().pending();
var requested = java.time.Instant.now();
if (route.equals("removal")) {
a.core.cursor = a.core.inventory.getItemInOffHand().clone();
a.core.inventory.setItemInOffHand(null); f.changed(a);
@@ -399,7 +401,14 @@ class FantasyStickLifecycleNativeTest {
while (!f.tasks.isEmpty()) f.tasks.remove().run();
assertArrayEquals(restored, a.core.snapshot());
try (var reopened = new games.dmg.fantasystick.persistence.EquipmentSessionStore(data.resolve(route), java.time.Clock.systemUTC())) {
assertNull(reopened.find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow().pending());
var state = reopened.find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow();
assertNull(state.pending());
var exit = state.lastExit();
assertEquals(session.sessionId(), exit.sessionId()); assertEquals(a.core.record.id(), exit.characterId());
assertFalse(exit.exitedAt().isBefore(requested)); assertFalse(exit.exitedAt().isAfter(java.time.Instant.now()));
assertEquals(java.time.Duration.ofSeconds(900), java.time.Duration.between(exit.exitedAt(), exit.deadline()));
assertEquals(state, reopened.completeExit(a.core.id, session.sessionId(), java.time.Duration.ofHours(1))
.toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS), "Repeated lifecycle acknowledgment must not extend the delay");
}
}
}
@@ -617,6 +626,23 @@ class FantasyStickLifecycleNativeTest {
var exit = f.receipts().find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow().lastExit();
assertEquals(java.time.Duration.ofSeconds(value.equals("default") ? 900 : Long.parseLong(value)),
java.time.Duration.between(exit.exitedAt(), exit.deadline()));
assertEquals(a.core.record.id(), exit.characterId());
var other = new Actor(directory);
a.core.inventory.setItemInOffHand(other.core.inventory.getItemInOffHand().clone());
var before = a.core.snapshot();
f.dispatcher.accept(new org.bukkit.event.player.PlayerJoinEvent(a.player, (net.kyori.adventure.text.Component) null));
f.tick(); f.tick(); // Join receipt reconciliation, then actual coordinator eligibility.
if (value.equals("0")) {
f.tick(); assertTrue(a.core.marker().endsWith("|PACKED"), "Configured zero reaches entry, not only persisted arithmetic");
} else {
assertArrayEquals(before, a.core.snapshot()); assertTrue(a.core.marker().endsWith("|RESTORED"));
assertTrue(a.messages.getLast().matches("(?s).*Wait [1-9][0-9]* seconds.*same character may be resumed now.*"), a.messages::toString);
var state = f.receipts().find(a.core.id).toCompletableFuture().get(5, java.util.concurrent.TimeUnit.SECONDS).orElseThrow();
assertNull(state.pending()); assertEquals(exit, state.lastExit());
a.core.inventory.setItemInOffHand(new CharacterSheets().create(a.core.record));
f.dispatcher.accept(new org.bukkit.event.player.PlayerJoinEvent(a.player, (net.kyori.adventure.text.Component) null));
f.tick(); f.tick(); f.tick(); assertTrue(a.core.marker().endsWith("|PACKED"));
}
}
}
}