@allurereport/plugin-awesome 3.0.0-beta.13 → 3.0.0-beta.15

package/dist/charts.d.ts

@@ -1,14 +1,115 @@
-import type { Statistic, TestStatus } from "@allurereport/core-api";
+import type { HistoryDataPoint, SeverityLevel, Statistic, TestResult, TestStatus } from "@allurereport/core-api";
+import type { AllureStore, PluginContext } from "@allurereport/plugin-api";
 import type { PieArcDatum } from "d3-shape";
-export type TestResultSlice = {
+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 declare enum ChartType {
+    Trend = "trend",
+    Pie = "pie"
+}
+export declare enum ChartData {
+    Status = "status",
+    Severity = "severity"
+}
+export type ChartMode = "raw" | "percent";
+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: ChartData;
+    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: ChartData;
+    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 TestResultChartData = {
+export type PieChartData = {
+    type: ChartType.Pie;
+    title?: string;
+    slices: PieSlice[];
     percentage: number;
-    slices: TestResultSlice[];
 };
-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 getPieChartData: (stats: Statistic) => TestResultChartData;
+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[];
+    statistic: Statistic;
+    testResults: TestResult[];
+}, context: PluginContext) => TrendChartData | undefined;
+export declare const generateAllCharts: (writer: AwesomeDataWriter, store: AllureStore, options: AwesomeOptions, context: PluginContext) => Promise<void>;

package/dist/charts.js

@@ -1,4 +1,5 @@
-import { statusesList } from "@allurereport/core-api";
+import { getPieChartDataDashboard, getSeverityTrendData, getStatusTrendData, DEFAULT_CHART_HISTORY_LIMIT } from "@allurereport/web-commons";
+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()
@@ -6,21 +7,161 @@ 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 getPieChartData = (stats) => {
-    const convertedStatuses = statusesList
-        .filter((status) => !!stats?.[status])
-        .map((status) => ({
-        status,
-        count: stats[status],
-    }));
-    const arcsData = d3Pie(convertedStatuses);
-    const slices = arcsData.map((arcData) => ({
-        d: d3Arc(arcData),
-        ...arcData.data,
-    }));
-    const percentage = getPercentage(stats.passed ?? 0, stats.total);
+export var ChartType;
+(function (ChartType) {
+    ChartType["Trend"] = "trend";
+    ChartType["Pie"] = "pie";
+})(ChartType || (ChartType = {}));
+export var ChartData;
+(function (ChartData) {
+    ChartData["Status"] = "status";
+    ChartData["Severity"] = "severity";
+})(ChartData || (ChartData = {}));
+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) * 100,
+        };
+        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 = "raw", metadata = {} } = chartOptions;
+    const { executionIdAccessor, executionNameAccessor } = metadata;
+    const executionId = executionIdAccessor ? executionIdAccessor(executionOrder) : `execution-${executionOrder}`;
+    const { points, series } = mode === "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,
+        title,
+        points,
         slices,
-        percentage,
+        series,
+        min,
+        max,
     };
 };
+const generatePieChart = (options, stores) => {
+    const { statistic } = stores;
+    return getPieChartDataDashboard(statistic, options);
+};
+export const generateCharts = async (options, store, context) => {
+    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);
+        }
+        else if (chartOptions.type === ChartType.Pie) {
+            chart = generatePieChart(chartOptions, { statistic });
+        }
+        if (chart) {
+            acc[chartId] = chart;
+        }
+        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 === ChartData.Status) {
+        return getStatusTrendData(statistic, context.reportName, historyDataPoints, newOptions);
+    }
+    else if (dataType === ChartData.Severity) {
+        return getSeverityTrendData(testResults, context.reportName, historyDataPoints, newOptions);
+    }
+};
+export const generateAllCharts = async (writer, store, options, context) => {
+    const charts = await generateCharts(options, store, context);
+    if (charts && Object.keys(charts).length > 0) {
+        await writer.writeWidget("charts.json", charts);
+    }
+};

