@allurereport/ci 3.17.0 → 3.18.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { applyAllureCiEnv } from "./ciEnv.js";
 export { detect } from "./detect.js";
 export { isLocalCiDescriptor } from "./detectors/local.js";
+export * from "./reportContext.js";
+export * from "./reportMarkdown.js";

package/dist/index.js

@@ -1,3 +1,5 @@
 export { applyAllureCiEnv } from "./ciEnv.js";
 export { detect } from "./detect.js";
 export { isLocalCiDescriptor } from "./detectors/local.js";
+export * from "./reportContext.js";
+export * from "./reportMarkdown.js";

package/dist/reportContext.d.ts

@@ -0,0 +1,59 @@
+import type { PluginSummary, QualityGateValidationResult, TestResultRegistry } from "@allurereport/plugin-api";
+declare const TEST_STATUSES: ["failed", "broken", "passed", "skipped", "unknown"];
+export type ReportContextStatusStats = Record<(typeof TEST_STATUSES)[number], number> & {
+    total: number;
+};
+export type ReportContextFlagStats = {
+    new: number;
+    flaky: number;
+    retry: number;
+};
+export type ReportContextResolutionStats = {
+    issues: number;
+    muted: number;
+    accepted: number;
+};
+export type ReportContextEnvironment = {
+    name: string;
+    stats: ReportContextStatusStats;
+    flags: ReportContextFlagStats;
+    duration: number;
+};
+export type ReportContextTestReport = PluginSummary & {
+    summaryFile?: string;
+    reportPath?: string;
+};
+export type ReportContextArtifact = {
+    name: string;
+    path: string;
+};
+export type ReportContextTotals = {
+    stats: ReportContextStatusStats;
+    flags: ReportContextFlagStats;
+    resolutions: ReportContextResolutionStats;
+    duration: number;
+};
+export type ReportContextQualityGate = QualityGateValidationResult[] | Record<string, QualityGateValidationResult[]>;
+export type ReportContext = {
+    reports: ReportContextTestReport[];
+    testResults?: TestResultRegistry;
+    totals: ReportContextTotals;
+    environments: ReportContextEnvironment[];
+    artifacts: ReportContextArtifact[];
+    qualityGate?: ReportContextQualityGate;
+};
+export type ReportContextData = {
+    reports?: ReportContextTestReport[];
+    summaries?: PluginSummary[];
+    testResults?: TestResultRegistry;
+    artifacts?: ReportContextArtifact[];
+    qualityGate?: ReportContextQualityGate;
+};
+export type ReadReportContextFilesOptions = {
+    onError?: (message: string) => void;
+};
+export type CreateReportContextOptions = ReadReportContextFilesOptions;
+export declare const readReportContextFiles: (reportDir: string, options?: ReadReportContextFilesOptions) => Promise<ReportContextData>;
+export declare const createReportContextFromData: (data: ReportContextData) => ReportContext;
+export declare const createReportContext: (reportDir: string, options?: CreateReportContextOptions) => Promise<ReportContext>;
+export {};

package/dist/reportContext.js

