1500 lines
38 KiB
JavaScript
1500 lines
38 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import { spawn, spawnSync } from 'node:child_process';
|
|
import { mkdirSync } from 'node:fs';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { chromium } from 'playwright';
|
|
import {
|
|
desktopBrowserContextOptions,
|
|
desktopBrowserDeviceScaleFactor,
|
|
desktopBrowserViewport,
|
|
desktopBrowserViewportBounds
|
|
} from './desktop-browser-viewport.mjs';
|
|
|
|
const renderer =
|
|
process.env.VERIFY_CAMP_EXPLORATION_CHECKPOINT_RENDERER;
|
|
const rendererNames = ['canvas', 'webgl'];
|
|
const fixture = Object.freeze({
|
|
visitId: 'first-pursuit-scout-tent',
|
|
battleId: 'first-battle-zhuo-commandery',
|
|
campaignStep: 'first-camp',
|
|
actorId: 'jian-yong',
|
|
movementAnchorId: 'zhang-fei',
|
|
exitId: 'camp-exit',
|
|
choiceId: 'trace-river-ambush',
|
|
itemId: '상처약',
|
|
itemAmount: 1,
|
|
bondId: 'liu-bei__jian-yong',
|
|
bondExp: 10
|
|
});
|
|
|
|
if (!renderer) {
|
|
for (const requestedRenderer of rendererNames) {
|
|
const result = spawnSync(
|
|
process.execPath,
|
|
[fileURLToPath(import.meta.url)],
|
|
{
|
|
cwd: process.cwd(),
|
|
env: {
|
|
...process.env,
|
|
VERIFY_CAMP_EXPLORATION_CHECKPOINT_RENDERER:
|
|
requestedRenderer
|
|
},
|
|
stdio: 'inherit'
|
|
}
|
|
);
|
|
if (result.status !== 0) {
|
|
process.exit(result.status ?? 1);
|
|
}
|
|
}
|
|
process.exit(0);
|
|
}
|
|
|
|
assert(
|
|
rendererNames.includes(renderer),
|
|
`Unsupported camp exploration checkpoint renderer "${renderer}".`
|
|
);
|
|
|
|
const baseUrl =
|
|
process.env.VERIFY_CAMP_EXPLORATION_CHECKPOINT_URL ??
|
|
'http://127.0.0.1:41808/heros_web/';
|
|
const targetUrl = withDebugOptions(baseUrl, renderer);
|
|
const localSeedUrl = withDebugOptions(
|
|
'http://127.0.0.1:41808/heros_web/',
|
|
renderer
|
|
);
|
|
|
|
let serverProcess;
|
|
let seedServerProcess;
|
|
let browser;
|
|
|
|
try {
|
|
mkdirSync('dist', { recursive: true });
|
|
serverProcess = await ensureLocalServer(targetUrl);
|
|
browser = await chromium.launch({
|
|
headless:
|
|
process.env.VERIFY_CAMP_EXPLORATION_CHECKPOINT_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.addInitScript(() => {
|
|
const marker =
|
|
'heros-web:qa:camp-exploration-checkpoint-storage-cleared';
|
|
if (window.sessionStorage.getItem(marker) === '1') {
|
|
return;
|
|
}
|
|
window.localStorage.clear();
|
|
window.sessionStorage.setItem(marker, '1');
|
|
});
|
|
await page.goto(targetUrl, {
|
|
waitUntil: 'domcontentloaded',
|
|
timeout: 90000
|
|
});
|
|
await waitForDebugApi(page);
|
|
|
|
let seeded;
|
|
if (isLocalUrl(targetUrl)) {
|
|
seeded = await seedFirstCampVisit(page, fixture);
|
|
} else {
|
|
const bridge = await createSeedBridge(
|
|
browser,
|
|
localSeedUrl,
|
|
fixture
|
|
);
|
|
seedServerProcess = bridge.serverProcess;
|
|
seeded = bridge.seeded;
|
|
await installCampaignSaves(page, bridge.campaignSaves);
|
|
}
|
|
assertSeededVisit(seeded);
|
|
|
|
await reloadToTitle(page);
|
|
assertRuntimeBaseline(
|
|
await readRuntimeProbe(page, 'TitleScene'),
|
|
renderer,
|
|
'seeded first-camp title'
|
|
);
|
|
await continueToExploration(page);
|
|
assertRuntimeBaseline(
|
|
await readRuntimeProbe(
|
|
page,
|
|
'CampVisitExplorationScene'
|
|
),
|
|
renderer,
|
|
'first-camp exploration'
|
|
);
|
|
|
|
const savedPlayer = await createPlayerCheckpoint(page);
|
|
const playerResume = await reloadAndContinueToExploration(page);
|
|
assertExactPlayer(
|
|
playerResume.player,
|
|
savedPlayer,
|
|
`${renderer}: position checkpoint resume`
|
|
);
|
|
assertExactCheckpointPlayer(
|
|
playerResume.campaign.explorationCheckpoint,
|
|
savedPlayer,
|
|
`${renderer}: persisted position checkpoint`
|
|
);
|
|
|
|
const dialogueBeforeReload =
|
|
await openAndAdvanceActorDialogue(page);
|
|
const dialogueResume =
|
|
await reloadAndContinueToExploration(page);
|
|
assertExactPlayer(
|
|
dialogueResume.player,
|
|
dialogueBeforeReload.player,
|
|
`${renderer}: dialogue player resume`
|
|
);
|
|
assertDialogueResume(
|
|
dialogueResume,
|
|
dialogueBeforeReload,
|
|
`${renderer}: actor dialogue resume`
|
|
);
|
|
|
|
const choiceBeforeReload = await advanceToChoicePanel(page);
|
|
const choiceResume =
|
|
await reloadAndContinueToExploration(page);
|
|
await waitForChoiceReady(page);
|
|
const readyChoiceResume = await readExploration(page);
|
|
assertChoiceResume(
|
|
readyChoiceResume,
|
|
choiceBeforeReload,
|
|
`${renderer}: choice panel resume`
|
|
);
|
|
assertRuntimeBaseline(
|
|
await readRuntimeProbe(
|
|
page,
|
|
'CampVisitExplorationScene'
|
|
),
|
|
renderer,
|
|
'resumed choice panel'
|
|
);
|
|
await page.screenshot({
|
|
path:
|
|
`dist/camp-exploration-checkpoint-choice-${renderer}.png`
|
|
});
|
|
|
|
const rewardBefore = rewardSnapshot(
|
|
await readCampaignStates(page)
|
|
);
|
|
assertRewardNotYetApplied(
|
|
rewardBefore,
|
|
`${renderer}: pre-choice reward state`
|
|
);
|
|
|
|
const selectedChoice = readyChoiceResume.choice.choices.find(
|
|
({ id }) => id === fixture.choiceId
|
|
);
|
|
assert(
|
|
selectedChoice,
|
|
`${renderer}: choice ${fixture.choiceId} is unavailable.`
|
|
);
|
|
const choiceBounds = assertFiniteBounds(
|
|
selectedChoice.bounds,
|
|
`${renderer}: ${fixture.choiceId} choice`
|
|
);
|
|
assertBoundsContained(
|
|
choiceBounds,
|
|
desktopBrowserViewportBounds,
|
|
`${renderer}: ${fixture.choiceId} choice`
|
|
);
|
|
await clickSceneBounds(
|
|
page,
|
|
'CampVisitExplorationScene',
|
|
choiceBounds
|
|
);
|
|
await waitForChoiceResponse(page, 0);
|
|
|
|
const rewardAfterChoice = rewardSnapshot(
|
|
await readCampaignStates(page)
|
|
);
|
|
assertRewardAppliedExactlyOnce(
|
|
rewardBefore,
|
|
rewardAfterChoice,
|
|
`${renderer}: first choice commit`
|
|
);
|
|
|
|
const advancedResponse = await page.evaluate(() =>
|
|
window.__HEROS_DEBUG__
|
|
?.scene('CampVisitExplorationScene')
|
|
?.debugAdvanceDialogue?.() ?? false
|
|
);
|
|
assert.equal(
|
|
advancedResponse,
|
|
true,
|
|
`${renderer}: could not advance the choice response.`
|
|
);
|
|
await waitForChoiceResponse(page, 1);
|
|
const responseBeforeReload = await readExploration(page);
|
|
assert.equal(
|
|
responseBeforeReload.dialogue.sourceNpcId,
|
|
fixture.actorId
|
|
);
|
|
assert.equal(
|
|
responseBeforeReload.campaign.explorationCheckpoint?.overlay
|
|
?.dialogueKey,
|
|
'first-choice-response'
|
|
);
|
|
|
|
const responseResume =
|
|
await reloadAndContinueToExploration(page);
|
|
assertChoiceResponseResume(
|
|
responseResume,
|
|
responseBeforeReload,
|
|
`${renderer}: choice response resume`
|
|
);
|
|
const rewardAfterReload = rewardSnapshot(
|
|
await readCampaignStates(page)
|
|
);
|
|
assert.deepEqual(
|
|
rewardAfterReload,
|
|
rewardAfterChoice,
|
|
`${renderer}: reloading the response duplicated or changed rewards.`
|
|
);
|
|
assertRewardAppliedExactlyOnce(
|
|
rewardBefore,
|
|
rewardAfterReload,
|
|
`${renderer}: post-reload reward state`
|
|
);
|
|
|
|
await finishActiveDialogue(page);
|
|
await exitExplorationNormally(page);
|
|
await waitForCampReady(page, fixture.campaignStep);
|
|
assertRuntimeBaseline(
|
|
await readRuntimeProbe(page, 'CampScene'),
|
|
renderer,
|
|
'normal checkpoint-clearing exit'
|
|
);
|
|
assertCheckpointCleared(
|
|
await readCampaignStates(page),
|
|
`${renderer}: normal exit`
|
|
);
|
|
|
|
await reloadToTitle(page);
|
|
await clickContinue(page);
|
|
await waitForCampReady(page, fixture.campaignStep);
|
|
assertCheckpointCleared(
|
|
await readCampaignStates(page),
|
|
`${renderer}: continue after normal exit`
|
|
);
|
|
assert(
|
|
!(await page.evaluate(() =>
|
|
window.__HEROS_DEBUG__
|
|
?.activeScenes?.()
|
|
.includes('CampVisitExplorationScene')
|
|
)),
|
|
`${renderer}: a cleared checkpoint reopened exploration.`
|
|
);
|
|
|
|
const actionableConsoleErrors = consoleErrors.filter(
|
|
(message) =>
|
|
!message.includes(
|
|
'The AudioContext was not allowed to start'
|
|
)
|
|
);
|
|
assert.deepEqual(
|
|
pageErrors,
|
|
[],
|
|
`${renderer}: page errors: ${pageErrors.join('\n')}`
|
|
);
|
|
assert.deepEqual(
|
|
actionableConsoleErrors,
|
|
[],
|
|
`${renderer}: console errors: ${actionableConsoleErrors.join(
|
|
'\n'
|
|
)}`
|
|
);
|
|
|
|
console.log(
|
|
JSON.stringify(
|
|
{
|
|
renderer,
|
|
viewport: {
|
|
...desktopBrowserViewport,
|
|
deviceScaleFactor:
|
|
desktopBrowserDeviceScaleFactor,
|
|
browserZoom: '100%'
|
|
},
|
|
checkpoint: {
|
|
exactPlayerResume: savedPlayer,
|
|
dialogue: {
|
|
sourceNpcId:
|
|
dialogueBeforeReload.dialogue.sourceNpcId,
|
|
lineIndex:
|
|
dialogueBeforeReload.dialogue.lineIndex
|
|
},
|
|
choicePanelResumed:
|
|
choiceResume.choice.open === true,
|
|
response: {
|
|
sourceNpcId:
|
|
responseBeforeReload.dialogue.sourceNpcId,
|
|
lineIndex:
|
|
responseBeforeReload.dialogue.lineIndex
|
|
},
|
|
rewardCommittedOnce: true,
|
|
normalExitCleared: true
|
|
},
|
|
pageErrors: pageErrors.length,
|
|
consoleErrors: actionableConsoleErrors.length
|
|
},
|
|
null,
|
|
2
|
|
)
|
|
);
|
|
} finally {
|
|
await browser?.close();
|
|
await stopServerProcess(serverProcess);
|
|
await stopServerProcess(seedServerProcess);
|
|
}
|
|
|
|
function withDebugOptions(url, requestedRenderer) {
|
|
const parsed = new URL(url);
|
|
parsed.searchParams.set('debug', '1');
|
|
parsed.searchParams.set('renderer', requestedRenderer);
|
|
return parsed.toString();
|
|
}
|
|
|
|
function isLocalUrl(url) {
|
|
return ['localhost', '127.0.0.1', '0.0.0.0'].includes(
|
|
new URL(url).hostname
|
|
);
|
|
}
|
|
|
|
async function waitForDebugApi(page) {
|
|
await page.waitForFunction(
|
|
() =>
|
|
document.querySelector('canvas') !== null &&
|
|
window.__HEROS_GAME__ !== undefined &&
|
|
window.__HEROS_DEBUG__ !== undefined,
|
|
undefined,
|
|
{ timeout: 90000 }
|
|
);
|
|
}
|
|
|
|
async function seedFirstCampVisit(page, requested) {
|
|
return page.evaluate(async (seed) => {
|
|
const campaignModule = await import(
|
|
'/heros_web/src/game/state/campaignState.ts'
|
|
);
|
|
const { battleScenarios } = await import(
|
|
'/heros_web/src/game/data/battles.ts'
|
|
);
|
|
const scenario = battleScenarios[seed.battleId];
|
|
if (!scenario) {
|
|
throw new Error(
|
|
`Missing battle scenario ${seed.battleId}.`
|
|
);
|
|
}
|
|
|
|
campaignModule.resetCampaignState();
|
|
campaignModule.setFirstBattleReport({
|
|
battleId: scenario.id,
|
|
battleTitle: scenario.title,
|
|
outcome: 'victory',
|
|
turnNumber: 6,
|
|
rewardGold: scenario.baseVictoryGold,
|
|
defeatedEnemies: scenario.units.filter(
|
|
(unit) => unit.faction === 'enemy'
|
|
).length,
|
|
totalEnemies: scenario.units.filter(
|
|
(unit) => unit.faction === 'enemy'
|
|
).length,
|
|
objectives: [],
|
|
units: scenario.units,
|
|
bonds: (scenario.bonds ?? []).map((bond) => ({
|
|
...bond,
|
|
battleExp: 0
|
|
})),
|
|
itemRewards: [],
|
|
completedCampDialogues: [],
|
|
completedCampVisits: [],
|
|
createdAt: '2026-07-28T00:00:00.000Z'
|
|
});
|
|
campaignModule.completeCampaignAftermath(scenario.id);
|
|
campaignModule.setActiveCampVisitId(seed.visitId);
|
|
|
|
const campaign = campaignModule.getCampaignState();
|
|
const slot = campaignModule.readCampaignSaveState(1);
|
|
const bond = campaign.bonds.find(
|
|
({ id }) => id === seed.bondId
|
|
);
|
|
return {
|
|
step: campaign.step,
|
|
latestBattleId: campaign.latestBattleId ?? null,
|
|
activeCampVisitId:
|
|
campaign.activeCampVisitId ?? null,
|
|
slotActiveCampVisitId:
|
|
slot?.activeCampVisitId ?? null,
|
|
checkpoint:
|
|
campaign.explorationCheckpoint ?? null,
|
|
completedVisitCount:
|
|
campaign.completedCampVisits.filter(
|
|
(id) => id === seed.visitId
|
|
).length,
|
|
inventoryItem:
|
|
campaign.inventory[seed.itemId] ?? 0,
|
|
bond: bond
|
|
? {
|
|
level: bond.level,
|
|
exp: bond.exp,
|
|
battleExp: bond.battleExp
|
|
}
|
|
: null
|
|
};
|
|
}, requested);
|
|
}
|
|
|
|
function assertSeededVisit(seeded) {
|
|
assert.equal(seeded.step, fixture.campaignStep);
|
|
assert.equal(seeded.latestBattleId, fixture.battleId);
|
|
assert.equal(
|
|
seeded.activeCampVisitId,
|
|
fixture.visitId
|
|
);
|
|
assert.equal(
|
|
seeded.slotActiveCampVisitId,
|
|
fixture.visitId
|
|
);
|
|
assert.equal(seeded.checkpoint, null);
|
|
assert.equal(seeded.completedVisitCount, 0);
|
|
assert(
|
|
seeded.bond,
|
|
`${renderer}: seed is missing ${fixture.bondId}.`
|
|
);
|
|
}
|
|
|
|
async function createSeedBridge(
|
|
activeBrowser,
|
|
seedUrl,
|
|
requested
|
|
) {
|
|
const localServerProcess = await ensureLocalServer(seedUrl);
|
|
const context = await activeBrowser.newContext(
|
|
desktopBrowserContextOptions
|
|
);
|
|
try {
|
|
const page = await context.newPage();
|
|
page.setDefaultTimeout(30000);
|
|
await page.addInitScript(() => window.localStorage.clear());
|
|
await page.goto(seedUrl, {
|
|
waitUntil: 'domcontentloaded',
|
|
timeout: 90000
|
|
});
|
|
await waitForDebugApi(page);
|
|
const seeded = await seedFirstCampVisit(page, requested);
|
|
const campaignSaves = await readCampaignSaves(page);
|
|
assert(
|
|
Object.keys(campaignSaves).length >= 2,
|
|
'Local seed bridge did not create current and slot saves.'
|
|
);
|
|
return {
|
|
seeded,
|
|
campaignSaves,
|
|
serverProcess: localServerProcess
|
|
};
|
|
} catch (error) {
|
|
await stopServerProcess(localServerProcess);
|
|
throw error;
|
|
} finally {
|
|
await context.close();
|
|
}
|
|
}
|
|
|
|
async function installCampaignSaves(page, campaignSaves) {
|
|
await page.evaluate((saves) => {
|
|
Object.keys(window.localStorage)
|
|
.filter((key) =>
|
|
key.startsWith('heros-web:campaign-state')
|
|
)
|
|
.forEach((key) => window.localStorage.removeItem(key));
|
|
for (const [key, value] of Object.entries(saves)) {
|
|
window.localStorage.setItem(key, value);
|
|
}
|
|
}, campaignSaves);
|
|
}
|
|
|
|
async function reloadToTitle(page) {
|
|
await page.reload({
|
|
waitUntil: 'domcontentloaded',
|
|
timeout: 90000
|
|
});
|
|
await waitForDebugApi(page);
|
|
await page.waitForFunction(
|
|
() => {
|
|
const debug = window.__HEROS_DEBUG__;
|
|
const title = debug?.title?.();
|
|
const continueItem = title?.focus?.items?.find(
|
|
({ id }) => id === 'continue'
|
|
);
|
|
return (
|
|
debug?.activeScenes?.().includes('TitleScene') &&
|
|
title?.scene === 'TitleScene' &&
|
|
title?.navigating === false &&
|
|
title?.focus?.scope === 'main' &&
|
|
continueItem?.enabled === true &&
|
|
continueItem?.bounds
|
|
);
|
|
},
|
|
undefined,
|
|
{ timeout: 90000 }
|
|
);
|
|
await afterTwoFrames(page);
|
|
}
|
|
|
|
async function clickContinue(page) {
|
|
const item = await page.evaluate(() =>
|
|
window.__HEROS_DEBUG__
|
|
?.title?.()
|
|
?.focus?.items?.find(({ id }) => id === 'continue') ??
|
|
null
|
|
);
|
|
assert.equal(
|
|
item?.enabled,
|
|
true,
|
|
`${renderer}: title continue button is unavailable.`
|
|
);
|
|
const bounds = assertFiniteBounds(
|
|
item.bounds,
|
|
`${renderer}: title continue button`
|
|
);
|
|
assertBoundsContained(
|
|
bounds,
|
|
desktopBrowserViewportBounds,
|
|
`${renderer}: title continue button`
|
|
);
|
|
await clickSceneBounds(page, 'TitleScene', bounds);
|
|
}
|
|
|
|
async function continueToExploration(page) {
|
|
await clickContinue(page);
|
|
return waitForExplorationReady(page);
|
|
}
|
|
|
|
async function reloadAndContinueToExploration(page) {
|
|
await reloadToTitle(page);
|
|
return continueToExploration(page);
|
|
}
|
|
|
|
async function waitForExplorationReady(page) {
|
|
try {
|
|
await page.waitForFunction(
|
|
(visitId) => {
|
|
const debug = window.__HEROS_DEBUG__;
|
|
const exploration =
|
|
debug?.campVisitExploration?.();
|
|
return (
|
|
debug
|
|
?.activeScenes?.()
|
|
.includes('CampVisitExplorationScene') &&
|
|
exploration?.ready === true &&
|
|
exploration?.locationId === visitId &&
|
|
exploration?.visit?.id === visitId &&
|
|
exploration?.requiredTexturesReady === true
|
|
);
|
|
},
|
|
fixture.visitId,
|
|
{ timeout: 90000 }
|
|
);
|
|
} catch (error) {
|
|
const diagnostic = await page.evaluate(() => ({
|
|
activeScenes:
|
|
window.__HEROS_DEBUG__?.activeScenes?.() ?? [],
|
|
title: window.__HEROS_DEBUG__?.title?.() ?? null,
|
|
exploration:
|
|
window.__HEROS_DEBUG__?.campVisitExploration?.() ??
|
|
null
|
|
}));
|
|
throw new Error(
|
|
`${renderer}: exploration did not become ready: ` +
|
|
JSON.stringify(diagnostic),
|
|
{ cause: error }
|
|
);
|
|
}
|
|
await afterTwoFrames(page);
|
|
const exploration = await readExploration(page);
|
|
assert.equal(
|
|
exploration.campaignStep,
|
|
fixture.campaignStep
|
|
);
|
|
return exploration;
|
|
}
|
|
|
|
async function readExploration(page) {
|
|
return page.evaluate(
|
|
() =>
|
|
window.__HEROS_DEBUG__?.campVisitExploration?.() ??
|
|
null
|
|
);
|
|
}
|
|
|
|
async function createPlayerCheckpoint(page) {
|
|
await page.waitForTimeout(450);
|
|
const teleported = await page.evaluate((targetId) =>
|
|
window.__HEROS_DEBUG__
|
|
?.scene('CampVisitExplorationScene')
|
|
?.debugTeleportTo?.(targetId) ?? false,
|
|
fixture.movementAnchorId
|
|
);
|
|
assert.equal(
|
|
teleported,
|
|
true,
|
|
`${renderer}: could not create the movement checkpoint.`
|
|
);
|
|
|
|
await page.keyboard.down('ArrowRight');
|
|
await page.waitForTimeout(260);
|
|
await page.keyboard.up('ArrowRight');
|
|
try {
|
|
await page.waitForFunction(
|
|
() => {
|
|
const state =
|
|
window.__HEROS_DEBUG__?.campVisitExploration?.();
|
|
const player = state?.player;
|
|
const checkpoint =
|
|
state?.campaign?.explorationCheckpoint;
|
|
return (
|
|
player &&
|
|
player.moving === false &&
|
|
player.direction === 'east' &&
|
|
checkpoint?.overlay === undefined &&
|
|
Math.abs(checkpoint?.player?.x - player.x) <= 0.05 &&
|
|
Math.abs(checkpoint?.player?.y - player.y) <= 0.05 &&
|
|
checkpoint?.player?.direction === player.direction
|
|
);
|
|
},
|
|
undefined,
|
|
{ timeout: 10000 }
|
|
);
|
|
} catch (error) {
|
|
const diagnostic = await readExploration(page);
|
|
throw new Error(
|
|
`${renderer}: movement checkpoint did not settle: ` +
|
|
JSON.stringify({
|
|
activeScenes:
|
|
await page.evaluate(
|
|
() =>
|
|
window.__HEROS_DEBUG__?.activeScenes?.() ??
|
|
[]
|
|
),
|
|
player: diagnostic?.player ?? null,
|
|
checkpoint:
|
|
diagnostic?.campaign?.explorationCheckpoint ??
|
|
null,
|
|
movement: diagnostic?.movement ?? null
|
|
}),
|
|
{ cause: error }
|
|
);
|
|
}
|
|
const exploration = await readExploration(page);
|
|
const player = exactPlayer(
|
|
exploration.campaign.explorationCheckpoint?.player
|
|
);
|
|
assertExactCheckpointPlayer(
|
|
exploration.campaign.explorationCheckpoint,
|
|
player,
|
|
`${renderer}: newly saved player checkpoint`
|
|
);
|
|
return player;
|
|
}
|
|
|
|
async function openAndAdvanceActorDialogue(page) {
|
|
const interacted = await page.evaluate((actorId) =>
|
|
window.__HEROS_DEBUG__
|
|
?.scene('CampVisitExplorationScene')
|
|
?.debugInteractWith?.(actorId) ?? false,
|
|
fixture.actorId
|
|
);
|
|
assert.equal(
|
|
interacted,
|
|
true,
|
|
`${renderer}: could not interact with ${fixture.actorId}.`
|
|
);
|
|
await waitForDialogue(page, {
|
|
sourceNpcId: fixture.actorId,
|
|
lineIndex: 0,
|
|
dialogueKey: 'visit-interaction'
|
|
});
|
|
|
|
const advanced = await page.evaluate(() =>
|
|
window.__HEROS_DEBUG__
|
|
?.scene('CampVisitExplorationScene')
|
|
?.debugAdvanceDialogue?.() ?? false
|
|
);
|
|
assert.equal(
|
|
advanced,
|
|
true,
|
|
`${renderer}: could not advance the actor dialogue.`
|
|
);
|
|
await waitForDialogue(page, {
|
|
sourceNpcId: fixture.actorId,
|
|
lineIndex: 1,
|
|
dialogueKey: 'visit-interaction'
|
|
});
|
|
return readExploration(page);
|
|
}
|
|
|
|
async function waitForDialogue(
|
|
page,
|
|
{ sourceNpcId, lineIndex, dialogueKey }
|
|
) {
|
|
await page.waitForFunction(
|
|
(expected) => {
|
|
const state =
|
|
window.__HEROS_DEBUG__?.campVisitExploration?.();
|
|
const overlay =
|
|
state?.campaign?.explorationCheckpoint?.overlay;
|
|
return (
|
|
state?.dialogue?.active === true &&
|
|
state.dialogue.sourceNpcId ===
|
|
expected.sourceNpcId &&
|
|
state.dialogue.lineIndex === expected.lineIndex &&
|
|
overlay?.type === 'dialogue' &&
|
|
overlay.dialogueKey === expected.dialogueKey &&
|
|
overlay.sourceNpcId === expected.sourceNpcId &&
|
|
overlay.lineIndex === expected.lineIndex
|
|
);
|
|
},
|
|
{ sourceNpcId, lineIndex, dialogueKey },
|
|
{ timeout: 10000 }
|
|
);
|
|
await afterTwoFrames(page);
|
|
}
|
|
|
|
function assertDialogueResume(actual, expected, label) {
|
|
assert.equal(actual.dialogue.active, true, label);
|
|
assert.equal(
|
|
actual.dialogue.sourceNpcId,
|
|
expected.dialogue.sourceNpcId,
|
|
`${label}: source changed.`
|
|
);
|
|
assert.equal(
|
|
actual.dialogue.lineIndex,
|
|
expected.dialogue.lineIndex,
|
|
`${label}: line changed.`
|
|
);
|
|
assert.equal(
|
|
actual.dialogue.totalLines,
|
|
expected.dialogue.totalLines,
|
|
`${label}: dialogue content changed.`
|
|
);
|
|
const actualOverlay =
|
|
actual.campaign.explorationCheckpoint?.overlay;
|
|
const expectedOverlay =
|
|
expected.campaign.explorationCheckpoint?.overlay;
|
|
assert.deepEqual(
|
|
actualOverlay,
|
|
expectedOverlay,
|
|
`${label}: checkpoint overlay changed.`
|
|
);
|
|
}
|
|
|
|
async function advanceToChoicePanel(page) {
|
|
for (let attempt = 0; attempt < 8; attempt += 1) {
|
|
const state = await readExploration(page);
|
|
if (state?.choice?.open) {
|
|
break;
|
|
}
|
|
assert.equal(
|
|
state?.dialogue?.active,
|
|
true,
|
|
`${renderer}: dialogue closed before the choice panel opened.`
|
|
);
|
|
const advanced = await page.evaluate(() =>
|
|
window.__HEROS_DEBUG__
|
|
?.scene('CampVisitExplorationScene')
|
|
?.debugAdvanceDialogue?.() ?? false
|
|
);
|
|
assert.equal(
|
|
advanced,
|
|
true,
|
|
`${renderer}: failed to advance toward the choice panel.`
|
|
);
|
|
await page.waitForTimeout(80);
|
|
}
|
|
await page.waitForFunction(
|
|
() => {
|
|
const state =
|
|
window.__HEROS_DEBUG__?.campVisitExploration?.();
|
|
const overlay =
|
|
state?.campaign?.explorationCheckpoint?.overlay;
|
|
return (
|
|
state?.dialogue?.active === false &&
|
|
state?.choice?.open === true &&
|
|
state.choice.mode === 'visit' &&
|
|
state.choice.choices.length === 2 &&
|
|
overlay?.type === 'choice' &&
|
|
overlay.mode === 'visit'
|
|
);
|
|
},
|
|
undefined,
|
|
{ timeout: 10000 }
|
|
);
|
|
await afterTwoFrames(page);
|
|
return readExploration(page);
|
|
}
|
|
|
|
async function waitForChoiceReady(page) {
|
|
await page.waitForFunction(
|
|
() => {
|
|
const choice =
|
|
window.__HEROS_DEBUG__
|
|
?.campVisitExploration?.()
|
|
?.choice;
|
|
return (
|
|
choice?.open === true &&
|
|
choice?.ready === true &&
|
|
choice.choices.length === 2 &&
|
|
choice.choices.every(
|
|
({ interactive, bounds }) =>
|
|
interactive === true &&
|
|
bounds &&
|
|
Number.isFinite(bounds.x) &&
|
|
Number.isFinite(bounds.y)
|
|
)
|
|
);
|
|
},
|
|
undefined,
|
|
{ timeout: 10000 }
|
|
);
|
|
await afterTwoFrames(page);
|
|
}
|
|
|
|
function assertChoiceResume(actual, expected, label) {
|
|
assert.equal(actual.choice.open, true, label);
|
|
assert.equal(actual.choice.mode, expected.choice.mode);
|
|
assert.equal(
|
|
actual.choice.sourceNpcId,
|
|
expected.choice.sourceNpcId
|
|
);
|
|
assert.deepEqual(
|
|
actual.choice.choices.map(({ id }) => id),
|
|
expected.choice.choices.map(({ id }) => id),
|
|
`${label}: choice IDs changed.`
|
|
);
|
|
assert.deepEqual(
|
|
actual.campaign.explorationCheckpoint?.overlay,
|
|
expected.campaign.explorationCheckpoint?.overlay,
|
|
`${label}: choice checkpoint changed.`
|
|
);
|
|
for (const choice of actual.choice.choices) {
|
|
const bounds = assertFiniteBounds(
|
|
choice.bounds,
|
|
`${label}: ${choice.id}`
|
|
);
|
|
assertBoundsContained(
|
|
bounds,
|
|
desktopBrowserViewportBounds,
|
|
`${label}: ${choice.id}`
|
|
);
|
|
}
|
|
}
|
|
|
|
async function waitForChoiceResponse(page, lineIndex) {
|
|
await waitForDialogue(page, {
|
|
sourceNpcId: fixture.actorId,
|
|
lineIndex,
|
|
dialogueKey: 'first-choice-response'
|
|
});
|
|
const state = await readExploration(page);
|
|
assert.equal(state.choice.open, false);
|
|
assert.equal(state.visit.completed, true);
|
|
assert.equal(state.visit.choiceId, fixture.choiceId);
|
|
}
|
|
|
|
function assertChoiceResponseResume(actual, expected, label) {
|
|
assertDialogueResume(actual, expected, label);
|
|
assert.equal(actual.visit.completed, true, label);
|
|
assert.equal(
|
|
actual.visit.choiceId,
|
|
fixture.choiceId,
|
|
`${label}: selected choice changed.`
|
|
);
|
|
assert.equal(
|
|
actual.choice.open,
|
|
false,
|
|
`${label}: response reopened the choice panel.`
|
|
);
|
|
}
|
|
|
|
async function finishActiveDialogue(page) {
|
|
for (let attempt = 0; attempt < 8; attempt += 1) {
|
|
const state = await readExploration(page);
|
|
if (!state?.dialogue?.active) {
|
|
break;
|
|
}
|
|
const advanced = await page.evaluate(() =>
|
|
window.__HEROS_DEBUG__
|
|
?.scene('CampVisitExplorationScene')
|
|
?.debugAdvanceDialogue?.() ?? false
|
|
);
|
|
assert.equal(
|
|
advanced,
|
|
true,
|
|
`${renderer}: could not finish the response dialogue.`
|
|
);
|
|
await page.waitForTimeout(80);
|
|
}
|
|
await page.waitForFunction(
|
|
() => {
|
|
const state =
|
|
window.__HEROS_DEBUG__?.campVisitExploration?.();
|
|
return (
|
|
state?.dialogue?.active === false &&
|
|
state?.choice?.open === false &&
|
|
state?.campaign?.explorationCheckpoint &&
|
|
state.campaign.explorationCheckpoint.overlay ===
|
|
undefined
|
|
);
|
|
},
|
|
undefined,
|
|
{ timeout: 10000 }
|
|
);
|
|
}
|
|
|
|
async function exitExplorationNormally(page) {
|
|
const startedExit = await page.evaluate((exitId) =>
|
|
window.__HEROS_DEBUG__
|
|
?.scene('CampVisitExplorationScene')
|
|
?.debugInteractWith?.(exitId) ?? false,
|
|
fixture.exitId
|
|
);
|
|
assert.equal(
|
|
startedExit,
|
|
true,
|
|
`${renderer}: normal camp exit did not start.`
|
|
);
|
|
}
|
|
|
|
async function waitForCampReady(page, expectedStep) {
|
|
try {
|
|
await page.waitForFunction(
|
|
(step) => {
|
|
const debug = window.__HEROS_DEBUG__;
|
|
const camp = debug?.camp?.();
|
|
return (
|
|
debug?.activeScenes?.().includes('CampScene') &&
|
|
camp?.scene === 'CampScene' &&
|
|
camp?.campaignObjectiveJournal?.snapshot &&
|
|
camp?.campaign?.step === step
|
|
);
|
|
},
|
|
expectedStep,
|
|
{ timeout: 90000 }
|
|
);
|
|
} catch (error) {
|
|
const diagnostic = await page.evaluate(() => ({
|
|
activeScenes:
|
|
window.__HEROS_DEBUG__?.activeScenes?.() ?? [],
|
|
camp: window.__HEROS_DEBUG__?.camp?.() ?? null,
|
|
exploration:
|
|
window.__HEROS_DEBUG__?.campVisitExploration?.() ??
|
|
null
|
|
}));
|
|
throw new Error(
|
|
`${renderer}: CampScene did not become ready: ` +
|
|
JSON.stringify(diagnostic),
|
|
{ cause: error }
|
|
);
|
|
}
|
|
await afterTwoFrames(page);
|
|
}
|
|
|
|
function exactPlayer(player) {
|
|
assert(
|
|
player &&
|
|
Number.isFinite(player.x) &&
|
|
Number.isFinite(player.y) &&
|
|
['north', 'south', 'east', 'west'].includes(
|
|
player.direction
|
|
),
|
|
`${renderer}: invalid player snapshot ${JSON.stringify(
|
|
player
|
|
)}.`
|
|
);
|
|
return {
|
|
x: player.x,
|
|
y: player.y,
|
|
direction: player.direction
|
|
};
|
|
}
|
|
|
|
function assertExactPlayer(actual, expected, label) {
|
|
assert.deepEqual(
|
|
exactPlayer(actual),
|
|
exactPlayer(expected),
|
|
`${label}: exact x/y/direction changed.`
|
|
);
|
|
}
|
|
|
|
function assertExactCheckpointPlayer(
|
|
checkpoint,
|
|
expected,
|
|
label
|
|
) {
|
|
assert(
|
|
checkpoint,
|
|
`${label}: exploration checkpoint is missing.`
|
|
);
|
|
assert.equal(checkpoint.version, 1, label);
|
|
assert.equal(
|
|
checkpoint.scene,
|
|
'camp-visit-exploration',
|
|
label
|
|
);
|
|
assert.equal(checkpoint.contextId, fixture.visitId, label);
|
|
assert.deepEqual(
|
|
checkpoint.player,
|
|
expected,
|
|
`${label}: checkpoint player differs.`
|
|
);
|
|
}
|
|
|
|
async function readCampaignSaves(page) {
|
|
return page.evaluate(() =>
|
|
Object.fromEntries(
|
|
Object.keys(window.localStorage)
|
|
.filter((key) =>
|
|
key.startsWith('heros-web:campaign-state')
|
|
)
|
|
.sort()
|
|
.map((key) => [
|
|
key,
|
|
window.localStorage.getItem(key)
|
|
])
|
|
)
|
|
);
|
|
}
|
|
|
|
async function readCampaignStates(page) {
|
|
const saves = await readCampaignSaves(page);
|
|
return Object.fromEntries(
|
|
Object.entries(saves).map(([key, value]) => [
|
|
key,
|
|
JSON.parse(value)
|
|
])
|
|
);
|
|
}
|
|
|
|
function rewardSnapshot(states) {
|
|
const entries = Object.entries(states);
|
|
assert(
|
|
entries.length >= 2,
|
|
`${renderer}: expected current and slot campaign saves.`
|
|
);
|
|
return Object.fromEntries(
|
|
entries.map(([key, state]) => {
|
|
const bond = state.bonds.find(
|
|
({ id }) => id === fixture.bondId
|
|
);
|
|
const reportBond = state.firstBattleReport?.bonds.find(
|
|
({ id }) => id === fixture.bondId
|
|
);
|
|
assert(
|
|
bond && reportBond,
|
|
`${renderer}: ${key} is missing ${fixture.bondId}.`
|
|
);
|
|
return [
|
|
key,
|
|
{
|
|
completedVisitCount:
|
|
state.completedCampVisits.filter(
|
|
(id) => id === fixture.visitId
|
|
).length,
|
|
reportCompletedVisitCount:
|
|
state.firstBattleReport.completedCampVisits.filter(
|
|
(id) => id === fixture.visitId
|
|
).length,
|
|
choiceId:
|
|
state.campVisitChoiceIds[fixture.visitId] ??
|
|
null,
|
|
inventory: { ...state.inventory },
|
|
bond: {
|
|
level: bond.level,
|
|
exp: bond.exp,
|
|
battleExp: bond.battleExp
|
|
},
|
|
reportBond: {
|
|
level: reportBond.level,
|
|
exp: reportBond.exp,
|
|
battleExp: reportBond.battleExp
|
|
}
|
|
}
|
|
];
|
|
})
|
|
);
|
|
}
|
|
|
|
function assertRewardNotYetApplied(snapshot, label) {
|
|
for (const [key, state] of Object.entries(snapshot)) {
|
|
assert.equal(
|
|
state.completedVisitCount,
|
|
0,
|
|
`${label}: ${key} already completed the visit.`
|
|
);
|
|
assert.equal(
|
|
state.reportCompletedVisitCount,
|
|
0,
|
|
`${label}: ${key} report already completed the visit.`
|
|
);
|
|
assert.equal(
|
|
state.choiceId,
|
|
null,
|
|
`${label}: ${key} already remembers a choice.`
|
|
);
|
|
}
|
|
}
|
|
|
|
function assertRewardAppliedExactlyOnce(
|
|
before,
|
|
after,
|
|
label
|
|
) {
|
|
assert.deepEqual(
|
|
Object.keys(after),
|
|
Object.keys(before),
|
|
`${label}: campaign save keys changed.`
|
|
);
|
|
for (const key of Object.keys(before)) {
|
|
const previous = before[key];
|
|
const current = after[key];
|
|
assert.equal(
|
|
current.completedVisitCount,
|
|
1,
|
|
`${label}: ${key} visit completion count mismatch.`
|
|
);
|
|
assert.equal(
|
|
current.reportCompletedVisitCount,
|
|
1,
|
|
`${label}: ${key} report completion count mismatch.`
|
|
);
|
|
assert.equal(
|
|
current.choiceId,
|
|
fixture.choiceId,
|
|
`${label}: ${key} choice mismatch.`
|
|
);
|
|
assert.equal(
|
|
current.inventory[fixture.itemId] ?? 0,
|
|
(previous.inventory[fixture.itemId] ?? 0) +
|
|
fixture.itemAmount,
|
|
`${label}: ${key} inventory reward mismatch.`
|
|
);
|
|
for (const [itemId, amount] of Object.entries(
|
|
current.inventory
|
|
)) {
|
|
if (itemId !== fixture.itemId) {
|
|
assert.equal(
|
|
amount,
|
|
previous.inventory[itemId],
|
|
`${label}: ${key} changed unrelated item ${itemId}.`
|
|
);
|
|
}
|
|
}
|
|
assert.deepEqual(
|
|
current.bond,
|
|
{
|
|
level: previous.bond.level,
|
|
exp: previous.bond.exp + fixture.bondExp,
|
|
battleExp:
|
|
previous.bond.battleExp + fixture.bondExp
|
|
},
|
|
`${label}: ${key} campaign bond reward mismatch.`
|
|
);
|
|
assert.deepEqual(
|
|
current.reportBond,
|
|
current.bond,
|
|
`${label}: ${key} report bond diverged.`
|
|
);
|
|
}
|
|
}
|
|
|
|
function assertCheckpointCleared(states, label) {
|
|
const entries = Object.entries(states);
|
|
assert(
|
|
entries.length >= 2,
|
|
`${label}: expected current and slot saves.`
|
|
);
|
|
for (const [key, state] of entries) {
|
|
assert.equal(
|
|
state.activeCampVisitId ?? null,
|
|
null,
|
|
`${label}: ${key} retained the active visit.`
|
|
);
|
|
assert.equal(
|
|
state.explorationCheckpoint ?? null,
|
|
null,
|
|
`${label}: ${key} retained the exploration checkpoint.`
|
|
);
|
|
}
|
|
}
|
|
|
|
async function clickSceneBounds(page, sceneKey, bounds) {
|
|
const point = await page.evaluate(
|
|
({ key, requestedBounds }) => {
|
|
const scene = window.__HEROS_DEBUG__?.scene(key);
|
|
const canvasBounds =
|
|
document.querySelector('canvas')?.getBoundingClientRect();
|
|
if (!scene || !canvasBounds) {
|
|
return null;
|
|
}
|
|
return {
|
|
x:
|
|
canvasBounds.left +
|
|
(requestedBounds.x +
|
|
requestedBounds.width / 2) *
|
|
canvasBounds.width /
|
|
scene.scale.width,
|
|
y:
|
|
canvasBounds.top +
|
|
(requestedBounds.y +
|
|
requestedBounds.height / 2) *
|
|
canvasBounds.height /
|
|
scene.scale.height
|
|
};
|
|
},
|
|
{ key: sceneKey, requestedBounds: bounds }
|
|
);
|
|
assert(
|
|
point &&
|
|
Number.isFinite(point.x) &&
|
|
Number.isFinite(point.y),
|
|
`Unable to map ${sceneKey} bounds ${JSON.stringify(
|
|
bounds
|
|
)}.`
|
|
);
|
|
await page.mouse.click(point.x, point.y);
|
|
}
|
|
|
|
function assertFiniteBounds(bounds, label) {
|
|
assert(
|
|
bounds &&
|
|
Number.isFinite(bounds.x) &&
|
|
Number.isFinite(bounds.y) &&
|
|
Number.isFinite(bounds.width) &&
|
|
Number.isFinite(bounds.height) &&
|
|
bounds.width > 0 &&
|
|
bounds.height > 0,
|
|
`${label}: invalid bounds ${JSON.stringify(bounds)}.`
|
|
);
|
|
return bounds;
|
|
}
|
|
|
|
function assertBoundsContained(bounds, container, label) {
|
|
assert(
|
|
bounds.x >= container.x &&
|
|
bounds.y >= container.y &&
|
|
bounds.x + bounds.width <=
|
|
container.x + container.width &&
|
|
bounds.y + bounds.height <=
|
|
container.y + container.height,
|
|
`${label}: ${JSON.stringify(bounds)} is outside ` +
|
|
JSON.stringify(container)
|
|
);
|
|
}
|
|
|
|
async function afterTwoFrames(page) {
|
|
await page.evaluate(
|
|
() =>
|
|
new Promise((resolve) => {
|
|
requestAnimationFrame(() =>
|
|
requestAnimationFrame(resolve)
|
|
);
|
|
})
|
|
);
|
|
}
|
|
|
|
async function readRuntimeProbe(page, sceneKey) {
|
|
return page.evaluate((key) => {
|
|
const game = window.__HEROS_GAME__;
|
|
const scene = game?.scene.getScene(key);
|
|
const canvas = document.querySelector('canvas');
|
|
const canvasBounds = canvas?.getBoundingClientRect();
|
|
return {
|
|
viewport: {
|
|
width: window.innerWidth,
|
|
height: window.innerHeight,
|
|
dpr: window.devicePixelRatio,
|
|
zoom: window.visualViewport?.scale ?? 1
|
|
},
|
|
canvas: canvas
|
|
? {
|
|
width: canvas.width,
|
|
height: canvas.height,
|
|
bounds: canvasBounds
|
|
? {
|
|
x: canvasBounds.x,
|
|
y: canvasBounds.y,
|
|
width: canvasBounds.width,
|
|
height: canvasBounds.height
|
|
}
|
|
: null
|
|
}
|
|
: null,
|
|
renderer: {
|
|
requested: new URLSearchParams(
|
|
window.location.search
|
|
).get('renderer'),
|
|
type: game?.renderer?.type ?? null,
|
|
name: game?.renderer?.constructor?.name ?? null
|
|
},
|
|
scene: scene
|
|
? {
|
|
width: scene.scale.width,
|
|
height: scene.scale.height
|
|
}
|
|
: null
|
|
};
|
|
}, sceneKey);
|
|
}
|
|
|
|
function assertRuntimeBaseline(
|
|
runtime,
|
|
requestedRenderer,
|
|
label
|
|
) {
|
|
assert.deepEqual(
|
|
runtime.viewport,
|
|
{
|
|
width: desktopBrowserViewport.width,
|
|
height: desktopBrowserViewport.height,
|
|
dpr: desktopBrowserDeviceScaleFactor,
|
|
zoom: 1
|
|
},
|
|
`${label}: viewport, DPR, or browser zoom mismatch.`
|
|
);
|
|
assert.deepEqual(
|
|
runtime.canvas,
|
|
{
|
|
width: desktopBrowserViewport.width,
|
|
height: desktopBrowserViewport.height,
|
|
bounds: {
|
|
x: 0,
|
|
y: 0,
|
|
width: desktopBrowserViewport.width,
|
|
height: desktopBrowserViewport.height
|
|
}
|
|
},
|
|
`${label}: canvas did not fill the CSS viewport.`
|
|
);
|
|
assert.deepEqual(
|
|
runtime.scene,
|
|
{
|
|
width: desktopBrowserViewport.width,
|
|
height: desktopBrowserViewport.height
|
|
},
|
|
`${label}: Phaser scene size mismatch.`
|
|
);
|
|
assert.equal(
|
|
runtime.renderer.requested,
|
|
requestedRenderer,
|
|
`${label}: renderer query mismatch.`
|
|
);
|
|
assert.equal(
|
|
runtime.renderer.type,
|
|
requestedRenderer === 'canvas' ? 1 : 2,
|
|
`${label}: expected ${requestedRenderer}: ` +
|
|
JSON.stringify(runtime.renderer)
|
|
);
|
|
}
|
|
|
|
async function ensureLocalServer(url) {
|
|
if (await canReach(url)) {
|
|
return undefined;
|
|
}
|
|
|
|
const parsed = new URL(url);
|
|
if (
|
|
!['localhost', '127.0.0.1', '0.0.0.0'].includes(
|
|
parsed.hostname
|
|
)
|
|
) {
|
|
throw new Error(`No server responded at ${url}`);
|
|
}
|
|
|
|
const stderr = [];
|
|
const child = spawn(
|
|
process.execPath,
|
|
[
|
|
'node_modules/vite/bin/vite.js',
|
|
'--host',
|
|
'127.0.0.1',
|
|
'--port',
|
|
parsed.port || '41808',
|
|
'--strictPort'
|
|
],
|
|
{
|
|
cwd: process.cwd(),
|
|
env: process.env,
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
windowsHide: true
|
|
}
|
|
);
|
|
child.stderr.on('data', (chunk) =>
|
|
stderr.push(chunk.toString())
|
|
);
|
|
child.stdout.on('data', () => {});
|
|
|
|
for (let attempt = 0; attempt < 120; attempt += 1) {
|
|
if (await canReach(url)) {
|
|
return child;
|
|
}
|
|
await delay(250);
|
|
}
|
|
|
|
await stopServerProcess(child);
|
|
throw new Error(
|
|
`Vite server did not start at ${url}\n${stderr.join('')}`
|
|
);
|
|
}
|
|
|
|
async function canReach(url) {
|
|
try {
|
|
const response = await fetch(url, {
|
|
signal: AbortSignal.timeout(1000)
|
|
});
|
|
return response.ok;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function delay(ms) {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
async function stopServerProcess(child) {
|
|
if (!child || child.exitCode !== null) {
|
|
return;
|
|
}
|
|
const exited = new Promise((resolve) =>
|
|
child.once('exit', resolve)
|
|
);
|
|
child.kill();
|
|
await Promise.race([exited, delay(5000)]);
|
|
if (child.exitCode === null) {
|
|
child.kill('SIGKILL');
|
|
await Promise.race([exited, delay(2000)]);
|
|
}
|
|
}
|