package/dist/generators.js

@@ -1,12 +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, } from "@allurereport/web-commons";
+import { createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, getPieChartData, } 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 { getPieChartData } from "./charts.js";
 import { convertFixtureResult, convertTestResult } from "./converters.js";
 import { filterEnv } from "./environments.js";
 const require = createRequire(import.meta.url);
@@ -199,11 +198,15 @@ export const generateHistoryDataPoints = async (writer, store) => {
     return result;
 };
 export const generateStaticFiles = async (payload) => {
-    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", } = payload;
+    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, layout = "base", charts = [], defaultSection = "", } = payload;
     const compile = Handlebars.compile(template);
     const manifest = await readTemplateManifest(payload.singleFile);
     const headTags = [];
     const bodyTags = [];
+    const sections = [];
+    if (charts.length) {
+        sections.push("charts");
+    }
     if (!payload.singleFile) {
         for (const key in manifest) {
             const fileName = manifest[key];
@@ -230,16 +233,20 @@ export const generateStaticFiles = async (payload) => {
         const mainJsContentBuffer = await readFile(mainJsSource);
         bodyTags.push(createScriptTag(`data:text/javascript;base64,${mainJsContentBuffer.toString("base64")}`));
     }
+    const now = Date.now();
     const reportOptions = {
         reportName,
         logo,
         theme,
         reportLanguage,
-        createdAt: Date.now(),
+        createdAt: now,
         reportUuid,
         groupBy: groupBy?.length ? groupBy : ["parentSuite", "suite", "subSuite"],
+        cacheKey: now.toString(),
         layout,
         allureVersion,
+        sections,
+        defaultSection,
     };
     const html = compile({
         headTags: headTags.join("\n"),

package/dist/model.d.ts

@@ -1,4 +1,5 @@
 import type { EnvironmentsConfig, TestResult } from "@allurereport/core-api";
+import type { ChartOptions } from "./charts.js";
 export type AwesomeOptions = {
     reportName?: string;
     singleFile?: boolean;
@@ -14,6 +15,9 @@ export type AwesomeOptions = {
         name: string;
     };
     filter?: (testResult: TestResult) => boolean;
+    charts?: ChartOptions[];
+    sections?: string[];
+    defaultSection?: string;
 };
 export type TemplateManifest = Record<string, string>;
 export type AwesomePluginOptions = AwesomeOptions;

package/dist/plugin.js

@@ -13,6 +13,7 @@ var _AwesomePlugin_writer, _AwesomePlugin_generate;
 import { getWorstStatus } from "@allurereport/core-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 { InMemoryReportDataWriter, ReportFileDataWriter } from "./writer.js";
 export class AwesomePlugin {
@@ -26,6 +27,7 @@ export class AwesomePlugin {
             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));
             await generateHistoryDataPoints(__classPrivateFieldGet(this, _AwesomePlugin_writer, "f"), store);
@@ -84,11 +86,14 @@ export class AwesomePlugin {
         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));
+        const createdAt = allTrs.reduce((acc, { stop }) => Math.max(acc, stop || 0), 0);
         return {
             name: this.options.reportName || context.reportName,
             stats: await store.testsStatistic(this.options.filter),
             status: worstStatus ?? "passed",
             duration,
+            createdAt,
+            plugin: "Awesome",
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-awesome",
-  "version": "3.0.0-beta.13",
+  "version": "3.0.0-beta.15",
   "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.13",
-    "@allurereport/plugin-api": "3.0.0-beta.13",
-    "@allurereport/web-awesome": "3.0.0-beta.13",
-    "@allurereport/web-commons": "3.0.0-beta.13",
+    "@allurereport/core-api": "3.0.0-beta.15",
+    "@allurereport/plugin-api": "3.0.0-beta.15",
+    "@allurereport/web-awesome": "3.0.0-beta.15",
+    "@allurereport/web-commons": "3.0.0-beta.15",
     "d3-shape": "^3.2.0",
     "handlebars": "^4.7.8"
   },