@@ -0,0 +1,252 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { glob } from "glob";
+const TEST_RESULTS_REGISTRY_FILENAME = "test-results.json";
+const QUALITY_GATE_RESULTS_FILENAME = "quality-gate.json";
+const ARTIFACTS_MANIFEST_FILENAME = "artifacts.json";
+const SUMMARY_FILENAME = "summary.json";
+const TEST_STATUSES = ["failed", "broken", "passed", "skipped", "unknown"];
+const emptyStatusStats = () => ({
+    failed: 0,
+    broken: 0,
+    passed: 0,
+    skipped: 0,
+    unknown: 0,
+    total: 0,
+});
+const emptyFlagStats = () => ({
+    new: 0,
+    flaky: 0,
+    retry: 0,
+});
+const emptyResolutionStats = () => ({
+    issues: 0,
+    muted: 0,
+    accepted: 0,
+});
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isTestStatus = (value) => typeof value === "string" && TEST_STATUSES.includes(value);
+const normalizePath = (filePath) => filePath.split(sep).join("/");
+const readOptionalJson = async (filePath, onError) => {
+    if (!existsSync(filePath)) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch (err) {
+        onError?.(`Failed to read Allure report context file ${filePath}: ${String(err)}`);
+        return undefined;
+    }
+};
+const isPluginSummary = (value) => {
+    if (!isRecord(value) || typeof value.name !== "string" || !isRecord(value.stats)) {
+        return false;
+    }
+    return typeof value.duration === "number" && isTestStatus(value.status);
+};
+const getReportPath = (reportDir, summaryFile) => normalizePath(relative(resolve(reportDir), dirname(resolve(summaryFile))));
+const readPluginSummary = async (reportDir, filePath, onError) => {
+    const value = await readOptionalJson(filePath, onError);
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isPluginSummary(value)) {
+        onError?.(`Ignoring unsupported Allure plugin summary file ${filePath}`);
+        return undefined;
+    }
+    return {
+        ...value,
+        summaryFile: filePath,
+        reportPath: getReportPath(reportDir, filePath),
+    };
+};
+const findSummaryFiles = async (reportDir) => (await glob(`**/${SUMMARY_FILENAME}`, {
+    absolute: true,
+    cwd: reportDir,
+    ignore: [`**/widgets/${SUMMARY_FILENAME}`],
+    nodir: true,
+})).toSorted((left, right) => left.localeCompare(right));
+const normalizeTestResultRegistry = (value, onError) => {
+    if (!isRecord(value) || !isRecord(value.byId)) {
+        if (value !== undefined) {
+            onError?.("Ignoring unsupported Allure test result registry shape");
+        }
+        return undefined;
+    }
+    return {
+        byId: value.byId,
+    };
+};
+const normalizeArtifacts = (value, onError) => {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        onError?.("Ignoring unsupported Allure artifacts manifest shape");
+        return [];
+    }
+    const byPath = new Map();
+    value.forEach((artifact) => {
+        if (!isRecord(artifact) || typeof artifact.name !== "string" || typeof artifact.path !== "string") {
+            return;
+        }
+        if (!byPath.has(artifact.path)) {
+            byPath.set(artifact.path, {
+                name: artifact.name,
+                path: artifact.path,
+            });
+        }
+    });
+    return [...byPath.values()].toSorted((left, right) => left.path.localeCompare(right.path) || left.name.localeCompare(right.name));
+};
+const isQualityGateResult = (value) => {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return typeof value.success === "boolean" && typeof value.rule === "string" && typeof value.message === "string";
+};
+const normalizeQualityGate = (value, onError) => {
+    if (Array.isArray(value)) {
+        return value.filter(isQualityGateResult);
+    }
+    if (!isRecord(value)) {
+        if (value !== undefined) {
+            onError?.("Ignoring unsupported Allure quality gate results shape");
+        }
+        return undefined;
+    }
+    const entries = Object.entries(value).flatMap(([environment, results]) => Array.isArray(results) ? [[environment, results.filter(isQualityGateResult)]] : []);
+    if (!entries.length) {
+        if (Object.keys(value).length > 0) {
+            onError?.("Ignoring unsupported Allure quality gate results shape");
+        }
+        return undefined;
+    }
+    return Object.fromEntries(entries);
+};
+const addStatus = (stats, status) => {
+    stats[status] += 1;
+    stats.total += 1;
+};
+const getSummaryIdSet = (summaries, key) => new Set(summaries.flatMap((summary) => summary[key] ?? []));
+const applyMaxSummaryStats = (stats, summaries) => {
+    summaries.forEach((summary) => {
+        TEST_STATUSES.forEach((status) => {
+            stats[status] = Math.max(stats[status], summary.stats[status] ?? 0);
+        });
+        stats.total = Math.max(stats.total, summary.stats.total);
+    });
+};
+const createTotals = (registry, summaries) => {
+    const totals = {
+        stats: emptyStatusStats(),
+        flags: emptyFlagStats(),
+        resolutions: emptyResolutionStats(),
+        duration: 0,
+    };
+    if (!registry) {
+        applyMaxSummaryStats(totals.stats, summaries);
+        totals.duration = summaries.reduce((max, summary) => Math.max(max, summary.duration), 0);
+        return totals;
+    }
+    Object.values(registry.byId).forEach((testResult) => {
+        if (!isRecord(testResult) || !isTestStatus(testResult.status)) {
+            return;
+        }
+        addStatus(totals.stats, testResult.status);
+        if (typeof testResult.duration === "number") {
+            totals.duration += testResult.duration;
+        }
+    });
+    return totals;
+};
+const addFlags = (flags, testResultId, newTestIds, flakyTestIds, retryTestIds) => {
+    if (newTestIds.has(testResultId)) {
+        flags.new += 1;
+    }
+    if (flakyTestIds.has(testResultId)) {
+        flags.flaky += 1;
+    }
+    if (retryTestIds.has(testResultId)) {
+        flags.retry += 1;
+    }
+};
+const createEnvironmentContext = (registry, summaries) => {
+    if (!registry) {
+        return [];
+    }
+    const newTestIds = getSummaryIdSet(summaries, "newTests");
+    const flakyTestIds = getSummaryIdSet(summaries, "flakyTests");
+    const retryTestIds = getSummaryIdSet(summaries, "retryTests");
+    const environmentsByName = new Map();
+    Object.entries(registry.byId).forEach(([testResultId, testResult]) => {
+        if (!isRecord(testResult) || !isTestStatus(testResult.status) || typeof testResult.environment !== "string") {
+            return;
+        }
+        const environment = testResult.environment.trim();
+        if (!environment || environment === "default") {
+            return;
+        }
+        const context = environmentsByName.get(environment) ?? {
+            name: environment,
+            stats: emptyStatusStats(),
+            flags: emptyFlagStats(),
+            duration: 0,
+        };
+        addStatus(context.stats, testResult.status);
+        addFlags(context.flags, testResultId, newTestIds, flakyTestIds, retryTestIds);
+        if (typeof testResult.duration === "number") {
+            context.duration += testResult.duration;
+        }
+        environmentsByName.set(environment, context);
+    });
+    return [...environmentsByName.values()].toSorted((left, right) => left.name.localeCompare(right.name));
+};
+const createReport = (summary) => ({ ...summary });
+const sortReports = (reports) => reports.toSorted((left, right) => left.name.localeCompare(right.name));
+const getResolutionStats = (summaries) => {
+    const stats = emptyResolutionStats();
+    summaries.forEach((summary) => {
+        stats.issues = Math.max(stats.issues, summary.stats.resolutions?.issues ?? 0);
+        stats.muted = Math.max(stats.muted, summary.stats.resolutions?.muted ?? 0);
+        stats.accepted = Math.max(stats.accepted, summary.stats.resolutions?.accepted ?? 0);
+    });
+    return stats;
+};
+const applySummaryFlags = (totals, summaries) => {
+    totals.flags.new = getSummaryIdSet(summaries, "newTests").size;
+    totals.flags.flaky = getSummaryIdSet(summaries, "flakyTests").size;
+    totals.flags.retry = getSummaryIdSet(summaries, "retryTests").size;
+    totals.resolutions = getResolutionStats(summaries);
+};
+export const readReportContextFiles = async (reportDir, options = {}) => {
+    const { onError } = options;
+    const summaryFiles = await findSummaryFiles(reportDir);
+    const reports = (await Promise.all(summaryFiles.map((summaryFile) => readPluginSummary(reportDir, summaryFile, onError)))).filter((summary) => summary !== undefined);
+    const registry = normalizeTestResultRegistry(await readOptionalJson(join(reportDir, TEST_RESULTS_REGISTRY_FILENAME), onError), onError);
+    const artifacts = normalizeArtifacts(await readOptionalJson(join(reportDir, ARTIFACTS_MANIFEST_FILENAME), onError), onError);
+    const qualityGate = normalizeQualityGate(await readOptionalJson(join(reportDir, QUALITY_GATE_RESULTS_FILENAME), onError), onError);
+    return {
+        reports,
+        testResults: registry,
+        artifacts,
+        qualityGate,
+    };
+};
+export const createReportContextFromData = (data) => {
+    const reports = sortReports(data.reports ?? data.summaries?.map(createReport) ?? []);
+    const artifacts = [...(data.artifacts ?? [])].toSorted((left, right) => left.path.localeCompare(right.path) || left.name.localeCompare(right.name));
+    const totals = createTotals(data.testResults, reports);
+    applySummaryFlags(totals, reports);
+    return {
+        reports,
+        testResults: data.testResults,
+        totals,
+        environments: createEnvironmentContext(data.testResults, reports),
+        artifacts,
+        qualityGate: data.qualityGate,
+    };
+};
+export const createReportContext = async (reportDir, options = {}) => createReportContextFromData(await readReportContextFiles(reportDir, options));

