@midscene/test 1.15.2 → 1.15.3-beta-20261012131523.0

package/dist/es/cli/index.mjs

@@ -634,6 +634,9 @@ const writeTestProjectRunResult = (options)=>{
         ...result.reportPath ? {
             report: relativeToSummary(result.summaryPath, result.reportPath)
         } : {},
+        ...result.markdownPath ? {
+            markdown: relativeToSummary(result.summaryPath, result.markdownPath)
+        } : {},
         summary: result.summary,
         projects: result.projects.map((project)=>({
                 projectId: project.projectId,
@@ -1022,6 +1025,103 @@ async function prepareTestRun(options) {
         onProgress: options.onProgress ?? (()=>{})
     };
 }
+const result_markdown_text = (value)=>value.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll('|', '&#124;').replaceAll('[', '&#91;').replaceAll(']', '&#93;').replaceAll('*', '&#42;').replaceAll('_', '&#95;').replaceAll('`', '&#96;').replaceAll('\\', '&#92;').replace(/[\r\n]+/g, ' ');
+const duration = (ms)=>{
+    const seconds = Math.round(ms / 1000);
+    return seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+};
+const href = (from, target)=>relative(dirname(from), target).split(sep).map(encodeURIComponent).join('/');
+function renderTestResultMarkdown(dump, options = {}) {
+    const { summary } = dump;
+    const outcome = 'success' === dump.status ? `✅ **${summary.passed}/${summary.total} passed**` : `❌ **${summary.failed} failed** · ${summary.passed} passed · ${summary.notRun} not run`;
+    const lines = [
+        '## Midscene Test',
+        '',
+        `${outcome} · ${duration(dump.durationMs)}`,
+        ''
+    ];
+    if (summary.filtered) lines.push(`**Filtered:** ${summary.filtered}`, '');
+    const infrastructure = [
+        summary.collectionErrors ? `${summary.collectionErrors} collection errors` : '',
+        summary.documentFailures ? `${summary.documentFailures} document failures` : '',
+        summary.projectFailures ? `${summary.projectFailures} project failures` : ''
+    ].filter(Boolean);
+    if (infrastructure.length) lines.push(`**Infrastructure:** ${infrastructure.join(' · ')}`, '');
+    const groups = [];
+    const errors = [];
+    const recordSteps = (label, steps)=>{
+        for (const step of steps)if ('failed' === step.status) errors.push(`${label} / ${step.node}: ${step.error?.message ?? 'Step failed'}`);
+    };
+    for (const project of dump.projects){
+        if (project.lifecycle?.setupError) errors.push(`${project.name}: ${project.lifecycle.setupError.message}`);
+        for (const error of project.lifecycle?.teardownErrors ?? [])errors.push(`${project.name}: ${error.message}`);
+        for (const error of project.collectionErrors)errors.push(`${project.name} / ${error.sourcePath}: ${error.error.message}`);
+        for (const document of project.documents){
+            const name = document.sourcePath.replace(/\\/g, '/').replace(/\.(?:yaml|yml)$/, '');
+            const group = {
+                name: dump.projects.length > 1 ? `${project.name} / ${name}` : name,
+                rows: []
+            };
+            groups.push(group);
+            recordSteps(`${project.name} / ${document.sourcePath}`, [
+                ...document.beforeAll,
+                ...document.afterAll
+            ]);
+            for (const error of document.teardownErrors ?? [])errors.push(`${document.sourcePath}: ${error.message}`);
+            for (const failure of document.hostErrors ?? [])errors.push(`${document.sourcePath} / ${failure.phase}: ${failure.error.message}`);
+            for (const testCase of document.cases){
+                const attempt = testCase.attempts.at(-1);
+                const steps = attempt ? [
+                    ...attempt.beforeEach,
+                    ...attempt.steps,
+                    ...attempt.afterEach
+                ] : [];
+                const failedSteps = steps.filter((step)=>'failed' === step.status);
+                const step = failedSteps.at(-1) ?? [
+                    ...steps
+                ].reverse().find((item)=>item.agentDetails?.length) ?? steps.at(-1);
+                const route = new URLSearchParams({
+                    'runner-page': 'case',
+                    'runner-project': project.projectId,
+                    'runner-case': testCase.caseId,
+                    ...step ? {
+                        'runner-step': step.id
+                    } : {}
+                });
+                const target = options.reportHref ? `${options.reportHref}#${route}` : void 0;
+                const name = target ? `[${result_markdown_text(testCase.name)}](<${target}>)` : result_markdown_text(testCase.name);
+                group.rows.push(`  - ${'success' === testCase.status ? '✅' : 'not-run' === testCase.status ? '⏭️' : '❌'} ${name}`);
+            }
+        }
+    }
+    for (const diagnostic of dump.diagnostics ?? [])if ('error' === diagnostic.level) errors.push(diagnostic.message);
+    if (errors.length) lines.push('### Execution errors', '', ...errors.map((error)=>`- ${result_markdown_text(error)}`), '');
+    for (const group of groups)if (group.rows.length) lines.push(`- ${result_markdown_text(group.name)}`, ...group.rows);
+    if (!groups.some((group)=>group.rows.length)) lines.push('No cases were reported.');
+    if (options.reportHref) lines.push('', `[Open the Midscene Test report ↗](<${options.reportHref}>)`);
+    return `${lines.join('\n')}\n`;
+}
+const emptyIndex = ()=>({
+        sources: [],
+        metrics: {
+            modelCallCount: 0,
+            modelTimeMs: 0,
+            promptTokens: 0,
+            cachedInputTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+        }
+    });
+async function writeTestResultMarkdown(result, index = emptyIndex()) {
+    const output = join(dirname(result.summaryPath), 'result.md');
+    const dump = buildTestRunReportDump(result, index);
+    await writeFile(output, renderTestResultMarkdown(dump, {
+        ...result.reportPath ? {
+            reportHref: href(output, result.reportPath)
+        } : {}
+    }));
+    return output;
+}
 const stepPosition = (info)=>'case' === info.scope ? info.case : info.document;
 const formatStep = (info)=>{
     const position = stepPosition(info);
@@ -1480,6 +1580,7 @@ async function runPreparedTestProject(plan) {
         } : {}
     };
     let completedResult = result;
+    let reportIndex;
     const publish = async (operation, path, callback)=>{
         try {
             await callback();
@@ -1510,6 +1611,7 @@ async function runPreparedTestProject(plan) {
                 overwrite: false,
                 sources: collectTestRunReportSources(completedResult),
                 buildRunnerDump: (index)=>{
+                    reportIndex = index;
                     const dump = buildTestRunReportDump(completedResult, index);
                     const warn = getDebug('test-runner:report-assembler', {
                         console: true
@@ -1527,6 +1629,13 @@ async function runPreparedTestProject(plan) {
     for (const publication of plan.publications)await publish(publication.operation, publication.path, async ()=>{
         await publication.publish(completedResult);
     });
+    await publish('write-result', join(dirname(summaryPath), 'result.md'), async ()=>{
+        const markdownPath = await writeTestResultMarkdown(completedResult, reportIndex);
+        completedResult = {
+            ...completedResult,
+            markdownPath
+        };
+    });
     await writeSummary();
     if (hasInfrastructureError) throw new WorkflowExecutionFailure(completedResult, infrastructureErrors);
     return completedResult;