@epoint-testtech/ep-stage-skill 0.0.9 → 0.5.0-alpha.2

package/dist/test/cli/run.test.js

@@ -0,0 +1,429 @@
+/**
+ * run.ts 单元测试（新协议 v1-draft，Task 5）。
+ *
+ * 覆盖：
+ * - parseRunArgs 缺参 / 非法 / --headless 默认 true / --headless false 关闭无头；
+ * - runRun（端到端：runGenerateTestcase → runRun）：
+ *   · 只传 testcase.json5 也能定位 projectDir/specPath；
+ *   · spec 缺失时自动先跑 runSpec 组装 glue 骨架；
+ *   · spec 追加段含 AI_APPEND_MARKER（新注释 generationStrategy=ai）；
+ *   · 追加 test 数量 === ai 候选数量；
+ *   · blocked 候选不进入 AI Runtime Task，但仍保留在 testcase 审阅数据；
+ *   · run 会落 `.ep-stage/ai-runtime-trace.json5`；
+ *   · credentials.json5 缺失时不崩溃，result.credentialsNotice 含提示；
+ *   · 已有 AI 追加段时重跑覆盖（幂等）；
+ *   · spec 不存在时抛错。
+ */
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import JSON5 from 'json5';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AI_APPEND_MARKER, buildPlaywrightCommand, loadAiSnippets, parseRunArgs, prepareAiRuntimeTasks, runRun, } from '../../src/cli/run.js';
+import { runSpec } from '../../src/cli/spec.js';
+import { runGenerateTestcase } from '../../src/cli/generate-testcase.js';
+/** code_list.json5 fixture 路径（e2e 014 新协议样例）。 */
+const CODE_LIST_PATH = path.resolve(__dirname, '../../../../e2e/glue-code-mvp/src/tests/014-测试需求10-20260622/_docs/code_list.json5');
+const DIRECT_URL = 'http://example.test/epoint-web/perpage/zwplace/gxhzwplacelist.html';
+let tmpRoot;
+beforeEach(() => {
+    tmpRoot = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-run-v1-'));
+});
+/**
+ * 构造最小 glue 项目夹具。
+ *
+ * @param name - 临时项目名。
+ * @returns projectDir / caseDir。
+ */
+function makeGlueProjectFixture(name) {
+    const projectDir = path.join(tmpRoot, name);
+    const caseDir = path.join(projectDir, 'src', 'tests', 'req-014');
+    mkdirSync(path.join(projectDir, 'src', 'skeletons'), { recursive: true });
+    writeFileSync(path.join(projectDir, 'package.json'), '{"name":"fixture-project"}\n', 'utf8');
+    writeFileSync(path.join(projectDir, 'playwright.config.ts'), 'export default {};\n', 'utf8');
+    return { projectDir, caseDir };
+}
+/**
+ * 端到端产 testcase.json5 + spec 到临时 glue 项目。
+ *
+ * @param name - 临时项目名。
+ * @returns testcase 路径 + spec 路径 + projectDir。
+ */
+function generateFixtures(name) {
+    const { projectDir, caseDir } = makeGlueProjectFixture(name);
+    const gen = runGenerateTestcase({
+        codeList: CODE_LIST_PATH,
+        testsDir: caseDir,
+        directUrl: DIRECT_URL,
+    });
+    const specPath = path.join(caseDir, 'crud.spec.ts');
+    const testcase = JSON5.parse(readFileSync(gen.testcasePath, 'utf8'));
+    testcase.runtimeContext = {
+        testProjectDir: projectDir,
+        caseDir,
+        specPath,
+    };
+    writeFileSync(gen.testcasePath, `${JSON5.stringify(testcase, null, 2)}\n`, 'utf8');
+    runSpec({ testcase: gen.testcasePath, out: specPath });
+    return { testcasePath: gen.testcasePath, specPath, projectDir, caseDir };
+}
+/**
+ * 单测默认依赖：推理固定 snippet，执行固定成功，避免误触发真实 Playwright。
+ *
+ * @returns 可注入 runRun 的稳定依赖。
+ */
+function passingDeps() {
+    return {
+        loadAiSnippets: ({ tasks }) => tasks.map((task) => ({
+            caseId: task.caseId,
+            status: 'resolved',
+            observation: {
+                pageState: 'unit-test',
+            },
+            decision: {
+                action: 'append deterministic snippet',
+            },
+            actionFlow: ['emit snippet'],
+            verification: {
+                assertionExpectation: task.assertionExpectation,
+            },
+            specSnippet: [
+                `test(${JSON.stringify(task.title)}, async ({ page }) => {`,
+                `  // caseId: ${task.caseId}`,
+                `  await test.step(${JSON.stringify(task.businessIntent)}, async () => {`,
+                `    await expect(page.locator('body')).toBeVisible();`,
+                '  });',
+                '});',
+            ].join('\n'),
+            evidence: [{ source: 'unit-test', note: 'deterministic snippet' }],
+        })),
+        executeFullSpec: async () => ({ passed: true, output: 'ok' }),
+    };
+}
+describe('parseRunArgs', () => {
+    it('缺 --testcase 时抛错', () => {
+        expect(() => parseRunArgs([])).toThrow(/缺少 --testcase/);
+    });
+    it('参数对非法时抛错', () => {
+        expect(() => parseRunArgs(['--testcase'])).toThrow(/无效参数对/);
+    });
+    it('--headless 默认 true', () => {
+        const args = parseRunArgs(['--testcase', '/t']);
+        expect(args.headless).toBe(true);
+    });
+    it('--headless false 关闭无头', () => {
+        const args = parseRunArgs(['--testcase', '/t', '--headless', 'false']);
+        expect(args.headless).toBe(false);
+    });
+    it('--ai-snippets 透传 Agent 结果包路径', () => {
+        const args = parseRunArgs(['--testcase', '/t', '--ai-snippets', '/tmp/ai-snippets.json5']);
+        expect(args.aiSnippets).toBe('/tmp/ai-snippets.json5');
+    });
+});
+describe('runRun（新协议 v1-draft 端到端）', () => {
+    it('prepare-tasks 输出任务包到 trace 并组装 glue spec', () => {
+        const { testcasePath, specPath } = generateFixtures('req-prepare');
+        rmSync(specPath);
+        const result = prepareAiRuntimeTasks(testcasePath);
+        expect(result.specPath).toBe(specPath);
+        expect(result.taskCount).toBeGreaterThan(0);
+        expect(result.blockedCount).toBeGreaterThan(0);
+        expect(existsSync(result.tracePath)).toBe(true);
+        const trace = JSON5.parse(readFileSync(result.tracePath, 'utf8'));
+        expect(trace.tasks.length).toBe(result.taskCount);
+        expect(trace.results).toEqual([]);
+        expect(existsSync(specPath)).toBe(true);
+    });
+    it('只传 testcase.json5 也能定位 projectDir/specPath', async () => {
+        const { testcasePath, specPath, projectDir } = generateFixtures('req-entry');
+        const result = await runRun({
+            testcase: testcasePath,
+            headless: false,
+        }, passingDeps());
+        expect(result.specPath).toBe(specPath);
+        expect(result.reportDir).toContain(path.join(projectDir, 'e2e/glue-code-mvp/glue-report'));
+    });
+    it('spec 缺失时自动先跑 runSpec 组装 glue 骨架', async () => {
+        const { testcasePath, specPath } = generateFixtures('req-autospec');
+        rmSync(specPath);
+        const result = await runRun({
+            testcase: testcasePath,
+            headless: true,
+        }, passingDeps());
+        expect(result.specPath).toBe(specPath);
+        expect(readFileSync(specPath, 'utf8')).toContain(AI_APPEND_MARKER);
+    });
+    it('存在 AI tasks 但缺少 ai-snippets.json5 时停止等待 Agent，不追加占位 snippet、不执行 Playwright', async () => {
+        const { testcasePath, specPath } = generateFixtures('req-needs-review');
+        const calls = [];
+        const result = await runRun({
+            testcase: testcasePath,
+            headless: true,
+        }, {
+            executeFullSpec: async () => {
+                calls.push('execute');
+                return { passed: true, output: 'should not run' };
+            },
+        });
+        expect(calls).toEqual([]);
+        expect(result.aiRuntimeTracePath).toBe(path.join(path.dirname(testcasePath), '.ep-stage', 'ai-runtime-trace.json5'));
+        const body = readFileSync(specPath, 'utf8');
+        expect(body).not.toContain(AI_APPEND_MARKER);
+        const trace = JSON5.parse(readFileSync(result.aiRuntimeTracePath, 'utf8'));
+        expect(trace.results.length).toBe(trace.tasks.length);
+        expect(trace.results.every((result) => result.status === 'needs_review')).toBe(true);
+    });
+    it('runtimeContext 缺失时向上查找测试项目目录', async () => {
+        const { testcasePath, specPath } = generateFixtures('req-fallback');
+        const testcase = JSON5.parse(readFileSync(testcasePath, 'utf8'));
+        delete testcase.runtimeContext;
+        writeFileSync(testcasePath, `${JSON5.stringify(testcase, null, 2)}\n`, 'utf8');
+        rmSync(specPath);
+        const result = await runRun({
+            testcase: testcasePath,
+            headless: true,
+        }, passingDeps());
+        expect(result.specPath).toBe(specPath);
+        expect(readFileSync(specPath, 'utf8')).toContain(AI_APPEND_MARKER);
+    });
+    it('追加 Agent resolved snippet，marker 为新注释（generationStrategy=ai）', async () => {
+        const { testcasePath, specPath } = generateFixtures('req-014');
+        const result = await runRun({
+            testcase: testcasePath,
+            headless: true,
+        }, passingDeps());
+        expect(result.version).toBe('v1');
+        const body = readFileSync(specPath, 'utf8');
+        // marker 出现且为新注释语义。
+        expect(body).toContain(AI_APPEND_MARKER);
+        expect(body).toMatch(/基于 uncoveredCandidates\[\]\.generationStrategy=ai/);
+        // 追加段来自 AI Runtime Result 的 specSnippet，不再生成 TODO 占位。
+        expect(body).toMatch(/test\(.*?, async \(\{ page \}\) => \{/);
+        expect(body).toMatch(/\/\/ caseId: /);
+        expect(body).toMatch(/await test\.step/);
+        expect(body).not.toMatch(/TODO: AI runtime 推理后填入实际 Playwright 步骤/);
+    });
+    it('追加 test 数量 === ai 候选数量', async () => {
+        const { testcasePath, specPath } = generateFixtures('req-count');
+        const testcase = JSON5.parse(readFileSync(testcasePath, 'utf8'));
+        const expectedAiCount = testcase.uncoveredCandidates.filter((c) => c.generationStrategy === 'ai' && c.coverageStatus !== 'blocked').length;
+        // fixture 至少有 ai 候选，断言有意义。
+        expect(expectedAiCount).toBeGreaterThan(0);
+        await runRun({ testcase: testcasePath, headless: true }, passingDeps());
+        const body = readFileSync(specPath, 'utf8');
+        // 追加段中 test( 出现次数 === ai 候选数（marker 之后的区段计数）。
+        const markerIdx = body.indexOf(AI_APPEND_MARKER);
+        const appended = body.slice(markerIdx);
+        const testCount = (appended.match(/test\(/g) ?? []).length;
+        expect(testCount).toBe(expectedAiCount);
+    });
+    it('写入 ai-runtime-trace.json5，且 blocked 候选不进入 tasks', async () => {
+        const { testcasePath, specPath } = generateFixtures('req-blocked');
+        const testcase = JSON5.parse(readFileSync(testcasePath, 'utf8'));
+        const blockedCandidates = testcase.uncoveredCandidates.filter((c) => c.generationStrategy === 'ai' && c.coverageStatus === 'blocked');
+        expect(blockedCandidates.map((c) => c.label)).toEqual(expect.arrayContaining(['统计看板（无入口）', '移动端查询（无入口）']));
+        const blockedCaseIds = blockedCandidates.map((c) => c.caseId);
+        await runRun({ testcase: testcasePath, headless: true }, passingDeps());
+        expect(existsSync(specPath)).toBe(true);
+        const tracePath = path.join(path.dirname(testcasePath), '.ep-stage', 'ai-runtime-trace.json5');
+        expect(existsSync(tracePath)).toBe(true);
+        const trace = JSON5.parse(readFileSync(tracePath, 'utf8'));
+        const taskCaseIds = trace.tasks.map((task) => task.caseId);
+        expect(taskCaseIds).not.toEqual(expect.arrayContaining(blockedCaseIds));
+        expect(taskCaseIds.length).toBe(testcase.uncoveredCandidates.filter((c) => c.generationStrategy === 'ai' && c.coverageStatus !== 'blocked').length);
+        const specBody = readFileSync(specPath, 'utf8');
+        const appended = specBody.slice(specBody.indexOf(AI_APPEND_MARKER));
+        for (const caseId of blockedCaseIds) {
+            expect(appended).not.toContain(caseId);
+        }
+    });
+    it('loadAiSnippets 只接受当前 testcase 的 resolved snippet', () => {
+        const { testcasePath, caseDir } = generateFixtures('req-snippets-validation');
+        const prepared = prepareAiRuntimeTasks(testcasePath);
+        const trace = JSON5.parse(readFileSync(prepared.tracePath, 'utf8'));
+        const snippetsPath = path.join(caseDir, '.ep-stage', 'ai-snippets.json5');
+        writeFileSync(snippetsPath, `${JSON5.stringify({
+            schemaVersion: 'ep-stage-ai-snippets/v1',
+            testcasePath,
+            generatedAt: '2026-07-02T00:00:00.000Z',
+            results: [
+                {
+                    caseId: trace.tasks[0].caseId,
+                    status: 'resolved',
+                    specSnippet: 'test("resolved", async () => {});',
+                },
+                {
+                    caseId: trace.tasks[1].caseId,
+                    status: 'needs_review',
+                    specSnippet: 'test("not merged", async () => {});',
+                },
+            ],
+        }, null, 2)}\n`, 'utf8');
+        const results = loadAiSnippets({
+            snippetsPath,
+            testcasePath,
+            tasks: trace.tasks,
+        });
+        expect(results.map((result) => result.caseId)).toEqual([trace.tasks[0].caseId]);
+        writeFileSync(snippetsPath, `${JSON5.stringify({
+            schemaVersion: 'ep-stage-ai-snippets/v1',
+            testcasePath: '/tmp/other/testcase.json5',
+            results: [],
+        }, null, 2)}\n`, 'utf8');
+        expect(() => loadAiSnippets({
+            snippetsPath,
+            testcasePath,
+            tasks: trace.tasks,
+        })).toThrow(/testcasePath 与当前 testcase 不匹配/);
+    });
+    it('trace task 包含 entryContext / knownContext / codingRules', async () => {
+        const { testcasePath } = generateFixtures('req-trace-payload');
+        await runRun({ testcase: testcasePath, headless: true }, passingDeps());
+        const tracePath = path.join(path.dirname(testcasePath), '.ep-stage', 'ai-runtime-trace.json5');
+        const trace = JSON5.parse(readFileSync(tracePath, 'utf8'));
+        expect(trace.tasks.length).toBeGreaterThan(0);
+        expect(trace.tasks[0].entryContext).toMatchObject({
+            role: expect.any(String),
+        });
+        expect(trace.tasks[0].knownContext).toMatchObject({
+            queryKey: expect.anything(),
+            precondition: expect.anything(),
+            steps: expect.anything(),
+            assertion: expect.anything(),
+        });
+        expect(trace.tasks[0].codingRules).toMatchObject({
+            devRulesPath: 'docs/00-memory/dev-rules.md',
+        });
+    });
+    it('prepare-tasks 按 testcase.testAccess.credentialRef 读取运行访问数据', () => {
+        const { testcasePath, caseDir } = generateFixtures('req-credential-ref');
+        const testcase = JSON5.parse(readFileSync(testcasePath, 'utf8'));
+        testcase.testAccess = {
+            credentialRef: 'runtime-access.json5',
+            requiredRoles: ['业务管理员'],
+        };
+        writeFileSync(testcasePath, `${JSON5.stringify(testcase, null, 2)}\n`, 'utf8');
+        writeFileSync(path.join(caseDir, 'runtime-access.json5'), `${JSON5.stringify([
+            {
+                directUrl: DIRECT_URL,
+                loginUrl: 'http://example.test/login',
+                systemName: '政务系统',
+                role: '业务管理员',
+                username: 'demo-user',
+                password: 'demo-password',
+            },
+        ], null, 2)}\n`, 'utf8');
+        const result = prepareAiRuntimeTasks(testcasePath);
+        const trace = JSON5.parse(readFileSync(result.tracePath, 'utf8'));
+        expect(trace.tasks.length).toBeGreaterThan(0);
+        expect(trace.tasks[0].entryContext).toMatchObject({
+            directUrl: DIRECT_URL,
+            loginUrl: 'http://example.test/login',
+            systemName: '政务系统',
+            role: '业务管理员',
+            username: 'demo-user',
+            password: 'demo-password',
+        });
+    });
+    it('凭据文件缺失时不崩溃，result.credentialsNotice 含提示', async () => {
+        const { testcasePath } = generateFixtures('req-cred');
+        // fixture 默认不产 credentials.json5（generate-testcase 产 credentials.template.json5）。
+        const result = await runRun({
+            testcase: testcasePath,
+            headless: true,
+        }, passingDeps());
+        expect(result.credentialsNotice).toMatch(/未找到凭据文件/);
+        expect(result.credentialsNotice).toContain(path.join(path.dirname(testcasePath), 'credentials.json5'));
+    });
+    it('已有 AI 追加段时重跑覆盖（幂等）', async () => {
+        const { testcasePath, specPath } = generateFixtures('req-idem');
+        // 第一次写入。
+        await runRun({ testcase: testcasePath, headless: true }, passingDeps());
+        // 注入一条"旧"标记文本，模拟历史追加段残留。
+        const afterFirst = readFileSync(specPath, 'utf8');
+        const injected = afterFirst.replace(AI_APPEND_MARKER, `${AI_APPEND_MARKER}\ntest("历史残留-不应保留", async () => {});`);
+        writeFileSync(specPath, injected, 'utf8');
+        // 第二次重跑。
+        await runRun({ testcase: testcasePath, headless: true }, passingDeps());
+        const body = readFileSync(specPath, 'utf8');
+        // 历史残留被擦掉。
+        expect(body).not.toMatch(/历史残留-不应保留/);
+        // marker 只出现一次（重跑不叠加）。
+        const markerCount = (body.match(/AI 钻探追加/g) ?? []).length;
+        expect(markerCount).toBe(1);
+    });
+    it('无法从 testcase.json5 定位测试项目目录时抛错', async () => {
+        const caseDir = path.join(tmpRoot, 'orphan-case');
+        mkdirSync(path.join(caseDir, '.ep-stage'), { recursive: true });
+        writeFileSync(path.join(caseDir, 'testcase.json5'), `${JSON5.stringify({
+            schemaVersion: 'ep-stage-testcase/v1-draft',
+            testcaseId: 'orphan',
+            contractRef: '.ep-stage/contract.json5',
+            scenario: 'crud',
+            moduleId: 'demo',
+            moduleName: '演示模块',
+            cases: [],
+            uncoveredCandidates: [],
+        }, null, 2)}\n`, 'utf8');
+        await expect(runRun({
+            testcase: path.join(caseDir, 'testcase.json5'),
+            headless: true,
+        })).rejects.toThrow(/无法从 testcase\.json5 定位测试项目目录/);
+    });
+    it('成功路径会合并 specSnippet、写 trace results 并执行完整 spec', async () => {
+        const { testcasePath, specPath, projectDir } = generateFixtures('req-success-loop');
+        const calls = [];
+        const result = await runRun({ testcase: testcasePath, headless: false }, {
+            ...passingDeps(),
+            executeFullSpec: async (input) => {
+                calls.push(input);
+                return { passed: true, output: 'ok' };
+            },
+        });
+        expect(calls).toEqual([{ projectDir, specPath, headless: false }]);
+        expect(result.aiRuntimeTracePath).toBe(path.join(path.dirname(testcasePath), '.ep-stage', 'ai-runtime-trace.json5'));
+        expect(result.repairReportPath).toBeUndefined();
+        const trace = JSON5.parse(readFileSync(result.aiRuntimeTracePath, 'utf8'));
+        expect(trace.results.length).toBeGreaterThan(0);
+        expect(trace.results[0].specSnippet).toContain('await test.step');
+    });
+    it('执行失败时写 repair report 并停止等待人审', async () => {
+        const { testcasePath, caseDir } = generateFixtures('req-fail-loop');
+        const result = await runRun({ testcase: testcasePath, headless: false }, {
+            ...passingDeps(),
+            executeFullSpec: async () => ({
+                passed: false,
+                output: 'Timeout 30000ms exceeded for locator(".submit")',
+            }),
+        });
+        expect(result.repairReportPath).toBe(path.join(caseDir, '.ep-stage', 'repair-runs', '001', 'repair-report.md'));
+        const report = readFileSync(result.repairReportPath, 'utf8');
+        expect(report).toContain('失败用例');
+        expect(report).toContain('locator_or_wait_error');
+        expect(report).toContain('需要你确认');
+        const trace = JSON5.parse(readFileSync(result.aiRuntimeTracePath, 'utf8'));
+        expect(trace.repairRounds).toEqual([
+            expect.objectContaining({
+                round: 1,
+                status: 'failed',
+                failureType: 'locator_or_wait_error',
+            }),
+        ]);
+    });
+    it('默认 executor 的 Playwright 命令从项目目录执行完整 spec', () => {
+        expect(buildPlaywrightCommand({
+            projectDir: '/tmp/project',
+            specPath: '/tmp/project/src/tests/req/crud.spec.ts',
+            headless: true,
+        })).toEqual({
+            command: 'npx',
+            args: ['playwright', 'test', '/tmp/project/src/tests/req/crud.spec.ts'],
+            cwd: '/tmp/project',
+        });
+        expect(buildPlaywrightCommand({
+            projectDir: '/tmp/project',
+            specPath: '/tmp/project/src/tests/req/crud.spec.ts',
+            headless: false,
+        }).args).toEqual(['playwright', 'test', '/tmp/project/src/tests/req/crud.spec.ts', '--headed']);
+    });
+});

package/dist/test/cli/spec.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=spec.test.d.ts.map

package/dist/test/cli/spec.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.test.d.ts","sourceRoot":"","sources":["../../../test/cli/spec.test.ts"],"names":[],"mappings":""}

package/dist/test/cli/spec.test.js

@@ -0,0 +1,112 @@
+/**
+ * spec.ts 单元测试（新协议 v1-draft，Task 4）。
+ *
+ * 覆盖：
+ * - parseSpecArgs 缺参 / 非法 / -- 分隔符
+ * - runSpec：
+ *   · 端到端：先 runGenerateTestcase 产 contract.json5 + testcase.json5，再 runSpec 装配 v1 .spec.ts；
+ *   · 产出含 test.describe、crudSlots（来自 skeletonSlots.crud）、
+ *     胶水模式生成 marker；
+ *   · spec.ts 不读 .ep-stage/contract.json（旧）；
+ *   · 门禁：cases[0].reviewStatus='needs_review' 时 runSpec 抛错。
+ */
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import JSON5 from 'json5';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { parseSpecArgs, runSpec } from '../../src/cli/spec.js';
+import { runGenerateTestcase } from '../../src/cli/generate-testcase.js';
+/** code_list.json5 fixture 路径（e2e 014 新协议样例）。 */
+const CODE_LIST_PATH = path.resolve(__dirname, '../../../../e2e/glue-code-mvp/src/tests/014-测试需求10-20260622/_docs/code_list.json5');
+const DIRECT_URL = 'http://example.test/epoint-web/perpage/zwplace/gxhzwplacelist.html';
+let tmpRoot;
+beforeEach(() => {
+    tmpRoot = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-spec-v1-'));
+});
+afterEach(() => {
+    // 留 tmpdir 给宿主清理。
+});
+/**
+ * 端到端产 contract.json5 + testcase.json5 到临时目录。
+ *
+ * @param testsDir - 临时 tests 目录。
+ * @returns testcase 路径 + spec 输出路径。
+ */
+function generateFixtures(testsDir) {
+    const result = runGenerateTestcase({ codeList: CODE_LIST_PATH, testsDir, directUrl: DIRECT_URL });
+    return { testcasePath: result.testcasePath, specOut: path.join(testsDir, 'crud.spec.ts') };
+}
+describe('parseSpecArgs', () => {
+    it('缺 --testcase 时抛错', () => {
+        expect(() => parseSpecArgs(['--out', '/x'])).toThrow(/缺少 --testcase/);
+    });
+    it('缺 --out 时抛错', () => {
+        expect(() => parseSpecArgs(['--testcase', '/x'])).toThrow(/缺少 --out/);
+    });
+    it('参数对非法时抛错', () => {
+        expect(() => parseSpecArgs(['--testcase'])).toThrow(/无效参数对/);
+    });
+    it('-- 分隔符被忽略', () => {
+        const args = parseSpecArgs(['--', '--testcase', '/a', '--out', '/b']);
+        expect(args).toEqual({ testcase: '/a', out: '/b' });
+    });
+});
+describe('runSpec（新协议 v1-draft）', () => {
+    it('端到端装配 v1 .spec.ts（含 marker + test.describe + crudSlots）', () => {
+        const testsDir = path.join(tmpRoot, 'requirement-014');
+        const { testcasePath, specOut } = generateFixtures(testsDir);
+        const result = runSpec({ testcase: testcasePath, out: specOut });
+        expect(result).toEqual({ specPath: specOut, version: 'v1' });
+        expect(existsSync(specOut)).toBe(true);
+        const body = readFileSync(specOut, 'utf8');
+        // 头部 marker（基于 contract.skeletonSlots + glue cases）。
+        expect(body).toMatch(/^\/\/ === 胶水模式生成（基于 contract\.skeletonSlots \+ glue cases）===/);
+        // Playwright test.describe 入口。
+        expect(body).toMatch(/test\.describe\(/);
+        // crudSlots 来自 contract.scenario.skeletonSlots.crud（moduleId=zwplace）。
+        expect(body).toMatch(/crudSlots: CrudFlowSlots/);
+        expect(body).toContain("'zwplace'");
+        // 模块名（场所窗口信息管理）出现在 suite 标题。
+        expect(body).toContain('场所窗口信息管理');
+    });
+    it('spec.ts 不读旧 .ep-stage/contract.json（仅消费 contract.json5）', () => {
+        const testsDir = path.join(tmpRoot, 'requirement-no-old-contract');
+        const { testcasePath, specOut } = generateFixtures(testsDir);
+        // 显式确保不存在旧 contract.json（只有 contract.json5）。
+        const oldContract = path.join(testsDir, '.ep-stage', 'contract.json');
+        expect(existsSync(oldContract)).toBe(false);
+        // 仍能正常装配（说明只依赖 contract.json5）。
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).not.toThrow();
+    });
+    it('缺 .ep-stage/contract.json5 时抛错引导（中文）', () => {
+        const testsDir = path.join(tmpRoot, 'requirement-missing');
+        const { testcasePath } = generateFixtures(testsDir);
+        // 复制一份合法 testcase 到不含 .ep-stage 目录的位置，制造 locateContract 返回 null。
+        const fakeTestsDir = path.join(tmpRoot, 'requirement-fake');
+        mkdirSync(fakeTestsDir, { recursive: true });
+        const fakeTestcase = path.join(fakeTestsDir, 'testcase.json5');
+        writeFileSync(fakeTestcase, readFileSync(testcasePath, 'utf8'), 'utf8');
+        expect(() => runSpec({ testcase: fakeTestcase, out: path.join(fakeTestsDir, 'out.spec.ts') })).toThrow(/未找到.*contract\.json5/);
+    });
+    it('门禁：cases[0].reviewStatus=needs_review 时 runSpec 抛错', () => {
+        const testsDir = path.join(tmpRoot, 'requirement-gate');
+        const { testcasePath, specOut } = generateFixtures(testsDir);
+        // 读出 testcase，把第一条 case 的 reviewStatus 改成 needs_review 后回写。
+        const testcase = JSON5.parse(readFileSync(testcasePath, 'utf8'));
+        testcase.cases[0].reviewStatus = 'needs_review';
+        writeFileSync(testcasePath, JSON5.stringify(testcase, null, 2), 'utf8');
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).toThrow(/未确认用例/);
+    });
+    it('门禁不阻断 uncoveredCandidates 的 ai/blocked（014 默认产线应通过）', () => {
+        // 014 默认装配产 6 条 uncoveredCandidates（含 blocked），
+        // runSpec 仍应正常装配，验证门禁不因 gap 候选阻断。
+        const testsDir = path.join(tmpRoot, 'requirement-gap-pass');
+        const { testcasePath, specOut } = generateFixtures(testsDir);
+        const testcase = JSON5.parse(readFileSync(testcasePath, 'utf8'));
+        // 确认 fixture 含 ai/blocked 候选（否则断言无意义）。
+        const hasAiBlocked = testcase.uncoveredCandidates.some((c) => c.generationStrategy === 'ai' && c.coverageStatus === 'blocked');
+        expect(hasAiBlocked).toBe(true);
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).not.toThrow();
+    });
+});

package/dist/test/code-list-json5.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=code-list-json5.test.d.ts.map

package/dist/test/code-list-json5.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-list-json5.test.d.ts","sourceRoot":"","sources":["../../test/code-list-json5.test.ts"],"names":[],"mappings":""}

package/dist/test/code-list-json5.test.js

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { assertCodeListJson5Path, extractCodeListJson5, extractCodeListJson5Object, } from '../src/extractors/code-list-json5.js';
+function writeJson5Fixture(body) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ep-stage-code-list-json5-'));
+    const file = path.join(dir, 'code_list.json5');
+    fs.writeFileSync(file, body, 'utf8');
+    return file;
+}
+describe('code_list.json5 extractor', () => {
+    it('读取新协议 queryFields，不要求旧 searchConditions / roles.menuPath', () => {
+        const fixture = writeJson5Fixture(`{
+      module: 'zwplace',
+      moduleName: '场所窗口信息管理',
+      systems: [{ name: '集成受理平台' }],
+      pages: [
+        {
+          role: 'list',
+          path: 'src/main/webapp/perpage/zwplace/gxhzwplacelist.html',
+          directUrl: 'http://example/page-list',
+          description: '列表页',
+          queryFields: [
+            { label: '场所名称', type: 'input', bind: 'dataBean.placename' },
+            { label: '场所分类', type: 'listbox', modelRef: 'placecategoryModel' },
+            { label: '状态', type: 'listbox', modelRef: 'statusModel' },
+          ],
+          buttons: [],
+          rowActions: [],
+        },
+      ],
+    }`);
+        const result = extractCodeListJson5(fixture);
+        expect(result.module).toBe('zwplace');
+        expect(result.moduleName).toBe('场所窗口信息管理');
+        expect(result.roles).toEqual([]);
+        expect(result.pages.find((p) => p.role === 'list')?.directUrl).toBe('http://example/page-list');
+        expect(result.pages.find((p) => p.role === 'list')?.queryFields?.map((i) => i.label))
+            .toEqual(['场所名称', '场所分类', '状态']);
+    });
+    it('rejects markdown code_list inputs', () => {
+        expect(() => assertCodeListJson5Path('/tmp/code_list.md'))
+            .toThrow('glue-generate-testcase 只接受 _docs/code_list.json5');
+    });
+    it('extracts optional testAccess systems and roles from code_list object', () => {
+        const extracted = extractCodeListJson5Object({
+            schemaVersion: 'ep-stage-code-list/v1-draft',
+            requirement: { id: '014', title: '测试需求' },
+            module: 'zwplace',
+            moduleName: '场所窗口信息管理',
+            systems: [{ name: '政务系统' }],
+            pages: [],
+            testAccess: {
+                systems: [
+                    {
+                        systemName: '政务系统',
+                        loginUrl: 'http://example/login',
+                        roles: [
+                            {
+                                role: '业务管理员',
+                                username: 'yz',
+                                password: 'secret',
+                                permissions: ['新增'],
+                            },
+                        ],
+                    },
+                ],
+            },
+        });
+        expect(extracted.testAccess?.systems?.[0]?.roles[0]?.password).toBe('secret');
+    });
+    it('rejects malformed testAccess systems structure', () => {
+        expect(() => extractCodeListJson5Object({
+            module: 'zwplace',
+            moduleName: '场所窗口信息管理',
+            systems: [{ name: '政务系统' }],
+            pages: [],
+            testAccess: {
+                systems: 'bad',
+            },
+        })).toThrow(/testAccess\.systems/);
+    });
+});

package/dist/test/code-list.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=code-list.test.d.ts.map

package/dist/test/code-list.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-list.test.d.ts","sourceRoot":"","sources":["../../test/code-list.test.ts"],"names":[],"mappings":""}