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

package/dist/test/util/i18n-testcase.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from 'vitest';
+import { i18nTestcase } from '../../src/util/i18n-testcase.js';
+/**
+ * REQ-UX-03：testcase.json5 英文字段名 / 状态值 → testcase.md 中文显示文案。
+ * 映射表见 spec §4.6。CLI 写 testcase.md 时调用本 util；testcase.json5 内部字段名永远英文。
+ *
+ * 说明：`unresolved` 在 spec 表中同时出现于「字段名」(未确认项) 和「状态值」(未解决)，
+ * 这是已知冲突；当前实现以扁平 lookup 表为准（后者覆盖前者），见 i18nTestcase 注释。
+ */
+describe('i18nTestcase', () => {
+    describe('审阅状态值', () => {
+        it('confirmed → 已确认', () => {
+            expect(i18nTestcase('confirmed')).toBe('已确认');
+        });
+        it('needs_review → 待审阅', () => {
+            expect(i18nTestcase('needs_review')).toBe('待审阅');
+        });
+        it('blocked → 已阻断', () => {
+            expect(i18nTestcase('blocked')).toBe('已阻断');
+        });
+        it('planned → 已计划', () => {
+            expect(i18nTestcase('planned')).toBe('已计划');
+        });
+        it('candidate → 候选', () => {
+            expect(i18nTestcase('candidate')).toBe('候选');
+        });
+        it('resolved → 已解决', () => {
+            expect(i18nTestcase('resolved')).toBe('已解决');
+        });
+    });
+    describe('推荐动作值', () => {
+        it('infer → 推理', () => {
+            expect(i18nTestcase('infer')).toBe('推理');
+        });
+        it('supplement-hints → 补充 hints', () => {
+            expect(i18nTestcase('supplement-hints')).toBe('补充 hints');
+        });
+        it('skip → 跳过', () => {
+            expect(i18nTestcase('skip')).toBe('跳过');
+        });
+    });
+    describe('场景值', () => {
+        it('crud.single-page → 单页 CRUD', () => {
+            expect(i18nTestcase('crud.single-page')).toBe('单页 CRUD');
+        });
+        it('crud.nested → 嵌套 CRUD', () => {
+            expect(i18nTestcase('crud.nested')).toBe('嵌套 CRUD');
+        });
+        it('statistic → 统计视图', () => {
+            expect(i18nTestcase('statistic')).toBe('统计视图');
+        });
+        it('approval → 审批流', () => {
+            expect(i18nTestcase('approval')).toBe('审批流');
+        });
+    });
+    describe('字段名', () => {
+        it('caseId → 用例 ID', () => {
+            expect(i18nTestcase('caseId')).toBe('用例 ID');
+        });
+        it('actionId → 动作 ID', () => {
+            expect(i18nTestcase('actionId')).toBe('动作 ID');
+        });
+        it('scenario → 场景类型', () => {
+            expect(i18nTestcase('scenario')).toBe('场景类型');
+        });
+        it('menuPath → 菜单路径', () => {
+            expect(i18nTestcase('menuPath')).toBe('菜单路径');
+        });
+        it('requiredRole → 操作角色', () => {
+            expect(i18nTestcase('requiredRole')).toBe('操作角色');
+        });
+        it('requiredSystems → 需求系统集', () => {
+            expect(i18nTestcase('requiredSystems')).toBe('需求系统集');
+        });
+        it('requiredRoles → 需求角色集', () => {
+            expect(i18nTestcase('requiredRoles')).toBe('需求角色集');
+        });
+        it('coveredActions → 骨架已命中动作', () => {
+            expect(i18nTestcase('coveredActions')).toBe('骨架已命中动作');
+        });
+        it('uncoveredCandidates → 骨架未命中候选', () => {
+            expect(i18nTestcase('uncoveredCandidates')).toBe('骨架未命中候选');
+        });
+        it('businessIntent → 业务意图', () => {
+            expect(i18nTestcase('businessIntent')).toBe('业务意图');
+        });
+        it('assertionExpectation → 预期断言', () => {
+            expect(i18nTestcase('assertionExpectation')).toBe('预期断言');
+        });
+        it('recommendedAction → 推荐动作', () => {
+            expect(i18nTestcase('recommendedAction')).toBe('推荐动作');
+        });
+        it('reviewStatus → 审阅状态', () => {
+            expect(i18nTestcase('reviewStatus')).toBe('审阅状态');
+        });
+        it('evidence → 证据', () => {
+            expect(i18nTestcase('evidence')).toBe('证据');
+        });
+    });
+    describe('未知值兜底', () => {
+        it('未知值原样返回', () => {
+            expect(i18nTestcase('some-unknown-value')).toBe('some-unknown-value');
+        });
+        it('空字符串原样返回', () => {
+            expect(i18nTestcase('')).toBe('');
+        });
+        it('英文字段名未在表中时原样返回', () => {
+            expect(i18nTestcase('createdAt')).toBe('createdAt');
+        });
+    });
+    describe('unresolved 冲突（已知 trade-off）', () => {
+        // spec §4.6 中 `unresolved` 同时是字段名（未确认项）和状态值（未解决）。
+        // 扁平 lookup 表无法同时持有两个映射，后定义的状态值覆盖字段名。
+        // 字段名场景下 CLI 可在调用前对 key 做硬编码标签替换；此 util 保留单值兜底。
+        it('unresolved → 未解决（状态值优先）', () => {
+            expect(i18nTestcase('unresolved')).toBe('未解决');
+        });
+    });
+});

