fix(sessions): complete character-switch delay behavior
This commit is contained in:
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"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user