npm - @allurereport/plugin-classic - Versions diffs - 3.0.0-beta.8 → 3.0.0 - Mend

@allurereport/plugin-classic 3.0.0-beta.8 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/generators.js CHANGED Viewed

@@ -1,29 +1,28 @@
-import { createBaseUrlScript, createFaviconLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, } from "@allurereport/web-commons";
+import { compareBy, createBaseUrlScript, createFontLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
+import { createTreeByCategories, createTreeByLabels, filterTree, sortTree, transformTree, } from "@allurereport/plugin-api";
+import { getPieChartValues } 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 { byLabels, collapseTree, createTree, createWidget } from "./tree.js";
-import { updateStatistic, updateTime } from "./utils.js";
+import { matchCategories } from "./categories.js";
+import { convertFixtureResult, convertTestResult } from "./converters.js";
 const require = createRequire(import.meta.url);
 const template = `<!DOCTYPE html>
-<html dir="ltr" lang="{{reportLanguage}}">
+<html dir="ltr" lang="en">
 <head>
     <meta charset="utf-8">
-    <title>{{reportName}}</title>
+    <title> {{ reportName }} </title>
+    <link rel="icon" href="favicon.ico">
     {{{ headTags }}}
 </head>
 <body>
-    <svg id="__SVG_SPRITE_NODE__" aria-hidden="true" style="position: absolute; width: 0; height: 0"></svg>
-    <div id="alert"></div>
-    <div id="content">
-        <span class="spinner">
-            <span class="spinner__circle"></span>
-        </span>
-    </div>
-    <div id="popup"></div>
-    {{{ bodyTags }}}
+    <div id="app"></div>
     ${createBaseUrlScript()}
+    <script>
+      window.allure = window.allure || {};
+    </script>
+    {{{ bodyTags }}}
     {{#if analyticsEnable}}
     <script async src="https://www.googletagmanager.com/gtag/js?id=G-LNDJ3J7WT0"></script>
     <script>
@@ -31,15 +30,15 @@ const template = `<!DOCTYPE html>
         function gtag(){dataLayer.push(arguments);}
         gtag('js', new Date());
         gtag('config', 'G-LNDJ3J7WT0', {
-          'allureVersion': '{{allureVersion}}',
-          'report':'classic',
-          'reportUuid': '{{reportUuid}}',
-          'single_file': '{{singleFile}}'
+          "report": "classic",
+          "allureVersion": "{{ allureVersion }}",
+          "reportUuid": "{{ reportUuid }}",
+          "single_file": "{{singleFile}}"
         });
     </script>
     {{/if}}
     <script>
-      window.allureReportOptions = {{{ reportOptions }}};
+      window.allureReportOptions = {{{ reportOptions }}}
     </script>
     {{{ reportFilesScript }}}
 </body>
@@ -50,219 +49,105 @@ export const readTemplateManifest = async (singleFileMode) => {
     const templateManifest = await readFile(templateManifestSource, { encoding: "utf-8" });
     return JSON.parse(templateManifest);
 };
-export const readManifestEntry = async (options) => {
-    const { fileName, singleFile, mimeType, inserter, reportFiles } = options;
-    const filePath = require.resolve(join("@allurereport/web-classic/dist", singleFile ? "single" : "multi", fileName));
-    const scriptContentBuffer = await readFile(filePath);
-    if (singleFile) {
-        return inserter(`data:${mimeType};base64,${scriptContentBuffer.toString("base64")}`);
-    }
-    await reportFiles.addFile(fileName, scriptContentBuffer);
-    return inserter(fileName);
-};
-export const generateStaticFiles = async (payload) => {
-    const { reportName, reportLanguage, singleFile, reportFiles, reportDataFiles, reportUuid, allureVersion } = payload;
-    const compile = Handlebars.compile(template);
-    const manifest = await readTemplateManifest(singleFile);
-    const headTags = [];
-    const bodyTags = [];
-    for (const key in manifest) {
-        const fileName = manifest[key];
-        const filePath = require.resolve(join("@allurereport/web-classic/dist", singleFile ? "single" : "multi", fileName));
-        if (key === "favicon.ico") {
-            const tag = await readManifestEntry({
-                fileName,
-                singleFile,
-                reportFiles,
-                inserter: createFaviconLinkTag,
-                mimeType: "image/x-icon",
-            });
-            headTags.push(tag);
-            continue;
-        }
-        if (key === "main.css") {
-            const tag = await readManifestEntry({
-                fileName,
-                singleFile,
-                reportFiles,
-                inserter: createStylesLinkTag,
-                mimeType: "text/css",
-            });
-            headTags.push(tag);
-            continue;
+const createBreadcrumbs = (convertedTr) => {
+    const labelsByType = convertedTr.labels.reduce((acc, label) => {
+        if (!acc[label.name]) {
+            acc[label.name] = [];
         }
-        if (key === "main.js") {
-            const tag = await readManifestEntry({
-                fileName,
-                singleFile,
-                reportFiles,
-                inserter: createScriptTag,
-                mimeType: "text/javascript",
+        acc[label.name].push(label.value || "");
+        return acc;
+    }, {});
+    const parentSuites = labelsByType.parentSuite || [""];
+    const suites = labelsByType.suite || [""];
+    const subSuites = labelsByType.subSuite || [""];
+    return parentSuites.reduce((acc, parentSuite) => {
+        suites.forEach((suite) => {
+            subSuites.forEach((subSuite) => {
+                const path = [parentSuite, suite, subSuite].filter(Boolean);
+                if (path.length > 0) {
+                    acc.push(path);
+                }
             });
-            bodyTags.push(tag);
-            continue;
-        }
-        if (singleFile) {
-            continue;
-        }
-        const fileContent = await readFile(filePath);
-        await reportFiles.addFile(basename(filePath), fileContent);
-    }
-    const reportOptions = {
-        reportName: reportName ?? "Allure Report",
-        reportLanguage: reportLanguage ?? "en",
-        createdAt: Date.now(),
-    };
-    const html = compile({
-        headTags: headTags.join("\n"),
-        bodyTags: bodyTags.join("\n"),
-        reportFilesScript: createReportDataScript(reportDataFiles),
-        reportOptions: JSON.stringify(reportOptions),
-        analyticsEnable: true,
-        allureVersion,
-        reportLanguage,
-        reportUuid,
-        reportName,
-        singleFile,
-    });
-    await reportFiles.addFile("index.html", Buffer.from(html, "utf8"));
-};
-export const generateTree = async (writer, name, labelNames, tests) => {
-    const fileName = `${name}.json`;
-    const data = createTree(tests, byLabels(labelNames));
-    await writer.writeData(fileName, data);
-    const widgetData = createWidget(data);
-    await writer.writeWidget(fileName, widgetData);
-};
-export const generatePackagesData = async (writer, tests) => {
-    const classifier = (test) => {
-        return (test.labels
-            .find((label) => label.name === "package")
-            ?.value?.split(".")
-            ?.map((group) => ({
-            groups: [group],
-        })) ?? []);
-    };
-    const data = createTree(tests, classifier);
-    const packagesData = collapseTree(data);
-    await writer.writeData("packages.json", packagesData);
-};
-export const generateCategoriesData = async (writer, tests) => {
-    const classifier = (test) => {
-        const byMessage = { groups: [test.statusMessage ?? "No message"] };
-        const categories = test.extra.categories;
-        if (!categories || categories.length === 0) {
-            return undefined;
-        }
-        const groups = categories.map((c) => c.name);
-        return [{ groups }, byMessage];
-    };
-    const data = createTree(tests, classifier);
-    const fileName = "categories.json";
-    await writer.writeData(fileName, data);
-    const widgetData = createWidget(data);
-    await writer.writeWidget(fileName, widgetData);
-};
-export const generateTimelineData = async (writer, tests) => {
-    const classifier = (test) => {
-        return [{ groups: [test.hostId ?? "Default"] }, { groups: [test.threadId ?? "Default"] }];
-    };
-    const data = createTree(tests, classifier);
-    await writer.writeData("timeline.json", data);
+        });
+        return acc;
+    }, []);
 };
-export const generateTestResults = async (writer, tests) => {
-    for (const test of tests) {
-        await writer.writeTestCase(test);
+export const generateTestResults = async (writer, store) => {
+    const allTr = await store.allTestResults({ includeHidden: true });
+    let convertedTrs = [];
+    for (const tr of allTr) {
+        const trFixtures = await store.fixturesByTrId(tr.id);
+        const convertedTrFixtures = trFixtures.map(convertFixtureResult);
+        const convertedTr = convertTestResult(tr);
+        const { error, status, flaky } = convertedTr;
+        const categories = (await store.metadataByKey("allure2_categories")) ?? [];
+        const matchedCategories = matchCategories(categories, {
+            message: error?.message,
+            trace: error?.trace,
+            status,
+            flaky,
+        });
+        convertedTr.categories = matchedCategories;
+        convertedTr.history = (await store.historyByTrId(tr.id)) ?? [];
+        convertedTr.retries = await store.retriesByTrId(tr.id);
+        convertedTr.retry = convertedTr.retries.length > 0;
+        convertedTr.setup = convertedTrFixtures.filter((f) => f.type === "before");
+        convertedTr.teardown = convertedTrFixtures.filter((f) => f.type === "after");
+        convertedTr.attachments = (await store.attachmentsByTrId(tr.id)).map((attachment) => ({
+            link: attachment,
+            type: "attachment",
+        }));
+        convertedTr.breadcrumbs = createBreadcrumbs(convertedTr);
+        convertedTrs.push(convertedTr);
     }
+    convertedTrs = convertedTrs.sort(nullsLast(compareBy("start", ordinal()))).map((tr, idx) => ({
+        ...tr,
+        order: idx + 1,
+    }));
+    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 generateSummaryJson = async (writer, reportName, tests) => {
-    const statistic = { total: 0 };
-    const time = {};
-    tests
-        .filter((test) => !test.hidden)
-        .forEach((test) => {
-        updateStatistic(statistic, test);
-        updateTime(time, test);
-    });
-    const data = {
-        reportName,
-        statistic,
-        time,
-    };
-    await writer.writeWidget("summary.json", data);
-};
-export const generateEnvironmentJson = async (writer, env) => {
-    await writer.writeWidget("environment.json", env);
-};
-export const generateExecutorJson = async (writer, executor) => {
-    await writer.writeWidget("executors.json", executor ? [executor] : []);
-};
-export const generateDefaultWidgetData = async (writer, tests, ...fileNames) => {
-    const statusChartData = tests
-        .filter((test) => !test.hidden)
-        .map(({ uid, name, status, time, extra: { severity = "normal" } }) => {
+export const generateTree = async (writer, treeName, labels, tests) => {
+    const visibleTests = tests.filter((test) => !test.hidden);
+    const tree = createTreeByLabels(visibleTests, labels, ({ id, name, status, duration, flaky, transition, start, retries }) => {
+        const retriesCount = retries?.length ?? 0;
         return {
-            uid,
+            nodeId: id,
+            retry: Boolean(retriesCount),
+            retriesCount,
             name,
             status,
-            time,
-            severity,
+            duration,
+            flaky,
+            transition,
+            start,
         };
+    }, undefined, (group, leaf) => {
+        incrementStatistic(group.statistic, leaf.status);
     });
-    for (const fileName of fileNames) {
-        await writer.writeWidget(fileName, statusChartData);
-    }
+    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);
 };
-export const generateEmptyTrendData = async (writer, ...fileNames) => {
-    for (const fileName of fileNames) {
-        await writer.writeWidget(fileName, [
-            {
-                uid: "invalid",
-                name: "invalid",
-                statistic: { total: 0 },
-            },
-        ]);
-    }
+export const generateEnvironmentJson = async (writer, env) => {
+    await writer.writeWidget("allure_environment.json", env);
 };
-export const generateTrendData = async (writer, reportName, tests, historyDataPoints) => {
-    const statistic = { total: 0 };
-    tests
-        .filter((test) => !test.hidden)
-        .forEach((test) => {
-        updateStatistic(statistic, test);
-    });
-    const history = historyDataPoints.map((point) => {
-        const stat = { total: 0 };
-        Object.values(point.testResults).forEach((testResult) => {
-            updateStatistic(stat, testResult);
-        });
-        return {
-            data: stat,
-            timestamp: point.timestamp,
-            reportName: point.name,
-        };
-    });
-    history
-        .sort((a, b) => b.timestamp - a.timestamp)
-        .forEach((element, index) => {
-        element.buildOrder = history.length - index;
-    });
-    const data = [
-        {
-            data: statistic,
-            timestamp: new Date().getTime(),
-            buildOrder: history.length + 1,
-            reportName: reportName,
-        },
-        ...history,
-    ];
-    await writer.writeWidget("history-trend.json", data);
+export const generateStatistic = async (writer, statistic) => {
+    await writer.writeWidget("allure_statistic.json", statistic);
+};
+export const generatePieChart = async (writer, statistic) => {
+    const chartData = getPieChartValues(statistic);
+    await writer.writeWidget("allure_pie_chart.json", chartData);
 };
-export const generateAttachmentsData = async (writer, attachmentLinks, contentFunction) => {
+export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
     const result = new Map();
     for (const { id, ext, ...link } of attachmentLinks) {
         if (link.missed) {
-            continue;
+            return;
         }
         const content = await contentFunction(id);
         if (!content) {
@@ -274,3 +159,104 @@ export const generateAttachmentsData = async (writer, attachmentLinks, contentFu
     }
     return result;
 };
+export const generateHistoryDataPoints = async (writer, store) => {
+    const result = new Map();
+    const allHistoryPoints = await store.allHistoryDataPoints();
+    for (const historyPoint of allHistoryPoints.slice(0, 6)) {
+        const src = `history/${historyPoint.uuid}.json`;
+        await writer.writeData(src, historyPoint);
+    }
+    return result;
+};
+export const generateStaticFiles = async (payload) => {
+    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "auto", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, } = payload;
+    const compile = Handlebars.compile(template);
+    const manifest = await readTemplateManifest(payload.singleFile);
+    const headTags = [];
+    const bodyTags = [];
+    if (!payload.singleFile) {
+        for (const key in manifest) {
+            const fileName = manifest[key];
+            const filePath = require.resolve(join("@allurereport/web-classic/dist", singleFile ? "single" : "multi", fileName));
+            if (key.includes(".woff")) {
+                headTags.push(createFontLinkTag(fileName));
+            }
+            if (key === "main.css") {
+                headTags.push(createStylesLinkTag(fileName));
+            }
+            if (key === "main.js") {
+                bodyTags.push(createScriptTag(fileName));
+            }
+            if (singleFile) {
+                continue;
+            }
+            const fileContent = await readFile(filePath);
+            await reportFiles.addFile(basename(filePath), fileContent);
+        }
+    }
+    else {
+        const mainJs = manifest["main.js"];
+        const mainJsSource = require.resolve(`@allurereport/web-classic/dist/single/${mainJs}`);
+        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: now,
+        reportUuid,
+        groupBy: groupBy?.length ? groupBy : ["parentSuite", "suite", "subSuite"],
+        allureVersion,
+        cacheKey: now.toString(),
+    };
+    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);
+        }
+        throw err;
+    }
+};
+export const generateTreeByCategories = async (writer, treeName, tests) => {
+    const visibleTests = tests.filter((test) => !test.hidden);
+    const tree = createTreeByCategories(visibleTests, ({ id, name, status, duration, flaky, transition, start, retries }) => {
+        const retriesCount = retries?.length ?? 0;
+        return {
+            nodeId: id,
+            retry: Boolean(retriesCount),
+            retriesCount,
+            name,
+            status,
+            duration,
+            flaky,
+            transition,
+            start,
+        };
+    }, undefined, (group, leaf) => {
+        incrementStatistic(group.statistic, leaf.status);
+    });
+    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);
+};

package/dist/index.d.ts CHANGED Viewed

@@ -1,2 +1,2 @@
-import { Allure2Plugin } from "./plugin.js";
-export default Allure2Plugin;
+export type { ClassicPluginOptions } from "./model.js";
+export { ClassicPlugin as default } from "./plugin.js";

package/dist/index.js CHANGED Viewed

@@ -1,2 +1 @@
-import { Allure2Plugin } from "./plugin.js";
-export default Allure2Plugin;
+export { ClassicPlugin as default } from "./plugin.js";

package/dist/model.d.ts CHANGED Viewed

@@ -1,146 +1,26 @@
-import type { Statistic } from "@allurereport/core-api";
-export type Allure2Status = "failed" | "broken" | "passed" | "skipped" | "unknown";
-export interface Allure2Time {
-    start?: number;
-    stop?: number;
-    duration?: number;
-}
-export interface Allure2Label {
-    name?: string;
-    value?: string;
-}
-export interface Allure2Link {
-    name?: string;
-    url?: string;
-    type?: string;
-}
-export interface Allure2Parameter {
-    name?: string;
-    value?: string;
-}
-export interface Allure2Attachment {
-    uid: string;
-    name?: string;
-    source?: string;
-    type?: string;
-    size?: number;
-}
-export interface Allure2Step {
-    name: string;
-    time: Allure2Time;
-    status: Allure2Status;
-    statusMessage?: string;
-    statusTrace?: string;
-    steps: Allure2Step[];
-    attachments: Allure2Attachment[];
-    parameters: Allure2Parameter[];
-    stepsCount: number;
-    attachmentsCount: number;
-    shouldDisplayMessage: boolean;
-    hasContent: boolean;
-    attachmentStep: boolean;
-}
-export type Allure2StageResult = Allure2Step | Omit<Allure2Step, "name">;
-export interface Allure2TestResult {
-    uid: string;
-    name: string;
-    fullName?: string;
-    historyId?: string;
-    testId?: string;
-    time: Allure2Time;
-    description?: string;
-    descriptionHtml?: string;
-    status: Allure2Status;
-    statusMessage?: string;
-    statusTrace?: string;
-    flaky: boolean;
-    newFailed: boolean;
-    newBroken: boolean;
-    newPassed: boolean;
-    retriesCount: number;
-    retriesStatusChange: boolean;
-    beforeStages: Allure2StageResult[];
-    testStage: Allure2StageResult;
-    afterStages: Allure2StageResult[];
-    labels: Allure2Label[];
-    parameters: Allure2Parameter[];
-    links: Allure2Link[];
-    hostId?: string;
-    threadId?: string;
-    hidden: boolean;
-    retry: boolean;
-    extra: {
-        [key: string]: any;
+import type { TestResult, TestStatus } from "@allurereport/core-api";
+export type ClassicOptions = {
+    reportName?: string;
+    singleFile?: boolean;
+    logo?: string;
+    theme?: "light" | "dark" | "auto";
+    reportLanguage?: "en";
+    groupBy?: string[];
+    ci?: {
+        type: "github" | "jenkins";
+        url: string;
+        name: string;
     };
-}
-export declare const statisticKeys: (keyof Statistic)[];
-export interface GroupTime {
-    start?: number;
-    stop?: number;
-    duration?: number;
-    minDuration?: number;
-    maxDuration?: number;
-    sumDuration?: number;
-}
-export interface SummaryData {
-    reportName: string;
-    statistic: Statistic;
-    time: GroupTime;
-}
-export type Allure2SeverityLevel = "blocker" | "critical" | "normal" | "minor" | "trivial";
-export declare const severityValues: Allure2SeverityLevel[];
-export interface StatusChartData {
-    uid: string;
-    name: string;
-    time: Allure2Time;
-    status: Allure2Status;
-    severity: Allure2SeverityLevel;
-}
-export interface Allure2Category {
+    filter?: (tr: TestResult) => boolean;
+};
+export type TemplateManifest = Record<string, string>;
+export type ClassicPluginOptions = ClassicOptions;
+export interface ClassicCategory {
     name: string;
     description?: string;
     descriptionHtml?: string;
     messageRegex?: string;
     traceRegex?: string;
-    matchedStatuses?: Allure2Status[];
+    matchedStatuses?: TestStatus[];
     flaky?: boolean;
 }
-export interface Allure2RetryItem {
-    uid: string;
-    status: Allure2Status;
-    statusDetails?: string;
-    time: Allure2Time;
-}
-export interface Allure2HistoryItem {
-    uid: string;
-    reportUrl: string;
-    status: Allure2Status;
-    statusDetails?: string;
-    time: Allure2Time;
-}
-export interface Allure2HistoryData {
-    statistic: Statistic;
-    items: Allure2HistoryItem[];
-}
-export interface Allure2HistoryTrendItem {
-    data: Statistic;
-    buildOrder?: number;
-    reportUrl?: string;
-    reportName?: string;
-}
-export type Allure2Options = {
-    reportName?: string;
-    singleFile?: boolean;
-    reportLanguage?: string;
-};
-export type Allure2PluginOptions = Allure2Options;
-export interface Allure2ExecutorInfo {
-    name: string;
-    type: string;
-    url: string;
-    buildOrder: number;
-    buildName: string;
-    buildUrl: string;
-    reportName: string;
-    reportUrl: string;
-}

package/dist/model.js CHANGED Viewed

@@ -1,2 +1 @@
-export const statisticKeys = ["failed", "broken", "passed", "skipped", "unknown", "total"];
-export const severityValues = ["blocker", "critical", "normal", "minor", "trivial"];
+export {};

package/dist/plugin.d.ts CHANGED Viewed

@@ -1,9 +1,11 @@
-import { type AllureStore, type Plugin, type PluginContext } from "@allurereport/plugin-api";
-import type { Allure2PluginOptions } from "./model.js";
-export declare class Allure2Plugin implements Plugin {
+import { type AllureStore, type Plugin, type PluginContext, type PluginSummary } from "@allurereport/plugin-api";
+import type { ClassicPluginOptions } from "./model.js";
+export declare class ClassicPlugin implements Plugin {
     #private;
-    readonly options: Allure2PluginOptions;
-    constructor(options?: Allure2PluginOptions);
+    readonly options: ClassicPluginOptions;
+    constructor(options?: ClassicPluginOptions);
+    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>;
 }