From 3d045ff99b7ea53b4183dee8df36ef655b646f0c Mon Sep 17 00:00:00 2001 From: Dylan Garvis Date: Fri, 18 Sep 2026 19:11:18 -0400 Subject: [PATCH] fix(sessions): complete character-switch delay behavior --- .../session/EquipmentSessions.java | 18 +- .../EquipmentSessionEventsNativeTest.java | 41 ++- .../EquipmentSessionsNativeTest.java | 274 +++++++++++++++++- .../FantasyStickLifecycleNativeTest.java | 28 +- .../EquipmentSessionStoreTest.java | 33 +++ 5 files changed, 384 insertions(+), 10 deletions(-) diff --git a/src/main/java/games/dmg/fantasystick/session/EquipmentSessions.java b/src/main/java/games/dmg/fantasystick/session/EquipmentSessions.java index a5e4f37..6ad57cc 100644 --- a/src/main/java/games/dmg/fantasystick/session/EquipmentSessions.java +++ b/src/main/java/games/dmg/fantasystick/session/EquipmentSessions.java @@ -6,6 +6,7 @@ import games.dmg.fantasystick.items.SessionControls; import games.dmg.fantasystick.persistence.CharacterRecord; import games.dmg.fantasystick.persistence.CharacterStorage; import games.dmg.fantasystick.persistence.EquipmentSessionStore; +import java.time.Clock; import java.time.Duration; import java.time.Instant; import java.util.Arrays; @@ -36,6 +37,7 @@ public final class EquipmentSessions implements AutoCloseable { private final CharacterStorage characters; private final EquipmentSessionStore receipts; private final Duration switchDelay; + private final Clock clock; private final Consumer nextTick; private final Consumer notices; private final Consumer diagnostics; @@ -91,9 +93,16 @@ public final class EquipmentSessions implements AutoCloseable { public EquipmentSessions(CharacterStorage characters, EquipmentSessionStore receipts, Duration switchDelay, Consumer nextTick, Consumer notices, Consumer diagnostics) { + this(characters, receipts, switchDelay, Clock.systemUTC(), nextTick, notices, diagnostics); + } + + /** Supply the same wall clock as persistence when testing entry/exit deadline boundaries. */ + public EquipmentSessions(CharacterStorage characters, EquipmentSessionStore receipts, Duration switchDelay, Clock clock, + Consumer nextTick, Consumer notices, Consumer diagnostics) { this.characters = Objects.requireNonNull(characters); this.receipts = Objects.requireNonNull(receipts); this.switchDelay = Objects.requireNonNull(switchDelay); + this.clock = Objects.requireNonNull(clock); if (switchDelay.isNegative()) throw new IllegalArgumentException("Negative switch delay"); this.nextTick = Objects.requireNonNull(nextTick); this.notices = Objects.requireNonNull(notices); @@ -214,9 +223,12 @@ public final class EquipmentSessions implements AutoCloseable { if (state.pending() != null) { refuse(attempt, "RECOVERY_REQUIRED", "An unresolved equipment receipt requires validated recovery."); return; } - if (!state.canEnter(attempt.character, switchDelay, Instant.now())) { - refuse(attempt, "COOLDOWN", "Wait until " + state.lastExit().deadline() - + " to switch characters; the same character may be resumed now."); return; + Instant now = clock.instant(); + if (!state.canEnter(attempt.character, switchDelay, now)) { + Duration remaining = Duration.between(now, state.lastExit().deadline()); + long seconds = remaining.getSeconds() + (remaining.getNano() == 0 ? 0 : 1); + refuse(attempt, "COOLDOWN", "Wait " + seconds + " seconds to switch characters (until " + + state.lastExit().deadline() + "); the same character may be resumed now."); return; } } if (!entryNativeSafe(attempt, loaded.state().orElse(null))) { diff --git a/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionEventsNativeTest.java b/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionEventsNativeTest.java index 1e57e67..5915485 100644 --- a/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionEventsNativeTest.java +++ b/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionEventsNativeTest.java @@ -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(); diff --git a/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionsNativeTest.java b/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionsNativeTest.java index 8963c60..e3c2bed 100644 --- a/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionsNativeTest.java +++ b/src/nativeTest/java/games/dmg/fantasystick/EquipmentSessionsNativeTest.java @@ -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 failures = new CopyOnWriteArrayList<>(); final ArrayList 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); diff --git a/src/nativeTest/java/games/dmg/fantasystick/FantasyStickLifecycleNativeTest.java b/src/nativeTest/java/games/dmg/fantasystick/FantasyStickLifecycleNativeTest.java index 24af4ce..fac5604 100644 --- a/src/nativeTest/java/games/dmg/fantasystick/FantasyStickLifecycleNativeTest.java +++ b/src/nativeTest/java/games/dmg/fantasystick/FantasyStickLifecycleNativeTest.java @@ -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")); + } } } } diff --git a/src/test/java/games/dmg/fantasystick/persistence/EquipmentSessionStoreTest.java b/src/test/java/games/dmg/fantasystick/persistence/EquipmentSessionStoreTest.java index 65cdc5c..eb6eac4 100644 --- a/src/test/java/games/dmg/fantasystick/persistence/EquipmentSessionStoreTest.java +++ b/src/test/java/games/dmg/fantasystick/persistence/EquipmentSessionStoreTest.java @@ -183,6 +183,39 @@ class EquipmentSessionStoreTest { } } + @Test + void completedExitUsesRequestTimeBehindAWorkerBacklogAndRetriesKeepThatDeadline() throws Exception { + var entered = new CountDownLatch(1); + var release = new CountDownLatch(1); + var time = new AtomicReference<>(NOW); + Clock clock = new Clock() { + @Override public ZoneId getZone() { return ZoneOffset.UTC; } + @Override public Clock withZone(ZoneId zone) { return this; } + @Override public Instant instant() { return time.get(); } + }; + try (var store = new EquipmentSessionStore(data, clock, (source, target) -> { + entered.countDown(); waitFor(release); replace(source, target); + })) { + var preparation = store.prepare(player, session, character); + CompletionStage completion; + try { + assertTrue(entered.await(5, TimeUnit.SECONDS)); + time.set(NOW.plusSeconds(2)); + completion = store.completeExit(player, session, Duration.ofSeconds(900)); + assertFalse(completion.toCompletableFuture().isDone()); + time.set(NOW.plusSeconds(3600)); // Worker cannot execute the exit until after its deadline. + } finally { release.countDown(); } + await(preparation); + var completed = await(completion); + assertNull(completed.pending()); + assertEquals(NOW.plusSeconds(2), completed.lastExit().exitedAt()); + assertEquals(NOW.plusSeconds(902), completed.lastExit().deadline()); + assertTrue(completed.canEnter(UUID.randomUUID(), Duration.ofSeconds(900), clock.instant())); + assertEquals(completed, await(store.completeExit(player, session, Duration.ofDays(1)))); + assertEquals(completed, await(store.recordExit(player, session, Duration.ofDays(1)))); + } + } + @Test void failedForcedTemporaryReplacementPreservesOriginalAndRetryIsPossible() throws Exception { EquipmentSessionStore.State original;