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

package/dist/test/stage-context.test.js

@@ -0,0 +1,263 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import JSON5 from 'json5';
+import { describe, expect, it } from 'vitest';
+import { readStageContext, resolveStageContext, writeProjectIndex, } from '../src/index.js';
+/**
+ * 创建隔离的临时目录，避免测试读写真实用户 HOME 或项目文件。
+ *
+ * @param prefix - 临时目录前缀。
+ * @returns 生成后的临时目录绝对路径。
+ */
+function createTempDir(prefix) {
+    return path.join(os.tmpdir(), `${prefix}-${crypto.randomUUID()}`);
+}
+describe('stage context resolution', () => {
+    it('parses explicit stage-context.md and normalizes relative env path', () => {
+        const projectDir = createTempDir('ep-stage-context');
+        mkdirSync(projectDir, { recursive: true });
+        const knowledgeRoot = path.join(projectDir, '..', 'knowledge-project');
+        const stageContextPath = path.join(projectDir, 'stage-context.md');
+        writeFileSync(stageContextPath, [
+            '---',
+            'projectName: demo-project',
+            'projectDir: .',
+            'mode: glue',
+            'envPath: .env',
+            'knowledgeRoot: ../knowledge-project',
+            'codeListPaths:',
+            '  - ../knowledge-project/_docs/code_list.md',
+            '---',
+            '',
+            '# demo-project',
+        ].join('\n'));
+        const context = readStageContext(stageContextPath);
+        expect(context).toMatchObject({
+            projectName: 'demo-project',
+            projectDir,
+            mode: 'glue',
+            envPath: '.env',
+            envFilePath: path.join(projectDir, '.env'),
+            knowledgeRoot: path.resolve(knowledgeRoot),
+            stageContextPath,
+            codeListPaths: [path.resolve(projectDir, '../knowledge-project/_docs/code_list.md')],
+        });
+    });
+    it('resolves current project from user index by code list path when local context is absent', () => {
+        const homeDir = createTempDir('ep-stage-home');
+        const projectDir = createTempDir('ep-stage-project');
+        const cwd = createTempDir('ep-stage-outside-cwd');
+        const knowledgeRoot = createTempDir('ep-stage-knowledge');
+        const codeListPath = path.join(knowledgeRoot, '_docs', 'code_list.md');
+        mkdirSync(cwd, { recursive: true });
+        mkdirSync(projectDir, { recursive: true });
+        mkdirSync(path.dirname(codeListPath), { recursive: true });
+        writeFileSync(path.join(projectDir, '.env'), 'LOGIN_SYSTEM_URL=http://example.test/login\n');
+        writeFileSync(codeListPath, '# code list\n');
+        writeProjectIndex({
+            homeDir,
+            projects: [
+                {
+                    projectName: 'indexed-project',
+                    projectDir,
+                    mode: 'glue',
+                    envPath: '.env',
+                    knowledgeRoot,
+                    codeListPaths: [codeListPath],
+                },
+            ],
+        });
+        const result = resolveStageContext({
+            cwd,
+            codeListPath,
+            homeDir,
+        });
+        expect(result.context).toMatchObject({
+            projectName: 'indexed-project',
+            projectDir,
+            mode: 'glue',
+            envFilePath: path.join(projectDir, '.env'),
+            knowledgeRoot,
+            codeListPaths: [codeListPath],
+        });
+        expect(result.trace).toMatchObject({
+            stage: 'context-resolution',
+            stageLabel: '项目上下文解析',
+            gate: { status: 'confirmed' },
+            reasoningSummary: {
+                conclusion: expect.stringContaining('projects.index.json5'),
+                needsHumanReview: false,
+            },
+        });
+    });
+    it('uses stage-context.md as source of truth when user index has stageContextPath', () => {
+        const homeDir = createTempDir('ep-stage-home-source');
+        const projectDir = createTempDir('ep-stage-source-project');
+        const oldKnowledgeRoot = path.join(projectDir, 'old knowledge');
+        const newKnowledgeRoot = path.join(projectDir, 'new knowledge');
+        const stageContextPath = path.join(projectDir, 'stage-context.md');
+        const codeListPath = path.join(newKnowledgeRoot, '_docs', 'code_list.md');
+        mkdirSync(path.dirname(codeListPath), { recursive: true });
+        writeFileSync(path.join(projectDir, 'actual.env'), 'LOGIN_USERNAME=demo-user\n');
+        writeFileSync(codeListPath, '# code list\n');
+        writeFileSync(stageContextPath, [
+            '---',
+            'projectName: context-project',
+            'projectDir: .',
+            'mode: glue',
+            'envPath: actual.env',
+            'knowledgeRoot: "new knowledge"',
+            'codeListPaths:',
+            '  - "new knowledge/_docs/code_list.md"',
+            '---',
+            '',
+            '# context-project',
+        ].join('\n'));
+        writeProjectIndex({
+            homeDir,
+            projects: [
+                {
+                    projectName: 'stale-index-project',
+                    projectDir,
+                    mode: 'glue',
+                    envPath: 'old.env',
+                    knowledgeRoot: oldKnowledgeRoot,
+                    codeListPaths: [codeListPath],
+                    stageContextPath,
+                },
+            ],
+        });
+        const result = resolveStageContext({
+            cwd: createTempDir('ep-stage-source-outside'),
+            codeListPath,
+            homeDir,
+        });
+        expect(result.context).toMatchObject({
+            projectName: 'context-project',
+            envPath: 'actual.env',
+            envFilePath: path.join(projectDir, 'actual.env'),
+            knowledgeRoot: newKnowledgeRoot,
+            codeListPaths: [codeListPath],
+            stageContextPath,
+        });
+        expect(result.context.knowledgeRoot).not.toBe(oldKnowledgeRoot);
+        expect(result.trace.inputs).toContainEqual(expect.objectContaining({
+            kind: 'context_source',
+            path: path.join(homeDir, '.ep-stage', 'projects.index.json5'),
+        }));
+        expect(result.trace.outputs).toContainEqual(expect.objectContaining({
+            kind: 'stage_context',
+            path: stageContextPath,
+        }));
+    });
+    it('reads user project index with JSON5 comments and trailing commas', () => {
+        const homeDir = createTempDir('ep-stage-home-json5');
+        const projectDir = createTempDir('ep-stage-json5-project');
+        const codeListPath = path.join(projectDir, 'knowledge', '_docs', 'code_list.md');
+        const indexDir = path.join(homeDir, '.ep-stage');
+        mkdirSync(indexDir, { recursive: true });
+        mkdirSync(path.dirname(codeListPath), { recursive: true });
+        writeFileSync(path.join(projectDir, '.env'), 'LOGIN_USERNAME=demo-user\n');
+        writeFileSync(codeListPath, '# code list\n');
+        writeFileSync(path.join(indexDir, 'projects.index.json5'), `{
+        // 用户可编辑索引允许注释
+        projects: [
+          {
+            projectName: 'json5-project',
+            projectDir: '${projectDir}',
+            mode: 'glue',
+            envPath: '.env',
+            codeListPaths: [
+              '${codeListPath}',
+            ],
+          },
+        ],
+      }`);
+        const result = resolveStageContext({
+            projectDir,
+            codeListPath,
+            homeDir,
+        });
+        expect(result.context.projectName).toBe('json5-project');
+        expect(result.context.envFilePath).toBe(path.join(projectDir, '.env'));
+        expect(result.trace.reasoningSummary?.evidenceChain[0]).toMatchObject({
+            source: 'human',
+            path: path.join(indexDir, 'projects.index.json5'),
+        });
+    });
+    it('creates a debug stage context from explicit projectDir when no context or index exists', () => {
+        const homeDir = createTempDir('ep-stage-home-debug');
+        const projectDir = createTempDir('ep-stage-debug-project');
+        const codeListPath = path.join(projectDir, 'knowledge', '_docs', 'code_list.md');
+        mkdirSync(path.dirname(codeListPath), { recursive: true });
+        writeFileSync(codeListPath, '# code list\n');
+        const result = resolveStageContext({
+            projectDir,
+            codeListPath,
+            homeDir,
+        });
+        expect(result.context).toMatchObject({
+            projectName: path.basename(projectDir),
+            projectDir,
+            mode: 'glue',
+            envPath: '.env',
+            envFilePath: path.join(projectDir, '.env'),
+            codeListPaths: [codeListPath],
+        });
+        expect(result.trace).toMatchObject({
+            gate: { status: 'needs_review' },
+            reasoningSummary: {
+                conclusion: expect.stringContaining('显式 --project-dir'),
+                needsHumanReview: true,
+            },
+        });
+    });
+    it('writes v1 project index and keeps reading legacy JSON5 index files', () => {
+        const homeDir = createTempDir('ep-stage-home-version');
+        const projectDir = createTempDir('ep-stage-version-project');
+        mkdirSync(projectDir, { recursive: true });
+        const indexPath = writeProjectIndex({
+            homeDir,
+            projects: [
+                {
+                    projectName: 'versioned-project',
+                    projectDir,
+                    mode: 'glue',
+                    envPath: '.env',
+                },
+            ],
+        });
+        const parsedIndex = JSON5.parse(readFileSync(indexPath, 'utf8'));
+        expect(parsedIndex).toMatchObject({
+            version: 1,
+            projects: [
+                {
+                    projectName: 'versioned-project',
+                    projectDir,
+                },
+            ],
+        });
+        const legacyHomeDir = createTempDir('ep-stage-legacy-version');
+        const legacyProjectDir = createTempDir('ep-stage-legacy-project');
+        const legacyIndexDir = path.join(legacyHomeDir, '.ep-stage');
+        mkdirSync(legacyProjectDir, { recursive: true });
+        mkdirSync(legacyIndexDir, { recursive: true });
+        writeFileSync(path.join(legacyProjectDir, '.env'), 'LOGIN_USERNAME=demo-user\n');
+        writeFileSync(path.join(legacyIndexDir, 'projects.index.json5'), `{
+        // legacy index without version
+        projects: [
+          {
+            projectName: 'legacy-project',
+            projectDir: '${legacyProjectDir}',
+            mode: 'glue',
+            envPath: '.env',
+          },
+        ],
+      }`);
+        expect(resolveStageContext({
+            projectDir: legacyProjectDir,
+            homeDir: legacyHomeDir,
+        }).context.projectName).toBe('legacy-project');
+    });
+});

