@allurereport/plugin-allure2 3.16.0 → 3.17.0

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>;