package/dist/test/util/softlink.test.d.ts

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

package/dist/test/util/softlink.test.d.ts.map

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

package/dist/test/util/softlink.test.js

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync, existsSync, readFileSync, lstatSync, mkdirSync, symlinkSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createSoftlinkWithFallback, softlinkFs } from '../../src/util/softlink.js';
+/**
+ * REQ-FILE-02：跨平台软链 fallback util
+ * 三档 fallback：symlink（macOS/Linux）→ hardlink → copy + 时间戳警示（Windows 无管理员权限）。
+ *
+ * 注：fallback 路径通过 softlinkFs.* spy 模拟失败；ESM namespace 不可写，
+ * 因此 softlink.ts 显式暴露 softlinkFs 对象供测试替换。
+ */
+describe('createSoftlinkWithFallback', () => {
+    let tmpDir;
+    let target;
+    let linkPath;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(path.join(os.tmpdir(), 'softlink-test-'));
+        target = path.join(tmpDir, 'code_list.md');
+        linkPath = path.join(tmpDir, 'requirement', 'code_list.md');
+        writeFileSync(target, '# upstream code list\n');
+        mkdirSync(path.dirname(linkPath), { recursive: true });
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('symlink 成功时返回 strategy=symlink，且链接指向 target', () => {
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('symlink');
+        expect(result.warned).toBeUndefined();
+        expect(existsSync(linkPath)).toBe(true);
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
+        // 通过链接读到的内容应该和源文件一致
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('目标已存在时先 unlink 再创建（覆盖语义）', () => {
+        // 先放一个老文件占位
+        writeFileSync(linkPath, '# stale content\n');
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('symlink');
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('目标已存在且为旧 symlink 时也能覆盖', () => {
+        // 先建一个指向别处的 symlink
+        const altTarget = path.join(tmpDir, 'alt.md');
+        writeFileSync(altTarget, '# alt\n');
+        symlinkSync(altTarget, linkPath, 'file');
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('symlink');
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('symlink 失败时回退到 hardlink', () => {
+        // mock softlinkFs.symlinkSync 抛错，模拟 Windows 无权限
+        vi.spyOn(softlinkFs, 'symlinkSync').mockImplementation(() => {
+            throw new Error('EPERM: operation not permitted');
+        });
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('hardlink');
+        expect(result.warned).toBeUndefined();
+        expect(existsSync(linkPath)).toBe(true);
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(false);
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+    it('symlink 与 hardlink 均失败时回退到 copy，并返回 warned=true', () => {
+        vi.spyOn(softlinkFs, 'symlinkSync').mockImplementation(() => {
+            throw new Error('EPERM: symlink not permitted');
+        });
+        vi.spyOn(softlinkFs, 'linkSync').mockImplementation(() => {
+            throw new Error('EXDEV: cross-device link not permitted');
+        });
+        const result = createSoftlinkWithFallback(target, linkPath);
+        expect(result.strategy).toBe('copy');
+        expect(result.warned).toBe(true);
+        expect(existsSync(linkPath)).toBe(true);
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(false);
+        // copy 的文件内容等于源文件
+        expect(readFileSync(linkPath, 'utf8')).toBe('# upstream code list\n');
+    });
+});

package/dist/test/validation/contract.test.d.ts

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

package/dist/test/validation/contract.test.d.ts.map

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

package/dist/test/validation/contract.test.js

@@ -0,0 +1,116 @@
+import { describe, it, expect } from 'vitest';
+import { validateContract } from '../../src/validation/contract.js';
+/**
+ * 构造一份满足 contract v1-draft schema 的最小合法契约对象。
+ *
+ * @returns 合法 contract v1-draft 对象。
+ */
+function makeValidContract() {
+    return {
+        schemaVersion: 'ep-stage-contract/v1-draft',
+        contractId: 'CONTRACT-001',
+        contractKind: 'crud_export',
+        base: {
+            module: { id: 'org-management', label: '组织管理' },
+            navigation: { entryMode: 'menu', menuPath: '系统管理 > 组织管理' },
+            credentials: { source: '.env' },
+        },
+        scenario: {
+            kind: 'crud_export',
+            searchFields: [
+                { field: 'orgName', label: '组织名称', component: 'input' },
+            ],
+            skeletonSlots: {
+                crud: { moduleId: 'org-management', searchConditions: [], frames: [], locators: {}, assertions: [] },
+                export: { moduleId: 'org-management', label: '导出', mode: 'button' },
+            },
+            gapCandidates: [
+                { gapId: 'GAP-001', label: '批量删除', generationStrategy: 'ai' },
+            ],
+        },
+        unresolvedSlots: [],
+    };
+}
+describe('validateContract', () => {
+    it('合法 v1-draft contract 通过', () => {
+        const result = validateContract(makeValidContract());
+        expect(result.schemaVersion).toBe('ep-stage-contract/v1-draft');
+        expect(result.scenario.skeletonSlots.crud).toBeDefined();
+        expect(result.scenario.skeletonSlots.export).toBeDefined();
+    });
+    it('schemaVersion 非 ep-stage-contract/v1-draft 报错', () => {
+        const c = { ...makeValidContract(), schemaVersion: 'v2' };
+        expect(() => validateContract(c)).toThrow(/schemaVersion/);
+    });
+    it('缺 scenario.searchFields[] 报错', () => {
+        const c = makeValidContract();
+        const sc = c.scenario;
+        delete sc.searchFields;
+        expect(() => validateContract(c)).toThrow(/searchFields/);
+    });
+    it('searchFields 为空数组报错', () => {
+        const c = makeValidContract();
+        const sc = c.scenario;
+        sc.searchFields = [];
+        expect(() => validateContract(c)).toThrow(/searchFields/);
+    });
+    it('缺 scenario.skeletonSlots 报错', () => {
+        const c = makeValidContract();
+        const sc = c.scenario;
+        delete sc.skeletonSlots;
+        expect(() => validateContract(c)).toThrow(/skeletonSlots/);
+    });
+    it('缺 scenario.skeletonSlots.crud 报错', () => {
+        const c = makeValidContract();
+        const sc = c.scenario;
+        const slots = sc.skeletonSlots;
+        delete slots.crud;
+        expect(() => validateContract(c)).toThrow(/crud/);
+    });
+    it('缺 scenario.skeletonSlots.export 报错', () => {
+        const c = makeValidContract();
+        const sc = c.scenario;
+        const slots = sc.skeletonSlots;
+        delete slots.export;
+        expect(() => validateContract(c)).toThrow(/export/);
+    });
+    it('缺 unresolvedSlots[] 报错', () => {
+        const c = makeValidContract();
+        delete c.unresolvedSlots;
+        expect(() => validateContract(c)).toThrow(/unresolvedSlots/);
+    });
+    it('缺 base.module 报错', () => {
+        const c = makeValidContract();
+        const base = c.base;
+        delete base.module;
+        expect(() => validateContract(c)).toThrow(/base\.module/);
+    });
+    it('缺 base.navigation 报错', () => {
+        const c = makeValidContract();
+        const base = c.base;
+        delete base.navigation;
+        expect(() => validateContract(c)).toThrow(/base\.navigation/);
+    });
+    it('base.navigation.entryMode 非法值报错', () => {
+        const c = makeValidContract();
+        const base = c.base;
+        const nav = base.navigation;
+        nav.entryMode = 'unknown';
+        expect(() => validateContract(c)).toThrow(/entryMode/);
+    });
+    it('directUrl 模式缺 base.navigation.directUrl 报错', () => {
+        const c = makeValidContract();
+        const base = c.base;
+        const nav = base.navigation;
+        nav.entryMode = 'directUrl';
+        delete nav.menuPath;
+        expect(() => validateContract(c)).toThrow(/base\.navigation\.directUrl/);
+    });
+    it('gapCandidates[].generationStrategy 非法值报错', () => {
+        const c = makeValidContract();
+        const sc = c.scenario;
+        const gaps = sc.gapCandidates;
+        gaps[0].generationStrategy = 'unknown';
+        expect(() => validateContract(c)).toThrow(/generationStrategy/);
+    });
+});

package/dist/test/validation/credentials.test.d.ts

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

package/dist/test/validation/credentials.test.d.ts.map

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

package/dist/test/validation/credentials.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from 'vitest';
+import { validateCredentials } from '../../src/validation/credentials.js';
+describe('validateCredentials', () => {
+    it('合法数组（≥1 条）通过', () => {
+        const result = validateCredentials([
+            {
+                url: 'http://example.test',
+                username: 'admin',
+                password: 'pwd',
+                role: '系统管理员',
+                systemName: '基础平台',
+            },
+        ]);
+        expect(result).toHaveLength(1);
+        expect(result[0]).toMatchObject({
+            url: 'http://example.test',
+            loginUrl: 'http://example.test',
+            username: 'admin',
+            password: 'pwd',
+            role: '系统管理员',
+            systemName: '基础平台',
+        });
+    });
+    it('允许无 role / systemName 的条目', () => {
+        const result = validateCredentials([
+            { url: 'http://example.test', username: 'admin', password: 'pwd' },
+        ]);
+        expect(result[0]).toEqual({
+            url: 'http://example.test',
+            loginUrl: 'http://example.test',
+            username: 'admin',
+            password: 'pwd',
+        });
+        expect(result[0]).not.toHaveProperty('role');
+        expect(result[0]).not.toHaveProperty('systemName');
+    });
+    it('非数组报错', () => {
+        expect(() => validateCredentials({ url: 'x' })).toThrow(/数组/);
+    });
+    it('空数组报错', () => {
+        expect(() => validateCredentials([])).toThrow(/至少|1 条/);
+    });
+    it('条目缺 loginUrl/url 报错', () => {
+        expect(() => validateCredentials([{ username: 'admin', password: 'pwd' }])).toThrow(/loginUrl/);
+    });
+    it('条目缺 username 报错', () => {
+        expect(() => validateCredentials([{ url: 'http://example.test', password: 'pwd' }])).toThrow(/username/);
+    });
+    it('条目缺 password 报错', () => {
+        expect(() => validateCredentials([{ url: 'http://example.test', username: 'admin' }])).toThrow(/password/);
+    });
+    it('条目空字符串字段（空白）报错', () => {
+        expect(() => validateCredentials([{ url: '  ', username: 'admin', password: 'pwd' }])).toThrow(/loginUrl/);
+    });
+    it('同 (url, role) 重复报错', () => {
+        expect(() => validateCredentials([
+            { url: 'http://example.test', username: 'a', password: 'p1', role: '管理员' },
+            { url: 'http://example.test', username: 'b', password: 'p2', role: '管理员' },
+        ])).toThrow(/重复/);
+    });
+    it('同 url 但 role 不同允许', () => {
+        const result = validateCredentials([
+            { url: 'http://example.test', username: 'a', password: 'p1', role: '管理员' },
+            { url: 'http://example.test', username: 'b', password: 'p2', role: '业务员' },
+        ]);
+        expect(result).toHaveLength(2);
+    });
+    it('同 url 都没 role 视作 (url, "") 也会触发重复', () => {
+        expect(() => validateCredentials([
+            { url: 'http://example.test', username: 'a', password: 'p1' },
+            { url: 'http://example.test', username: 'b', password: 'p2' },
+        ])).toThrow(/重复/);
+    });
+});

package/dist/test/validation/projects-index.test.d.ts

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

package/dist/test/validation/projects-index.test.d.ts.map

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

package/dist/test/validation/projects-index.test.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { validateProjectsIndex } from '../../src/validation/projects-index.js';
+describe('validateProjectsIndex', () => {
+    it('通过合法结构（含 systems[] 与 stageCreateVersion）', () => {
+        const obj = {
+            projects: [
+                {
+                    projectName: 'demo',
+                    projectDir: '/abs/demo',
+                    mode: 'glue',
+                    createdAt: '2026-06-25T00:00:00Z',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
+                },
+            ],
+            systems: [],
+        };
+        const result = validateProjectsIndex(obj);
+        expect(result.projects).toHaveLength(1);
+        expect(result.projects[0].stageCreateVersion).toBe('0.0.4-alpha.0');
+        expect(result.systems).toEqual([]);
+    });
+    it('缺 systems 字段时报结构化错误', () => {
+        expect(() => validateProjectsIndex({ projects: [] })).toThrow(/systems/);
+    });
+    it('项目条目缺 stageCreateVersion 报错（stage-context.md 砍掉后的元信息承接）', () => {
+        expect(() => validateProjectsIndex({
+            projects: [{ projectName: 'x', projectDir: '/x', mode: 'glue', requirements: [] }],
+            systems: [],
+        })).toThrow(/stageCreateVersion/);
+    });
+    it('不允许残留 stageContextPath / envPath / knowledgeRoot 字段', () => {
+        expect(() => validateProjectsIndex({
+            projects: [
+                {
+                    projectName: 'x',
+                    projectDir: '/x',
+                    mode: 'glue',
+                    createdAt: '2026-06-25T00:00:00Z',
+                    stageCreateVersion: '0.0.4-alpha.0',
+                    requirements: [],
+                    stageContextPath: '/x/stage-context.md', // 应被拒绝
+                },
+            ],
+            systems: [],
+        })).toThrow(/stageContextPath|removed/);
+    });
+});

package/dist/test/validation/testcase-v1-draft.test.d.ts

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

package/dist/test/validation/testcase-v1-draft.test.d.ts.map

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

package/dist/test/validation/testcase-v1-draft.test.js

@@ -0,0 +1,173 @@
+import { describe, it, expect } from 'vitest';
+import { validateTestcase } from '../../src/validation/testcase.js';
+/**
+ * 构造一份满足 testcase v1-draft schema 的最小合法用例对象。
+ *
+ * @returns 合法 testcase v1-draft 对象。
+ */
+function makeValidTestcase() {
+    return {
+        schemaVersion: 'ep-stage-testcase/v1-draft',
+        testcaseId: 'TC-001',
+        contractRef: '.ep-stage/contract.json5',
+        scenario: '组织管理 CRUD 主流程',
+        moduleId: 'org-management',
+        moduleName: '组织管理',
+        runtimeContext: {
+            testProjectDir: '/tmp/glue-project',
+            caseDir: '/tmp/glue-project/src/tests/014',
+            specPath: '/tmp/glue-project/src/tests/014/crud.spec.ts',
+        },
+        testAccess: {
+            systems: [
+                {
+                    systemName: '政务系统',
+                    loginUrl: 'http://example/login',
+                    roles: [
+                        {
+                            role: '业务管理员',
+                            username: 'yz',
+                            password: 'secret',
+                            permissions: ['新增', '修改', '删除', '导出'],
+                        },
+                    ],
+                },
+            ],
+        },
+        cases: [
+            {
+                caseId: 'CASE-001',
+                title: '管理员新增组织',
+                generationStrategy: 'glue',
+                coverageStatus: 'covered',
+                reviewStatus: 'confirmed',
+                queryKey: '场所名称',
+                precondition: '使用业务管理员登录并进入列表页',
+                steps: '新增、查询、编辑、删除场所窗口信息',
+                assertion: '列表可查询到新增数据，编辑后字段更新，删除后列表不再出现',
+            },
+        ],
+        uncoveredCandidates: [
+            {
+                caseId: 'CASE-002',
+                label: '导出',
+                generationStrategy: 'ai',
+                coverageStatus: 'gap',
+                requiredRole: '系统管理员',
+                businessIntent: '导出当前查询结果',
+                assertionExpectation: '断言下载文件存在',
+                queryKey: '导出',
+                precondition: '使用系统管理员登录并进入列表页',
+                steps: '点击导出并选择当前页',
+                assertion: '成功导出当前列表结果',
+            },
+        ],
+    };
+}
+describe('validateTestcase (v1-draft)', () => {
+    it('合法 v1-draft testcase 通过', () => {
+        const result = validateTestcase(makeValidTestcase());
+        expect(result.schemaVersion).toBe('ep-stage-testcase/v1-draft');
+        expect(result.cases).toHaveLength(1);
+        expect(result.uncoveredCandidates).toHaveLength(1);
+        expect(result.runtimeContext?.specPath).toBe('/tmp/glue-project/src/tests/014/crud.spec.ts');
+        expect(result.testAccess?.systems?.[0]?.roles[0]?.password).toBe('secret');
+        expect(result.cases[0]?.steps).toContain('新增');
+        expect(result.uncoveredCandidates[0]?.assertion).toContain('导出');
+    });
+    it('testAccess 允许角色账号密码缺省，供 generate 交互补齐', () => {
+        const tc = makeValidTestcase();
+        const systems = tc.testAccess.systems;
+        delete systems[0]?.roles[0]?.username;
+        delete systems[0]?.roles[0]?.password;
+        const result = validateTestcase(tc);
+        expect(result.testAccess?.systems?.[0]?.roles[0]?.username).toBeUndefined();
+        expect(result.testAccess?.systems?.[0]?.roles[0]?.password).toBeUndefined();
+    });
+    it('testAccess 允许仅引用 credentials.json5 并声明 requiredRoles', () => {
+        const tc = makeValidTestcase();
+        tc.testAccess = {
+            credentialRef: 'credentials.json5',
+            requiredRoles: ['业务管理员'],
+        };
+        const result = validateTestcase(tc);
+        expect(result.testAccess?.credentialRef).toBe('credentials.json5');
+        expect(result.testAccess?.requiredRoles).toEqual(['业务管理员']);
+    });
+    it('runtimeContext 结构非法时报错', () => {
+        const tc = makeValidTestcase();
+        delete tc.runtimeContext.specPath;
+        expect(() => validateTestcase(tc)).toThrow(/runtimeContext\.specPath/);
+    });
+    it('schemaVersion 非 ep-stage-testcase/v1-draft 报错', () => {
+        const tc = { ...makeValidTestcase(), schemaVersion: 'v2' };
+        expect(() => validateTestcase(tc)).toThrow(/schemaVersion/);
+    });
+    it('menuPath 可缺省', () => {
+        const result = validateTestcase(makeValidTestcase());
+        expect(result.menuPath).toBeUndefined();
+    });
+    it('缺 moduleId 报错', () => {
+        const tc = makeValidTestcase();
+        delete tc.moduleId;
+        expect(() => validateTestcase(tc)).toThrow(/moduleId/);
+    });
+    it('缺 moduleName 报错', () => {
+        const tc = makeValidTestcase();
+        delete tc.moduleName;
+        expect(() => validateTestcase(tc)).toThrow(/moduleName/);
+    });
+    it('缺 contractRef 报错', () => {
+        const tc = makeValidTestcase();
+        delete tc.contractRef;
+        expect(() => validateTestcase(tc)).toThrow(/contractRef/);
+    });
+    it('cases[].generationStrategy 非 glue 报错', () => {
+        const tc = makeValidTestcase();
+        const cases = tc.cases;
+        cases[0].generationStrategy = 'ai';
+        expect(() => validateTestcase(tc)).toThrow(/generationStrategy/);
+    });
+    it('cases[].reviewStatus 缺失报错', () => {
+        const tc = makeValidTestcase();
+        const cases = tc.cases;
+        delete cases[0].reviewStatus;
+        expect(() => validateTestcase(tc)).toThrow(/reviewStatus/);
+    });
+    it('cases[].reviewStatus 非法值报错', () => {
+        const tc = makeValidTestcase();
+        const cases = tc.cases;
+        cases[0].reviewStatus = 'unknown';
+        expect(() => validateTestcase(tc)).toThrow(/reviewStatus/);
+    });
+    it('uncoveredCandidates[].generationStrategy=glue 报错', () => {
+        const tc = makeValidTestcase();
+        const unc = tc.uncoveredCandidates;
+        unc[0].generationStrategy = 'glue';
+        expect(() => validateTestcase(tc)).toThrow(/generationStrategy/);
+    });
+    it('uncoveredCandidates[].generationStrategy=manual 报错', () => {
+        const tc = makeValidTestcase();
+        const unc = tc.uncoveredCandidates;
+        unc[0].generationStrategy = 'manual';
+        expect(() => validateTestcase(tc)).toThrow(/generationStrategy/);
+    });
+    it('uncoveredCandidates[].requiredRole 缺失报错', () => {
+        const tc = makeValidTestcase();
+        const unc = tc.uncoveredCandidates;
+        delete unc[0].requiredRole;
+        expect(() => validateTestcase(tc)).toThrow(/requiredRole/);
+    });
+    it('uncoveredCandidates[].businessIntent 缺失报错', () => {
+        const tc = makeValidTestcase();
+        const unc = tc.uncoveredCandidates;
+        delete unc[0].businessIntent;
+        expect(() => validateTestcase(tc)).toThrow(/businessIntent/);
+    });
+    it('uncoveredCandidates[].assertionExpectation 缺失报错', () => {
+        const tc = makeValidTestcase();
+        const unc = tc.uncoveredCandidates;
+        delete unc[0].assertionExpectation;
+        expect(() => validateTestcase(tc)).toThrow(/assertionExpectation/);
+    });
+});

package/dist/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAEA,wBAKG"}