@allurereport/plugin-allure2 3.15.0 → 3.16.1

package/README.md

@@ -1,4 +1,4 @@
-# Classic Plugin
+# Allure 2 Plugin
 
 [<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
 
@@ -12,16 +12,17 @@
 
 ## Overview
 
-The plugin generates a classic Allure Report.
+The plugin generates an Allure 2-compatible report using the Allure 2.46.0 UI built from
+the checked-in `@allurereport/web-allure2` sources and embedded in the plugin package.
 
 ## Install
 
 Use your favorite package manager to install the package:
 
 ```shell
-npm add @allurereport/plugin-classic
-yarn add @allurereport/plugin-classic
-pnpm add @allurereport/plugin-classic
+npm add @allurereport/plugin-allure2
+yarn add @allurereport/plugin-allure2
+pnpm add @allurereport/plugin-allure2
 ```
 
 Then, add the plugin to the Allure configuration file:
@@ -34,7 +35,7 @@ export default defineConfig({
   output: "./allure-report",
   historyPath: "./history.jsonl",
   plugins: {
-+    classic: {
++    allure2: {
 +      options: {
 +        reportName: "HelloWorld",
 +      },
@@ -47,8 +48,8 @@ export default defineConfig({
 
 The plugin accepts the following options:
 
-| Option           | Description                                     | Type                                                         | Default         |
-|------------------|-------------------------------------------------|--------------------------------------------------------------|-----------------|
-| `reportName`     | Name of the report                              | `string`                                                     | `Allure Report` |
-| `singleFile`     | Writes the report as a single `index.html` file | `boolean`                                                    | `false`         |
-| `reportLanguage` | Default language of the report                  | `string`                                                     | OS language     |
+| Option           | Description                                     | Type      | Default         |
+| ---------------- | ----------------------------------------------- | --------- | --------------- |
+| `reportName`     | Name of the report                              | `string`  | `Allure Report` |
+| `singleFile`     | Writes the report as a single `index.html` file | `boolean` | `false`         |
+| `reportLanguage` | Default language of the report                  | `string`  | OS language     |

package/dist/categories.js

@@ -7,14 +7,17 @@ const testDefects = {
     matchedStatuses: ["broken"],
 };
 export const matchCategories = (categories, result) => {
-    const matched = categories.filter((category) => categoryMatch(category, result));
-    if (matched.length === 0 && categoryMatch(productDefects, result)) {
-        matched.push(productDefects);
+    const matched = categories.find((category) => categoryMatch(category, result));
+    if (matched) {
+        return [matched];
     }
-    if (matched.length === 0 && categoryMatch(testDefects, result)) {
-        matched.push(testDefects);
+    if (categoryMatch(productDefects, result)) {
+        return [productDefects];
     }
-    return matched;
+    if (categoryMatch(testDefects, result)) {
+        return [testDefects];
+    }
+    return [];
 };
 const categoryMatch = (category, result) => {
     const { status, statusMessage, statusTrace, flaky } = result;

package/dist/converters.d.ts

@@ -1,11 +1,12 @@
 import type { HistoryTestResult, TestFixtureResult, TestResult } from "@allurereport/core-api";
-import type { Allure2Category, Allure2TestResult } from "./model.js";
+import type { Allure2Category, Allure2HistoryData, Allure2TestResult } from "./model.js";
 type ConvertContext = {
     attachmentMap: Map<string, string>;
     fixtures: TestFixtureResult[];
     categories: Allure2Category[];
     retries: TestResult[];
     history: HistoryTestResult[];
+    legacyHistory?: Allure2HistoryData;
 };
 export declare const convertTestResult: (context: ConvertContext, test: TestResult) => Allure2TestResult;
 export {};

package/dist/converters.js

@@ -1,31 +1,70 @@
-import { filterIncludedInSuccessRate, isStep, redactParameters } from "@allurereport/core-api";
+import { isStep, redactParameters } from "@allurereport/core-api";
 import { matchCategories } from "./categories.js";
 import { severityValues } from "./model.js";
-import { updateStatistic } from "./utils.js";
+import { createStatistic, updateStatistic } from "./utils.js";
 const sortByTime = (a, b) => a.time.start !== undefined && b.time.start !== undefined ? a.time.start - b.time.start : 0;
 const convertStatus = (status) => status;
+const getTopLevelAttachmentCount = (result) => {
+    if (result.sourceMetadata.readerId !== "allure2") {
+        return 0;
+    }
+    const value = result.sourceMetadata.metadata.allure2_top_level_attachment_count;
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : 0;
+};
+const hasMessage = (step, message) => step.statusMessage === message || step.steps.some((child) => hasMessage(child, message));
+const summarize = (name, statusMessage, steps, attachments, parametersCount) => {
+    const stepsCount = steps.reduce((count, step) => count + 1 + step.stepsCount, 0);
+    const attachmentsCount = attachments.length + steps.reduce((count, step) => count + step.attachmentsCount, 0);
+    const shouldDisplayMessage = !!statusMessage && !steps.some((step) => hasMessage(step, statusMessage));
+    return {
+        stepsCount,
+        attachmentsCount,
+        shouldDisplayMessage,
+        hasContent: steps.length + attachments.length + parametersCount > 0 || shouldDisplayMessage,
+        attachmentStep: stepsCount === 0 && attachmentsCount === 1 && name !== undefined && name === attachments[0]?.name,
+    };
+};
 const convertStageResult = (context, result) => {
-    const { name: _name, ...testStage } = convertStep(context, {
-        name: "test",
-        steps: result.steps,
-        start: result.start,
-        stop: result.stop,
-        duration: result.duration,
+    const topLevelAttachmentCount = Math.min(getTopLevelAttachmentCount(result), result.steps.length);
+    const attachmentStart = result.steps.length - topLevelAttachmentCount;
+    const attachmentCandidates = result.steps.slice(attachmentStart);
+    const stageSteps = [
+        ...result.steps.slice(0, attachmentStart),
+        ...attachmentCandidates.filter((step) => isStep(step)),
+    ];
+    const attachments = attachmentCandidates
+        .filter((step) => !isStep(step))
+        .map((step) => convertAttachment(context, step));
+    const steps = stageSteps.map((step) => convertStep(context, step));
+    const name = "type" in result ? result.name : undefined;
+    const statusMessage = result.error?.message;
+    const summary = summarize(name, statusMessage, steps, attachments, 0);
+    return {
+        ...(name === undefined ? {} : { name }),
+        time: {
+            start: result.start,
+            stop: result.stop,
+            duration: result.duration,
+        },
         status: result.status,
+        statusMessage,
+        statusTrace: result.error?.trace,
+        steps,
+        attachments,
         parameters: [],
-        type: "step",
-    });
-    return testStage;
+        ...summary,
+    };
 };
 const convertStep = (context, step) => {
     if (isStep(step)) {
         const name = step.name;
-        const steps = step.steps.map((child) => convertStep(context, child));
-        const stepsCount = steps.length;
+        const steps = step.steps.filter((child) => isStep(child)).map((child) => convertStep(context, child));
+        const attachments = step.steps
+            .filter((child) => !isStep(child))
+            .map((child) => convertAttachment(context, child));
         const parameters = redactParameters(step.parameters);
-        const parametersCount = parameters.length;
-        const statusMessage = step.error?.message;
-        const shouldDisplayMessage = !!statusMessage || steps.findIndex((s) => s.statusMessage === statusMessage) > 0;
+        const statusMessage = step.error?.message ?? step.message;
+        const summary = summarize(name, statusMessage, steps, attachments, parameters.length);
         return {
             name,
             time: {
@@ -35,15 +74,11 @@ const convertStep = (context, step) => {
             },
             status: step.status,
             statusMessage,
-            statusTrace: step.error?.trace,
+            statusTrace: step.error?.trace ?? step.trace,
             steps,
-            attachments: [],
+            attachments,
             parameters,
-            stepsCount,
-            attachmentsCount: 0,
-            hasContent: stepsCount + parametersCount > 0 || shouldDisplayMessage,
-            shouldDisplayMessage,
-            attachmentStep: false,
+            ...summary,
         };
     }
     const stepName = step.link.name;
@@ -87,8 +122,30 @@ const extractSeverity = (test) => {
     return (maybeSeverity ? severityValues.find((value) => value === maybeSeverity) : undefined) ?? "normal";
 };
 const importantStatuses = ["failed", "broken", "passed"];
+const isImportantStatus = (status) => importantStatuses.includes(status);
+const getAllure2Links = (test) => {
+    if (test.sourceMetadata.readerId !== "allure2") {
+        return undefined;
+    }
+    const links = test.sourceMetadata.metadata.allure2_links;
+    if (!Array.isArray(links)) {
+        return undefined;
+    }
+    return links.map((link) => ({
+        name: typeof link?.name === "string" ? link.name : undefined,
+        url: typeof link?.url === "string" ? link.url : undefined,
+        type: typeof link?.type === "string" ? link.type : undefined,
+    }));
+};
+const isFlakyFromHistory = (currentStatus, historyItems) => {
+    if (currentStatus !== "failed" && currentStatus !== "broken") {
+        return false;
+    }
+    const statuses = historyItems.slice(0, 5).map(({ status }) => status);
+    return statuses.includes("passed") && statuses.indexOf("passed") < statuses.lastIndexOf("failed");
+};
 export const convertTestResult = (context, test) => {
-    const testStage = convertStageResult(context, test);
+    const testStage = test.steps.length > 0 ? convertStageResult(context, test) : null;
     const beforeStages = context.fixtures
         .filter((value) => value.type === "before")
         .map((fixture) => convertStageResult(context, fixture))
@@ -103,8 +160,6 @@ export const convertTestResult = (context, test) => {
     const status = convertStatus(test.status);
     const statusMessage = test.error?.message;
     const statusTrace = test.error?.trace;
-    const flaky = false;
-    const categories = matchCategories(context.categories, { statusMessage, statusTrace, status, flaky });
     const retries = context.retries.map((retry) => ({
         uid: retry.id,
         status: convertStatus(retry.status),
@@ -115,25 +170,38 @@ export const convertTestResult = (context, test) => {
             duration: retry.duration,
         },
     }));
-    const retriesStatusChange = status in importantStatuses &&
-        retries.find((tr) => tr.status in importantStatuses && tr.status !== status) !== undefined;
-    const lastHistoryStatus = context.history.find(filterIncludedInSuccessRate)?.status;
+    const retriesStatusChange = isImportantStatus(status) &&
+        retries.find((retry) => isImportantStatus(retry.status) && retry.status !== status) !== undefined;
+    const historyItems = context.legacyHistory
+        ? context.legacyHistory.items.map((item) => ({
+            uid: item.uid,
+            status: item.status,
+            reportUrl: item.reportUrl,
+            statusDetails: item.statusDetails,
+            time: { ...item.time },
+        }))
+        : context.history.map((historyTestResult) => ({
+            uid: historyTestResult.id,
+            status: convertStatus(historyTestResult.status),
+            reportUrl: historyTestResult.url,
+            statusDetails: historyTestResult.error?.message,
+            time: {
+                start: historyTestResult.start,
+                stop: historyTestResult.stop,
+                duration: historyTestResult.duration,
+            },
+        }));
+    const lastHistoryStatus = historyItems.find(({ status: historyStatus }) => isImportantStatus(historyStatus))?.status;
     const newFailed = lastHistoryStatus === "passed" && test.status === "failed";
     const newBroken = lastHistoryStatus === "passed" && test.status === "broken";
     const newPassed = lastHistoryStatus !== undefined && lastHistoryStatus !== "passed" && test.status === "passed";
-    const historyItems = context.history.map((htr) => ({
-        uid: htr.id,
-        status: convertStatus(htr.status),
-        reportUrl: "unsupported",
-        statusDetails: htr.error?.message,
-        time: {
-            start: htr.start,
-            stop: htr.stop,
-            duration: htr.duration,
-        },
-    }));
-    const statistic = { total: 0 };
-    historyItems.forEach((historyItem) => updateStatistic(statistic, historyItem));
+    const flaky = test.flaky || isFlakyFromHistory(status, historyItems);
+    const categories = matchCategories(context.categories, { statusMessage, statusTrace, status, flaky });
+    const statistic = createStatistic(context.legacyHistory?.statistic);
+    if (!context.legacyHistory) {
+        historyItems.forEach((historyItem) => updateStatistic(statistic, historyItem));
+    }
+    updateStatistic(statistic, test);
     const history = {
         statistic,
         items: historyItems,
@@ -155,7 +223,7 @@ export const convertTestResult = (context, test) => {
         statusMessage,
         statusTrace,
         labels: test.labels,
-        links: test.links,
+        links: getAllure2Links(test) ?? test.links,
         parameters: redactParameters(test.parameters),
         afterStages,
         beforeStages,

package/dist/generators.d.ts

@@ -1,18 +1,10 @@
-import type { AttachmentLink, HistoryDataPoint } from "@allurereport/core-api";
+import type { AttachmentLink, GlobalAttachmentLink, HistoryDataPoint, TestError } from "@allurereport/core-api";
 import type { ReportFiles, ResultFile } from "@allurereport/plugin-api";
-import type { Allure2ExecutorInfo, Allure2TestResult } from "./model.js";
+import type { ReportStaticManifest } from "@allurereport/plugin-api/static-assets";
+import type { Allure2CategoriesTrendItem, Allure2DurationTrendItem, Allure2ExecutorInfo, Allure2LegacyHistoryTrendItem, Allure2RetryTrendItem, Allure2TestResult } from "./model.js";
 import type { Allure2DataWriter, ReportFile } from "./writer.js";
-export type TemplateManifest = Record<string, string>;
-export declare const getPackageRoot: () => Promise<string>;
-export declare const readTemplateManifest: (packageRoot: string, singleFileMode?: boolean) => Promise<TemplateManifest>;
-export declare const readManifestEntry: (options: {
-    fileName: string;
-    singleFile?: boolean;
-    mimeType: string;
-    reportFiles: ReportFiles;
-    inserter: (content: string) => string;
-    packageRoot: string;
-}) => Promise<string>;
+export type TemplateManifest = ReportStaticManifest;
+export declare const readTemplateManifest: () => Promise<TemplateManifest>;
 export declare const generateStaticFiles: (payload: {
     allureVersion: string;
     reportName: string;
@@ -34,6 +26,9 @@ export declare const generateEnvironmentJson: (writer: Allure2DataWriter, env: {
 }[]) => Promise<void>;
 export declare const generateExecutorJson: (writer: Allure2DataWriter, executor?: Partial<Allure2ExecutorInfo>) => Promise<void>;
 export declare const generateDefaultWidgetData: (writer: Allure2DataWriter, tests: Allure2TestResult[], ...fileNames: string[]) => Promise<void>;
-export declare const generateEmptyTrendData: (writer: Allure2DataWriter, ...fileNames: string[]) => Promise<void>;
-export declare const generateTrendData: (writer: Allure2DataWriter, reportName: string, tests: Allure2TestResult[], historyDataPoints: HistoryDataPoint[]) => Promise<void>;
+export declare const generateHistoryTrendData: (writer: Allure2DataWriter, reportName: string, tests: Allure2TestResult[], historyDataPoints: HistoryDataPoint[], legacyHistory?: Allure2LegacyHistoryTrendItem[], executor?: Partial<Allure2ExecutorInfo>) => Promise<void>;
+export declare const generateDurationTrendData: (writer: Allure2DataWriter, tests: Allure2TestResult[], history?: Allure2DurationTrendItem[], executor?: Partial<Allure2ExecutorInfo>) => Promise<void>;
+export declare const generateRetryTrendData: (writer: Allure2DataWriter, tests: Allure2TestResult[], history?: Allure2RetryTrendItem[], executor?: Partial<Allure2ExecutorInfo>) => Promise<void>;
+export declare const generateCategoriesTrendData: (writer: Allure2DataWriter, tests: Allure2TestResult[], history?: Allure2CategoriesTrendItem[], executor?: Partial<Allure2ExecutorInfo>) => Promise<void>;
 export declare const generateAttachmentsData: (writer: Allure2DataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string>>;
+export declare const generateGlobalsData: (writer: Allure2DataWriter, globalErrors: TestError[], globalAttachments: GlobalAttachmentLink[], attachmentMap: Map<string, string>, attachmentTimestamps?: Record<string, number>, errorTimestamps?: Array<number | undefined>) => Promise<void>;

package/dist/generators.js

@@ -1,11 +1,9 @@
-import { readFile } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { createBaseUrlScript, createFaviconLinkTag, createReportDataScript, stringifyForInlineScript, createScriptTag, createStylesLinkTag, } from "@allurereport/core-api";
-import { findUp } from "find-up";
+import { createBaseUrlScript, createScriptTag, createStylesLinkTag } from "@allurereport/core-api";
+import { copyReportStaticAssets, getReportStaticAsset, readReportStaticAssets, } from "@allurereport/plugin-api/static-assets";
 import Handlebars from "handlebars";
 import { byLabels, collapseTree, createTree, createWidget } from "./tree.js";
-import { updateStatistic, updateTime } from "./utils.js";
+import { createStatistic, updateStatistic, updateTime } from "./utils.js";
+const reportStaticArchive = new URL("../dist/static/report.tar", import.meta.url);
 const writeConcurrently = async (items, write, concurrency = 64) => {
     for (let i = 0; i < items.length; i += concurrency) {
         await Promise.all(items.slice(i, i + concurrency).map(write));
@@ -15,14 +13,11 @@ const template = `<!DOCTYPE html>
 <html dir="ltr" lang="{{reportLanguage}}">
 <head>
     <meta charset="utf-8">
+    <meta name="allure-report-uuid" content="{{reportUuid}}">
     <title>{{reportName}}</title>
     {{{ headTags }}}
-    <script>
-      window.allureReportOptions = {{{ reportOptions }}};
-    </script>
 </head>
 <body>
-    <svg id="__SVG_SPRITE_NODE__" aria-hidden="true" style="position: absolute; width: 0; height: 0"></svg>
     <div id="alert"></div>
     <div id="content">
         <span class="spinner">
@@ -30,19 +25,29 @@ const template = `<!DOCTYPE html>
         </span>
     </div>
     <div id="popup"></div>
+    <script>
+      window.__allureCoreLoaded = new Promise(function (resolve, reject) {
+        window.__allureResolveCoreLoaded = resolve;
+        window.__allureRejectCoreLoaded = reject;
+      });
+    </script>
     {{{ bodyTags }}}
+    <script>
+      if (typeof window.__allureResolveCoreLoaded === "function") {
+        window.__allureResolveCoreLoaded([]);
+      }
+    </script>
     ${createBaseUrlScript()}
     {{#if analyticsEnable}}
-    <script async src="https://www.googletagmanager.com/gtag/js?id=G-LNDJ3J7WT0"></script>
+    <script async src="https://www.googletagmanager.com/gtag/js?id=G-FVWC4GKEYS"></script>
     <script>
         window.dataLayer = window.dataLayer || [];
         function gtag(){dataLayer.push(arguments);}
         gtag('js', new Date());
-        gtag('config', 'G-LNDJ3J7WT0', {
+        gtag('config', 'G-FVWC4GKEYS', {
           'allureVersion': '{{allureVersion}}',
-          'report':'classic',
           'reportUuid': '{{reportUuid}}',
-          'single_file': '{{singleFile}}'
+          'single_file': {{singleFile}}
         });
     </script>
     {{/if}}
@@ -51,90 +56,62 @@ const template = `<!DOCTYPE html>
 </html>
 `;
 const compiledTemplate = Handlebars.compile(template);
-export const getPackageRoot = async () => {
-    const packageJsonPath = await findUp("package.json", {
-        cwd: dirname(fileURLToPath(import.meta.url)),
-    });
-    return dirname(packageJsonPath);
-};
-export const readTemplateManifest = async (packageRoot, singleFileMode) => {
-    const templateManifestPath = join(packageRoot, "static", singleFileMode ? "single" : "multi", "manifest.json");
-    const templateManifest = await readFile(templateManifestPath, { encoding: "utf-8" });
-    return JSON.parse(templateManifest);
+const createEmbeddedReportDataScript = (reportFiles) => {
+    const reportFilesDeclaration = reportFiles
+        .map(({ name, value }) => `d(${JSON.stringify(name)},${JSON.stringify(value)})`)
+        .join(",");
+    return `
+    <script>
+      window.reportDataReady = false;
+      window.reportData = window.reportData || {};
+
+      function d(name, value) {
+        return new Promise(function (resolve) {
+          window.reportData[name] = value;
+          resolve(true);
+        });
+      }
+    </script>
+    <script>
+      Promise.allSettled([${reportFilesDeclaration}]).then(function () {
+        window.reportDataReady = true;
+      });
+    </script>
+  `;
 };
-export const readManifestEntry = async (options) => {
-    const { fileName, singleFile, mimeType, inserter, reportFiles, packageRoot } = options;
-    const filePath = join(packageRoot, "static", singleFile ? "single" : "multi", fileName);
-    const scriptContentBuffer = await readFile(filePath);
-    if (singleFile) {
-        return inserter(`data:${mimeType};base64,${scriptContentBuffer.toString("base64")}`);
-    }
-    await reportFiles.addFile(fileName, scriptContentBuffer);
-    return inserter(fileName);
+export const readTemplateManifest = async () => {
+    const { manifest } = await readReportStaticAssets(reportStaticArchive);
+    return manifest;
 };
 export const generateStaticFiles = async (payload) => {
-    const packageRoot = await getPackageRoot();
     const { reportName, reportLanguage, singleFile, reportFiles, reportDataFiles, reportUuid, allureVersion } = payload;
-    const manifest = await readTemplateManifest(packageRoot, singleFile);
+    const staticAssets = await readReportStaticAssets(reportStaticArchive);
+    const { manifest } = staticAssets;
+    const mainJs = manifest["main.js"];
+    const mainCss = manifest["main.css"];
     const headTags = [];
     const bodyTags = [];
-    for (const key in manifest) {
-        const fileName = manifest[key];
-        if (key === "favicon.ico") {
-            const tag = await readManifestEntry({
-                fileName,
-                singleFile,
-                reportFiles,
-                inserter: createFaviconLinkTag,
-                mimeType: "image/x-icon",
-                packageRoot,
-            });
-            headTags.push(tag);
-            continue;
+    if (!singleFile) {
+        if (mainCss) {
+            headTags.push(createStylesLinkTag(mainCss));
         }
-        if (key === "main.css") {
-            const tag = await readManifestEntry({
-                fileName,
-                singleFile,
-                reportFiles,
-                inserter: createStylesLinkTag,
-                mimeType: "text/css",
-                packageRoot,
-            });
-            headTags.push(tag);
-            continue;
-        }
-        if (key === "main.js") {
-            const tag = await readManifestEntry({
-                fileName,
-                singleFile,
-                reportFiles,
-                inserter: createScriptTag,
-                mimeType: "text/javascript",
-                packageRoot,
-            });
-            bodyTags.push(tag);
-            continue;
-        }
-        if (singleFile) {
-            continue;
+        bodyTags.push(createScriptTag(mainJs));
+        await copyReportStaticAssets(staticAssets, reportFiles);
+    }
+    else {
+        if (mainCss) {
+            const mainCssContent = getReportStaticAsset(staticAssets, mainCss);
+            headTags.push(createStylesLinkTag(`data:text/css;base64,${mainCssContent.toString("base64")}`));
         }
-        const filePath = join(packageRoot, "static", singleFile ? "single" : "multi", fileName);
-        const fileContent = await readFile(filePath);
-        await reportFiles.addFile(basename(filePath), fileContent);
+        const mainJsContent = getReportStaticAsset(staticAssets, mainJs);
+        bodyTags.push(createScriptTag(`data:text/javascript;base64,${mainJsContent.toString("base64")}`));
     }
-    const reportOptions = {
-        reportName: reportName ?? "Allure Report",
-        reportLanguage: reportLanguage ?? "en",
-        createdAt: Date.now(),
-    };
     try {
         const html = compiledTemplate({
             headTags: headTags.join("\n"),
             bodyTags: bodyTags.join("\n"),
-            reportFilesScript: createReportDataScript(reportDataFiles),
-            reportOptions: stringifyForInlineScript(reportOptions),
-            analyticsEnable: true,
+            reportFilesScript: singleFile ? createEmbeddedReportDataScript(reportDataFiles) : "",
+            analyticsEnable: process.env.ALLURE_NO_ANALYTICS?.toLowerCase() !== "true",
             allureVersion,
             reportLanguage,
             reportUuid,
@@ -198,7 +175,7 @@ export const generateTestResults = async (writer, tests) => {
     await writeConcurrently(tests, (test) => writer.writeTestCase(test));
 };
 export const generateSummaryJson = async (writer, reportName, tests) => {
-    const statistic = { total: 0 };
+    const statistic = createStatistic();
     const time = {};
     tests
         .filter((test) => !test.isRetry)
@@ -235,50 +212,85 @@ export const generateDefaultWidgetData = async (writer, tests, ...fileNames) =>
         await writer.writeWidget(fileName, statusChartData);
     }
 };
-export const generateEmptyTrendData = async (writer, ...fileNames) => {
-    for (const fileName of fileNames) {
-        await writer.writeWidget(fileName, [
-            {
-                uid: "invalid",
-                name: "invalid",
-                statistic: { total: 0 },
-            },
-        ]);
-    }
-};
-export const generateTrendData = async (writer, reportName, tests, historyDataPoints) => {
-    const statistic = { total: 0 };
+const trendIdentity = (executor) => ({
+    buildOrder: executor?.buildOrder,
+    reportName: executor?.reportName,
+    reportUrl: executor?.reportUrl,
+});
+const prependTrendItem = (current, previous) => [current, ...previous].slice(0, 20);
+export const generateHistoryTrendData = async (writer, reportName, tests, historyDataPoints, legacyHistory = [], executor) => {
+    const statistic = createStatistic();
     tests
         .filter((test) => !test.isRetry)
         .forEach((test) => {
         updateStatistic(statistic, test);
     });
-    const history = historyDataPoints.map((point) => {
-        const stat = { total: 0 };
-        Object.values(point.testResults).forEach((testResult) => {
-            updateStatistic(stat, testResult);
+    const history = legacyHistory.length
+        ? legacyHistory.map(({ data, statistic: legacyStatistic, ...item }) => ({
+            ...item,
+            data: createStatistic(data ?? legacyStatistic),
+        }))
+        : historyDataPoints
+            .map((point) => {
+            const stat = createStatistic();
+            Object.values(point.testResults).forEach((testResult) => {
+                updateStatistic(stat, testResult);
+            });
+            return {
+                data: stat,
+                reportName: point.name,
+                reportUrl: point.url,
+                timestamp: point.timestamp,
+            };
+        })
+            .sort((left, right) => right.timestamp - left.timestamp)
+            .map(({ timestamp: _timestamp, ...item }, index, values) => ({
+            ...item,
+            buildOrder: values.length - index,
+        }));
+    const current = {
+        data: statistic,
+        ...(executor
+            ? trendIdentity(executor)
+            : {
+                buildOrder: history.length + 1,
+                reportName,
+            }),
+    };
+    await writer.writeWidget("history-trend.json", prependTrendItem(current, history));
+};
+export const generateDurationTrendData = async (writer, tests, history = [], executor) => {
+    const time = {};
+    tests.forEach((test) => updateTime(time, test));
+    const current = {
+        data: { duration: time.duration ?? 0 },
+        ...trendIdentity(executor),
+    };
+    await writer.writeWidget("duration-trend.json", prependTrendItem(current, history));
+};
+export const generateRetryTrendData = async (writer, tests, history = [], executor) => {
+    const current = {
+        data: {
+            run: tests.filter((test) => !test.isRetry).length,
+            retry: tests.filter((test) => test.isRetry).length,
+        },
+        ...trendIdentity(executor),
+    };
+    await writer.writeWidget("retry-trend.json", prependTrendItem(current, history));
+};
+export const generateCategoriesTrendData = async (writer, tests, history = [], executor) => {
+    const categories = {};
+    tests.forEach((test) => {
+        const testCategories = test.extra.categories ?? [];
+        testCategories.forEach(({ name }) => {
+            categories[name] = (categories[name] ?? 0) + 1;
         });
-        return {
-            data: stat,
-            timestamp: point.timestamp,
-            reportName: point.name,
-        };
-    });
-    history
-        .sort((a, b) => b.timestamp - a.timestamp)
-        .forEach((element, index) => {
-        element.buildOrder = history.length - index;
     });
-    const data = [
-        {
-            data: statistic,
-            timestamp: new Date().getTime(),
-            buildOrder: history.length + 1,
-            reportName: reportName,
-        },
-        ...history,
-    ];
-    await writer.writeWidget("history-trend.json", data);
+    const current = {
+        data: categories,
+        ...trendIdentity(executor),
+    };
+    await writer.writeWidget("categories-trend.json", prependTrendItem(current, history));
 };
 export const generateAttachmentsData = async (writer, attachmentLinks, contentFunction) => {
     const result = new Map();
@@ -296,3 +308,31 @@ export const generateAttachmentsData = async (writer, attachmentLinks, contentFu
     }
     return result;
 };
+export const generateGlobalsData = async (writer, globalErrors, globalAttachments, attachmentMap, attachmentTimestamps = {}, errorTimestamps = []) => {
+    const data = {
+        errors: globalErrors.map(({ message, trace, actual, expected }, index) => ({
+            message,
+            trace,
+            actual,
+            expected,
+            timestamp: errorTimestamps[index],
+        })),
+        attachments: globalAttachments.flatMap((attachment) => {
+            const source = attachmentMap.get(attachment.id);
+            if (!source) {
+                return [];
+            }
+            return [
+                {
+                    uid: attachment.id,
+                    name: attachment.name,
+                    source,
+                    type: attachment.contentType ?? "application/octet-stream",
+                    size: !attachment.missed ? attachment.contentLength : undefined,
+                    timestamp: attachment.originalFileName ? attachmentTimestamps[attachment.originalFileName] : undefined,
+                },
+            ];
+        }),
+    };
+    await writer.writeWidget("globals.json", data);
+};

package/dist/model.d.ts

@@ -25,6 +25,22 @@ export interface Allure2Attachment {
     type?: string;
     size?: number;
 }
+export interface Allure2GlobalError {
+    timestamp?: number;
+    message?: string;
+    trace?: string;
+    actual?: string;
+    expected?: string;
+}
+export interface Allure2GlobalAttachment extends Allure2Attachment {
+    source: string;
+    type: string;
+    timestamp?: number;
+}
+export interface Allure2GlobalsData {
+    errors: Allure2GlobalError[];
+    attachments: Allure2GlobalAttachment[];
+}
 export interface Allure2Step {
     name: string;
     time: Allure2Time;
@@ -60,7 +76,7 @@ export interface Allure2TestResult {
     retriesCount: number;
     retriesStatusChange: boolean;
     beforeStages: Allure2StageResult[];
-    testStage: Allure2StageResult;
+    testStage: Allure2StageResult | null;
     afterStages: Allure2StageResult[];
     labels: Allure2Label[];
     parameters: Allure2Parameter[];
@@ -113,7 +129,7 @@ export interface Allure2RetryItem {
 }
 export interface Allure2HistoryItem {
     uid: string;
-    reportUrl: string;
+    reportUrl?: string;
     status: Allure2Status;
     statusDetails?: string;
     time: Allure2Time;
@@ -128,6 +144,25 @@ export interface Allure2HistoryTrendItem {
     reportUrl?: string;
     reportName?: string;
 }
+export interface Allure2LegacyHistoryTrendItem extends Omit<Allure2HistoryTrendItem, "data"> {
+    data?: Statistic;
+    statistic?: Statistic;
+}
+export interface Allure2TrendItem<T extends Record<string, number> = Record<string, number>> {
+    data: T;
+    buildOrder?: number;
+    reportUrl?: string;
+    reportName?: string;
+}
+export type Allure2DurationTrendItem = Allure2TrendItem<{
+    duration: number;
+}>;
+export type Allure2RetryTrendItem = Allure2TrendItem<{
+    run: number;
+    retry: number;
+}>;
+export type Allure2CategoriesTrendItem = Allure2TrendItem<Record<string, number>>;
+export type Allure2LegacyHistory = Record<string, Allure2HistoryData>;
 export type Allure2Options = {
     reportName?: string;
     singleFile?: boolean;

package/dist/model.js

@@ -1,2 +1,2 @@
-export const statisticKeys = ["failed", "broken", "passed", "skipped", "unknown", "total"];
+export const statisticKeys = ["failed", "broken", "skipped", "passed", "unknown", "total"];
 export const severityValues = ["blocker", "critical", "normal", "minor", "trivial"];

package/dist/plugin.js

@@ -6,7 +6,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _Allure2Plugin_generate;
 import { createPluginSummary, preciseTreeLabels, } from "@allurereport/plugin-api";
 import { convertTestResult } from "./converters.js";
-import { generateAttachmentsData, generateCategoriesData, generateDefaultWidgetData, generateEmptyTrendData, generateEnvironmentJson, generateExecutorJson, generatePackagesData, generateStaticFiles, generateSummaryJson, generateTestResults, generateTimelineData, generateTree, generateTrendData, } from "./generators.js";
+import { generateAttachmentsData, generateCategoriesData, generateCategoriesTrendData, generateDefaultWidgetData, generateDurationTrendData, generateEnvironmentJson, generateExecutorJson, generateGlobalsData, generateHistoryTrendData, generatePackagesData, generateRetryTrendData, generateStaticFiles, generateSummaryJson, generateTestResults, generateTimelineData, generateTree, } from "./generators.js";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
 export class Allure2Plugin {
     constructor(options = {}) {
@@ -16,7 +16,15 @@ export class Allure2Plugin {
             const writer = singleFile ? new InMemoryReportDataWriter() : new ReportFileDataWriter(context.reportFiles);
             const attachmentLinks = await store.allAttachments();
             const attachmentMap = await generateAttachmentsData(writer, attachmentLinks, (id) => store.attachmentContentById(id));
+            const [globalErrors, globalAttachments] = await Promise.all([
+                store.allGlobalErrors(),
+                store.allGlobalAttachments(),
+            ]);
+            const globalAttachmentTimestamps = (await store.metadataByKey("allure2_global_attachment_timestamps")) ?? {};
+            const globalErrorTimestamps = (await store.metadataByKey("allure2_global_error_timestamps")) ?? [];
+            await generateGlobalsData(writer, globalErrors, globalAttachments, attachmentMap, globalAttachmentTimestamps, globalErrorTimestamps);
             const categories = (await store.metadataByKey("allure2_categories")) ?? [];
+            const legacyHistory = (await store.metadataByKey("allure2_history")) ?? {};
             const environmentItems = (await store.metadataByKey("allure_environment")) ?? [];
             const tests = await store.allTestResults({ includeRetries: true });
             const related = await store.relatedByTestResultIds(tests.map(({ id }) => id));
@@ -31,6 +39,7 @@ export class Allure2Plugin {
                     categories,
                     retries,
                     history,
+                    legacyHistory: value.historyId ? legacyHistory[value.historyId] : undefined,
                 }, value);
                 allTr.push(allure2TestResult);
             }
@@ -51,10 +60,16 @@ export class Allure2Plugin {
             await generateEnvironmentJson(writer, environmentItems);
             const executor = await store.metadataByKey("allure2_executor");
             const historyDataPoints = await store.allHistoryDataPoints();
+            const historyTrend = (await store.metadataByKey("allure2_history_trend")) ?? [];
+            const durationTrend = (await store.metadataByKey("allure2_duration_trend")) ?? [];
+            const retryTrend = (await store.metadataByKey("allure2_retry_trend")) ?? [];
+            const categoriesTrend = (await store.metadataByKey("allure2_categories_trend")) ?? [];
             await generateExecutorJson(writer, executor);
             await generateDefaultWidgetData(writer, displayedTr, "duration.json", "status-chart.json", "severity.json");
-            await generateTrendData(writer, reportName, displayedTr, historyDataPoints);
-            await generateEmptyTrendData(writer, "duration-trend.json", "categories-trend.json", "retry-trend.json");
+            await generateHistoryTrendData(writer, reportName, displayedTr, historyDataPoints, historyTrend, executor);
+            await generateDurationTrendData(writer, displayedTr, durationTrend, executor);
+            await generateRetryTrendData(writer, allTr, retryTrend, executor);
+            await generateCategoriesTrendData(writer, allTr, categoriesTrend, executor);
             const reportDataFiles = singleFile ? writer.reportFiles() : [];
             await generateStaticFiles({
                 allureVersion: context.allureVersion,

package/dist/tree.d.ts

@@ -19,6 +19,7 @@ export interface TreeLeaf extends TreeNode {
     newPassed: boolean;
     retriesCount: number;
     retriesStatusChange: boolean;
+    retry: boolean;
     tags: string[];
     parameters: string[];
 }

package/dist/tree.js

@@ -15,6 +15,7 @@ const createLeaf = (endNode, test) => {
         newPassed: test.newPassed,
         retriesCount: test.retriesCount,
         retriesStatusChange: test.retriesStatusChange,
+        retry: test.retry,
         parameters: test.parameters.filter((p) => p.value).map((p) => p.value),
         tags: test.extra.tags ?? [],
     };

package/dist/utils.d.ts

@@ -1,6 +1,7 @@
 import type { Statistic } from "@allurereport/core-api";
 import type { Allure2Status, Allure2TestResult, GroupTime } from "./model.js";
 import type { TreeGroup } from "./tree.js";
+export declare const createStatistic: (source?: Partial<Statistic>) => Statistic;
 export declare const updateStatistic: (statistic: Statistic, test: {
     status: Allure2Status;
 }) => undefined;

package/dist/utils.js

@@ -1,4 +1,14 @@
 import { statisticKeys } from "./model.js";
+export const createStatistic = (source = {}) => ({
+    failed: 0,
+    broken: 0,
+    skipped: 0,
+    passed: 0,
+    unknown: 0,
+    ...source,
+    total: source.total ??
+        (source.failed ?? 0) + (source.broken ?? 0) + (source.skipped ?? 0) + (source.passed ?? 0) + (source.unknown ?? 0),
+});
 export const updateStatistic = (statistic, test) => {
     statistic[test.status] = (statistic[test.status] ?? 0) + 1;
     statistic.total = (statistic.total ?? 0) + 1;
@@ -22,7 +32,7 @@ export const updateTime = (time, test) => {
     }
 };
 export const calculateStatisticByLeafs = (treeGroup) => {
-    const current = { total: 0 };
+    const current = createStatistic();
     treeGroup.children.forEach((child) => {
         if ("children" in child) {
             const childGroup = child;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@allurereport/plugin-allure2",
-  "version": "3.15.0",
-  "description": "The classic version of Allure HTML report",
+  "version": "3.16.1",
+  "description": "The Allure 2-compatible HTML report",
   "keywords": [
     "allure",
     "html",
@@ -23,19 +23,19 @@
     ".": "./dist/index.js"
   },
   "scripts": {
-    "build": "run clean && tsc --project ./tsconfig.json",
+    "build": "run clean && tsc --project ./tsconfig.json && node ../../scripts/pack-report-static.mjs ../web-allure2/dist/multi ./dist/static/report.tar",
     "clean": "rimraf ./dist",
     "test": "rimraf ./out && vitest run",
     "lint": "oxlint --import-plugin src test features stories",
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.15.0",
-    "@allurereport/plugin-api": "3.15.0",
-    "find-up": "^8.0.0",
+    "@allurereport/core-api": "3.16.1",
+    "@allurereport/plugin-api": "3.16.1",
     "handlebars": "^4.7.9"
   },
   "devDependencies": {
+    "@allurereport/web-allure2": "3.16.1",
     "@types/node": "^20",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",