package/dist/test/testcase-generator.test.d.ts

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

package/dist/test/testcase-generator.test.d.ts.map

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

package/dist/test/testcase-generator.test.js

@@ -0,0 +1,276 @@
+import { describe, expect, it } from 'vitest';
+import { generateGlueTestcases } from '../src/index.js';
+/**
+ * 构造用例生成器测试所需的最小 CRUD 契约。
+ *
+ * @returns 包含完整 CRUD 流程槽位的测试契约。
+ */
+function createCrudContract() {
+    return {
+        contractVersion: 'crud-business-module/v1',
+        module: {
+            id: 'zwplace',
+            label: '场所窗口信息管理',
+        },
+        pages: {
+            list: {
+                role: 'list',
+                pageId: 'gxhzwplacelist',
+                title: '场所窗口信息列表',
+                iframeSrcKeyword: 'gxhzwplacelist',
+                fields: [],
+                buttons: [],
+                grids: [],
+                dialogs: [],
+                sources: [],
+            },
+        },
+        dataKey: {
+            field: 'windowname',
+            label: '窗口名称',
+            availability: 'derivable',
+            generationStrategy: 'timestamp_prefix',
+            sources: [],
+        },
+        searchConditions: [
+            {
+                field: 'windowname',
+                label: '窗口名称',
+                component: 'input',
+                seedValue: '自动化测试窗口',
+                generationStrategy: 'timestamp_prefix',
+                sources: [],
+            },
+        ],
+        flows: {
+            create: {
+                entryButton: {
+                    pageRole: 'list',
+                    label: '新增场所窗口',
+                    sources: [],
+                },
+                targetPageId: 'gxhzwplaceadd',
+                saveButton: {
+                    pageRole: 'add',
+                    label: '保存并关闭',
+                    sources: [],
+                },
+                overrideFields: [],
+            },
+            search: {
+                searchField: {
+                    pageRole: 'list',
+                    field: 'windowname',
+                    label: '窗口名称',
+                    sources: [],
+                },
+                submitControl: {
+                    pageRole: 'list',
+                    label: '查询',
+                    sources: [],
+                },
+                resultGrid: 'datagrid',
+            },
+            update: {
+                entryAction: {
+                    pageRole: 'list',
+                    label: '修改',
+                    sources: [],
+                },
+                targetPageId: 'gxhzwplaceedit',
+                updateField: {
+                    pageRole: 'edit',
+                    field: 'windowname',
+                    label: '窗口名称',
+                    sources: [],
+                },
+                saveButton: {
+                    pageRole: 'edit',
+                    label: '保存并关闭',
+                    sources: [],
+                },
+            },
+            delete: {
+                entryButton: {
+                    pageRole: 'list',
+                    label: '删除选定',
+                    sources: [],
+                },
+                expectedOutcome: 'success_delete',
+                confirmControl: {
+                    pageRole: 'list',
+                    label: '确定',
+                    sources: [],
+                },
+            },
+        },
+        assertions: [],
+        businessRules: [],
+        unresolvedSlots: [],
+    };
+}
+/**
+ * 构造用例生成器测试所需的 coverage diff trace。
+ *
+ * @returns 默认无未确认项的 coverage diff。
+ */
+function createCoverageDiff() {
+    return {
+        moduleId: 'zwplace',
+        skeletonCoverageId: 'crud-plus-export/v1',
+        covered: [
+            {
+                actionId: 'zwplace.list.create',
+                label: '新增场所信息管理',
+                pageId: 'gxhzwplacelist',
+                status: 'covered',
+                reason: '动作标签已被当前骨架能力覆盖。',
+            },
+        ],
+        partiallyCovered: [],
+        gapCandidates: [],
+        unresolved: [],
+        nestedCrudCandidates: [],
+        baseline: { plannedWorkflows: [], candidateWorkflows: [], unresolvedWorkflows: [] },
+        comparison: { both: [], onlyBaseline: [], onlyGeneralized: [] },
+        reasoningSummary: {
+            conclusion: 'CRUD 单页能力已覆盖。',
+            evidenceChain: [],
+            alternatives: ['crud.single-page'],
+            confidence: 'medium',
+            risks: [],
+            needsHumanReview: false,
+        },
+    };
+}
+/**
+ * 胶水测试用例生成器测试。
+ *
+ * 验证 generateGlueTestcases 能从同一份 CRUD contract、已确认场景与 coverage diff
+ * 生成可审阅 JSON + Markdown。
+ */
+describe('glue testcase generator', () => {
+    it('renders reviewable markdown and json cases from a confirmed scenario and contract', () => {
+        const output = generateGlueTestcases({
+            contract: createCrudContract(),
+            menu: '场所窗口信息管理>场所窗口信息列表',
+            scenarios: ['crud.single-page', 'crud.nested'],
+            confirmedScenarios: ['crud.single-page'],
+            coverageDiff: createCoverageDiff(),
+        });
+        expect(output.json.cases).toHaveLength(4);
+        expect(output.json.cases.map((item) => item.caseId)).toEqual([
+            'zwplace.create',
+            'zwplace.read',
+            'zwplace.update',
+            'zwplace.delete',
+        ]);
+        expect(output.json.cases[0]).toMatchObject({
+            caseId: 'zwplace.create',
+            reviewStatus: 'confirmed',
+        });
+        expect(output.json.cases[0]?.evidence).toContain('skeleton=crud.skeleton-testcase/v1');
+        expect(output.markdown).toContain('| TC-CRUD-001 |');
+        expect(output.markdown).toContain('查询字段：窗口名称');
+        expect(output.markdown).not.toContain('{{');
+    });
+    it('requires contract and menu instead of free-form module fields', () => {
+        expect(() => generateGlueTestcases({
+            moduleId: 'zwplace',
+            moduleName: '场所窗口信息管理',
+            scenarioStatus: 'confirmed',
+            scenarios: ['crud.single-page'],
+            confirmedScenarios: ['crud.single-page'],
+            coverageDiff: createCoverageDiff(),
+        })).toThrow('生成胶水测试用例必须提供 contract 和 menu');
+    });
+    it('keeps testcase gate in needs_review when coverage diff has unresolved items', () => {
+        const coverageDiff = createCoverageDiff();
+        coverageDiff.unresolved = [
+            {
+                actionId: 'zwplace.list.export',
+                label: '导出',
+                pageId: 'gxhzwplacelist',
+                status: 'unresolved',
+                reason: '导出动作是否纳入本轮 CRUD 用例需要人工确认。',
+            },
+        ];
+        const output = generateGlueTestcases({
+            contract: createCrudContract(),
+            menu: '场所窗口信息管理>场所窗口信息列表',
+            scenarios: ['crud.single-page'],
+            confirmedScenarios: ['crud.single-page'],
+            coverageDiff,
+        });
+        expect(output.json.cases.every((item) => item.reviewStatus === 'needs_review')).toBe(true);
+        expect(output.json.cases[0]?.unresolved).toEqual([
+            'coverageDiff.unresolved: 导出动作是否纳入本轮 CRUD 用例需要人工确认。',
+        ]);
+        expect(output.json.reasoningSummary.risks).toContain('coverageDiff.unresolved: 导出动作是否纳入本轮 CRUD 用例需要人工确认。');
+        expect(output.json.reasoningSummary.evidenceChain).toContainEqual({
+            source: 'human',
+            path: 'testcase-generation.json',
+            text: 'unresolved=coverageDiff.unresolved: 导出动作是否纳入本轮 CRUD 用例需要人工确认。',
+        });
+    });
+    it('renders nested CRUD candidates with the CRUD testcase skeleton and unresolved gate', () => {
+        const coverageDiff = createCoverageDiff();
+        coverageDiff.nestedCrudCandidates = [
+            {
+                pageId: 'gxhzwplaceadd',
+                evidence: ['弹窗页面中存在 mini-datagrid', '按钮 添加窗口'],
+                supportedActions: ['create', 'delete'],
+                unresolvedReason: '子表保存后断言需要人工确认',
+            },
+        ];
+        const output = generateGlueTestcases({
+            contract: createCrudContract(),
+            menu: '场所窗口信息管理>场所窗口信息列表',
+            scenarios: ['crud.nested'],
+            confirmedScenarios: ['crud.nested'],
+            coverageDiff,
+        });
+        expect(output.json.cases[0]).toMatchObject({
+            scenario: 'crud.nested',
+            reviewStatus: 'needs_review',
+            unresolved: ['coverageDiff.nestedCrudCandidates[gxhzwplaceadd]: 子表保存后断言需要人工确认'],
+        });
+        expect(output.json.cases[0]?.evidence).toContain('skeleton=crud.skeleton-testcase/v1');
+        expect(output.markdown).toContain('| TC-CRUD-001 |');
+        expect(output.markdown).not.toContain('{{');
+    });
+    it('does not let nested CRUD candidates block a confirmed crud.single-page scenario', () => {
+        const coverageDiff = createCoverageDiff();
+        coverageDiff.nestedCrudCandidates = [
+            {
+                pageId: 'gxhzwplaceadd',
+                evidence: ['弹窗页面中存在 mini-datagrid', '按钮 添加窗口'],
+                supportedActions: ['create', 'delete'],
+                unresolvedReason: '子表保存后断言需要人工确认',
+            },
+        ];
+        const output = generateGlueTestcases({
+            contract: createCrudContract(),
+            menu: '场所窗口信息管理>场所窗口信息列表',
+            scenarios: ['crud.single-page', 'crud.nested'],
+            confirmedScenarios: ['crud.single-page'],
+            coverageDiff,
+        });
+        expect(output.json.cases.every((item) => item.reviewStatus === 'confirmed')).toBe(true);
+        expect(output.json.cases[0]?.unresolved).toEqual([]);
+        expect(output.json.reasoningSummary.needsHumanReview).toBe(false);
+        expect(output.json.reasoningSummary.risks).toEqual([]);
+    });
+    it('surfaces inferred menu candidates in testcase unresolved output for human review', () => {
+        const output = generateGlueTestcases({
+            contract: createCrudContract(),
+            menu: '未确认菜单路径',
+            menuReviewHint: 'menu.candidate: 场所窗口信息管理>场所窗口信息列表 | 场所窗口信息列表',
+            scenarios: ['crud.single-page'],
+            confirmedScenarios: ['crud.single-page'],
+            coverageDiff: createCoverageDiff(),
+        });
+        expect(output.json.cases[0]?.unresolved).toContain('menu.candidate: 场所窗口信息管理>场所窗口信息列表 | 场所窗口信息列表');
+        expect(output.markdown).toContain('menu.candidate: 场所窗口信息管理>场所窗口信息列表 | 场所窗口信息列表');
+    });
+});

package/dist/test/testcase-skeleton.test.d.ts

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

package/dist/test/testcase-skeleton.test.d.ts.map

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