@epoint-testtech/ep-stage-skill 0.0.3-alpha.2 → 0.0.4-alpha.1

package/dist/test/cli/generate-testcase.test.js

@@ -0,0 +1,130 @@
+/**
+ * generate-testcase.ts 单元测试。
+ *
+ * 覆盖：
+ * - parseGenerateTestcaseArgs 缺参 / 非法参数对 / -- 分隔符
+ * - decideScenario 3 档优先级（CLI 参数 / hints / 默认）
+ * - renderTestcaseMarkdown：i18n 字段名 / 状态值；硬编码「未确认项」标题；
+ *   `unresolved` 字段标题与状态值映射不冲突。
+ *
+ * 端到端 testcase 子命令（含 probe / 文件落盘）依赖主仓 knowledge-project 物料，
+ * 由 Phase 5 真机验收覆盖，此处不重复。
+ */
+import { describe, expect, it } from 'vitest';
+import { decideScenario, parseGenerateTestcaseArgs, renderTestcaseMarkdown, } from '../../src/cli/generate-testcase.js';
+function makeTestcase(overrides = {}) {
+    return {
+        schemaVersion: 'v2',
+        scenario: 'crud.single-page',
+        moduleId: 'zwplace',
+        moduleName: '场所窗口信息管理',
+        menuPath: '业务管理 > 场所窗口信息',
+        requiredSystems: [{ url: 'https://example.com', systemName: '示例系统' }],
+        requiredRoles: [{ role: 'admin', hint: '后台管理员' }],
+        coveredActions: [
+            { actionId: 'create', kind: '新增', evidence: ['contract=crud-business-module/v1'] },
+        ],
+        uncoveredCandidates: [
+            {
+                actionId: 'export',
+                label: '导出 CSV',
+                status: 'planned',
+                requiredRole: 'admin',
+                businessIntent: '导出列表为 CSV 文件',
+                assertionExpectation: '下载完成且文件非空',
+                evidence: ['contract=crud-business-module/v1'],
+            },
+        ],
+        cases: [
+            {
+                caseId: 'zwplace.create',
+                title: '新增场所窗口',
+                scenario: 'crud.single-page',
+                reviewStatus: 'needs_review',
+                requiredRole: 'admin',
+                evidence: ['contract=crud-business-module/v1'],
+                steps: ['打开新增弹窗', '提交表单'],
+                assertions: ['弹窗关闭', '列表多一条'],
+                unresolved: ['菜单路径待确认'],
+            },
+        ],
+        reasoningSummary: {
+            conclusion: '基于契约推理生成 1 条用例',
+            evidenceChain: ['contract=crud-business-module/v1'],
+            alternatives: [],
+            confidence: 'medium',
+            risks: [],
+            needsHumanReview: true,
+        },
+        ...overrides,
+    };
+}
+describe('parseGenerateTestcaseArgs', () => {
+    it('缺 --code-list 时抛错', () => {
+        expect(() => parseGenerateTestcaseArgs(['--tests-dir', '/x'])).toThrow(/缺少 --code-list/);
+    });
+    it('缺 --tests-dir 时抛错', () => {
+        expect(() => parseGenerateTestcaseArgs(['--code-list', '/x'])).toThrow(/缺少 --tests-dir/);
+    });
+    it('参数对非法时抛错', () => {
+        expect(() => parseGenerateTestcaseArgs(['--code-list'])).toThrow(/无效参数对/);
+    });
+    it('-- 分隔符被忽略', () => {
+        const args = parseGenerateTestcaseArgs(['--', '--code-list', '/a', '--tests-dir', '/b']);
+        expect(args.codeList).toBe('/a');
+        expect(args.testsDir).toBe('/b');
+    });
+    it('解析 scenario / hints / project-dir / requirement-dir', () => {
+        const args = parseGenerateTestcaseArgs([
+            '--code-list', '/a',
+            '--tests-dir', '/b',
+            '--scenario', 'statistic',
+            '--hints', '/h.json',
+            '--project-dir', '/p',
+            '--requirement-dir', '/r',
+        ]);
+        expect(args.scenario).toBe('statistic');
+        expect(args.hints).toBe('/h.json');
+        expect(args.projectDir).toBe('/p');
+        expect(args.requirementDir).toBe('/r');
+    });
+});
+describe('decideScenario 3 档优先级', () => {
+    it('①档 --scenario CLI 参数优先', () => {
+        expect(decideScenario({ codeList: '', testsDir: '', scenario: 'approval', hints: '/path?scenario=statistic' })).toBe('approval');
+    });
+    it('②档 hints 路径含 scenario=', () => {
+        expect(decideScenario({ codeList: '', testsDir: '', hints: '/path?scenario=statistic.kpi' })).toBe('statistic.kpi');
+    });
+    it('③档默认 crud.single-page', () => {
+        expect(decideScenario({ codeList: '', testsDir: '' })).toBe('crud.single-page');
+    });
+    it('hints 路径不含 scenario= 时回落默认', () => {
+        expect(decideScenario({ codeList: '', testsDir: '', hints: '/h.json' })).toBe('crud.single-page');
+    });
+});
+describe('renderTestcaseMarkdown', () => {
+    it('字段名翻译为中文', () => {
+        const md = renderTestcaseMarkdown(makeTestcase());
+        expect(md).toMatch(/场景类型：单页 CRUD/);
+        expect(md).toMatch(/菜单路径：业务管理/);
+        expect(md).toMatch(/操作角色：admin/);
+        expect(md).toMatch(/骨架已命中动作/);
+        expect(md).toMatch(/骨架未命中候选/);
+    });
+    it('状态值翻译为中文', () => {
+        const md = renderTestcaseMarkdown(makeTestcase());
+        expect(md).toMatch(/状态：已计划/); // planned
+        expect(md).toMatch(/审阅状态：待审阅/); // needs_review
+    });
+    it('未确认项字段标题硬编码「未确认项」（不被状态值映射污染）', () => {
+        const md = renderTestcaseMarkdown(makeTestcase());
+        expect(md).toMatch(/未确认项：菜单路径待确认/);
+        // i18nTestcase('unresolved') 仍为「未解决」，不允许出现在字段标题位置
+        expect(md).not.toMatch(/^\s*-\s+未解决：/m);
+    });
+    it('无 uncoveredCandidates 时显示「（无）」', () => {
+        const md = renderTestcaseMarkdown(makeTestcase({ uncoveredCandidates: [] }));
+        expect(md).toMatch(/骨架未命中候选\n（无）/);
+    });
+});

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

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

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

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

