@allurereport/plugin-awesome 3.0.0-beta.16 → 3.0.0-beta.18

package/README.md

@@ -47,11 +47,12 @@ 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`         |
-| `logo`           | Path to the logo image                          | `string`                                                     | `null`          |
-| `theme`          | Default color theme of the report               | `light \| dark`                                              | OS theme        |
-| `reportLanguage` | Default language of the report                  | `string`                                                     | OS language     |
-| `ci`             | CI data which will be rendered in the report    | `{ type: "github" \| "jenkins", url: string, name: string }` | `undefined`     |
+| Option           | Description                                     | Type    | Default                 |
+|------------------|-------------------------------------------------|---------|-------------------------|
+| `reportName`     | Name of the report                              | `string` | `Allure Report`         |
+| `singleFile`     | Writes the report as a single `index.html` file | `boolean` | `false`                 |
+| `logo`           | Path to the logo image                          | `string` | `null`                  |
+| `theme`          | Default color theme of the report               | `light \| dark` | OS theme                |
+| `reportLanguage` | Default language of the report                  | `string` | OS language             |
+| `ci`             | CI data which will be rendered in the report    | `{ type: "github" \| "jenkins", url: string, name: string }` | `undefined`             |
+| `groupBy`        | By default, tests are grouped using the `titlePath` provided by the test framework.    | `string`| Grouping by `titlepath` |

package/dist/charts.d.ts

@@ -1,108 +1,14 @@
-import type { HistoryDataPoint, SeverityLevel, Statistic, TestResult, TestStatus } from "@allurereport/core-api";
-import type { AllureStore, PluginContext } from "@allurereport/plugin-api";
-import { ChartDataType, ChartMode, ChartType } from "@allurereport/web-commons";
-import type { PieArcDatum } from "d3-shape";
+import { type HistoryDataPoint, type Statistic, type TestResult } from "@allurereport/core-api";
+import { type GeneratedChartsData, type PluginContext } from "@allurereport/plugin-api";
 import type { AwesomeOptions } from "./model.js";
 import type { AwesomeDataWriter } from "./writer.js";
-export type BasePieSlice = Pick<PieSlice, "status" | "count">;
-export declare const d3Arc: import("d3-shape").Arc<any, PieArcDatum<BasePieSlice>>;
-export declare const d3Pie: import("d3-shape").Pie<any, BasePieSlice>;
-export declare const getPercentage: (value: number, total: number) => number;
-export type ChartId = string;
-export type ExecutionIdFn = (executionOrder: number) => string;
-export type ExecutionNameFn = (executionOrder: number) => string;
-export type TrendMetadataFnOverrides = {
-    executionIdAccessor?: ExecutionIdFn;
-    executionNameAccessor?: ExecutionNameFn;
-};
-export type TrendChartOptions = {
-    type: ChartType.Trend;
-    dataType: ChartDataType;
-    mode?: ChartMode;
-    title?: string;
-    limit?: number;
-    metadata?: TrendMetadataFnOverrides;
-};
-export type TrendPointId = string;
-export type TrendSliceId = string;
-export type BaseMetadata = Record<string, unknown>;
-export interface BaseTrendSliceMetadata extends Record<string, unknown> {
-    executionId: string;
-    executionName: string;
-}
-export type TrendSliceMetadata<Metadata extends BaseMetadata> = BaseTrendSliceMetadata & Metadata;
-export type TrendPoint = {
-    x: string;
-    y: number;
-};
-export type TrendSlice<Metadata extends BaseMetadata> = {
-    min: number;
-    max: number;
-    metadata: TrendSliceMetadata<Metadata>;
-};
-export type GenericTrendChartData<Metadata extends BaseMetadata, SeriesType extends string> = {
-    type: ChartType.Trend;
-    dataType: ChartDataType;
-    mode: ChartMode;
-    title?: string;
-    points: Record<TrendPointId, TrendPoint>;
-    slices: Record<TrendSliceId, TrendSlice<Metadata>>;
-    series: Record<SeriesType, TrendPointId[]>;
-    min: number;
-    max: number;
-};
-export interface StatusMetadata extends BaseTrendSliceMetadata {
-}
-export type StatusTrendSliceMetadata = TrendSliceMetadata<StatusMetadata>;
-export type StatusTrendSlice = TrendSlice<StatusTrendSliceMetadata>;
-export type StatusTrendChartData = GenericTrendChartData<StatusTrendSliceMetadata, TestStatus>;
-export interface SeverityMetadata extends BaseTrendSliceMetadata {
-}
-export type SeverityTrendSliceMetadata = TrendSliceMetadata<SeverityMetadata>;
-export type SeverityTrendSlice = TrendSlice<SeverityTrendSliceMetadata>;
-export type SeverityTrendChartData = GenericTrendChartData<SeverityTrendSliceMetadata, SeverityLevel>;
-export type TrendChartData = StatusTrendChartData | SeverityTrendChartData;
-export type PieChartOptions = {
-    type: ChartType.Pie;
-    title?: string;
-};
-export type PieSlice = {
-    status: TestStatus;
-    count: number;
-    d: string | null;
-};
-export type PieChartData = {
-    type: ChartType.Pie;
-    title?: string;
-    slices: PieSlice[];
-    percentage: number;
-};
-export type GeneratedChartData = TrendChartData | PieChartData;
-export type GeneratedChartsData = Record<ChartId, GeneratedChartData>;
-export type ChartOptions = TrendChartOptions | PieChartOptions;
-export type DashboardOptions = {
-    reportName?: string;
-    singleFile?: boolean;
-    logo?: string;
-    theme?: "light" | "dark";
-    reportLanguage?: "en" | "ru";
-    layout?: ChartOptions[];
-    filter?: (testResult: TestResult) => boolean;
-};
-export type TrendDataType = TestStatus | SeverityLevel;
-export type TrendCalculationResult<T extends TrendDataType> = {
-    points: Record<TrendPointId, TrendPoint>;
-    series: Record<T, TrendPointId[]>;
-};
-export declare const createEmptyStats: <T extends TrendDataType>(items: readonly T[]) => Record<T, number>;
-export declare const createEmptySeries: <T extends TrendDataType>(items: readonly T[]) => Record<T, string[]>;
-export declare const normalizeStatistic: <T extends TrendDataType>(statistic: Partial<Record<T, number>>, itemType: readonly T[]) => Record<T, number>;
-export declare const mergeTrendDataGeneric: <M extends BaseTrendSliceMetadata, T extends TrendDataType>(trendData: GenericTrendChartData<M, T>, trendDataPart: GenericTrendChartData<M, T>, itemType: readonly T[]) => GenericTrendChartData<M, T>;
-export declare const getTrendDataGeneric: <M extends BaseTrendSliceMetadata, T extends TrendDataType>(stats: Record<T, number>, reportName: string, executionOrder: number, itemType: readonly T[], chartOptions: TrendChartOptions) => GenericTrendChartData<M, T>;
-export declare const generateCharts: (options: AwesomeOptions, store: AllureStore, context: PluginContext) => Promise<GeneratedChartsData | undefined>;
-export declare const generateTrendChart: (options: TrendChartOptions, stores: {
-    historyDataPoints: HistoryDataPoint[];
+export declare const generateCharts: (options: AwesomeOptions, context: PluginContext, stores: {
+    trs: TestResult[];
     statistic: Statistic;
-    testResults: TestResult[];
-}, context: PluginContext) => TrendChartData | undefined;
-export declare const generateAllCharts: (writer: AwesomeDataWriter, store: AllureStore, options: AwesomeOptions, context: PluginContext) => Promise<void>;
+    history: HistoryDataPoint[];
+}) => Promise<GeneratedChartsData | undefined>;
+export declare const generateAllCharts: (writer: AwesomeDataWriter, options: AwesomeOptions, context: PluginContext, stores: {
+    trs: TestResult[];
+    statistic: Statistic;
+    history: HistoryDataPoint[];
+}) => Promise<void>;

package/dist/charts.js

@@ -1,137 +1,22 @@
-import { ChartDataType, ChartMode, ChartType, DEFAULT_CHART_HISTORY_LIMIT, getPieChartDataDashboard, getSeverityTrendData, getStatusTrendData, } from "@allurereport/web-commons";
+import { ChartType } from "@allurereport/core-api";
+import { generateComingSoonChart, generatePieChart, generateTrendChart, } from "@allurereport/plugin-api";
 import { randomUUID } from "crypto";
-import { arc, pie } from "d3-shape";
-export const d3Arc = arc().innerRadius(40).outerRadius(50).cornerRadius(2).padAngle(0.03);
-export const d3Pie = pie()
-    .value((d) => d.count)
-    .padAngle(0.03)
-    .sortValues((a, b) => a - b);
-export const getPercentage = (value, total) => Math.floor((value / total) * 10000) / 100;
-export const createEmptyStats = (items) => items.reduce((acc, item) => ({ ...acc, [item]: 0 }), {});
-export const createEmptySeries = (items) => items.reduce((acc, item) => ({ ...acc, [item]: [] }), {});
-export const normalizeStatistic = (statistic, itemType) => {
-    return itemType.reduce((acc, item) => {
-        acc[item] = statistic[item] ?? 0;
-        return acc;
-    }, {});
-};
-const calculateRawValues = (stats, executionId, itemType) => {
-    const points = {};
-    const series = createEmptySeries(itemType);
-    itemType.forEach((item) => {
-        const pointId = `${executionId}-${item}`;
-        const value = stats[item] ?? 0;
-        points[pointId] = {
-            x: executionId,
-            y: value,
-        };
-        series[item].push(pointId);
-    });
-    return { points, series };
-};
-const calculatePercentValues = (stats, executionId, itemType) => {
-    const points = {};
-    const series = createEmptySeries(itemType);
-    const values = Object.values(stats);
-    const total = values.reduce((sum, value) => sum + value, 0);
-    if (total === 0) {
-        return { points, series };
-    }
-    itemType.forEach((item) => {
-        const pointId = `${executionId}-${item}`;
-        const value = stats[item] ?? 0;
-        points[pointId] = {
-            x: executionId,
-            y: value / total,
-        };
-        series[item].push(pointId);
-    });
-    return { points, series };
-};
-export const mergeTrendDataGeneric = (trendData, trendDataPart, itemType) => {
-    return {
-        ...trendData,
-        points: {
-            ...trendData.points,
-            ...trendDataPart.points,
-        },
-        slices: {
-            ...trendData.slices,
-            ...trendDataPart.slices,
-        },
-        series: Object.entries(trendDataPart.series).reduce((series, [group, pointIds]) => {
-            if (Array.isArray(pointIds)) {
-                return {
-                    ...series,
-                    [group]: [...(trendData.series?.[group] || []), ...pointIds],
-                };
-            }
-            return series;
-        }, trendData.series || createEmptySeries(itemType)),
-        min: Math.min(trendData.min ?? Infinity, trendDataPart.min),
-        max: Math.max(trendData.max ?? -Infinity, trendDataPart.max),
-    };
-};
-export const getTrendDataGeneric = (stats, reportName, executionOrder, itemType, chartOptions) => {
-    const { type, dataType, title, mode = ChartMode.Raw, metadata = {} } = chartOptions;
-    const { executionIdAccessor, executionNameAccessor } = metadata;
-    const executionId = executionIdAccessor ? executionIdAccessor(executionOrder) : `execution-${executionOrder}`;
-    const { points, series } = mode === ChartMode.Percent
-        ? calculatePercentValues(stats, executionId, itemType)
-        : calculateRawValues(stats, executionId, itemType);
-    const slices = {};
-    const pointsAsArray = Object.values(points);
-    const pointsCount = pointsAsArray.length;
-    const values = pointsAsArray.map((point) => point.y);
-    const min = pointsCount ? Math.min(...values) : 0;
-    const max = pointsCount ? Math.max(...values) : 0;
-    if (pointsCount > 0) {
-        const executionName = executionNameAccessor ? executionNameAccessor(executionOrder) : reportName;
-        slices[executionId] = {
-            min,
-            max,
-            metadata: {
-                executionId,
-                executionName,
-            },
-        };
-    }
-    return {
-        type,
-        dataType,
-        mode,
-        title,
-        points,
-        slices,
-        series,
-        min,
-        max,
-    };
-};
-const generatePieChart = (options, stores) => {
-    const { statistic } = stores;
-    return getPieChartDataDashboard(statistic, options);
-};
-export const generateCharts = async (options, store, context) => {
+export const generateCharts = async (options, context, stores) => {
     const { charts } = options;
     if (!charts) {
         return undefined;
     }
-    const historyDataPoints = await store.allHistoryDataPoints();
-    const statistic = await store.testsStatistic();
-    const testResults = await store.allTestResults();
     return charts.reduce((acc, chartOptions) => {
         const chartId = randomUUID();
         let chart;
         if (chartOptions.type === ChartType.Trend) {
-            chart = generateTrendChart(chartOptions, {
-                historyDataPoints,
-                statistic,
-                testResults,
-            }, context);
+            chart = generateTrendChart(chartOptions, stores, context);
         }
         else if (chartOptions.type === ChartType.Pie) {
-            chart = generatePieChart(chartOptions, { statistic });
+            chart = generatePieChart(chartOptions, stores);
+        }
+        else if ([ChartType.HeatMap, ChartType.Bar, ChartType.Funnel, ChartType.TreeMap].includes(chartOptions.type)) {
+            chart = generateComingSoonChart(chartOptions);
         }
         if (chart) {
             acc[chartId] = chart;
@@ -139,19 +24,8 @@ export const generateCharts = async (options, store, context) => {
         return acc;
     }, {});
 };
-export const generateTrendChart = (options, stores, context) => {
-    const newOptions = { limit: DEFAULT_CHART_HISTORY_LIMIT, ...options };
-    const { dataType } = newOptions;
-    const { statistic, historyDataPoints, testResults } = stores;
-    if (dataType === ChartDataType.Status) {
-        return getStatusTrendData(statistic, context.reportName, historyDataPoints, newOptions);
-    }
-    else if (dataType === ChartDataType.Severity) {
-        return getSeverityTrendData(testResults, context.reportName, historyDataPoints, newOptions);
-    }
-};
-export const generateAllCharts = async (writer, store, options, context) => {
-    const charts = await generateCharts(options, store, context);
+export const generateAllCharts = async (writer, options, context, stores) => {
+    const charts = await generateCharts(options, context, stores);
     if (charts && Object.keys(charts).length > 0) {
         await writer.writeWidget("charts.json", charts);
     }

package/dist/converters.js

@@ -36,6 +36,7 @@ export const convertTestResult = (tr) => {
         breadcrumbs: [],
         retry: false,
         transition: tr.transition,
+        titlePath: tr.titlePath || [],
     };
 };
 export const convertTestStepResult = (tsr) => {

package/dist/generators.d.ts

@@ -1,21 +1,30 @@
-import { type AttachmentLink, type EnvironmentItem } from "@allurereport/core-api";
-import { type AllureStore, type ReportFiles, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
+import { type AttachmentLink, type EnvironmentItem, type Statistic, type TestEnvGroup, type TestError, type TestResult } from "@allurereport/core-api";
+import { type AllureStore, type ExitCode, 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, filter?: TestResultFilter) => Promise<AwesomeTestResult[]>;
+export declare const generateTestResults: (writer: AwesomeDataWriter, store: AllureStore, trs: TestResult[], 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 generateTestEnvGroups: (writer: AwesomeDataWriter, groups: TestEnvGroup[]) => 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 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 generateStatistic: (writer: AwesomeDataWriter, data: {
+    stats: Statistic;
+    statsByEnv: Map<string, Statistic>;
+    envs: string[];
+}) => 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 generateGlobals: (writer: AwesomeDataWriter, payload: {
+    globalExitCode?: ExitCode;
+    globalAttachments?: AttachmentLink[];
+    globalErrors?: TestError[];
+    contentFunction: (id: string) => Promise<ResultFile | undefined>;
+}) => Promise<void>;
 export declare const generateStaticFiles: (payload: AwesomeOptions & {
     id: string;
     allureVersion: string;

package/dist/generators.js

@@ -1,13 +1,11 @@
-import { compareBy, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
-import { filterTree, } from "@allurereport/plugin-api";
-import { createTreeByLabels, sortTree, transformTree } from "@allurereport/plugin-api";
-import { createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, getPieChartData, } from "@allurereport/web-commons";
+import { compareBy, getPieChartValues, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
+import { createTreeByLabels, createTreeByTitlePath, filterTree, preciseTreeLabels, 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 { 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 +71,8 @@ const createBreadcrumbs = (convertedTr) => {
         return acc;
     }, []);
 };
-export const generateTestResults = async (writer, store, filter) => {
-    const allTr = (await store.allTestResults({ includeHidden: true })).filter((tr) => (filter ? filter(tr) : true));
+export const generateTestResults = async (writer, store, trs, filter) => {
+    const allTr = trs.filter((tr) => (filter ? filter(tr) : true));
     let convertedTrs = [];
     for (const tr of allTr) {
         const trFixtures = await store.fixturesByTrId(tr.id);
@@ -107,8 +105,7 @@ export const generateTestCases = async (writer, trs) => {
         await writer.writeTestCase(tr);
     }
 };
-export const generateTestEnvGroups = async (writer, store) => {
-    const groups = await store.allTestEnvGroups();
+export const generateTestEnvGroups = async (writer, groups) => {
     for (const group of groups) {
         const src = join("test-env-groups", `${group.id}.json`);
         await writer.writeData(src, group);
@@ -119,24 +116,55 @@ export const generateNav = async (writer, trs, filename = "nav.json") => {
 };
 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, transition, start, retry, retriesCount }) => ({
-        nodeId: id,
-        retry,
-        retriesCount,
-        name,
-        status,
-        start,
-        duration,
-        flaky,
-        transition,
-    }), undefined, (group, leaf) => {
-        incrementStatistic(group.statistic, leaf.status);
-    });
+    const tree = labels.length
+        ? buildTreeByLabels(visibleTests, labels)
+        : buildTreeByTitlePath(visibleTests);
     filterTree(tree, (leaf) => !leaf.hidden);
     sortTree(tree, nullsLast(compareBy("start", ordinal())));
     transformTree(tree, (leaf, idx) => ({ ...leaf, groupOrder: idx + 1 }));
     await writer.writeWidget(treeFilename, tree);
 };
+const buildTreeByLabels = (tests, labels) => {
+    return createTreeByLabels(tests, labels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
+};
+const buildTreeByTitlePath = (tests) => {
+    const testsWithTitlePath = [];
+    const testsWithoutTitlePath = [];
+    for (const test of tests) {
+        if (Array.isArray(test.titlePath) && test.titlePath.length > 0) {
+            testsWithTitlePath.push(test);
+        }
+        else {
+            testsWithoutTitlePath.push(test);
+        }
+    }
+    const treeByTitlePath = createTreeByTitlePath(testsWithTitlePath, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
+    const defaultLabels = preciseTreeLabels(["parentSuite", "suite", "subSuite"], testsWithoutTitlePath, ({ labels }) => labels.map(({ name }) => name));
+    const treeByDefaultLabels = createTreeByLabels(testsWithoutTitlePath, defaultLabels, leafFactory, undefined, (group, leaf) => incrementStatistic(group.statistic, leaf.status));
+    const mergedLeavesById = { ...treeByTitlePath.leavesById, ...treeByDefaultLabels.leavesById };
+    const mergedGroupsById = { ...treeByTitlePath.groupsById, ...treeByDefaultLabels.groupsById };
+    const mergedRootLeaves = Array.from(new Set([...(treeByTitlePath.root.leaves ?? []), ...(treeByDefaultLabels.root.leaves ?? [])]));
+    const mergedRootGroups = Array.from(new Set([...(treeByTitlePath.root.groups ?? []), ...(treeByDefaultLabels.root.groups ?? [])]));
+    return {
+        root: {
+            leaves: mergedRootLeaves,
+            groups: mergedRootGroups,
+        },
+        leavesById: mergedLeavesById,
+        groupsById: mergedGroupsById,
+    };
+};
+const leafFactory = ({ id, name, status, duration, flaky, start, transition, retry, retriesCount, }) => ({
+    nodeId: id,
+    name,
+    status,
+    duration,
+    flaky,
+    start,
+    retry,
+    retriesCount,
+    transition,
+});
 export const generateEnvironmentJson = async (writer, env) => {
     await writer.writeWidget("allure_environment.json", env);
 };
@@ -153,22 +181,17 @@ export const generateVariables = async (writer, store) => {
         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 generateStatistic = async (writer, data) => {
+    const { stats, statsByEnv, envs } = data;
+    await writer.writeWidget("statistic.json", stats);
+    await writer.writeWidget("pie_chart.json", getPieChartValues(stats));
+    for (const env of envs) {
+        const envStats = statsByEnv.get(env);
+        if (!envStats) {
+            continue;
+        }
+        await writer.writeWidget(join(env, "statistic.json"), envStats);
+        await writer.writeWidget(join(env, "pie_chart.json"), envStats);
     }
 };
 export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
@@ -196,8 +219,26 @@ export const generateHistoryDataPoints = async (writer, store) => {
     }
     return result;
 };
+export const generateGlobals = async (writer, payload) => {
+    const { globalExitCode = { original: 0 }, globalAttachments = [], globalErrors = [], contentFunction } = payload;
+    const globals = {
+        exitCode: globalExitCode,
+        errors: globalErrors,
+        attachments: [],
+    };
+    for (const attachment of globalAttachments) {
+        const src = `${attachment.id}${attachment.ext}`;
+        const content = await contentFunction(attachment.id);
+        if (!content) {
+            continue;
+        }
+        await writer.writeAttachment(src, content);
+        globals.attachments.push(attachment);
+    }
+    await writer.writeWidget("globals.json", globals);
+};
 export const generateStaticFiles = async (payload) => {
-    const { id, reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", charts = [], defaultSection = "", } = payload;
+    const { id, reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", charts = [], defaultSection = "", ci, } = payload;
     const compile = Handlebars.compile(template);
     const manifest = await readTemplateManifest(payload.singleFile);
     const headTags = [];
@@ -241,23 +282,34 @@ export const generateStaticFiles = async (payload) => {
         reportLanguage,
         createdAt: now,
         reportUuid,
-        groupBy: groupBy?.length ? groupBy : ["parentSuite", "suite", "subSuite"],
+        groupBy: groupBy?.length ? groupBy : [],
         cacheKey: now.toString(),
+        ci,
         layout,
         allureVersion,
         sections,
         defaultSection,
     };
-    const html = compile({
-        headTags: headTags.join("\n"),
-        bodyTags: bodyTags.join("\n"),
-        reportFilesScript: createReportDataScript(reportDataFiles),
-        reportOptions: JSON.stringify(reportOptions),
-        analyticsEnable: true,
-        allureVersion,
-        reportUuid,
-        reportName,
-        singleFile: payload.singleFile,
-    });
-    await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
+    try {
+        const html = compile({
+            headTags: headTags.join("\n"),
+            bodyTags: bodyTags.join("\n"),
+            reportFilesScript: createReportDataScript(reportDataFiles),
+            reportOptions: JSON.stringify(reportOptions),
+            analyticsEnable: true,
+            allureVersion,
+            reportUuid,
+            reportName,
+            singleFile: payload.singleFile,
+        });
+        await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
+    }
+    catch (err) {
+        if (err instanceof RangeError) {
+            console.error("The report is too large to be generated in the single file mode!");
+            process.exit(1);
+            return;
+        }
+        throw err;
+    }
 };

package/dist/model.d.ts

@@ -1,5 +1,5 @@
-import type { EnvironmentsConfig, TestResult } from "@allurereport/core-api";
-import type { ChartOptions } from "./charts.js";
+import type { CiDescriptor, EnvironmentsConfig, TestResult } from "@allurereport/core-api";
+import type { ChartOptions } from "@allurereport/plugin-api";
 export type AwesomeOptions = {
     reportName?: string;
     singleFile?: boolean;
@@ -9,11 +9,7 @@ export type AwesomeOptions = {
     groupBy?: string[];
     layout?: "base" | "split";
     environments?: Record<string, EnvironmentsConfig>;
-    ci?: {
-        type: "github" | "jenkins";
-        url: string;
-        name: string;
-    };
+    ci?: CiDescriptor;
     filter?: (testResult: TestResult) => boolean;
     charts?: ChartOptions[];
     sections?: string[];

package/dist/plugin.d.ts

@@ -1,4 +1,4 @@
-import type { AllureStore, Plugin, PluginContext, PluginSummary } from "@allurereport/plugin-api";
+import { type AllureStore, type Plugin, type PluginContext, type PluginSummary } from "@allurereport/plugin-api";
 import type { AwesomePluginOptions } from "./model.js";
 export declare class AwesomePlugin implements Plugin {
     #private;

package/dist/plugin.js

@@ -11,34 +11,56 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
 };
 var _AwesomePlugin_writer, _AwesomePlugin_generate;
 import { getWorstStatus } from "@allurereport/core-api";
+import { convertToSummaryTestResult, } from "@allurereport/plugin-api";
 import { preciseTreeLabels } from "@allurereport/plugin-api";
 import { join } from "node:path";
 import { generateAllCharts } from "./charts.js";
-import { generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateHistoryDataPoints, generateNav, generatePieChart, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateVariables, } from "./generators.js";
+import { filterEnv } from "./environments.js";
+import { generateAttachmentsFiles, generateEnvironmentJson, generateEnvirontmentsList, generateGlobals, generateHistoryDataPoints, generateNav, generateStaticFiles, generateStatistic, generateTestCases, generateTestEnvGroups, generateTestResults, generateTree, generateVariables, } from "./generators.js";
 import { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
 export class AwesomePlugin {
     constructor(options = {}) {
         this.options = options;
         _AwesomePlugin_writer.set(this, void 0);
         _AwesomePlugin_generate.set(this, async (context, store) => {
-            const { singleFile, groupBy = [] } = this.options ?? {};
+            const { singleFile, groupBy = [], filter } = this.options ?? {};
             const environmentItems = await store.metadataByKey("allure_environment");
             const reportEnvironments = await store.allEnvironments();
             const attachments = await store.allAttachments();
-            await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options.filter);
-            await generatePieChart(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options.filter);
-            await generateAllCharts(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, this.options, context);
-            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));
+            const allTrs = await store.allTestResults({ includeHidden: true });
+            const statistics = await store.testsStatistic(filter);
+            const environments = await store.allEnvironments();
+            const envStatistics = new Map();
+            const allTestEnvGroups = await store.allTestEnvGroups();
+            const allHistoryDataPoints = await store.allHistoryDataPoints();
+            const globalAttachments = await store.allGlobalAttachments();
+            const globalExitCode = await store.globalExitCode();
+            const globalErrors = await store.allGlobalErrors();
+            for (const env of environments) {
+                envStatistics.set(env, await store.testsStatistic(filterEnv(env, filter)));
+            }
+            await generateStatistic(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
+                stats: statistics,
+                statsByEnv: envStatistics,
+                envs: environments,
+            });
+            await generateAllCharts(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), this.options, context, {
+                trs: allTrs,
+                statistic: statistics,
+                history: allHistoryDataPoints,
+            });
+            const convertedTrs = await generateTestResults(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store, allTrs, this.options.filter);
+            const hasGroupBy = groupBy.length > 0;
+            const treeLabels = hasGroupBy
+                ? preciseTreeLabels(groupBy, convertedTrs, ({ labels }) => labels.map(({ name }) => name))
+                : [];
             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);
+            await generateTestEnvGroups(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), allTestEnvGroups);
             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));
+                const envConvertedTrs = convertedTrs.filter(({ environment }) => environment === reportEnvironment);
                 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"));
             }
@@ -51,6 +73,12 @@ export class AwesomePlugin {
                 await generateAttachmentsFiles(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), attachments, (id) => store.attachmentContentById(id));
             }
             const reportDataFiles = singleFile ? __classPrivateFieldGet(this, _AwesomePlugin_writer, "f").reportFiles() : [];
+            await generateGlobals(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), {
+                globalAttachments,
+                globalErrors,
+                globalExitCode,
+                contentFunction: (id) => store.attachmentContentById(id),
+            });
             await generateStaticFiles({
                 ...this.options,
                 id: context.id,
@@ -85,6 +113,9 @@ export class AwesomePlugin {
     }
     async info(context, store) {
         const allTrs = (await store.allTestResults()).filter((tr) => this.options.filter ? this.options.filter(tr) : true);
+        const newTrs = await store.allNewTestResults();
+        const retryTrs = allTrs.filter((tr) => !!tr?.retries?.length);
+        const flakyTrs = allTrs.filter((tr) => !!tr?.flaky);
         const duration = allTrs.reduce((acc, { duration: trDuration = 0 }) => acc + trDuration, 0);
         const worstStatus = getWorstStatus(allTrs.map(({ status }) => status));
         const createdAt = allTrs.reduce((acc, { stop }) => Math.max(acc, stop || 0), 0);
@@ -95,6 +126,9 @@ export class AwesomePlugin {
             duration,
             createdAt,
             plugin: "Awesome",
+            newTests: newTrs.map(convertToSummaryTestResult),
+            flakyTests: flakyTrs.map(convertToSummaryTestResult),
+            retryTests: retryTrs.map(convertToSummaryTestResult),
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.18",
   "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.16",
-    "@allurereport/plugin-api": "3.0.0-beta.16",
-    "@allurereport/web-awesome": "3.0.0-beta.16",
-    "@allurereport/web-commons": "3.0.0-beta.16",
+    "@allurereport/core-api": "3.0.0-beta.18",
+    "@allurereport/plugin-api": "3.0.0-beta.18",
+    "@allurereport/web-awesome": "3.0.0-beta.18",
+    "@allurereport/web-commons": "3.0.0-beta.18",
     "d3-shape": "^3.2.0",
     "handlebars": "^4.7.8"
   },
@@ -45,7 +45,7 @@
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "@vitest/runner": "^2.1.9",
-    "allure-vitest": "^3.0.9",
+    "allure-vitest": "^3.3.3",
     "eslint": "^8.57.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",