kdletters
321 lines
9.7 KiB
TypeScript
321 lines
9.7 KiB
TypeScript
import { EventEmitter } from 'node:events';
|
|
import { existsSync, mkdtempSync, rmSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join, resolve } from 'node:path';
|
|
|
|
import { describe, expect, test, vi } from 'vitest';
|
|
|
|
import {
|
|
ensureBackend,
|
|
isProcessGroupAlive,
|
|
preflightExistingVite,
|
|
readLinuxProcessGroupAlive,
|
|
resolveBackendTargetsFromState,
|
|
runWindowsTaskkill,
|
|
spawnChild,
|
|
stopChild,
|
|
terminateChildTree,
|
|
waitForChildTermination,
|
|
} from '../scripts/start-dev-stack.mjs';
|
|
|
|
const expectedDatabase = 'genarrative-game-creator-dev';
|
|
const expectedDataDir = resolve('server-rs/.spacetimedb/ai-game-creator/data');
|
|
|
|
function backendState(spacetimeDataDir?: string) {
|
|
return {
|
|
schemaVersion: spacetimeDataDir ? 2 : 1,
|
|
database: expectedDatabase,
|
|
...(spacetimeDataDir ? { spacetimeDataDir } : {}),
|
|
services: {
|
|
'api-server': {
|
|
status: 'running',
|
|
url: 'http://127.0.0.1:8082',
|
|
},
|
|
spacetime: {
|
|
status: 'running',
|
|
url: 'http://127.0.0.1:3101',
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
async function waitForFile(path: string, timeoutMs = 5000) {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (Date.now() < deadline) {
|
|
if (existsSync(path)) {
|
|
return;
|
|
}
|
|
await new Promise((resolveWait) => setTimeout(resolveWait, 25));
|
|
}
|
|
throw new Error(`等待测试进程标记超时: ${path}`);
|
|
}
|
|
|
|
describe('AI 游戏创作配套后端复用门禁', () => {
|
|
test('旧状态缺少专用 data dir 时拒绝复用同名健康后端', () => {
|
|
const targets = resolveBackendTargetsFromState(backendState(), {
|
|
requireAgcBackend: true,
|
|
expectedDatabase,
|
|
expectedSpacetimeDataDir: expectedDataDir,
|
|
});
|
|
|
|
expect(targets.hasMatchingDatabase).toBe(true);
|
|
expect(targets.hasMatchingDataDir).toBe(false);
|
|
expect(targets.hasMatchingBackend).toBe(false);
|
|
expect(targets.apiUrl).toBe('');
|
|
expect(targets.spacetimeUrl).toBe('');
|
|
});
|
|
|
|
test('只有数据库名和专用 data dir 都匹配时才允许复用', () => {
|
|
const wrongDir = resolveBackendTargetsFromState(
|
|
backendState(resolve('server-rs/.spacetimedb/local/data')),
|
|
{
|
|
requireAgcBackend: true,
|
|
expectedDatabase,
|
|
expectedSpacetimeDataDir: expectedDataDir,
|
|
},
|
|
);
|
|
const matching = resolveBackendTargetsFromState(
|
|
backendState(expectedDataDir),
|
|
{
|
|
requireAgcBackend: true,
|
|
expectedDatabase,
|
|
expectedSpacetimeDataDir: expectedDataDir,
|
|
},
|
|
);
|
|
|
|
expect(wrongDir.hasMatchingBackend).toBe(false);
|
|
expect(matching.hasMatchingBackend).toBe(true);
|
|
expect(matching.apiUrl).toBe('http://127.0.0.1:8082');
|
|
expect(matching.spacetimeUrl).toBe('http://127.0.0.1:3101');
|
|
});
|
|
});
|
|
|
|
describe('AI 游戏创作启动子进程生命周期', () => {
|
|
const posixTest = process.platform === 'win32' ? test.skip : test;
|
|
|
|
test('Linux 进程组只剩僵尸进程时视为已经停止', () => {
|
|
const procStats = new Map([
|
|
['/proc/101/stat', '101 (node worker) Z 1 700 700 0'],
|
|
['/proc/102/stat', '102 (other worker) S 1 701 701 0'],
|
|
]);
|
|
const readLinuxGroupAlive = (processGroupId: number) =>
|
|
readLinuxProcessGroupAlive(processGroupId, {
|
|
readdirImpl: () => ['101', '102', 'not-a-pid'],
|
|
readFileImpl: (path: string) => {
|
|
const stat = procStats.get(path);
|
|
if (!stat) {
|
|
throw new Error('missing proc stat fixture');
|
|
}
|
|
return stat;
|
|
},
|
|
});
|
|
const killImpl = vi.fn();
|
|
|
|
expect(readLinuxGroupAlive(700)).toBe(false);
|
|
expect(readLinuxGroupAlive(701)).toBe(true);
|
|
expect(
|
|
isProcessGroupAlive(700, {
|
|
platform: 'linux',
|
|
killImpl,
|
|
readLinuxGroupAlive,
|
|
}),
|
|
).toBe(false);
|
|
expect(killImpl).toHaveBeenCalledWith(-700, 0);
|
|
});
|
|
|
|
posixTest('npm 不可解析时进入受控 error 结果而不是未处理事件', async () => {
|
|
const child = spawnChild('genarrative-command-that-does-not-exist', [], {
|
|
cwd: process.cwd(),
|
|
});
|
|
|
|
const failure = await waitForChildTermination(child);
|
|
|
|
expect(failure.type).toBe('error');
|
|
expect(failure.error).toMatchObject({ code: 'ENOENT' });
|
|
});
|
|
|
|
posixTest('leader 退出后仍按保留的 PGID 清理后代进程', async () => {
|
|
const tempDir = mkdtempSync(join(tmpdir(), 'agc-process-group-'));
|
|
const readyPath = join(tempDir, 'descendant-ready');
|
|
const stoppedPath = join(tempDir, 'descendant-stopped');
|
|
const descendantSource = `
|
|
const { writeFileSync } = require('node:fs');
|
|
const [readyPath, stoppedPath] = process.argv.slice(1);
|
|
process.on('SIGTERM', () => {
|
|
writeFileSync(stoppedPath, 'stopped');
|
|
process.exit(0);
|
|
});
|
|
writeFileSync(readyPath, 'ready');
|
|
setInterval(() => {}, 1000);
|
|
`;
|
|
const leaderSource = `
|
|
const { spawn } = require('node:child_process');
|
|
const [readyPath, stoppedPath, descendantSource] = process.argv.slice(1);
|
|
const descendant = spawn(
|
|
process.execPath,
|
|
['-e', descendantSource, readyPath, stoppedPath],
|
|
{ stdio: 'ignore' },
|
|
);
|
|
descendant.unref();
|
|
process.exit(42);
|
|
`;
|
|
let child;
|
|
try {
|
|
child = spawnChild(
|
|
process.execPath,
|
|
['-e', leaderSource, readyPath, stoppedPath, descendantSource],
|
|
{ cwd: process.cwd() },
|
|
);
|
|
|
|
const failure = await waitForChildTermination(child);
|
|
expect(failure).toMatchObject({ type: 'exit', code: 42 });
|
|
await waitForFile(readyPath);
|
|
|
|
stopChild(child);
|
|
|
|
await waitForFile(stoppedPath);
|
|
} finally {
|
|
if (Number.isInteger(child?.pid)) {
|
|
try {
|
|
process.kill(-child.pid, 'SIGKILL');
|
|
} catch {
|
|
// 测试后代已经退出。
|
|
}
|
|
}
|
|
rmSync(tempDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test('后端句柄在 ready 等待前交给外层且异常时立即清理', async () => {
|
|
const child = Object.assign(new EventEmitter(), {
|
|
exitCode: null,
|
|
signalCode: null,
|
|
kill: vi.fn(),
|
|
});
|
|
const onBackendChild = vi.fn();
|
|
const waitUntilReady = vi.fn(async (receivedChild) => {
|
|
expect(receivedChild).toBe(child);
|
|
expect(onBackendChild).toHaveBeenCalledWith(child);
|
|
throw new Error('等待配套后端和数据库启动超时');
|
|
});
|
|
|
|
await expect(
|
|
ensureBackend({
|
|
checkBackendReady: async () => false,
|
|
spawnBackend: () => child,
|
|
onBackendChild,
|
|
waitUntilReady,
|
|
}),
|
|
).rejects.toThrow('等待配套后端和数据库启动超时');
|
|
|
|
expect(child.kill).toHaveBeenCalledWith('SIGTERM');
|
|
});
|
|
|
|
test('Windows 通过 taskkill 收束 Tauri CLI 进程树', async () => {
|
|
const child = Object.assign(new EventEmitter(), {
|
|
pid: 4821,
|
|
exitCode: 1,
|
|
signalCode: null,
|
|
kill: vi.fn(),
|
|
});
|
|
const taskkillImpl = vi.fn(async () => ({
|
|
timedOut: false,
|
|
code: 0,
|
|
error: null,
|
|
}));
|
|
|
|
const result = await terminateChildTree(child, {
|
|
platform: 'win32',
|
|
taskkillImpl,
|
|
});
|
|
|
|
expect(taskkillImpl).toHaveBeenCalledWith(4821);
|
|
expect(result).toMatchObject({ stopped: true, forced: true });
|
|
});
|
|
|
|
test('Windows taskkill 固定携带 PID、整树和强制参数', async () => {
|
|
const taskkill = Object.assign(new EventEmitter(), {
|
|
kill: vi.fn(),
|
|
});
|
|
const spawnImpl = vi.fn(() => {
|
|
queueMicrotask(() => taskkill.emit('exit', 0));
|
|
return taskkill;
|
|
});
|
|
|
|
await expect(
|
|
runWindowsTaskkill(4821, { spawnImpl, timeoutMs: 100 }),
|
|
).resolves.toMatchObject({ timedOut: false, code: 0, error: null });
|
|
expect(spawnImpl).toHaveBeenCalledWith(
|
|
'taskkill.exe',
|
|
['/PID', '4821', '/T', '/F'],
|
|
expect.objectContaining({ shell: false, windowsHide: true }),
|
|
);
|
|
});
|
|
});
|
|
|
|
describe('AI 游戏创作动态端口启动前预检', () => {
|
|
const endpoint = {
|
|
host: '127.0.0.1',
|
|
port: 10005,
|
|
url: 'http://127.0.0.1:10005/',
|
|
markerUrl: 'http://127.0.0.1:10005/__agc_dev_server.json',
|
|
portRange: { start: 10000, end: 10099, label: '10000-10099' },
|
|
};
|
|
const agcHtml = {
|
|
statusCode: 200,
|
|
body: '<html><title>陶泥儿</title><script src="/src/main.tsx"></script></html>',
|
|
};
|
|
|
|
test('旧 Vite marker 指向其它 API 时在启动后端前失败', async () => {
|
|
await expect(
|
|
preflightExistingVite({
|
|
endpoint,
|
|
readServer: async () => agcHtml,
|
|
portListening: async () => true,
|
|
readMarker: async () => ({
|
|
schemaVersion: 1,
|
|
app: 'ai-game-creator-shell',
|
|
apiTarget: 'http://127.0.0.1:10001',
|
|
}),
|
|
}),
|
|
).rejects.toThrow(
|
|
'API target http://127.0.0.1:10001. Its owning worktree cannot be proven',
|
|
);
|
|
});
|
|
|
|
test('marker target 看似匹配时仍拒绝复用无法证明归属的 Vite', async () => {
|
|
await expect(
|
|
preflightExistingVite({
|
|
endpoint,
|
|
readServer: async () => agcHtml,
|
|
portListening: async () => true,
|
|
readMarker: async () => ({
|
|
schemaVersion: 1,
|
|
app: 'ai-game-creator-shell',
|
|
apiTarget: 'http://127.0.0.1:10004',
|
|
}),
|
|
}),
|
|
).rejects.toThrow('Its owning worktree cannot be proven');
|
|
});
|
|
|
|
test('HTTP 探测无响应但端口已监听时失败关闭', async () => {
|
|
await expect(
|
|
preflightExistingVite({
|
|
endpoint,
|
|
readServer: async () => null,
|
|
portListening: async () => true,
|
|
}),
|
|
).rejects.toThrow('non-HTTP or unrecognized server');
|
|
});
|
|
|
|
test('当前动态端口未监听时允许继续启动', async () => {
|
|
await expect(
|
|
preflightExistingVite({
|
|
endpoint,
|
|
readServer: async () => null,
|
|
portListening: async () => false,
|
|
}),
|
|
).resolves.toEqual({ status: 'available', apiTarget: '' });
|
|
});
|
|
});
|