@allurereport/plugin-awesome 3.0.0-beta.10 → 3.0.0-beta.12

package/dist/charts.d.ts

@@ -11,4 +11,4 @@ export type TestResultChartData = {
 export declare const d3Arc: import("d3-shape").Arc<any, PieArcDatum<TestResultSlice>>;
 export declare const d3Pie: import("d3-shape").Pie<any, TestResultSlice>;
 export declare const getPercentage: (value: number, total: number) => number;
-export declare const getChartData: (stats: Statistic) => TestResultChartData;
+export declare const getPieChartData: (stats: Statistic) => TestResultChartData;

package/dist/charts.js

@@ -6,7 +6,7 @@ export const d3Pie = pie()
     .padAngle(0.03)
     .sortValues((a, b) => a - b);
 export const getPercentage = (value, total) => Math.floor((value / total) * 10000) / 100;
-export const getChartData = (stats) => {
+export const getPieChartData = (stats) => {
     const convertedStatuses = statusesList
         .filter((status) => !!stats?.[status])
         .map((status) => ({

package/dist/converters.js

@@ -27,6 +27,8 @@ export const convertTestResult = (tr) => {
         links: tr.links,
         steps: tr.steps,
         error: tr.error,
+        testCase: tr.testCase,
+        environment: tr.environment,
         setup: [],
         teardown: [],
         history: [],

package/dist/environments.d.ts

@@ -0,0 +1,3 @@
+import type { TestResult } from "@allurereport/core-api";
+import type { TestResultFilter } from "@allurereport/plugin-api";
+export declare const filterEnv: (env: string, filter?: TestResultFilter) => (testResult: TestResult) => boolean;

package/dist/environments.js

@@ -0,0 +1,8 @@
+export const filterEnv = (env, filter) => {
+    return (testResult) => {
+        if (testResult.environment !== env) {
+            return false;
+        }
+        return filter ? filter(testResult) : true;
+    };
+};

package/dist/generators.d.ts

@@ -1,14 +1,19 @@
-import { type AttachmentLink, type EnvironmentItem, type Statistic } from "@allurereport/core-api";
-import { type AllureStore, type ReportFiles, type ResultFile } from "@allurereport/plugin-api";
+import { type AttachmentLink, type EnvironmentItem } from "@allurereport/core-api";
+import { type AllureStore, type ReportFiles, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
 import type { AwesomeTestResult } from "@allurereport/web-awesome";
 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) => Promise<AwesomeTestResult[]>;
-export declare const generateTree: (writer: AwesomeDataWriter, treeName: string, labels: string[], tests: AwesomeTestResult[]) => Promise<void>;
+export declare const generateTestResults: (writer: AwesomeDataWriter, store: AllureStore, filter?: TestResultFilter) => Promise<AwesomeTestResult[]>;
+export declare const generateTestCases: (writer: AwesomeDataWriter, trs: AwesomeTestResult[]) => Promise<void>;
+export declare const generateTestEnvGroups: (writer: AwesomeDataWriter, store: AllureStore) => Promise<void>;
+export declare const generateNav: (writer: AwesomeDataWriter, trs: AwesomeTestResult[], filename?: string) => Promise<void>;
+export declare const generateTree: (writer: AwesomeDataWriter, treeFilename: string, labels: string[], tests: AwesomeTestResult[]) => Promise<void>;
 export declare const generateEnvironmentJson: (writer: AwesomeDataWriter, env: EnvironmentItem[]) => Promise<void>;
-export declare const generateStatistic: (writer: AwesomeDataWriter, statistic: Statistic) => Promise<void>;
-export declare const generatePieChart: (writer: AwesomeDataWriter, statistic: Statistic) => Promise<void>;
+export declare const generateEnvirontmentsList: (writer: AwesomeDataWriter, store: AllureStore) => Promise<void>;
+export declare const generateVariables: (writer: AwesomeDataWriter, store: AllureStore) => Promise<void>;
+export declare const generateStatistic: (writer: AwesomeDataWriter, store: AllureStore, filter?: TestResultFilter) => Promise<void>;
+export declare const generatePieChart: (writer: AwesomeDataWriter, store: AllureStore, filter?: TestResultFilter) => Promise<void>;
 export declare const generateAttachmentsFiles: (writer: AwesomeDataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string> | undefined>;
 export declare const generateHistoryDataPoints: (writer: AwesomeDataWriter, store: AllureStore) => Promise<Map<string, string>>;
 export declare const generateStaticFiles: (payload: AwesomeOptions & {

package/dist/generators.js

@@ -1,13 +1,14 @@
 import { compareBy, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
-import { filterTree } from "@allurereport/plugin-api";
+import { filterTree, } from "@allurereport/plugin-api";
 import { createTreeByLabels, sortTree, transformTree } from "@allurereport/plugin-api";
 import { createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, } from "@allurereport/web-commons";
 import Handlebars from "handlebars";
 import { readFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { basename, join } from "node:path";
-import { getChartData } from "./charts.js";
+import { getPieChartData } from "./charts.js";
 import { convertFixtureResult, convertTestResult } from "./converters.js";
+import { filterEnv } from "./environments.js";
 const require = createRequire(import.meta.url);
 const template = `<!DOCTYPE html>
 <html dir="ltr" lang="en">
@@ -73,8 +74,8 @@ const createBreadcrumbs = (convertedTr) => {
         return acc;
     }, []);
 };
-export const generateTestResults = async (writer, store) => {
-    const allTr = await store.allTestResults({ includeHidden: true });
+export const generateTestResults = async (writer, store, filter) => {
+    const allTr = (await store.allTestResults({ includeHidden: true })).filter((tr) => (filter ? filter(tr) : true));
     let convertedTrs = [];
     for (const tr of allTr) {
         const trFixtures = await store.fixturesByTrId(tr.id);
@@ -99,15 +100,31 @@ export const generateTestResults = async (writer, store) => {
     for (const convertedTr of convertedTrs) {
         await writer.writeTestCase(convertedTr);
     }
-    await writer.writeWidget("nav.json", convertedTrs.filter(({ hidden }) => !hidden).map(({ id }) => id));
     return convertedTrs;
 };
-export const generateTree = async (writer, treeName, labels, tests) => {
+export const generateTestCases = async (writer, trs) => {
+    for (const tr of trs) {
+        await writer.writeTestCase(tr);
+    }
+};
+export const generateTestEnvGroups = async (writer, store) => {
+    const groups = await store.allTestEnvGroups();
+    for (const group of groups) {
+        const src = join("test-env-groups", `${group.id}.json`);
+        await writer.writeData(src, group);
+    }
+};
+export const generateNav = async (writer, trs, filename = "nav.json") => {
+    await writer.writeWidget(filename, trs.filter(({ hidden }) => !hidden).map(({ id }) => id));
+};
+export const generateTree = async (writer, treeFilename, labels, tests) => {
     const visibleTests = tests.filter((test) => !test.hidden);
     const tree = createTreeByLabels(visibleTests, labels, ({ id, name, status, duration, flaky, start, retries }) => {
+        const retriesCount = retries?.length;
         return {
             nodeId: id,
-            retry: !!retries?.length,
+            retry: Boolean(retriesCount),
+            retriesCount,
             name,
             status,
             duration,
@@ -120,17 +137,41 @@ export const generateTree = async (writer, treeName, labels, tests) => {
     filterTree(tree, (leaf) => !leaf.hidden);
     sortTree(tree, nullsLast(compareBy("start", ordinal())));
     transformTree(tree, (leaf, idx) => ({ ...leaf, groupOrder: idx + 1 }));
-    await writer.writeWidget(`${treeName}.json`, tree);
+    await writer.writeWidget(treeFilename, tree);
 };
 export const generateEnvironmentJson = async (writer, env) => {
     await writer.writeWidget("allure_environment.json", env);
 };
-export const generateStatistic = async (writer, statistic) => {
-    await writer.writeWidget("allure_statistic.json", statistic);
+export const generateEnvirontmentsList = async (writer, store) => {
+    const environments = await store.allEnvironments();
+    await writer.writeWidget("environments.json", environments);
 };
-export const generatePieChart = async (writer, statistic) => {
-    const chartData = getChartData(statistic);
-    await writer.writeWidget("allure_pie_chart.json", chartData);
+export const generateVariables = async (writer, store) => {
+    const reportVariables = await store.allVariables();
+    const environments = await store.allEnvironments();
+    await writer.writeWidget("variables.json", reportVariables);
+    for (const env of environments) {
+        const envVariables = await store.envVariables(env);
+        await writer.writeWidget(join(env, "variables.json"), envVariables);
+    }
+};
+export const generateStatistic = async (writer, store, filter) => {
+    const statistic = await store.testsStatistic(filter);
+    const environments = await store.allEnvironments();
+    await writer.writeWidget("statistic.json", statistic);
+    for (const env of environments) {
+        const envStatistic = await store.testsStatistic(filterEnv(env, filter));
+        await writer.writeWidget(join(env, "statistic.json"), envStatistic);
+    }
+};
+export const generatePieChart = async (writer, store, filter) => {
+    const reportStatistic = await store.testsStatistic(filter);
+    const environments = await store.allEnvironments();
+    await writer.writeWidget("pie_chart.json", getPieChartData(reportStatistic));
+    for (const env of environments) {
+        const envStatistic = await store.testsStatistic(filterEnv(env, filter));
+        await writer.writeWidget(join(env, "pie_chart.json"), getPieChartData(envStatistic));
+    }
 };
 export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
     const result = new Map();

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 import { AwesomePlugin } from "./plugin.js";
+export type { AwesomePluginOptions } from "./model.js";
 export default AwesomePlugin;

package/dist/model.d.ts

@@ -1,4 +1,4 @@
-import type { EnvironmentsConfig } from "@allurereport/core-api";
+import type { EnvironmentsConfig, TestResult } from "@allurereport/core-api";
 export type AwesomeOptions = {
     reportName?: string;
     singleFile?: boolean;
@@ -13,6 +13,7 @@ export type AwesomeOptions = {
         url: string;
         name: string;
     };
+    filter?: (testResult: TestResult) => boolean;
 };
 export type TemplateManifest = Record<string, string>;
 export type AwesomePluginOptions = AwesomeOptions;

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { AllureStore, Plugin, PluginContext } from "@allurereport/plugin-api";
+import type { AllureStore, Plugin, PluginContext, PluginSummary } from "@allurereport/plugin-api";
 import type { AwesomePluginOptions } from "./model.js";
 export declare class AwesomePlugin implements Plugin {
     #private;
@@ -7,4 +7,5 @@ export declare class AwesomePlugin implements Plugin {
     start: (context: PluginContext) => Promise<void>;
     update: (context: PluginContext, store: AllureStore) => Promise<void>;
     done: (context: PluginContext, store: AllureStore) => Promise<void>;
+    info(context: PluginContext, store: AllureStore): Promise<PluginSummary>;
 }

package/dist/plugin.js

@@ -10,8 +10,10 @@ 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_generate;
+import { getWorstStatus } from "@allurereport/core-api";
 import { preciseTreeLabels } from "@allurereport/plugin-api";
-import { generateAttachmentsFiles, generateEnvironmentJson, generateHistoryDataPoints, generatePieChart, generateStaticFiles, generateStatistic, generateTestResults, generateTree, } from "./generators.js";
+import { join } from "node:path";
+import { generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateHistoryDataPoints, generateNav, generatePieChart, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateVariables, } from "./generators.js";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
 export class AwesomePlugin {
     constructor(options = {}) {
@@ -20,14 +22,26 @@ export class AwesomePlugin {
         _AwesomePlugin_generate.set(this, async (context, store) => {
             const { singleFile, groupBy = [] } = this.options ?? {};
             const environmentItems = await store.metadataByKey("allure_environment");
-            const statistic = await store.testsStatistic();
+            const reportEnvironments = await store.allEnvironments();
             const attachments = await store.allAttachments();
-            await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), statistic);
-            await generatePieChart(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), statistic);
-            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
+            await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options.filter);
+            await generatePieChart(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options.filter);
+            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options.filter);
             const treeLabels = preciseTreeLabels(!groupBy.length ? ["parentSuite", "suite", "subSuite"] : groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name));
-            await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), "tree", treeLabels, convertedTrs);
             await generateHistoryDataPoints(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
+            await generateTestCases(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs);
+            await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), "tree.json", treeLabels, convertedTrs);
+            await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), convertedTrs, "nav.json");
+            await generateTestEnvGroups(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
+            for (const reportEnvironment of reportEnvironments) {
+                const envTrs = await store.testResultsByEnvironment(reportEnvironment);
+                const envTrsIds = envTrs.map(({ id }) => id);
+                const envConvertedTrs = convertedTrs.filter(({ id }) => envTrsIds.includes(id));
+                await generateTree(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), join(reportEnvironment, "tree.json"), treeLabels, envConvertedTrs);
+                await generateNav(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), envConvertedTrs, join(reportEnvironment, "nav.json"));
+            }
+            await generateEnvirontmentsList(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
+            await generateVariables(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
             if (environmentItems?.length) {
                 await generateEnvironmentJson(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), environmentItems);
             }
@@ -66,5 +80,16 @@ export class AwesomePlugin {
             await __classPrivateFieldGet(this, _AwesomePlugin_generate, "f").call(this, context, store);
         };
     }
+    async info(context, store) {
+        const allTrs = (await store.allTestResults()).filter((tr) => this.options.filter ? this.options.filter(tr) : true);
+        const duration = allTrs.reduce((acc, { duration: trDuration = 0 }) => acc + trDuration, 0);
+        const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
+        return {
+            name: this.options.reportName || context.reportName,
+            stats: await store.testsStatistic(this.options.filter),
+            status: worstStatus ?? "passed",
+            duration,
+        };
+    }
 }
 _AwesomePlugin_writer = new WeakMap(), _AwesomePlugin_generate = new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.0.0-beta.10",
+  "version": "3.0.0-beta.12",
   "description": "Allure Awesome Plugin – brand new HTML report with modern design and new features",
   "keywords": [
     "allure",
@@ -30,10 +30,10 @@
     "test": "rimraf ./out && vitest run"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.0.0-beta.10",
-    "@allurereport/plugin-api": "3.0.0-beta.10",
-    "@allurereport/web-awesome": "3.0.0-beta.10",
-    "@allurereport/web-commons": "3.0.0-beta.10",
+    "@allurereport/core-api": "3.0.0-beta.12",
+    "@allurereport/plugin-api": "3.0.0-beta.12",
+    "@allurereport/web-awesome": "3.0.0-beta.12",
+    "@allurereport/web-commons": "3.0.0-beta.12",
     "d3-shape": "^3.2.0",
     "handlebars": "^4.7.8"
   },