@allurereport/plugin-awesome 3.19.1 → 3.20.1

package/dist/generators.d.ts

@@ -1,11 +1,12 @@
 import { type AttachmentLink, type EnvironmentIdentity, type EnvironmentItem, type HistoryTestResultUrlResolver, type MetricSample, type Statistic, type TestEnvGroup, type TestResult } from "@allurereport/core-api";
-import type { AllureStore, ReportExecutorInfo, ReportRunSummary, ReportTestResult, GlobalAttachmentLink, ExitCode, PluginContext, PluginGlobalError, QualityGateValidationResult, ReportFiles, ResultFile } from "@allurereport/plugin-api";
+import type { AllureStore, ReportExecutorInfo, ReportRunSummary, ReportTestResult, GlobalAttachmentLink, ExitCode, PluginContext, PluginGlobalError, QualityGateValidationResult, ReportFiles, ResultFile, TestResultRelatedData } from "@allurereport/plugin-api";
 import type { AwesomeOptions, TemplateManifest } from "./model.js";
 import type { AwesomeDataWriter, ReportFile } from "./writer.js";
 export declare const readTemplateManifest: (_singleFileMode?: boolean) => Promise<TemplateManifest>;
 export declare const generateTestResults: (_writer: AwesomeDataWriter, store: AllureStore, trs: TestResult[], options: {
     pluginId: string;
     hideLabels?: readonly (string | RegExp)[];
+    related?: TestResultRelatedData;
     resolveHistoryUrl?: HistoryTestResultUrlResolver;
 }) => Promise<ReportTestResult[]>;
 export declare const generateTestCases: (writer: AwesomeDataWriter, trs: ReportTestResult[]) => Promise<void>;

package/dist/generators.js

@@ -1,6 +1,6 @@
 import { randomUUID } from "node:crypto";
 import { defaultChartsConfig } from "@allurereport/charts-api";
-import { appLoaderFaviconDataUri, appLoaderStyles, compareBy, createAppLoaderMarkup, createBaseUrlScript, createFaviconLinkTag, createFontLinkTag, createReportDataScript, stringifyForInlineScript, createScriptTag, createStylesLinkTag, incrementStatistic, joinPosixPath, nullsLast, ordinal, severityLabelName, } from "@allurereport/core-api";
+import { appLoaderFaviconDataUri, appLoaderStyles, compareBy, createAppLoaderMarkup, createBaseUrlScript, createFaviconLinkTag, createFontLinkTag, createReportDataScript, stringifyForInlineScript, createScriptTag, createStylesLinkTag, incrementStatistic, joinPosixPath, nullsLast, ordinal, redactParameters, severityLabelName, } from "@allurereport/core-api";
 import { collapseTreeGroups, createTreeByLabels, createTreeByLabelsAndTitlePath, createTreeByTitlePath, preciseTreeLabels, processTree, } from "@allurereport/plugin-api";
 import { copyReportStaticAssets, getReportStaticAsset, readReportStaticAssets, } from "@allurereport/plugin-api/static-assets";
 import { generateCharts, getPieChartValues } from "@allurereport/web-commons";
@@ -78,9 +78,17 @@ const writeConcurrently = async (items, write, concurrency = 64) => {
         await Promise.all(items.slice(i, i + concurrency).map(write));
     }
 };