package/dist/test/cli/index.test.js

@@ -0,0 +1,113 @@
+/**
+ * src/cli/index.ts 路由测试（REQ-CLI-02 修订）。
+ *
+ * 覆盖：
+ * - --help / -h 打印 testcase / spec / run 3 子命令且不含 contract
+ * - 未知子命令 → process.exit(1)
+ * - 路由到 parseGenerateTestcaseArgs / parseSpecArgs / parseRunArgs
+ *
+ * 用 vi.mock 替换 generate-testcase / spec / run 模块，避免占位 throw 干扰路由判定。
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, symlinkSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const generateTestcase = vi.hoisted(() => ({
+    parseGenerateTestcaseArgs: vi.fn((argv) => ({ codeList: 'parsed', testsDir: argv.join(' ') })),
+    runGenerateTestcase: vi.fn(() => 'TESTCASE_OK'),
+}));
+const spec = vi.hoisted(() => ({
+    parseSpecArgs: vi.fn((argv) => ({ testcase: 'parsed', out: argv.join(' ') })),
+    runSpec: vi.fn(() => 'SPEC_OK'),
+}));
+const run = vi.hoisted(() => ({
+    parseRunArgs: vi.fn((argv) => ({ spec: 'parsed', testcase: argv.join(' '), headless: true })),
+    runRun: vi.fn(async () => 'RUN_OK'),
+}));
+vi.mock('../../src/cli/generate-testcase.js', () => generateTestcase);
+vi.mock('../../src/cli/spec.js', () => spec);
+vi.mock('../../src/cli/run.js', () => run);
+const { main, printHelp } = await import('../../src/cli/index.js');
+describe('ep-stage-skill CLI 路由', () => {
+    let logSpy;
+    let errSpy;
+    let exitSpy;
+    beforeEach(() => {
+        logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
+        errSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
+        exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code) => {
+            throw new Error(`__exit_${code ?? 0}__`);
+        }));
+    });
+    afterEach(() => {
+        logSpy.mockRestore();
+        errSpy.mockRestore();
+        exitSpy.mockRestore();
+        vi.clearAllMocks();
+    });
+    it('--help 打印 3 子命令 testcase/spec/run 且不注册 contract 子命令', async () => {
+        await main(['node', 'cli', '--help']);
+        const printed = logSpy.mock.calls.flat().join('\n');
+        expect(printed).toMatch(/ep-stage-skill testcase /);
+        expect(printed).toMatch(/ep-stage-skill spec /);
+        expect(printed).toMatch(/ep-stage-skill run /);
+        // 反向断言：不存在 `ep-stage-skill contract` 子命令入口
+        expect(printed).not.toMatch(/ep-stage-skill contract\b/);
+    });
+    it('-h 等价于 --help', async () => {
+        await main(['node', 'cli', '-h']);
+        expect(logSpy.mock.calls.flat().join('\n')).toMatch(/testcase/);
+    });
+    it('无参数时打印 help（不 exit）', async () => {
+        await main(['node', 'cli']);
+        expect(logSpy.mock.calls.flat().join('\n')).toMatch(/testcase/);
+        expect(exitSpy).not.toHaveBeenCalled();
+    });
+    it('printHelp 不注册 contract 子命令', () => {
+        printHelp();
+        expect(logSpy.mock.calls.flat().join('\n')).not.toMatch(/ep-stage-skill contract\b/);
+    });
+    it('未知子命令 exit 1 + stderr', async () => {
+        await expect(main(['node', 'cli', 'unknown-cmd'])).rejects.toThrow(/__exit_1__/);
+        expect(errSpy.mock.calls.flat().join('\n')).toMatch(/未知子命令/);
+    });
+    it('testcase 子命令路由到 runGenerateTestcase', async () => {
+        const result = await main(['node', 'cli', 'testcase', '--code-list', '/x']);
+        expect(generateTestcase.parseGenerateTestcaseArgs).toHaveBeenCalledWith(['--code-list', '/x']);
+        expect(generateTestcase.runGenerateTestcase).toHaveBeenCalled();
+        expect(result).toBe('TESTCASE_OK');
+    });
+    it('spec 子命令路由到 runSpec', async () => {
+        const result = await main(['node', 'cli', 'spec', '--testcase', '/t', '--out', '/o']);
+        expect(spec.parseSpecArgs).toHaveBeenCalledWith(['--testcase', '/t', '--out', '/o']);
+        expect(spec.runSpec).toHaveBeenCalled();
+        expect(result).toBe('SPEC_OK');
+    });
+    it('run 子命令路由到 runRun', async () => {
+        const result = await main(['node', 'cli', 'run', '--spec', '/s', '--testcase', '/t']);
+        expect(run.parseRunArgs).toHaveBeenCalledWith(['--spec', '/s', '--testcase', '/t']);
+        expect(run.runRun).toHaveBeenCalled();
+        expect(result).toBe('RUN_OK');
+    });
+    it('-- 分隔符被忽略', async () => {
+        await main(['node', 'cli', 'testcase', '--', '--code-list', '/x']);
+        expect(generateTestcase.parseGenerateTestcaseArgs).toHaveBeenCalledWith(['--code-list', '/x']);
+    });
+    it('软链 CLI 入口也应识别为直接执行', async () => {
+        const mod = await import('../../src/cli/index.js');
+        const tmpDir = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-skill-cli-'));
+        const realEntry = path.join(tmpDir, 'dist', 'src', 'cli', 'index.js');
+        const binEntry = path.join(tmpDir, '.bin', 'ep-stage-skill');
+        try {
+            mkdirSync(path.dirname(realEntry), { recursive: true });
+            mkdirSync(path.dirname(binEntry), { recursive: true });
+            writeFileSync(realEntry, '// mock cli entry\n', 'utf8');
+            symlinkSync(realEntry, binEntry);
+            expect(mod.isDirectExecution(pathToFileURL(realEntry).href, binEntry)).toBe(true);
+        }
+        finally {
+            rmSync(tmpDir, { recursive: true, force: true });
+        }
+    });
+});

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

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

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

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

package/dist/test/cli/probe.test.js

@@ -0,0 +1,31 @@
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { runProbeAndCoverage } from '../../src/cli/probe.js';
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../../..');
+const knowledgeRoot = join(repoRoot, 'knowledge-project/epoint-web-v9.5.2');
+const requirementDir = join(knowledgeRoot, '_docs/014-测试需求10-20260622');
+const codeListPath = join(requirementDir, 'code_list.md');
+const webappDir = join(knowledgeRoot, 'src/main/webapp/perpage/zwplace');
+const javaActionsDir = join(knowledgeRoot, 'src/main/java/com/epoint/zwplace/action');
+describe('runProbeAndCoverage spec fallback', () => {
+    it('在 code_list 缺少 spec.yaml 与 module-hints 时，仍能基于 HTML/Java 生成可审阅 testcase', () => {
+        const result = runProbeAndCoverage({
+            moduleId: 'zwplace',
+            codeListPath,
+            docsDir: requirementDir,
+            webappDir,
+            javaActionsDir,
+            scenario: 'crud.single-page',
+        });
+        expect(result.contract.dataKey.field).toBe('placename');
+        expect(result.contract.searchConditions?.[0]?.field).toBe('placename');
+        // 推理 hints 流入后，dataKey 已解析为 placename；unresolvedSlots 只剩非 dataKey 项。
+        expect(result.contract.unresolvedSlots.map((slot) => slot.slotId)).not.toContain('dataKey.selectedField');
+        expect(result.testcaseV2.moduleId).toBe('zwplace');
+        expect(result.testcaseV2.cases).toHaveLength(4);
+        // Task 3: inference trace 随 probe 返回。
+        expect(result.inferenceTrace.schemaVersion).toBe('inference-trace/v1');
+        expect(result.inferenceTrace.moduleHintsInference.dataKey.selectedField).toBe('placename');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,149 @@
+/**
+ * run.ts 单元测试（REQ-CHAIN-02 / REQ-SPEC-01）。
+ *
+ * 覆盖：
+ * - parseRunArgs 缺参 / 非法 / --headless 默认 true / --headless false 关闭无头；
+ * - runRun：
+ *   · v1 spec → 追加 AI 段产 v2（含 AI_APPEND_MARKER）；
+ *   · 已有 AI 追加段时重跑覆盖（幂等）；
+ *   · planned 为空时擦掉历史追加段（幂等收敛）；
+ *   · 不存在 spec 时抛错；
+ *   · 报告目录基于 projectDir 推导（ISO 时间戳）。
+ */
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AI_APPEND_MARKER, parseRunArgs, runRun } from '../../src/cli/run.js';
+let tmpRoot;
+beforeEach(() => {
+    tmpRoot = mkdtempSync(path.join(os.tmpdir(), 'ep-stage-run-'));
+});
+function makeTestcase(plannedCount = 1) {
+    const uncoveredCandidates = Array.from({ length: plannedCount }, (_, i) => ({
+        actionId: `gap-${i}`,
+        label: `导出 CSV ${i}`,
+        status: 'planned',
+        requiredRole: 'admin',
+        businessIntent: `导出列表 ${i}`,
+        assertionExpectation: `下载完成 ${i}`,
+        evidence: ['contract=crud-business-module/v1'],
+    }));
+    return {
+        schemaVersion: 'v2',
+        scenario: 'crud.single-page',
+        moduleId: 'zwplace',
+        moduleName: '场所窗口信息管理',
+        menuPath: '业务管理 > 场所',
+        requiredSystems: [{ url: '' }],
+        requiredRoles: [{ role: 'admin' }],
+        coveredActions: [],
+        uncoveredCandidates,
+        cases: [
+            {
+                caseId: 'zwplace.create',
+                title: '新增',
+                scenario: 'crud.single-page',
+                reviewStatus: 'needs_review',
+                requiredRole: 'admin',
+                evidence: ['contract=crud-business-module/v1'],
+                steps: [],
+                assertions: [],
+                unresolved: [],
+            },
+        ],
+        reasoningSummary: {
+            conclusion: '',
+            evidenceChain: [],
+            alternatives: [],
+            confidence: 'medium',
+            risks: [],
+            needsHumanReview: true,
+        },
+    };
+}
+function writeFixtures(opts) {
+    const dir = path.join(tmpRoot, 'req');
+    mkdirSync(dir, { recursive: true });
+    const specPath = path.join(dir, 'crud.spec.ts');
+    const testcasePath = path.join(dir, 'testcase.json5');
+    writeFileSync(specPath, opts.specBody, 'utf8');
+    writeFileSync(testcasePath, JSON.stringify(makeTestcase(opts.plannedCount ?? 1)), 'utf8');
+    return { specPath, testcasePath };
+}
+describe('parseRunArgs', () => {
+    it('缺 --spec 时抛错', () => {
+        expect(() => parseRunArgs(['--testcase', '/x'])).toThrow(/缺少 --spec/);
+    });
+    it('缺 --testcase 时抛错', () => {
+        expect(() => parseRunArgs(['--spec', '/x'])).toThrow(/缺少 --testcase/);
+    });
+    it('参数对非法时抛错', () => {
+        expect(() => parseRunArgs(['--spec'])).toThrow(/无效参数对/);
+    });
+    it('--headless 默认 true', () => {
+        const args = parseRunArgs(['--spec', '/s', '--testcase', '/t']);
+        expect(args.headless).toBe(true);
+    });
+    it('--headless false 关闭无头', () => {
+        const args = parseRunArgs(['--spec', '/s', '--testcase', '/t', '--headless', 'false']);
+        expect(args.headless).toBe(false);
+    });
+    it('--project-dir 透传', () => {
+        const args = parseRunArgs(['--spec', '/s', '--testcase', '/t', '--project-dir', '/p']);
+        expect(args.projectDir).toBe('/p');
+    });
+});
+describe('runRun', () => {
+    it('v1 spec 追加 AI 段产 v2', async () => {
+        const v1Body = '// === 胶水模式生成 ===\nconst x = 1;\n';
+        const { specPath, testcasePath } = writeFixtures({ specBody: v1Body });
+        const result = await runRun({
+            spec: specPath,
+            testcase: testcasePath,
+            headless: true,
+            projectDir: tmpRoot,
+        });
+        expect(result.version).toBe('v1-with-planned-stubs');
+        const body = readFileSync(specPath, 'utf8');
+        expect(body).toContain(AI_APPEND_MARKER);
+        expect(body).toMatch(/test\("导出 CSV 0"/);
+        expect(body).toMatch(/requiredRole: admin/);
+        expect(result.reportDir.startsWith(path.join(tmpRoot, 'e2e/glue-code-mvp/glue-report'))).toBe(true);
+    });
+    it('已有 AI 追加段时重跑覆盖（幂等）', async () => {
+        const v1Body = '// === 胶水模式生成 ===\nconst x = 1;\n';
+        const oldAppended = `\n\n${AI_APPEND_MARKER}\ntest("旧追加段", async () => {});\n`;
+        const { specPath, testcasePath } = writeFixtures({ specBody: v1Body + oldAppended });
+        await runRun({ spec: specPath, testcase: testcasePath, headless: true });
+        const body = readFileSync(specPath, 'utf8');
+        // 旧追加段被擦掉，只剩当次推理结果
+        expect(body).not.toMatch(/旧追加段/);
+        // 标记只出现一次（重跑不叠加）
+        expect(body.match(/AI 钻探追加/g)?.length).toBe(1);
+        expect(body).toMatch(/test\("导出 CSV 0"/);
+    });
+    it('planned 为空时擦掉历史追加段（幂等收敛）', async () => {
+        const v1Body = '// === 胶水模式生成 ===\nconst x = 1;';
+        const oldAppended = `\n\n${AI_APPEND_MARKER}\ntest("旧", async () => {});\n`;
+        const { specPath, testcasePath } = writeFixtures({
+            specBody: v1Body + oldAppended,
+            plannedCount: 0,
+        });
+        await runRun({ spec: specPath, testcase: testcasePath, headless: true });
+        const body = readFileSync(specPath, 'utf8');
+        expect(body).not.toContain(AI_APPEND_MARKER);
+        expect(body).not.toMatch(/旧追加段|旧/);
+    });
+    it('spec 不存在时抛错', async () => {
+        const dir = path.join(tmpRoot, 'r2');
+        mkdirSync(dir, { recursive: true });
+        const testcasePath = path.join(dir, 'testcase.json5');
+        writeFileSync(testcasePath, JSON.stringify(makeTestcase()), 'utf8');
+        await expect(runRun({
+            spec: path.join(dir, 'missing.spec.ts'),
+            testcase: testcasePath,
+            headless: true,
+        })).rejects.toThrow(/spec 不存在/);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,198 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import JSON5 from 'json5';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+// 边界测试目的：验证 runSpec 只消费 testcase.json5 + contract.json，不消费 inference-trace.json。
+// 因此 mock 掉 generateStageSkeletonCrudSpec，隔离骨架生成器的实现细节（避免 fixture 不完整导致崩溃）。
+vi.mock('../../src/generators/stage-skeleton-script.js', () => ({
+    generateStageSkeletonCrudSpec: vi.fn(() => '// skeleton stub\n'),
+}));
+import { generateStageSkeletonCrudSpec } from '../../src/generators/stage-skeleton-script.js';
+import { runSpec } from '../../src/cli/spec.js';
+/** 构造一份最小可用的 testcase v2 对象（用例与未覆盖项均为空 → 空数组满足门禁）。 */
+function makeBaseTestcase(overrides = {}) {
+    return {
+        schemaVersion: 'v2',
+        scenario: 'crud.single-page',
+        moduleId: 'm1',
+        moduleName: '模块',
+        menuPath: '一级>二级',
+        requiredSystems: [{ url: '', systemName: undefined }],
+        requiredRoles: [{ role: 'admin', hint: undefined }],
+        coveredActions: [],
+        uncoveredCandidates: [],
+        cases: [],
+        reasoningSummary: {
+            conclusion: 'ok',
+            evidenceChain: [],
+            alternatives: [],
+            confidence: 'high',
+            risks: [],
+            needsHumanReview: false,
+        },
+        ...overrides,
+    };
+}
+/** 构造一份最小 contract（mock 了生成器，结构不需 skeleton 完备）。 */
+function makeBaseContract(overrides = {}) {
+    return {
+        contractVersion: 'crud-business-module/v1',
+        module: { id: 'm1', label: '模块' },
+        pages: { list: { pageId: 'list', role: 'list', title: '列表', fields: [], buttons: [], grids: [] } },
+        dataKey: { field: 'name', label: '名称', availability: 'human_required', generationStrategy: 'human_required', sources: [] },
+        searchConditions: [],
+        flows: {},
+        assertions: [],
+        businessRules: [],
+        agentInferredWorkflows: [],
+        unresolvedSlots: [],
+        ...overrides,
+    };
+}
+describe('runSpec input boundary', () => {
+    let tmpDir = '';
+    beforeEach(() => {
+        vi.mocked(generateStageSkeletonCrudSpec).mockClear();
+    });
+    afterEach(() => {
+        if (tmpDir)
+            rmSync(tmpDir, { recursive: true, force: true });
+        tmpDir = '';
+    });
+    /** 在 tmpDir/case 下铺好 testcase + contract 文件，返回路径句柄。 */
+    function setupFixture(testcase, contract, opts) {
+        tmpDir = mkdtempSync(join(tmpdir(), 'ep-stage-spec-boundary-'));
+        const testsDir = join(tmpDir, 'case');
+        mkdirSync(join(testsDir, '.ep-stage'), { recursive: true });
+        const testcasePath = join(testsDir, 'testcase.json5');
+        const specOut = join(testsDir, 'crud.spec.ts');
+        writeFileSync(testcasePath, JSON5.stringify(testcase, null, 2), 'utf8');
+        writeFileSync(join(testsDir, '.ep-stage', 'contract.json'), JSON.stringify(contract, null, 2), 'utf8');
+        if (opts?.writeTrace) {
+            writeFileSync(join(testsDir, '.ep-stage', 'inference-trace.json'), '{"broken": true}\n', 'utf8');
+        }
+        return { testcasePath, specOut, testsDir };
+    }
+    it('不依赖 inference-trace.json，只消费 testcase.json5 与 contract.json（REQ-INFER-008）', () => {
+        // 写一份 trace 后立即删除，断言 runSpec 不依赖它
+        const { testcasePath, specOut, testsDir } = setupFixture(makeBaseTestcase(), makeBaseContract(), { writeTrace: true });
+        rmSync(join(testsDir, '.ep-stage', 'inference-trace.json'), { force: true });
+        const result = runSpec({ testcase: testcasePath, out: specOut });
+        expect(result.specPath).toBe(specOut);
+        expect(generateStageSkeletonCrudSpec).toHaveBeenCalledTimes(1);
+    });
+    it('缺失 contract.json 时抛中文错误，引导先跑 testcase（REQ-INFER-006）', () => {
+        const { testcasePath, specOut } = setupFixture(makeBaseTestcase(), makeBaseContract());
+        // 删掉 contract.json
+        rmSync(join(tmpDir, 'case', '.ep-stage', 'contract.json'));
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).toThrow(/contract\.json/);
+        expect(generateStageSkeletonCrudSpec).not.toHaveBeenCalled();
+    });
+    it('testcase 存在 needs_review 用例时阻断 spec 组装（REQ-INFER-007）', () => {
+        const testcase = makeBaseTestcase({
+            cases: [
+                {
+                    caseId: 'c1',
+                    title: 't',
+                    scenario: 's',
+                    reviewStatus: 'needs_review',
+                    requiredRole: 'admin',
+                    evidence: [],
+                    steps: [],
+                    assertions: [],
+                    unresolved: [],
+                },
+            ],
+        });
+        const { testcasePath, specOut } = setupFixture(testcase, makeBaseContract());
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).toThrow(/未确认用例.*needs_review\/blocked/);
+        expect(generateStageSkeletonCrudSpec).not.toHaveBeenCalled();
+    });
+    it('testcase 存在 blocked 用例时阻断 spec 组装（REQ-INFER-007）', () => {
+        const testcase = makeBaseTestcase({
+            cases: [
+                {
+                    caseId: 'c1',
+                    title: 't',
+                    scenario: 's',
+                    reviewStatus: 'blocked',
+                    requiredRole: 'admin',
+                    evidence: [],
+                    steps: [],
+                    assertions: [],
+                    unresolved: [],
+                },
+            ],
+        });
+        const { testcasePath, specOut } = setupFixture(testcase, makeBaseContract());
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).toThrow(/未确认用例.*needs_review\/blocked/);
+    });
+    it('testcase 存在 unresolved 未覆盖项时阻断 spec 组装（REQ-INFER-007）', () => {
+        const testcase = makeBaseTestcase({
+            uncoveredCandidates: [
+                {
+                    actionId: 'a1',
+                    label: 'l',
+                    status: 'unresolved',
+                    requiredRole: 'admin',
+                    businessIntent: 'b',
+                    assertionExpectation: 'e',
+                    evidence: [],
+                },
+            ],
+        });
+        const { testcasePath, specOut } = setupFixture(testcase, makeBaseContract());
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).toThrow(/candidate\/unresolved 未覆盖项/);
+        expect(generateStageSkeletonCrudSpec).not.toHaveBeenCalled();
+    });
+    it('testcase 存在 candidate 未覆盖项时阻断 spec 组装（REQ-INFER-007）', () => {
+        const testcase = makeBaseTestcase({
+            uncoveredCandidates: [
+                {
+                    actionId: 'a1',
+                    label: 'l',
+                    status: 'candidate',
+                    requiredRole: 'admin',
+                    businessIntent: 'b',
+                    assertionExpectation: 'e',
+                    evidence: [],
+                },
+            ],
+        });
+        const { testcasePath, specOut } = setupFixture(testcase, makeBaseContract());
+        expect(() => runSpec({ testcase: testcasePath, out: specOut })).toThrow(/candidate\/unresolved 未覆盖项/);
+    });
+    it('全部 confirmed + planned/resolved 时正常组装（门禁 happy path）', () => {
+        const testcase = makeBaseTestcase({
+            cases: [
+                {
+                    caseId: 'c1',
+                    title: 't',
+                    scenario: 's',
+                    reviewStatus: 'confirmed',
+                    requiredRole: 'admin',
+                    evidence: [],
+                    steps: [],
+                    assertions: [],
+                    unresolved: [],
+                },
+            ],
+            uncoveredCandidates: [
+                {
+                    actionId: 'a1',
+                    label: 'l',
+                    status: 'planned',
+                    requiredRole: 'admin',
+                    businessIntent: 'b',
+                    assertionExpectation: 'e',
+                    evidence: [],
+                },
+            ],
+        });
+        const { testcasePath, specOut } = setupFixture(testcase, makeBaseContract());
+        const result = runSpec({ testcase: testcasePath, out: specOut });
+        expect(result.specPath).toBe(specOut);
+        expect(generateStageSkeletonCrudSpec).toHaveBeenCalledTimes(1);
+    });
+});

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":""}