1540 lines
45 KiB
JavaScript
1540 lines
45 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { spawnSync } from 'node:child_process';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { chromium } from 'playwright';
|
|
import {
|
|
desktopBrowserContextOptions,
|
|
desktopBrowserDeviceScaleFactor,
|
|
desktopBrowserViewport
|
|
} from './desktop-browser-viewport.mjs';
|
|
import {
|
|
startVerificationPreview,
|
|
stopVerificationPreview
|
|
} from './verification-preview-server.mjs';
|
|
|
|
const renderers = ['canvas', 'webgl'];
|
|
const renderer = process.env.VERIFY_BATTLE_SAVE_GENERATION_RENDERER;
|
|
|
|
if (!renderer) {
|
|
for (const requestedRenderer of renderers) {
|
|
const result = spawnSync(process.execPath, [fileURLToPath(import.meta.url)], {
|
|
cwd: process.cwd(),
|
|
env: {
|
|
...process.env,
|
|
VERIFY_BATTLE_SAVE_GENERATION_RENDERER: requestedRenderer
|
|
},
|
|
stdio: 'inherit'
|
|
});
|
|
if (result.status !== 0) {
|
|
process.exit(result.status ?? 1);
|
|
}
|
|
}
|
|
process.exit(0);
|
|
}
|
|
|
|
assert(
|
|
renderers.includes(renderer),
|
|
`Unsupported battle-save generation renderer "${renderer}".`
|
|
);
|
|
|
|
const battleId = 'first-battle-zhuo-commandery';
|
|
const campaignStep = 'first-battle';
|
|
const campaignGeneration = 4;
|
|
const staleGeneration = 3;
|
|
const campaignKey = 'heros-web:campaign-state';
|
|
const campaignSlotKey = `${campaignKey}:slot-1`;
|
|
const manualSaveSlotKey = 'heros-web:manual-save:slot-1';
|
|
const battleBaseKey = `heros-web:battle:${battleId}`;
|
|
const battleSlotKey = `${battleBaseKey}:slot-1`;
|
|
const legacyBattleKey = 'heros-web:first-battle-state';
|
|
const battleStorageKeys = [battleSlotKey, battleBaseKey, legacyBattleKey];
|
|
const otherBattleBaseKey =
|
|
'heros-web:battle:second-battle-yellow-turban-pursuit';
|
|
const otherBattleSlotKey = `${otherBattleBaseKey}:slot-1`;
|
|
const otherBattleCheckpoint =
|
|
'{"sentinel":"preserve-other-battle-checkpoint"}';
|
|
const baseUrl =
|
|
process.env.VERIFY_BATTLE_SAVE_GENERATION_URL ??
|
|
`http://127.0.0.1:${renderer === 'canvas' ? 41825 : 41826}/heros_web/`;
|
|
const targetUrl = withDebugOptions(baseUrl, renderer);
|
|
|
|
let browser;
|
|
let serverProcess;
|
|
|
|
try {
|
|
serverProcess = await startVerificationPreview({
|
|
targetUrl,
|
|
explicitUrl: Boolean(
|
|
process.env.VERIFY_BATTLE_SAVE_GENERATION_URL
|
|
),
|
|
label:
|
|
`${renderer} battle save generation verification`
|
|
});
|
|
browser = await chromium.launch({
|
|
headless: process.env.VERIFY_BATTLE_SAVE_GENERATION_HEADLESS !== '0',
|
|
args:
|
|
renderer === 'webgl'
|
|
? ['--use-angle=swiftshader', '--enable-unsafe-swiftshader']
|
|
: []
|
|
});
|
|
const context = await browser.newContext(desktopBrowserContextOptions);
|
|
const page = await context.newPage();
|
|
page.setDefaultTimeout(30000);
|
|
|
|
const pageErrors = [];
|
|
const consoleErrors = [];
|
|
page.on('pageerror', (error) => pageErrors.push(error.stack ?? error.message));
|
|
page.on('console', (message) => {
|
|
if (message.type() === 'error') {
|
|
consoleErrors.push(message.text());
|
|
}
|
|
});
|
|
|
|
await page.goto(targetUrl, {
|
|
waitUntil: 'domcontentloaded',
|
|
timeout: 90000
|
|
});
|
|
await waitForDebugApi(page);
|
|
await page.evaluate(() => window.localStorage.clear());
|
|
await page.reload({
|
|
waitUntil: 'domcontentloaded',
|
|
timeout: 90000
|
|
});
|
|
await waitForTitle(page);
|
|
await assertDesktopRuntime(page, renderer);
|
|
|
|
await page.evaluate(async (requestedBattleId) => {
|
|
await window.__HEROS_DEBUG__?.goToBattle(requestedBattleId);
|
|
}, battleId);
|
|
await waitForBattleReady(page);
|
|
|
|
const fixture = await page.evaluate(
|
|
({
|
|
requestedBattleId,
|
|
requestedCampaignStep,
|
|
requestedCampaignGeneration,
|
|
requestedStaleGeneration,
|
|
requestedCampaignKey,
|
|
requestedCampaignSlotKey,
|
|
requestedBattleBaseKey,
|
|
requestedBattleSlotKey,
|
|
requestedLegacyBattleKey,
|
|
requestedBattleStorageKeys
|
|
}) => {
|
|
const scene = window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
if (
|
|
!scene ||
|
|
typeof scene.createBattleSaveState !== 'function' ||
|
|
typeof scene.saveBattleState !== 'function'
|
|
) {
|
|
throw new Error('BattleScene save internals are unavailable.');
|
|
}
|
|
|
|
// Persist a normalized campaign fixture and a fully valid battle-save
|
|
// shape through the production writer before applying generation markers.
|
|
scene.saveBattleState(1);
|
|
const campaignRaw =
|
|
window.localStorage.getItem(requestedCampaignSlotKey) ??
|
|
window.localStorage.getItem(requestedCampaignKey);
|
|
const battleRaw =
|
|
window.localStorage.getItem(requestedBattleSlotKey) ??
|
|
window.localStorage.getItem(requestedBattleBaseKey);
|
|
if (!campaignRaw || !battleRaw) {
|
|
throw new Error('The production save writer did not create the browser fixture.');
|
|
}
|
|
|
|
const campaign = JSON.parse(campaignRaw);
|
|
campaign.step = requestedCampaignStep;
|
|
campaign.activeSaveSlot = 1;
|
|
campaign.battleResumeGeneration = requestedCampaignGeneration;
|
|
campaign.storyCheckpoint = undefined;
|
|
campaign.explorationCheckpoint = undefined;
|
|
campaign.updatedAt = new Date().toISOString();
|
|
const serializedCampaign = JSON.stringify(campaign);
|
|
window.localStorage.setItem(requestedCampaignSlotKey, serializedCampaign);
|
|
window.localStorage.setItem(requestedCampaignKey, serializedCampaign);
|
|
|
|
const baseline = JSON.parse(battleRaw);
|
|
const markerIndex = baseline.units.findIndex((unit) => unit.id === 'liu-bei');
|
|
if (markerIndex < 0) {
|
|
throw new Error('The first-battle Liu Bei save fixture is unavailable.');
|
|
}
|
|
const baselineMarkerHp = baseline.units[markerIndex].hp;
|
|
const markerMaxHp = baseline.units[markerIndex].maxHp;
|
|
const staleMarkerHp = Math.max(1, Math.min(markerMaxHp, baselineMarkerHp - 7));
|
|
const validMarkerHp = Math.max(1, Math.min(markerMaxHp, baselineMarkerHp - 3));
|
|
if (
|
|
staleMarkerHp === baselineMarkerHp ||
|
|
validMarkerHp === baselineMarkerHp ||
|
|
staleMarkerHp === validMarkerHp
|
|
) {
|
|
throw new Error(
|
|
`Battle marker HP values are not distinguishable: ${JSON.stringify({
|
|
baselineMarkerHp,
|
|
staleMarkerHp,
|
|
validMarkerHp
|
|
})}`
|
|
);
|
|
}
|
|
|
|
const stale = structuredClone(baseline);
|
|
stale.battleId = requestedBattleId;
|
|
stale.campaignStep = requestedCampaignStep;
|
|
stale.battleResumeGeneration = requestedStaleGeneration;
|
|
stale.turnNumber = 8;
|
|
stale.activeFaction = 'ally';
|
|
stale.savedAt = new Date(Date.now() - 60_000).toISOString();
|
|
stale.units[markerIndex].hp = staleMarkerHp;
|
|
|
|
const valid = structuredClone(baseline);
|
|
valid.battleId = requestedBattleId;
|
|
valid.campaignStep = requestedCampaignStep;
|
|
valid.battleResumeGeneration = requestedCampaignGeneration;
|
|
valid.turnNumber = 6;
|
|
valid.activeFaction = 'ally';
|
|
valid.savedAt = new Date().toISOString();
|
|
valid.units[markerIndex].hp = validMarkerHp;
|
|
|
|
window.localStorage.removeItem(requestedBattleBaseKey);
|
|
window.localStorage.removeItem(requestedLegacyBattleKey);
|
|
window.localStorage.setItem(requestedBattleSlotKey, JSON.stringify(stale));
|
|
|
|
const storagePrototype = Object.getPrototypeOf(window.localStorage);
|
|
const originalRemoveItem = storagePrototype.removeItem;
|
|
const blockedKeys = new Set(requestedBattleStorageKeys);
|
|
const removalStats = {
|
|
attempts: 0,
|
|
blocked: 0,
|
|
keys: []
|
|
};
|
|
storagePrototype.removeItem = function removeItem(key) {
|
|
const normalizedKey = String(key);
|
|
if (this === window.localStorage && blockedKeys.has(normalizedKey)) {
|
|
removalStats.attempts += 1;
|
|
removalStats.blocked += 1;
|
|
removalStats.keys.push(normalizedKey);
|
|
throw new DOMException(
|
|
'Injected battle-save removal refusal',
|
|
'InvalidStateError'
|
|
);
|
|
}
|
|
return originalRemoveItem.call(this, key);
|
|
};
|
|
|
|
Object.defineProperty(window, '__HEROS_BATTLE_GENERATION_FIXTURE__', {
|
|
configurable: true,
|
|
value: {
|
|
baselineMarkerHp,
|
|
staleMarkerHp,
|
|
validMarkerHp,
|
|
valid,
|
|
removalStats,
|
|
restoreRemovalInterceptor() {
|
|
storagePrototype.removeItem = originalRemoveItem;
|
|
}
|
|
}
|
|
});
|
|
|
|
scene.scene.restart({
|
|
battleId: requestedBattleId,
|
|
resumeBattleSaveSlot: 1
|
|
});
|
|
|
|
return {
|
|
baselineMarkerHp,
|
|
staleMarkerHp,
|
|
validMarkerHp,
|
|
staleTurnNumber: stale.turnNumber,
|
|
validTurnNumber: valid.turnNumber
|
|
};
|
|
},
|
|
{
|
|
requestedBattleId: battleId,
|
|
requestedCampaignStep: campaignStep,
|
|
requestedCampaignGeneration: campaignGeneration,
|
|
requestedStaleGeneration: staleGeneration,
|
|
requestedCampaignKey: campaignKey,
|
|
requestedCampaignSlotKey: campaignSlotKey,
|
|
requestedBattleBaseKey: battleBaseKey,
|
|
requestedBattleSlotKey: battleSlotKey,
|
|
requestedLegacyBattleKey: legacyBattleKey,
|
|
requestedBattleStorageKeys: battleStorageKeys
|
|
}
|
|
);
|
|
|
|
await page.waitForFunction(
|
|
({ expectedBattleId, expectedBaselineHp }) => {
|
|
const battle = window.__HEROS_DEBUG__?.battle?.();
|
|
const fixtureState = window.__HEROS_BATTLE_GENERATION_FIXTURE__;
|
|
return (
|
|
battle?.battleId === expectedBattleId &&
|
|
battle?.mapBackgroundReady === true &&
|
|
['deployment', 'idle'].includes(battle?.phase) &&
|
|
battle?.turnNumber === 1 &&
|
|
battle?.units?.find((unit) => unit.id === 'liu-bei')?.hp ===
|
|
expectedBaselineHp &&
|
|
fixtureState?.removalStats?.blocked >= 1
|
|
);
|
|
},
|
|
{
|
|
expectedBattleId: battleId,
|
|
expectedBaselineHp: fixture.baselineMarkerHp
|
|
},
|
|
{ timeout: 90000 }
|
|
);
|
|
|
|
const staleProbe = await page.evaluate(
|
|
({
|
|
requestedBattleSlotKey,
|
|
requestedStaleGeneration
|
|
}) => {
|
|
const scene = window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
if (!scene) {
|
|
throw new Error('BattleScene is unavailable after stale resume rejection.');
|
|
}
|
|
const rejected =
|
|
scene.readBattleSaveState?.(1, true) === undefined;
|
|
const loadDisabled =
|
|
scene.isMapMenuActionDisabled?.('load') === true;
|
|
scene.showSaveSlotPanel?.('load');
|
|
const panelBeforeSelection =
|
|
window.__HEROS_DEBUG__?.battle?.();
|
|
scene.activateSaveSlotPanelSlot?.(1);
|
|
const panelAfterSelection =
|
|
window.__HEROS_DEBUG__?.battle?.();
|
|
scene.hideSaveSlotPanel?.();
|
|
|
|
const persisted = JSON.parse(
|
|
window.localStorage.getItem(requestedBattleSlotKey) ?? 'null'
|
|
);
|
|
const fixtureState =
|
|
window.__HEROS_BATTLE_GENERATION_FIXTURE__;
|
|
return {
|
|
rejected,
|
|
loadDisabled,
|
|
panelMode:
|
|
panelBeforeSelection?.saveSlotPanelMode ?? null,
|
|
panelStayedOpen:
|
|
panelAfterSelection?.saveSlotPanelVisible === true,
|
|
promptMode:
|
|
panelAfterSelection?.turnPromptMode ?? null,
|
|
persistedGeneration:
|
|
persisted?.battleResumeGeneration ?? null,
|
|
removalStats: {
|
|
attempts:
|
|
fixtureState?.removalStats?.attempts ?? 0,
|
|
blocked:
|
|
fixtureState?.removalStats?.blocked ?? 0,
|
|
keys: [
|
|
...(fixtureState?.removalStats?.keys ?? [])
|
|
]
|
|
}
|
|
};
|
|
},
|
|
{
|
|
requestedBattleSlotKey: battleSlotKey,
|
|
requestedStaleGeneration: staleGeneration
|
|
}
|
|
);
|
|
|
|
assert.equal(
|
|
staleProbe.rejected,
|
|
true,
|
|
`${renderer}: BattleScene accepted a stale generation.`
|
|
);
|
|
assert.equal(
|
|
staleProbe.loadDisabled,
|
|
true,
|
|
`${renderer}: manual Load remained enabled for a stale save.`
|
|
);
|
|
assert.equal(staleProbe.panelMode, 'load');
|
|
assert.equal(
|
|
staleProbe.panelStayedOpen,
|
|
true,
|
|
`${renderer}: selecting a stale Load row should be a no-op.`
|
|
);
|
|
assert.equal(
|
|
staleProbe.promptMode,
|
|
null,
|
|
`${renderer}: a stale save reached the Load confirmation prompt.`
|
|
);
|
|
assert.equal(
|
|
staleProbe.persistedGeneration,
|
|
staleGeneration,
|
|
`${renderer}: the removal-refusal fixture was not preserved.`
|
|
);
|
|
assert(
|
|
staleProbe.removalStats.blocked >= 1,
|
|
`${renderer}: no stale-save cleanup refusal was exercised.`
|
|
);
|
|
assert(
|
|
staleProbe.removalStats.keys.every((key) =>
|
|
battleStorageKeys.includes(key)
|
|
),
|
|
`${renderer}: removal refusal escaped the intended battle keys.`
|
|
);
|
|
|
|
await page.evaluate(() => {
|
|
window.__HEROS_BATTLE_GENERATION_FIXTURE__
|
|
?.restoreRemovalInterceptor?.();
|
|
});
|
|
|
|
const beforeControl = await page.evaluate(
|
|
({
|
|
requestedBattleSlotKey,
|
|
requestedCampaignSlotKey,
|
|
requestedManualSaveSlotKey,
|
|
requestedCampaignGeneration
|
|
}) => {
|
|
const scene = window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
const fixtureState =
|
|
window.__HEROS_BATTLE_GENERATION_FIXTURE__;
|
|
if (!scene || !fixtureState?.valid) {
|
|
throw new Error('The current-generation control fixture is unavailable.');
|
|
}
|
|
|
|
window.localStorage.setItem(
|
|
requestedBattleSlotKey,
|
|
JSON.stringify(fixtureState.valid)
|
|
);
|
|
const campaign = JSON.parse(
|
|
window.localStorage.getItem(
|
|
requestedCampaignSlotKey
|
|
) ?? 'null'
|
|
);
|
|
if (!campaign) {
|
|
throw new Error('The campaign fixture is unavailable for the protected manual control.');
|
|
}
|
|
window.localStorage.setItem(
|
|
requestedManualSaveSlotKey,
|
|
JSON.stringify({
|
|
version: 1,
|
|
slot: 1,
|
|
savedAt: fixtureState.valid.savedAt,
|
|
context: 'battle',
|
|
campaign,
|
|
battle: fixtureState.valid
|
|
})
|
|
);
|
|
const accepted = scene.readBattleSaveState?.(1, true);
|
|
const acceptedManual =
|
|
scene.readManualBattleSaveState?.(1, true);
|
|
const loadDisabled =
|
|
scene.isMapMenuActionDisabled?.('load') === true;
|
|
scene.showSaveSlotPanel?.('load');
|
|
const panel =
|
|
window.__HEROS_DEBUG__?.battle?.();
|
|
scene.activateSaveSlotPanelSlot?.(1);
|
|
const confirmation =
|
|
window.__HEROS_DEBUG__?.battle?.();
|
|
|
|
return {
|
|
acceptedGeneration:
|
|
accepted?.battleResumeGeneration ?? null,
|
|
acceptedTurnNumber:
|
|
accepted?.turnNumber ?? null,
|
|
acceptedManualTurnNumber:
|
|
acceptedManual?.turnNumber ?? null,
|
|
loadDisabled,
|
|
panelMode: panel?.saveSlotPanelMode ?? null,
|
|
confirmationMode:
|
|
confirmation?.turnPromptMode ?? null,
|
|
confirmationVisible:
|
|
confirmation?.turnPromptVisible === true,
|
|
expectedGeneration: requestedCampaignGeneration
|
|
};
|
|
},
|
|
{
|
|
requestedBattleSlotKey: battleSlotKey,
|
|
requestedCampaignSlotKey: campaignSlotKey,
|
|
requestedManualSaveSlotKey: manualSaveSlotKey,
|
|
requestedCampaignGeneration: campaignGeneration
|
|
}
|
|
);
|
|
|
|
assert.equal(
|
|
beforeControl.acceptedGeneration,
|
|
campaignGeneration,
|
|
`${renderer}: the current-generation control was not accepted.`
|
|
);
|
|
assert.equal(
|
|
beforeControl.acceptedTurnNumber,
|
|
fixture.validTurnNumber
|
|
);
|
|
assert.equal(
|
|
beforeControl.acceptedManualTurnNumber,
|
|
fixture.validTurnNumber
|
|
);
|
|
assert.equal(beforeControl.loadDisabled, false);
|
|
assert.equal(beforeControl.panelMode, 'load');
|
|
assert.equal(beforeControl.confirmationMode, 'load-confirm');
|
|
assert.equal(beforeControl.confirmationVisible, true);
|
|
|
|
await page.evaluate(() => {
|
|
const scene = window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
scene?.activateTurnPromptPrimaryAction?.();
|
|
});
|
|
try {
|
|
await page.waitForFunction(
|
|
({
|
|
expectedBattleId,
|
|
expectedTurnNumber,
|
|
expectedMarkerHp
|
|
}) => {
|
|
const battle = window.__HEROS_DEBUG__?.battle?.();
|
|
return (
|
|
battle?.battleId === expectedBattleId &&
|
|
battle?.turnNumber === expectedTurnNumber &&
|
|
battle?.activeFaction === 'ally' &&
|
|
battle?.phase === 'idle' &&
|
|
battle?.units?.find((unit) => unit.id === 'liu-bei')?.hp ===
|
|
expectedMarkerHp
|
|
);
|
|
},
|
|
{
|
|
expectedBattleId: battleId,
|
|
expectedTurnNumber: fixture.validTurnNumber,
|
|
expectedMarkerHp: fixture.validMarkerHp
|
|
},
|
|
{ timeout: 90000 }
|
|
);
|
|
} catch (error) {
|
|
const restoreDiagnostics = await page.evaluate(
|
|
({
|
|
requestedCampaignSlotKey,
|
|
requestedBattleSlotKey,
|
|
requestedManualSaveSlotKey
|
|
}) => ({
|
|
battle:
|
|
window.__HEROS_DEBUG__?.battle?.() ?? null,
|
|
campaign: JSON.parse(
|
|
window.localStorage.getItem(
|
|
requestedCampaignSlotKey
|
|
) ?? 'null'
|
|
),
|
|
battleSave: JSON.parse(
|
|
window.localStorage.getItem(
|
|
requestedBattleSlotKey
|
|
) ?? 'null'
|
|
),
|
|
manualSave: JSON.parse(
|
|
window.localStorage.getItem(
|
|
requestedManualSaveSlotKey
|
|
) ?? 'null'
|
|
)
|
|
}),
|
|
{
|
|
requestedCampaignSlotKey: campaignSlotKey,
|
|
requestedBattleSlotKey: battleSlotKey,
|
|
requestedManualSaveSlotKey: manualSaveSlotKey
|
|
}
|
|
);
|
|
throw new Error(
|
|
`${renderer}: protected manual restore did not become ready: ${JSON.stringify({
|
|
restoreDiagnostics,
|
|
pageErrors,
|
|
consoleErrors
|
|
})}`,
|
|
{ cause: error }
|
|
);
|
|
}
|
|
|
|
const restored = await page.evaluate(
|
|
({
|
|
requestedCampaignKey,
|
|
requestedCampaignSlotKey
|
|
}) => {
|
|
const battle = window.__HEROS_DEBUG__?.battle?.();
|
|
const current = JSON.parse(
|
|
window.localStorage.getItem(requestedCampaignKey) ?? 'null'
|
|
);
|
|
const slot = JSON.parse(
|
|
window.localStorage.getItem(requestedCampaignSlotKey) ?? 'null'
|
|
);
|
|
return {
|
|
turnNumber: battle?.turnNumber ?? null,
|
|
activeFaction: battle?.activeFaction ?? null,
|
|
markerHp:
|
|
battle?.units?.find((unit) => unit.id === 'liu-bei')?.hp ?? null,
|
|
campaignGeneration:
|
|
current?.battleResumeGeneration ?? null,
|
|
slotGeneration:
|
|
slot?.battleResumeGeneration ?? null,
|
|
campaignStep: current?.step ?? null,
|
|
slotStep: slot?.step ?? null
|
|
};
|
|
},
|
|
{
|
|
requestedCampaignKey: campaignKey,
|
|
requestedCampaignSlotKey: campaignSlotKey
|
|
}
|
|
);
|
|
|
|
assert.equal(restored.turnNumber, fixture.validTurnNumber);
|
|
assert.equal(restored.activeFaction, 'ally');
|
|
assert.equal(restored.markerHp, fixture.validMarkerHp);
|
|
assert.equal(restored.campaignGeneration, campaignGeneration);
|
|
assert.equal(restored.slotGeneration, campaignGeneration);
|
|
assert.equal(restored.campaignStep, campaignStep);
|
|
assert.equal(restored.slotStep, campaignStep);
|
|
|
|
const tutorialPendingEventProbe = await page.evaluate(() => {
|
|
const scene =
|
|
window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
if (
|
|
!scene ||
|
|
typeof scene.scheduleFirstBattleTutorial !==
|
|
'function'
|
|
) {
|
|
throw new Error(
|
|
'The first-battle tutorial resume probe is unavailable.'
|
|
);
|
|
}
|
|
const originalStart =
|
|
scene.startFirstBattleTutorial;
|
|
const originalDelayedCall =
|
|
scene.time.delayedCall;
|
|
const originalState = {
|
|
phase: scene.phase,
|
|
activeFaction: scene.activeFaction,
|
|
turnNumber: scene.turnNumber,
|
|
firstBattleTutorialStep:
|
|
scene.firstBattleTutorialStep,
|
|
activeBattleEvent: scene.activeBattleEvent,
|
|
battleEventQueue: scene.battleEventQueue,
|
|
battleEventObjects: scene.battleEventObjects
|
|
};
|
|
let tutorialStartCalls = 0;
|
|
let retryCalls = 0;
|
|
try {
|
|
scene.phase = 'idle';
|
|
scene.activeFaction = 'ally';
|
|
scene.turnNumber = 1;
|
|
scene.firstBattleTutorialStep = undefined;
|
|
scene.activeBattleEvent = undefined;
|
|
scene.battleEventObjects = [];
|
|
scene.battleEventQueue = [{
|
|
key: 'qa-restored-pending-event',
|
|
title: 'Restored pending event',
|
|
lines: ['This event must display before tutorial input.'],
|
|
priority: 'normal',
|
|
playCue: false
|
|
}];
|
|
scene.startFirstBattleTutorial = () => {
|
|
tutorialStartCalls += 1;
|
|
return true;
|
|
};
|
|
scene.time.delayedCall = () => {
|
|
retryCalls += 1;
|
|
return { remove() {} };
|
|
};
|
|
scene.scheduleFirstBattleTutorial();
|
|
return {
|
|
tutorialStartCalls,
|
|
retryCalls,
|
|
pendingEventCount:
|
|
scene.battleEventQueue.length
|
|
};
|
|
} finally {
|
|
scene.startFirstBattleTutorial = originalStart;
|
|
scene.time.delayedCall = originalDelayedCall;
|
|
scene.phase = originalState.phase;
|
|
scene.activeFaction = originalState.activeFaction;
|
|
scene.turnNumber = originalState.turnNumber;
|
|
scene.firstBattleTutorialStep =
|
|
originalState.firstBattleTutorialStep;
|
|
scene.activeBattleEvent =
|
|
originalState.activeBattleEvent;
|
|
scene.battleEventQueue =
|
|
originalState.battleEventQueue;
|
|
scene.battleEventObjects =
|
|
originalState.battleEventObjects;
|
|
}
|
|
});
|
|
assert.deepEqual(
|
|
tutorialPendingEventProbe,
|
|
{
|
|
tutorialStartCalls: 0,
|
|
retryCalls: 1,
|
|
pendingEventCount: 1
|
|
},
|
|
`${renderer}: a restored pending battle event was not allowed to finish before the first-battle tutorial resumed.`
|
|
);
|
|
|
|
const autosaveContract = await page.evaluate(() => {
|
|
const scene = window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
const battle = window.__HEROS_DEBUG__?.battle?.();
|
|
const fixtureState =
|
|
window.__HEROS_BATTLE_GENERATION_FIXTURE__;
|
|
fixtureState?.restoreRemovalInterceptor?.();
|
|
return {
|
|
sceneMethod:
|
|
typeof scene?.persistBattleAutosave === 'function',
|
|
debugState:
|
|
battle?.autosave ?? null
|
|
};
|
|
});
|
|
|
|
assert.equal(
|
|
autosaveContract.sceneMethod,
|
|
true,
|
|
`${renderer}: BattleScene.persistBattleAutosave(reason) is unavailable.`
|
|
);
|
|
assertAutosaveDebugState(
|
|
autosaveContract.debugState,
|
|
`${renderer}: initial autosave debug state`
|
|
);
|
|
|
|
const actionBaseline = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
const actionTrigger = await page.evaluate(() => {
|
|
const scene = window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
const unit = scene?.debugUnitById?.('liu-bei');
|
|
if (
|
|
!scene ||
|
|
!unit ||
|
|
typeof scene.completeUnitAction !== 'function'
|
|
) {
|
|
throw new Error(
|
|
'The ally-action autosave trigger is unavailable.'
|
|
);
|
|
}
|
|
scene.phase = 'command';
|
|
scene.activeFaction = 'ally';
|
|
scene.selectedUnit = unit;
|
|
scene.pendingMove = undefined;
|
|
scene.targetingAction = undefined;
|
|
scene.selectedUsable = undefined;
|
|
scene.completeUnitAction(unit, 'wait');
|
|
return {
|
|
phase:
|
|
window.__HEROS_DEBUG__?.battle?.()?.phase ?? null,
|
|
actedUnitIds: [
|
|
...(window.__HEROS_DEBUG__?.battle?.()?.actedUnitIds ?? [])
|
|
]
|
|
};
|
|
});
|
|
|
|
assert(
|
|
actionTrigger.actedUnitIds.includes('liu-bei'),
|
|
`${renderer}: the ally action did not complete.`
|
|
);
|
|
|
|
await page.waitForFunction(
|
|
({
|
|
requestedBattleSlotKey,
|
|
previousSavedAt,
|
|
previousWriteCount
|
|
}) => {
|
|
const persisted = JSON.parse(
|
|
window.localStorage.getItem(requestedBattleSlotKey) ??
|
|
'null'
|
|
);
|
|
const autosave =
|
|
window.__HEROS_DEBUG__?.battle?.()?.autosave;
|
|
return (
|
|
persisted?.savedAt &&
|
|
persisted.savedAt !== previousSavedAt &&
|
|
persisted.actedUnitIds?.includes('liu-bei') &&
|
|
autosave?.writeCount === previousWriteCount + 1 &&
|
|
autosave?.lastResult === 'saved' &&
|
|
autosave?.lastReason === 'ally-action'
|
|
);
|
|
},
|
|
{
|
|
requestedBattleSlotKey: battleSlotKey,
|
|
previousSavedAt: actionBaseline.state.savedAt,
|
|
previousWriteCount:
|
|
actionBaseline.autosave.writeCount
|
|
}
|
|
);
|
|
|
|
const actionAutosave = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
assertAutosaveWrite(
|
|
actionBaseline,
|
|
actionAutosave,
|
|
{
|
|
reason: 'ally-action',
|
|
expectedTurnNumber: fixture.validTurnNumber,
|
|
expectedActedUnitId: 'liu-bei'
|
|
},
|
|
`${renderer}: ally action autosave`
|
|
);
|
|
assert.equal(
|
|
actionAutosave.autosave.indicatorVisible,
|
|
true,
|
|
`${renderer}: a successful ally-action autosave did not expose visible save feedback.`
|
|
);
|
|
assert.match(
|
|
actionAutosave.autosave.indicatorText ?? '',
|
|
/자동 저장 완료/,
|
|
`${renderer}: the success save indicator was not clearly labeled.`
|
|
);
|
|
|
|
const unsafeAutosaves = [];
|
|
for (const [
|
|
unsafeIndex,
|
|
unsafePhase
|
|
] of ['command', 'animating'].entries()) {
|
|
const beforeUnsafe = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
const unsafeTurnNumber = 41 + unsafeIndex;
|
|
const eventProbe = await page.evaluate(
|
|
({
|
|
requestedPhase,
|
|
requestedTurnNumber
|
|
}) => {
|
|
const scene =
|
|
window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
const unit = scene?.debugUnitById?.('liu-bei');
|
|
if (
|
|
!scene ||
|
|
!unit ||
|
|
typeof scene.persistBattleAutosave !== 'function'
|
|
) {
|
|
throw new Error(
|
|
'The unsafe pagehide autosave probe is unavailable.'
|
|
);
|
|
}
|
|
scene.turnNumber = requestedTurnNumber;
|
|
scene.activeFaction = 'ally';
|
|
scene.phase = requestedPhase;
|
|
scene.selectedUnit =
|
|
requestedPhase === 'command' ? unit : undefined;
|
|
scene.pendingMove = undefined;
|
|
scene.targetingAction = undefined;
|
|
scene.selectedUsable = undefined;
|
|
window.dispatchEvent(new Event('pagehide'));
|
|
const battle =
|
|
window.__HEROS_DEBUG__?.battle?.();
|
|
return {
|
|
phase: battle?.phase ?? null,
|
|
turnNumber: battle?.turnNumber ?? null,
|
|
autosave: battle?.autosave ?? null
|
|
};
|
|
},
|
|
{
|
|
requestedPhase: unsafePhase,
|
|
requestedTurnNumber: unsafeTurnNumber
|
|
}
|
|
);
|
|
const afterUnsafe = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
|
|
assert.equal(eventProbe.phase, unsafePhase);
|
|
assert.equal(
|
|
eventProbe.turnNumber,
|
|
unsafeTurnNumber
|
|
);
|
|
assertAutosaveDebugState(
|
|
eventProbe.autosave,
|
|
`${renderer}: ${unsafePhase} pagehide debug state`
|
|
);
|
|
assert.equal(
|
|
afterUnsafe.raw,
|
|
beforeUnsafe.raw,
|
|
`${renderer}: ${unsafePhase} pagehide overwrote the last safe checkpoint.`
|
|
);
|
|
assert.equal(
|
|
afterUnsafe.autosave.writeCount,
|
|
beforeUnsafe.autosave.writeCount,
|
|
`${renderer}: ${unsafePhase} pagehide incremented the autosave write count.`
|
|
);
|
|
assert.equal(
|
|
afterUnsafe.autosave.skipCount,
|
|
beforeUnsafe.autosave.skipCount + 1,
|
|
`${renderer}: ${unsafePhase} pagehide did not record one safe-state skip.`
|
|
);
|
|
assert.equal(
|
|
afterUnsafe.autosave.failureCount,
|
|
beforeUnsafe.autosave.failureCount,
|
|
`${renderer}: ${unsafePhase} pagehide was reported as a failure instead of a skip.`
|
|
);
|
|
assert.equal(
|
|
afterUnsafe.autosave.lastResult,
|
|
'skipped'
|
|
);
|
|
assert.equal(
|
|
afterUnsafe.autosave.lastReason,
|
|
'pagehide'
|
|
);
|
|
assert.equal(
|
|
afterUnsafe.autosave.lastSavedAt,
|
|
beforeUnsafe.state.savedAt
|
|
);
|
|
unsafeAutosaves.push({
|
|
phase: unsafePhase,
|
|
turnNumber: unsafeTurnNumber,
|
|
writeCount: afterUnsafe.autosave.writeCount,
|
|
skipCount: afterUnsafe.autosave.skipCount,
|
|
checkpointSavedAt: afterUnsafe.state.savedAt
|
|
});
|
|
}
|
|
|
|
const readinessBaseline = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
const readinessTurnNumber = 42;
|
|
const readinessProbe = await page.evaluate(
|
|
(requestedTurnNumber) => {
|
|
const scene =
|
|
window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
if (!scene) {
|
|
throw new Error(
|
|
'The autosave readiness probe is unavailable.'
|
|
);
|
|
}
|
|
scene.turnNumber = requestedTurnNumber;
|
|
scene.activeFaction = 'ally';
|
|
scene.phase = 'idle';
|
|
scene.selectedUnit = undefined;
|
|
scene.pendingMove = undefined;
|
|
scene.targetingAction = undefined;
|
|
scene.selectedUsable = undefined;
|
|
scene.battleAutosaveReady = false;
|
|
window.dispatchEvent(new Event('pagehide'));
|
|
const blocked =
|
|
window.__HEROS_DEBUG__?.battle?.()?.autosave ??
|
|
null;
|
|
scene.battleAutosaveReady = true;
|
|
return blocked;
|
|
},
|
|
readinessTurnNumber
|
|
);
|
|
const readinessAfter = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
assertAutosaveDebugState(
|
|
readinessProbe,
|
|
`${renderer}: pre-initialization pagehide debug state`
|
|
);
|
|
assert.equal(
|
|
readinessAfter.raw,
|
|
readinessBaseline.raw,
|
|
`${renderer}: a pagehide before battle initialization replaced the last safe checkpoint.`
|
|
);
|
|
assert.equal(
|
|
readinessAfter.autosave.writeCount,
|
|
readinessBaseline.autosave.writeCount
|
|
);
|
|
assert.equal(
|
|
readinessAfter.autosave.skipCount,
|
|
readinessBaseline.autosave.skipCount + 1
|
|
);
|
|
assert.equal(
|
|
readinessAfter.autosave.lastResult,
|
|
'skipped'
|
|
);
|
|
assert.equal(
|
|
readinessAfter.autosave.lastReason,
|
|
'pagehide'
|
|
);
|
|
|
|
const idleBaseline = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
const idleTurnNumber = 43;
|
|
const idleMarkerHp = Math.max(
|
|
1,
|
|
fixture.validMarkerHp - 1
|
|
);
|
|
await page.evaluate(
|
|
({
|
|
requestedTurnNumber,
|
|
requestedMarkerHp
|
|
}) => {
|
|
const scene =
|
|
window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
const unit = scene?.debugUnitById?.('liu-bei');
|
|
if (
|
|
!scene ||
|
|
!unit ||
|
|
typeof scene.persistBattleAutosave !== 'function'
|
|
) {
|
|
throw new Error(
|
|
'The idle pagehide autosave probe is unavailable.'
|
|
);
|
|
}
|
|
scene.turnNumber = requestedTurnNumber;
|
|
scene.activeFaction = 'ally';
|
|
scene.phase = 'idle';
|
|
scene.selectedUnit = undefined;
|
|
scene.pendingMove = undefined;
|
|
scene.targetingAction = undefined;
|
|
scene.selectedUsable = undefined;
|
|
unit.hp = requestedMarkerHp;
|
|
window.dispatchEvent(new Event('pagehide'));
|
|
},
|
|
{
|
|
requestedTurnNumber: idleTurnNumber,
|
|
requestedMarkerHp: idleMarkerHp
|
|
}
|
|
);
|
|
|
|
await page.waitForFunction(
|
|
({
|
|
requestedBattleSlotKey,
|
|
previousSavedAt,
|
|
previousWriteCount,
|
|
expectedTurnNumber,
|
|
expectedMarkerHp
|
|
}) => {
|
|
const persisted = JSON.parse(
|
|
window.localStorage.getItem(requestedBattleSlotKey) ??
|
|
'null'
|
|
);
|
|
const autosave =
|
|
window.__HEROS_DEBUG__?.battle?.()?.autosave;
|
|
return (
|
|
persisted?.savedAt &&
|
|
persisted.savedAt !== previousSavedAt &&
|
|
persisted.turnNumber === expectedTurnNumber &&
|
|
persisted.units?.find(
|
|
(unit) => unit.id === 'liu-bei'
|
|
)?.hp === expectedMarkerHp &&
|
|
autosave?.writeCount === previousWriteCount + 1 &&
|
|
autosave?.lastResult === 'saved' &&
|
|
autosave?.lastReason === 'pagehide'
|
|
);
|
|
},
|
|
{
|
|
requestedBattleSlotKey: battleSlotKey,
|
|
previousSavedAt: idleBaseline.state.savedAt,
|
|
previousWriteCount:
|
|
idleBaseline.autosave.writeCount,
|
|
expectedTurnNumber: idleTurnNumber,
|
|
expectedMarkerHp: idleMarkerHp
|
|
}
|
|
);
|
|
|
|
const idleAutosave = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
assertAutosaveWrite(
|
|
idleBaseline,
|
|
idleAutosave,
|
|
{
|
|
reason: 'pagehide',
|
|
expectedTurnNumber: idleTurnNumber,
|
|
expectedActedUnitId: 'liu-bei',
|
|
expectedMarkerHp: idleMarkerHp
|
|
},
|
|
`${renderer}: ally idle pagehide autosave`
|
|
);
|
|
assert.equal(
|
|
idleAutosave.autosave.skipCount,
|
|
idleBaseline.autosave.skipCount,
|
|
`${renderer}: a safe idle pagehide was counted as skipped.`
|
|
);
|
|
|
|
const rollbackBaseline = await readAutosaveCheckpoint(
|
|
page,
|
|
battleSlotKey
|
|
);
|
|
const rollbackBaseRaw = await page.evaluate(
|
|
(requestedBattleBaseKey) =>
|
|
window.localStorage.getItem(requestedBattleBaseKey),
|
|
battleBaseKey
|
|
);
|
|
const rollbackProbe = await page.evaluate(
|
|
({
|
|
requestedBattleSlotKey,
|
|
requestedBattleBaseKey,
|
|
requestedOtherBattleSlotKey,
|
|
requestedOtherBattleBaseKey,
|
|
requestedOtherBattleCheckpoint
|
|
}) => {
|
|
const scene =
|
|
window.__HEROS_DEBUG__?.scene('BattleScene');
|
|
if (
|
|
!scene ||
|
|
typeof scene.persistBattleAutosave !== 'function'
|
|
) {
|
|
throw new Error(
|
|
'The autosave rollback probe is unavailable.'
|
|
);
|
|
}
|
|
scene.battleAutosaveReady = true;
|
|
scene.activeFaction = 'ally';
|
|
scene.phase = 'idle';
|
|
scene.selectedUnit = undefined;
|
|
scene.pendingMove = undefined;
|
|
scene.targetingAction = undefined;
|
|
scene.selectedUsable = undefined;
|
|
scene.turnNumber = 44;
|
|
window.localStorage.setItem(
|
|
requestedOtherBattleSlotKey,
|
|
requestedOtherBattleCheckpoint
|
|
);
|
|
window.localStorage.setItem(
|
|
requestedOtherBattleBaseKey,
|
|
requestedOtherBattleCheckpoint
|
|
);
|
|
|
|
const storagePrototype =
|
|
Object.getPrototypeOf(window.localStorage);
|
|
const originalSetItem = storagePrototype.setItem;
|
|
let injected = false;
|
|
storagePrototype.setItem = function setItem(
|
|
key,
|
|
value
|
|
) {
|
|
if (
|
|
this === window.localStorage &&
|
|
String(key) === requestedBattleSlotKey &&
|
|
!injected
|
|
) {
|
|
injected = true;
|
|
throw new DOMException(
|
|
'Injected autosave write refusal',
|
|
'QuotaExceededError'
|
|
);
|
|
}
|
|
return originalSetItem.call(this, key, value);
|
|
};
|
|
|
|
let saved;
|
|
try {
|
|
saved = scene.persistBattleAutosave('debug');
|
|
} finally {
|
|
storagePrototype.setItem = originalSetItem;
|
|
}
|
|
return {
|
|
saved,
|
|
injected,
|
|
slotRaw: window.localStorage.getItem(
|
|
requestedBattleSlotKey
|
|
),
|
|
baseRaw: window.localStorage.getItem(
|
|
requestedBattleBaseKey
|
|
),
|
|
otherBattleSlotRaw: window.localStorage.getItem(
|
|
requestedOtherBattleSlotKey
|
|
),
|
|
otherBattleBaseRaw: window.localStorage.getItem(
|
|
requestedOtherBattleBaseKey
|
|
),
|
|
autosave:
|
|
window.__HEROS_DEBUG__?.battle?.()?.autosave ??
|
|
null
|
|
};
|
|
},
|
|
{
|
|
requestedBattleSlotKey: battleSlotKey,
|
|
requestedBattleBaseKey: battleBaseKey,
|
|
requestedOtherBattleSlotKey: otherBattleSlotKey,
|
|
requestedOtherBattleBaseKey: otherBattleBaseKey,
|
|
requestedOtherBattleCheckpoint:
|
|
otherBattleCheckpoint
|
|
}
|
|
);
|
|
assert.equal(rollbackProbe.injected, true);
|
|
assert.equal(rollbackProbe.saved, false);
|
|
assert.equal(
|
|
rollbackProbe.slotRaw,
|
|
rollbackBaseline.raw,
|
|
`${renderer}: a failed autosave did not restore the canonical slot checkpoint.`
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.baseRaw,
|
|
rollbackBaseRaw,
|
|
`${renderer}: a failed autosave did not restore the slot-one compatibility checkpoint.`
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.otherBattleSlotRaw,
|
|
otherBattleCheckpoint,
|
|
`${renderer}: a failed autosave discarded another battle's canonical checkpoint in the same campaign slot.`
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.otherBattleBaseRaw,
|
|
otherBattleCheckpoint,
|
|
`${renderer}: a failed autosave discarded another battle's compatibility checkpoint in the same campaign slot.`
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.autosave.writeCount,
|
|
rollbackBaseline.autosave.writeCount
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.autosave.skipCount,
|
|
rollbackBaseline.autosave.skipCount
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.autosave.failureCount,
|
|
rollbackBaseline.autosave.failureCount + 1
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.autosave.lastResult,
|
|
'failed'
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.autosave.lastReason,
|
|
'debug'
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.autosave.lastSavedAt,
|
|
rollbackBaseline.state.savedAt
|
|
);
|
|
assert.equal(
|
|
rollbackProbe.autosave.indicatorVisible,
|
|
true,
|
|
`${renderer}: a failed autosave did not expose a persistent visible warning.`
|
|
);
|
|
assert.match(
|
|
rollbackProbe.autosave.indicatorText ?? '',
|
|
/자동 저장 실패/,
|
|
`${renderer}: the failed autosave warning was not clearly labeled.`
|
|
);
|
|
assert.equal(pageErrors.length, 0, pageErrors.join('\n'));
|
|
assert.equal(consoleErrors.length, 0, consoleErrors.join('\n'));
|
|
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
renderer,
|
|
viewport: desktopBrowserViewport,
|
|
deviceScaleFactor: desktopBrowserDeviceScaleFactor,
|
|
cssZoom: 1,
|
|
stale: {
|
|
campaignGeneration,
|
|
saveGeneration: staleGeneration,
|
|
requestedTurnNumber: fixture.staleTurnNumber,
|
|
liveTurnNumber: 1,
|
|
loadDisabled: staleProbe.loadDisabled,
|
|
removalRefusal: staleProbe.removalStats
|
|
},
|
|
control: {
|
|
campaignGeneration,
|
|
saveGeneration: beforeControl.acceptedGeneration,
|
|
restoredTurnNumber: restored.turnNumber,
|
|
restoredMarkerHp: restored.markerHp,
|
|
pendingEventBeforeTutorial:
|
|
tutorialPendingEventProbe
|
|
},
|
|
autosave: {
|
|
allyAction: {
|
|
phaseAfterAction:
|
|
actionTrigger.phase,
|
|
turnNumber:
|
|
actionAutosave.state.turnNumber,
|
|
actedUnitIds:
|
|
actionAutosave.state.actedUnitIds,
|
|
savedAt:
|
|
actionAutosave.state.savedAt,
|
|
debug:
|
|
actionAutosave.autosave
|
|
},
|
|
unsafePagehide:
|
|
unsafeAutosaves,
|
|
initializationGuard: {
|
|
turnNumber: readinessTurnNumber,
|
|
debug: readinessAfter.autosave
|
|
},
|
|
idlePagehide: {
|
|
turnNumber:
|
|
idleAutosave.state.turnNumber,
|
|
markerHp:
|
|
idleAutosave.state.units.find(
|
|
(unit) => unit.id === 'liu-bei'
|
|
)?.hp ?? null,
|
|
savedAt:
|
|
idleAutosave.state.savedAt,
|
|
debug:
|
|
idleAutosave.autosave
|
|
},
|
|
failedWriteRollback: {
|
|
slotPreserved:
|
|
rollbackProbe.slotRaw ===
|
|
rollbackBaseline.raw,
|
|
basePreserved:
|
|
rollbackProbe.baseRaw ===
|
|
rollbackBaseRaw,
|
|
otherBattleSlotPreserved:
|
|
rollbackProbe.otherBattleSlotRaw ===
|
|
otherBattleCheckpoint,
|
|
otherBattleBasePreserved:
|
|
rollbackProbe.otherBattleBaseRaw ===
|
|
otherBattleCheckpoint,
|
|
debug: rollbackProbe.autosave
|
|
}
|
|
},
|
|
pageErrors: pageErrors.length,
|
|
consoleErrors: consoleErrors.length
|
|
},
|
|
null,
|
|
2
|
|
)
|
|
);
|
|
} finally {
|
|
await browser?.close();
|
|
await stopVerificationPreview(serverProcess);
|
|
}
|
|
|
|
function withDebugOptions(url, requestedRenderer) {
|
|
const parsed = new URL(url);
|
|
parsed.searchParams.set('debug', '1');
|
|
parsed.searchParams.set('renderer', requestedRenderer);
|
|
parsed.searchParams.set('motion', 'reduced');
|
|
return parsed.toString();
|
|
}
|
|
|
|
async function waitForDebugApi(page) {
|
|
await page.waitForFunction(
|
|
() =>
|
|
Boolean(
|
|
document.querySelector('canvas') &&
|
|
window.__HEROS_GAME__ &&
|
|
window.__HEROS_DEBUG__
|
|
),
|
|
undefined,
|
|
{ timeout: 90000 }
|
|
);
|
|
}
|
|
|
|
async function waitForTitle(page) {
|
|
await page.waitForFunction(
|
|
() =>
|
|
window.__HEROS_DEBUG__?.activeScenes?.().includes('TitleScene'),
|
|
undefined,
|
|
{ timeout: 90000 }
|
|
);
|
|
}
|
|
|
|
async function waitForBattleReady(page) {
|
|
await page.waitForFunction(
|
|
(expectedBattleId) => {
|
|
const battle = window.__HEROS_DEBUG__?.battle?.();
|
|
return (
|
|
window.__HEROS_DEBUG__?.activeScenes?.().includes('BattleScene') &&
|
|
battle?.scene === 'BattleScene' &&
|
|
battle?.battleId === expectedBattleId &&
|
|
battle?.battleOutcome === null &&
|
|
['deployment', 'idle'].includes(battle?.phase) &&
|
|
battle?.mapBackgroundReady === true &&
|
|
battle?.resultVisible === false
|
|
);
|
|
},
|
|
battleId,
|
|
{ timeout: 90000 }
|
|
);
|
|
}
|
|
|
|
async function readAutosaveCheckpoint(
|
|
page,
|
|
requestedBattleSlotKey
|
|
) {
|
|
const checkpoint = await page.evaluate(
|
|
(storageKey) => {
|
|
const raw = window.localStorage.getItem(storageKey);
|
|
const battle =
|
|
window.__HEROS_DEBUG__?.battle?.();
|
|
return {
|
|
raw,
|
|
state: JSON.parse(raw ?? 'null'),
|
|
autosave: battle?.autosave ?? null
|
|
};
|
|
},
|
|
requestedBattleSlotKey
|
|
);
|
|
assert(
|
|
checkpoint.raw,
|
|
`Missing battle autosave checkpoint at ${requestedBattleSlotKey}.`
|
|
);
|
|
assert(
|
|
checkpoint.state,
|
|
`Invalid battle autosave checkpoint at ${requestedBattleSlotKey}.`
|
|
);
|
|
assertAutosaveDebugState(
|
|
checkpoint.autosave,
|
|
`Autosave debug state for ${requestedBattleSlotKey}`
|
|
);
|
|
return checkpoint;
|
|
}
|
|
|
|
function assertAutosaveDebugState(
|
|
autosave,
|
|
label
|
|
) {
|
|
assert(
|
|
autosave && typeof autosave === 'object',
|
|
`${label} is unavailable.`
|
|
);
|
|
for (const field of [
|
|
'writeCount',
|
|
'skipCount',
|
|
'failureCount'
|
|
]) {
|
|
assert(
|
|
Number.isInteger(autosave[field]) &&
|
|
autosave[field] >= 0,
|
|
`${label}.${field} must be a non-negative integer.`
|
|
);
|
|
}
|
|
assert(
|
|
[
|
|
'saved',
|
|
'skipped',
|
|
'failed',
|
|
null
|
|
].includes(autosave.lastResult),
|
|
`${label}.lastResult is invalid.`
|
|
);
|
|
assert(
|
|
autosave.lastReason === null ||
|
|
typeof autosave.lastReason === 'string',
|
|
`${label}.lastReason is invalid.`
|
|
);
|
|
assert(
|
|
autosave.lastSlot === null ||
|
|
autosave.lastSlot === 1,
|
|
`${label}.lastSlot is invalid.`
|
|
);
|
|
assert(
|
|
autosave.lastSavedAt === null ||
|
|
(
|
|
typeof autosave.lastSavedAt === 'string' &&
|
|
Number.isFinite(
|
|
Date.parse(autosave.lastSavedAt)
|
|
)
|
|
),
|
|
`${label}.lastSavedAt is invalid.`
|
|
);
|
|
assert(
|
|
typeof autosave.indicatorVisible === 'boolean',
|
|
`${label}.indicatorVisible must be boolean.`
|
|
);
|
|
assert(
|
|
autosave.indicatorText === null ||
|
|
typeof autosave.indicatorText === 'string',
|
|
`${label}.indicatorText is invalid.`
|
|
);
|
|
}
|
|
|
|
function assertAutosaveWrite(
|
|
before,
|
|
after,
|
|
{
|
|
reason,
|
|
expectedTurnNumber,
|
|
expectedActedUnitId,
|
|
expectedMarkerHp
|
|
},
|
|
label
|
|
) {
|
|
assert.notEqual(
|
|
after.raw,
|
|
before.raw,
|
|
`${label} did not update the active battle slot.`
|
|
);
|
|
assert.notEqual(
|
|
after.state.savedAt,
|
|
before.state.savedAt,
|
|
`${label} did not refresh savedAt.`
|
|
);
|
|
assert.equal(
|
|
after.state.turnNumber,
|
|
expectedTurnNumber,
|
|
`${label} saved the wrong turn.`
|
|
);
|
|
assert(
|
|
after.state.actedUnitIds.includes(
|
|
expectedActedUnitId
|
|
),
|
|
`${label} omitted the completed ally action.`
|
|
);
|
|
if (expectedMarkerHp !== undefined) {
|
|
assert.equal(
|
|
after.state.units.find(
|
|
(unit) => unit.id === 'liu-bei'
|
|
)?.hp,
|
|
expectedMarkerHp,
|
|
`${label} did not persist the live ally state.`
|
|
);
|
|
}
|
|
assert.equal(
|
|
after.autosave.writeCount,
|
|
before.autosave.writeCount + 1,
|
|
`${label} did not record exactly one write.`
|
|
);
|
|
assert.equal(
|
|
after.autosave.skipCount,
|
|
before.autosave.skipCount,
|
|
`${label} unexpectedly recorded a skip.`
|
|
);
|
|
assert.equal(
|
|
after.autosave.failureCount,
|
|
before.autosave.failureCount,
|
|
`${label} unexpectedly recorded a failure.`
|
|
);
|
|
assert.equal(
|
|
after.autosave.lastResult,
|
|
'saved'
|
|
);
|
|
assert.equal(
|
|
after.autosave.lastReason,
|
|
reason
|
|
);
|
|
assert.equal(after.autosave.lastSlot, 1);
|
|
assert.equal(
|
|
after.autosave.lastSavedAt,
|
|
after.state.savedAt
|
|
);
|
|
}
|
|
|
|
async function assertDesktopRuntime(page, expectedRenderer) {
|
|
const runtime = await page.evaluate(() => {
|
|
const canvas = document.querySelector('canvas');
|
|
const bounds = canvas?.getBoundingClientRect();
|
|
return {
|
|
innerWidth: window.innerWidth,
|
|
innerHeight: window.innerHeight,
|
|
devicePixelRatio: window.devicePixelRatio,
|
|
visualViewportScale: window.visualViewport?.scale ?? 1,
|
|
rootCssZoom: getComputedStyle(document.documentElement).zoom,
|
|
rendererType: window.__HEROS_GAME__?.renderer.type,
|
|
canvas: canvas
|
|
? {
|
|
width: canvas.width,
|
|
height: canvas.height,
|
|
clientWidth: canvas.clientWidth,
|
|
clientHeight: canvas.clientHeight,
|
|
bounds: bounds
|
|
? {
|
|
width: bounds.width,
|
|
height: bounds.height
|
|
}
|
|
: null
|
|
}
|
|
: null
|
|
};
|
|
});
|
|
|
|
assert.equal(runtime.innerWidth, desktopBrowserViewport.width);
|
|
assert.equal(runtime.innerHeight, desktopBrowserViewport.height);
|
|
assert.equal(runtime.devicePixelRatio, desktopBrowserDeviceScaleFactor);
|
|
assert.equal(runtime.visualViewportScale, 1);
|
|
assert(
|
|
runtime.rootCssZoom === '1' || runtime.rootCssZoom === 'normal',
|
|
`Unexpected CSS zoom ${runtime.rootCssZoom}.`
|
|
);
|
|
assert.equal(runtime.rendererType, expectedRenderer === 'canvas' ? 1 : 2);
|
|
assert.equal(runtime.canvas?.width, desktopBrowserViewport.width);
|
|
assert.equal(runtime.canvas?.height, desktopBrowserViewport.height);
|
|
assert.equal(runtime.canvas?.clientWidth, desktopBrowserViewport.width);
|
|
assert.equal(runtime.canvas?.clientHeight, desktopBrowserViewport.height);
|
|
assert.equal(runtime.canvas?.bounds?.width, desktopBrowserViewport.width);
|
|
assert.equal(runtime.canvas?.bounds?.height, desktopBrowserViewport.height);
|
|
}
|