+const mapConcurrently = async (items, map, concurrency = 8) => {
+    const results = [];
+    for (let i = 0; i < items.length; i += concurrency) {
+        results.push(...(await Promise.all(items.slice(i, i + concurrency).map(map))));
+    }
+    return results;
+};
 export const generateTestResults = async (_writer, store, trs, options) => {
     let convertedTrs = [];
-    const related = await store.relatedByTestResultIds(trs.map(({ id }) => id));
+    const related = options.related ?? (await store.relatedByTestResultIds(trs.map(({ id }) => id)));
+    const resolutionIssuesByTrId = related.resolutionIssuesByTrId;
     for (const tr of trs) {
         const trFixtures = related.fixturesByTrId.get(tr.id) ?? [];
         const convertedTrFixtures = [...trFixtures]
@@ -89,7 +97,6 @@ export const generateTestResults = async (_writer, store, trs, options) => {
         const convertedTr = convertTestResult(tr, {
             hideLabels: options.hideLabels,
         });
-        const resolutionIssue = await store.resolutionIssueByTestResultId(tr.id);
         convertedTr.history = (related.historyByTrId.get(tr.id) ?? []).map((item) => ({
             ...item,
             url: options.resolveHistoryUrl?.(item.url, options.pluginId, item.id) ?? "",
@@ -105,7 +112,9 @@ export const generateTestResults = async (_writer, store, trs, options) => {
             type: "attachment",
         }));
         convertedTr.breadcrumbs = createBreadcrumbs(convertedTr);
-        convertedTr.resolutionIssue = resolutionIssue;
+        convertedTr.resolutionIssue = resolutionIssuesByTrId
+            ? resolutionIssuesByTrId.get(tr.id)
+            : await store.resolutionIssueByTestResultId(tr.id);
         convertedTrs.push(convertedTr);
     }
     convertedTrs = convertedTrs.sort(nullsLast(compareBy("start", ordinal()))).map((tr, idx) => ({
@@ -273,7 +282,9 @@ const buildTreeByTitlePath = (tests) => {
     };
 };
 const buildTreeByLabelsAndTitlePathCombined = (tests, labels) => collapseTreeGroups(createTreeByLabelsAndTitlePath(tests, labels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status)));
-const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesCount, resolution, transition, tooltips, retryHash, groupedLabels, categories, }) => {
+const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesCount, resolution, transition, tooltips, retryHash, groupedLabels, categories, parameters, }) => {
+    const unresolvedFailure = (status === "failed" || status === "broken") && !resolution;
+    const parameterValues = redactParameters(parameters).flatMap(({ value }) => (value ? [value] : []));
     const leaf = {
         nodeId: id,
         id: retryHash ?? id,
@@ -285,9 +296,13 @@ const leafFactory = ({ id, name, status, duration, flaky, start, retry, retriesC
         retry,
         retriesCount,
         resolution,
+        resolutionStatus: resolution ?? (unresolvedFailure ? "none" : undefined),
         transition,
         tooltips,
     };
+    if (parameterValues.length) {
+        leaf.parameters = parameterValues;
+    }
     const severity = groupedLabels[severityLabelName]?.[0];
     if (severity) {
         leaf.severity = severity;
@@ -377,20 +392,19 @@ export const generateStatistic = async (writer, data) => {
     }
 };
 export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
-    const result = new Map();
-    for (const { id, ext, ...link } of attachmentLinks) {
+    const writtenAttachments = await mapConcurrently(attachmentLinks, async ({ id, ext, ...link }) => {
         if (link.missed) {
-            continue;
+            return;
         }
         const content = await contentFunction(id);
         if (!content) {
-            continue;
+            return;
         }
         const src = `${id}${ext}`;
         await writer.writeAttachment(src, content);
-        result.set(id, src);
-    }
-    return result;
+        return [id, src];
+    });
+    return new Map(writtenAttachments.filter((attachment) => attachment !== undefined));
 };
 export const generateHistoryDataPoints = async (writer, store) => {
     const result = new Map();
@@ -411,15 +425,22 @@ export const generateGlobals = async (writer, payload) => {
     if (globalExitCode) {
         globals.exitCode = globalExitCode;
     }
-    for (const attachment of globalAttachments) {
+    const attachmentWrites = new Map();
+    const writtenAttachments = await mapConcurrently(globalAttachments, async (attachment) => {
         const src = `${attachment.id}${attachment.ext}`;
         const content = await contentFunction(attachment.id);
         if (!content) {
-            continue;
+            return;
         }
-        await writer.writeAttachment(src, content);
-        globals.attachments.push(attachment);
-    }
+        let write = attachmentWrites.get(src);
+        if (!write) {
+            write = writer.writeAttachment(src, content);
+            attachmentWrites.set(src, write);
+        }
+        await write;
+        return attachment;
+    });
+    globals.attachments = writtenAttachments.filter((attachment) => attachment !== undefined);
     Object.entries(globalAttachmentsByEnv).forEach(([environmentId, attachments]) => {
         const attachmentIds = new Set(globals.attachments.map(({ id }) => id));
         const writtenAttachments = attachments.filter(({ id }) => attachmentIds.has(id));

package/dist/plugin.js

@@ -10,16 +10,15 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _AwesomePlugin_writer, _AwesomePlugin_generateAfterStart, _AwesomePlugin_generate;
-import { incrementStatistic, joinPosixPath, } from "@allurereport/core-api";
+import { incrementStatistic, validateEnvironmentId, joinPosixPath, } from "@allurereport/core-api";
 import { createPluginSummary, } from "@allurereport/plugin-api";
 import { preciseTreeLabels } from "@allurereport/plugin-api";
 import { applyCategoriesToTestResults, generateCategories } from "./categories.js";
 import { generateTimeline } from "./generateTimeline.js";
 import { generateAllCharts, generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateGlobals, generateHistoryDataPoints, generateMetricsWidget, generateNav, generateQualityGateResults, generateResolutionCategories, generateSearchIndex, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateTreeFilters, generateVariables, getRunSummary, } from "./generators.js";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
-const statisticByTestResults = async (store, testResults) => {
+const statisticByTestResults = (testResults, trIdsWithRetries) => {
     const statistic = { total: 0 };
-    const related = await store.relatedByTestResultIds(testResults.map(({ id }) => id));
     const incrementResolution = (testResult) => {
         if (testResult.resolution === "issue") {
             statistic.resolutions ?? (statistic.resolutions = {});
@@ -39,7 +38,7 @@ const statisticByTestResults = async (store, testResults) => {
             continue;
         }
         incrementStatistic(statistic, testResult.status);
-        if ((related.retriesByTrId.get(testResult.id)?.length ?? 0) > 0) {
+        if (trIdsWithRetries.has(testResult.id)) {
             statistic.retries = (statistic.retries ?? 0) + 1;
         }
         if (testResult.flaky) {
@@ -69,13 +68,15 @@ export class AwesomePlugin {
             const measure = (name, fn) => perf?.measure(name, fn) ?? fn();
             const hideLabels = context.hideLabels;
             const categories = context.categories ?? [];
-            const { environmentItems, executor, attachments, allTrs, runSummary, statistics, environments, allTestEnvGroups, globalAttachments, globalAttachmentsByEnv, globalExitCode, globalErrors, globalErrorsByEnv, qualityGateResults, } = await measure("readData", async () => {
+            const { environmentItems, executor, attachments, allTrs, related, runSummary, statistics, environments, allTestEnvGroups, globalAttachments, globalAttachmentsByEnv, globalExitCode, globalErrors, globalErrorsByEnv, qualityGateResults, } = await measure("readData", async () => {
                 const testResults = await store.allTestResults({ includeRetries: true, filter });
+                const relatedData = await store.relatedByTestResultIds(testResults.map(({ id }) => id));
                 return {
                     environmentItems: await store.metadataByKey("allure_environment"),
                     executor: await store.metadataByKey("allure2_executor"),
                     attachments: await store.allAttachments(),
                     allTrs: testResults,
+                    related: relatedData,
                     runSummary: getRunSummary(testResults),
                     statistics: await store.testsStatistic(filter),
                     environments: await store.allEnvironmentIdentities(),
@@ -116,9 +117,15 @@ export class AwesomePlugin {
             });
             const trsByEnvId = new Map();
             await measure("stats", async () => {
+                const trIdsWithRetries = new Set();
                 const envStatistics = new Map();
-                const pieStatistics = await statisticByTestResults(store, allTrs.filter(isActiveStatisticTestResult));
                 const pieEnvStatistics = new Map();
+                related.retriesByTrId.forEach((retries, trId) => {
+                    if (retries.length > 0) {
+                        trIdsWithRetries.add(trId);
+                    }
+                });
+                const pieStatistics = statisticByTestResults(allTrs.filter(isActiveStatisticTestResult), trIdsWithRetries);
                 for (const tr of allTrs) {
                     const environmentId = envIdByTrId.get(tr.id);
                     if (!environmentId) {
@@ -134,8 +141,8 @@ export class AwesomePlugin {
                 }
                 await Promise.all(environments.map(async ({ id }) => {
                     const envTrs = trsByEnvId.get(id) ?? [];
-                    envStatistics.set(id, await statisticByTestResults(store, envTrs));
-                    pieEnvStatistics.set(id, await statisticByTestResults(store, envTrs.filter(isActiveStatisticTestResult)));
+                    envStatistics.set(id, statisticByTestResults(envTrs, trIdsWithRetries));
+                    pieEnvStatistics.set(id, statisticByTestResults(envTrs.filter(isActiveStatisticTestResult), trIdsWithRetries));
                 }));
                 await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
                     stats: statistics,
@@ -157,6 +164,7 @@ export class AwesomePlugin {
             const convertedTrs = await measure("convert", () => generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs, {
                 pluginId: context.id,
                 hideLabels,
+                related,
                 resolveHistoryUrl: context.history?.resolveTestResultUrl,
             }));
             if (perf) {
@@ -194,7 +202,11 @@ export class AwesomePlugin {
             const convertedTrsById = new Map(convertedTrs.map((tr) => [tr.id, tr]));
             await measure("environmentsOutput", async () => {
                 for (const reportEnvironment of environments) {
-                    const envTrs = await store.testResultsByEnvironmentId(reportEnvironment.id, { includeRetries: true });
+                    const environmentIdValidation = validateEnvironmentId(reportEnvironment.id);
+                    if (!environmentIdValidation.valid) {
+                        throw new Error(`Invalid environmentId ${JSON.stringify(reportEnvironment.id)}: ${environmentIdValidation.reason}`);
+                    }
+                    const envTrs = trsByEnvId.get(reportEnvironment.id) ?? [];
                     const envConvertedTrs = envTrs
                         .map((tr) => convertedTrsById.get(tr.id))
                         .filter((tr) => Boolean(tr));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.19.1",
+  "version": "3.20.1",
   "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
   "keywords": [
     "allure",
@@ -30,16 +30,16 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/charts-api": "3.19.1",
-    "@allurereport/core-api": "3.19.1",
-    "@allurereport/plugin-api": "3.19.1",
-    "@allurereport/web-commons": "3.19.1",
+    "@allurereport/charts-api": "3.20.1",
+    "@allurereport/core-api": "3.20.1",
+    "@allurereport/plugin-api": "3.20.1",
+    "@allurereport/web-commons": "3.20.1",
     "d3-shape": "^3.2.0",
     "handlebars": "^4.7.9",
     "markdown-it": "^14.2.0"
   },
   "devDependencies": {
-    "@allurereport/web-awesome": "3.19.1",
+    "@allurereport/web-awesome": "3.20.1",
     "@types/d3-shape": "^3.1.8",
     "@types/markdown-it": "^14.1.2",
     "@types/node": "^20",