package/dist/reportMarkdown.d.ts

@@ -0,0 +1,6 @@
+import type { ReportContext } from "./reportContext.js";
+export type RenderReportSummaryMarkdownOptions = {
+    title?: string;
+    includeArtifacts?: boolean;
+};
+export declare const renderReportSummaryMarkdown: (context: ReportContext, options?: RenderReportSummaryMarkdownOptions) => string;

package/dist/reportMarkdown.js

@@ -0,0 +1,213 @@
+const STATUS_ORDER = ["passed", "failed", "broken", "skipped", "unknown"];
+const STATUS_LABELS = {
+    passed: "Passed tests",
+    failed: "Failed tests",
+    broken: "Broken tests",
+    skipped: "Skipped tests",
+    unknown: "Unknown tests",
+};
+const STATUS_ICON_BASE_URL = "https://allurecharts.qameta.workers.dev/dot";
+const STATUS_PIE_BASE_URL = "https://allurecharts.qameta.workers.dev/pie";
+const escapeHtml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+const tableCell = (value) => escapeHtml(String(value)).replaceAll("|", "&#124;").replaceAll("\n", "<br>");
+const isSafeHref = (href) => {
+    try {
+        const url = new URL(href);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(href);
+    }
+};
+const link = (label, href) => isSafeHref(href) ? `<a href="${escapeHtml(href)}">${escapeHtml(label)}</a>` : escapeHtml(label);
+const statusIcon = (status) => `<img alt="${STATUS_LABELS[status]}" src="${STATUS_ICON_BASE_URL}?type=${status}&size=8" width="8" height="8" />`;
+const statusPie = (stats) => {
+    const total = STATUS_ORDER.reduce((sum, status) => sum + (stats[status] ?? 0), 0);
+    if (total === 0) {
+        return "";
+    }
+    const params = new URLSearchParams({
+        passed: String(stats.passed ?? 0),
+        failed: String(stats.failed ?? 0),
+        broken: String(stats.broken ?? 0),
+        skipped: String(stats.skipped ?? 0),
+        unknown: String(stats.unknown ?? 0),
+        size: "32",
+    });
+    return `<img src="${STATUS_PIE_BASE_URL}?${params.toString()}" width="28px" height="28px" />&nbsp;&nbsp;&nbsp;&nbsp;`;
+};
+const formatDuration = (duration) => {
+    if (!Number.isFinite(duration) || duration <= 0) {
+        return "0ms";
+    }
+    if (duration < 1000) {
+        return `${Math.round(duration)}ms`;
+    }
+    const totalSeconds = Math.round(duration / 1000);
+    const seconds = totalSeconds % 60;
+    const totalMinutes = Math.floor(totalSeconds / 60);
+    const minutes = totalMinutes % 60;
+    const hours = Math.floor(totalMinutes / 60);
+    const parts = [];
+    if (hours) {
+        parts.push(`${hours}h`);
+    }
+    if (minutes) {
+        parts.push(`${minutes}m`);
+    }
+    if (seconds || parts.length === 0) {
+        parts.push(`${seconds}s`);
+    }
+    return parts.join(" ");
+};
+const formatStats = (stats) => {
+    const lines = [];
+    STATUS_ORDER.forEach((status) => {
+        const count = stats[status] ?? 0;
+        if (count > 0) {
+            lines.push(`${statusIcon(status)}&#8288;&nbsp;${count}`);
+        }
+    });
+    return lines.length ? lines.join("<br>") : "0";
+};
+const formatResolutions = (resolutions) => {
+    if (!resolutions) {
+        return "";
+    }
+    const lines = [
+        resolutions.issues ? `Issues: ${resolutions.issues}` : "",
+        resolutions.muted ? `Muted: ${resolutions.muted}` : "",
+        resolutions.accepted ? `Accepted: ${resolutions.accepted}` : "",
+    ].filter(Boolean);
+    return lines.join("<br>");
+};
+const hasResolutions = (resolutions) => resolutions.issues > 0 || resolutions.muted > 0 || resolutions.accepted > 0;
+const formatFlag = (value) => (value > 0 ? String(value) : "0");
+const renderTable = (rows, includeResolutions) => {
+    const headers = [
+        "&nbsp;&nbsp;&nbsp;&nbsp;",
+        "Scope",
+        "Duration",
+        "Stats",
+        ...(includeResolutions ? ["Resolutions"] : []),
+        "New",
+        "Flaky",
+        "Retry",
+    ];
+    const divider = headers.map(() => "---");
+    const body = rows.map((row) => [
+        statusPie(row.stats),
+        tableCell(row.name),
+        tableCell(formatDuration(row.duration)),
+        formatStats(row.stats),
+        ...(includeResolutions ? [formatResolutions(row.resolutions)] : []),
+        tableCell(formatFlag(row.flags.new)),
+        tableCell(formatFlag(row.flags.flaky)),
+        tableCell(formatFlag(row.flags.retry)),
+    ].join(" | "));
+    return [`| ${headers.join(" | ")} |`, `| ${divider.join(" | ")} |`, ...body.map((row) => `| ${row} |`)].join("\n");
+};
+const reportHref = (report) => report.remoteHref ?? report.href;
+const reportLabel = (report) => report.plugin ?? report.name;
+const reportLinkKind = (report) => report.plugin?.toLowerCase() === "testops" ? "testops" : "report";
+const toReportLink = (report) => {
+    const href = reportHref(report);
+    return href
+        ? {
+            label: reportLabel(report),
+            href,
+            kind: reportLinkKind(report),
+        }
+        : undefined;
+};
+const sortLinks = (links) => links.toSorted((left, right) => left.kind.localeCompare(right.kind) || left.label.localeCompare(right.label));
+const renderLinks = (label, links) => {
+    if (!links.length) {
+        return undefined;
+    }
+    return `**${escapeHtml(label)}:** ${links.map((item) => link(item.label, item.href)).join(", ")}`;
+};
+const renderReportLinks = (reports) => {
+    const links = sortLinks(reports.map(toReportLink).filter((item) => item !== undefined));
+    const reportLinks = links.filter(({ kind }) => kind === "report");
+    const testOpsLinks = links.filter(({ kind }) => kind === "testops");
+    return [renderLinks("Reports", reportLinks), renderLinks("TestOps", testOpsLinks)].filter((line) => line !== undefined);
+};
+const pluginSummaryToStatusStats = (report) => ({
+    failed: report.stats.failed ?? 0,
+    broken: report.stats.broken ?? 0,
+    passed: report.stats.passed ?? 0,
+    skipped: report.stats.skipped ?? 0,
+    unknown: report.stats.unknown ?? 0,
+    total: report.stats.total ?? 0,
+});
+const pluginSummaryToFlags = (report) => ({
+    new: report.newTests?.length ?? report.stats.new ?? 0,
+    flaky: report.flakyTests?.length ?? report.stats.flaky ?? 0,
+    retry: report.retryTests?.length ?? report.stats.retries ?? 0,
+});
+const pluginSummaryToResolutions = (report) => ({
+    issues: report.stats.resolutions?.issues ?? 0,
+    muted: report.stats.resolutions?.muted ?? 0,
+    accepted: report.stats.resolutions?.accepted ?? 0,
+});
+const renderFilteredReports = (reports) => {
+    const rows = reports.map((report) => ({
+        name: report.name,
+        duration: report.duration,
+        stats: pluginSummaryToStatusStats(report),
+        flags: pluginSummaryToFlags(report),
+        resolutions: pluginSummaryToResolutions(report),
+    }));
+    if (!rows.length) {
+        return undefined;
+    }
+    const includeResolutions = rows.some(({ resolutions }) => resolutions && hasResolutions(resolutions));
+    const links = renderReportLinks(reports);
+    return ["**Filtered Reports**", renderTable(rows, includeResolutions), ...links].join("\n\n");
+};
+const renderArtifacts = (artifacts) => {
+    if (!artifacts.length) {
+        return undefined;
+    }
+    const rows = artifacts.map(({ name, path }) => `| ${tableCell(name)} | ${tableCell(path)} |`);
+    return [
+        `<details>`,
+        `<summary>Artifacts used (${artifacts.length})</summary>`,
+        "",
+        "| Name | Path |",
+        "| --- | --- |",
+        ...rows,
+        "",
+        "</details>",
+    ].join("\n");
+};
+export const renderReportSummaryMarkdown = (context, options = {}) => {
+    const { title = "Allure Report Summary", includeArtifacts = true } = options;
+    const regularReports = context.reports.filter((report) => report.filtered !== true);
+    const filteredReports = context.reports.filter((report) => report.filtered === true);
+    const aggregateRows = [
+        {
+            name: "All tests",
+            duration: context.totals.duration,
+            stats: context.totals.stats,
+            flags: context.totals.flags,
+            resolutions: context.totals.resolutions,
+        },
+        ...context.environments.map((environment) => ({
+            name: environment.name,
+            duration: environment.duration,
+            stats: environment.stats,
+            flags: environment.flags,
+        })),
+    ];
+    const includeResolutions = hasResolutions(context.totals.resolutions);
+    const sections = [
+        `# ${escapeHtml(title)}`,
+        renderTable(aggregateRows, includeResolutions),
+        ...renderReportLinks(regularReports),
+        renderFilteredReports(filteredReports),
+        includeArtifacts ? renderArtifacts(context.artifacts) : undefined,
+    ].filter((section) => Boolean(section));
+    return `${sections.join("\n\n")}\n`;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/ci",
-  "version": "3.17.0",
+  "version": "3.18.0",
   "description": "Utilities set to get useful report data from different CI",
   "keywords": [
     "allure",
@@ -20,7 +20,9 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./report-context": "./dist/reportContext.js",
+    "./report-markdown": "./dist/reportMarkdown.js"
   },
   "scripts": {
     "build": "run clean && tsc --project ./tsconfig.json",
@@ -30,7 +32,9 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.17.0"
+    "@allurereport/core-api": "3.18.0",
+    "@allurereport/plugin-api": "3.18.0",
+    "glob": "^13.0.6"
   },
   "devDependencies": {
     "@types/node": "^20",