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

@allurereport/plugin-classic 3.0.0-beta.7 → 3.0.0-beta.9

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 (21) hide show

package/dist/generators.js CHANGED Viewed

@@ -1,29 +1,29 @@
-import { createBaseUrlScript, createFaviconLinkTag, createReportDataScript, createScriptTag, createStylesLinkTag, } from "@allurereport/web-commons";
+import { compareBy, incrementStatistic, nullsLast, ordinal, } from "@allurereport/core-api";
+import { createTreeByCategories, createTreeByLabels, filterTree, 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 { byLabels, collapseTree, createTree, createWidget } from "./tree.js";
-import { updateStatistic, updateTime } from "./utils.js";
+import { matchCategories } from "./categories.js";
+import { getChartData } from "./charts.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 +31,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,68 +50,162 @@ 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")}`);
+const createBreadcrumbs = (convertedTr) => {
+    const labelsByType = convertedTr.labels.reduce((acc, label) => {
+        if (!acc[label.name]) {
+            acc[label.name] = [];
+        }
+        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);
+                }
+            });
+        });
+        return acc;
+    }, []);
+};
+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 generateTree = async (writer, treeName, labels, tests) => {
+    const visibleTests = tests.filter((test) => !test.hidden);
+    const tree = createTreeByLabels(visibleTests, labels, ({ id, name, status, duration, flaky, start, retries }) => {
+        return {
+            nodeId: id,
+            retry: !!retries?.length,
+            name,
+            status,
+            duration,
+            flaky,
+            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);
+};
+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 generatePieChart = async (writer, statistic) => {
+    const chartData = getChartData(statistic);
+    await writer.writeWidget("allure_pie_chart.json", chartData);
+};
+export const generateAttachmentsFiles = async (writer, attachmentLinks, contentFunction) => {
+    const result = new Map();
+    for (const { id, ext, ...link } of attachmentLinks) {
+        if (link.missed) {
+            return;
+        }
+        const content = await contentFunction(id);
+        if (!content) {
+            continue;
+        }
+        const src = `${id}${ext}`;
+        await writer.writeAttachment(src, content);
+        result.set(id, src);
+    }
+    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);
     }
-    await reportFiles.addFile(fileName, scriptContentBuffer);
-    return inserter(fileName);
+    return result;
 };
 export const generateStaticFiles = async (payload) => {
-    const { reportName, reportLanguage, singleFile, reportFiles, reportDataFiles, reportUuid, allureVersion } = payload;
+    const { reportName = "Allure Report", reportLanguage = "en", singleFile, logo = "", theme = "light", groupBy, reportFiles, reportDataFiles, reportUuid, allureVersion, } = payload;
     const compile = Handlebars.compile(template);
-    const manifest = await readTemplateManifest(singleFile);
+    const manifest = await readTemplateManifest(payload.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;
-        }
-        if (key === "main.js") {
-            const tag = await readManifestEntry({
-                fileName,
-                singleFile,
-                reportFiles,
-                inserter: createScriptTag,
-                mimeType: "text/javascript",
-            });
-            bodyTags.push(tag);
-            continue;
-        }
-        if (singleFile) {
-            continue;
+    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);
         }
-        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 reportOptions = {
-        reportName: reportName ?? "Allure Report",
-        reportLanguage: reportLanguage ?? "en",
+        reportName,
+        logo,
+        theme,
+        reportLanguage,
         createdAt: Date.now(),
+        reportUuid,
+        groupBy: groupBy?.length ? groupBy : ["parentSuite", "suite", "subSuite"],
     };
     const html = compile({
         headTags: headTags.join("\n"),
@@ -120,157 +214,32 @@ export const generateStaticFiles = async (payload) => {
         reportOptions: JSON.stringify(reportOptions),
         analyticsEnable: true,
         allureVersion,
-        reportLanguage,
         reportUuid,
         reportName,
-        singleFile,
+        singleFile: payload.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);
-};
-export const generateTestResults = async (writer, tests) => {
-    for (const test of tests) {
-        await writer.writeTestCase(test);
-    }
-};
-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 generateTreeByCategories = async (writer, treeName, tests) => {
+    const visibleTests = tests.filter((test) => !test.hidden);
+    const tree = createTreeByCategories(visibleTests, ({ id, name, status, duration, flaky, start, retries }) => {
         return {
-            uid,
+            nodeId: id,
+            retry: !!retries?.length,
             name,
             status,
-            time,
-            severity,
-        };
-    });
-    for (const fileName of fileNames) {
-        await writer.writeWidget(fileName, statusChartData);
-    }
-};
-export const generateEmptyTrendData = async (writer, ...fileNames) => {
-    for (const fileName of fileNames) {
-        await writer.writeWidget(fileName, [
-            {
-                uid: "invalid",
-                name: "invalid",
-                statistic: { total: 0 },
-            },
-        ]);
-    }
-};
-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,
+            duration,
+            flaky,
+            start,
         };
+    }, undefined, (group, leaf) => {
+        incrementStatistic(group.statistic, leaf.status);
     });
-    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 generateAttachmentsData = async (writer, attachmentLinks, contentFunction) => {
-    const result = new Map();
-    for (const { id, ext, ...link } of attachmentLinks) {
-        if (link.missed) {
-            continue;
-        }
-        const content = await contentFunction(id);
-        if (!content) {
-            continue;
-        }
-        const src = `${id}${ext}`;
-        await writer.writeAttachment(src, content);
-        result.set(id, src);
-    }
-    return result;
+    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;
+import { AllureAwesomePlugin } from "./plugin.js";
+export default AllureAwesomePlugin;

package/dist/index.js CHANGED Viewed

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

package/dist/model.d.ts CHANGED Viewed

@@ -1,146 +1,25 @@
-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 { TestStatus } from "@allurereport/core-api";
+export type AllureAwesomeOptions = {
+    reportName?: string;
+    singleFile?: boolean;
+    logo?: string;
+    theme?: "light" | "dark";
+    reportLanguage?: "en" | "ru";
+    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 {
+};
+export type TemplateManifest = Record<string, string>;
+export type AllureAwesomePluginOptions = AllureAwesomeOptions;
+export interface AllureAwesomeCategory {
     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,10 @@
 import type { AllureStore, Plugin, PluginContext } from "@allurereport/plugin-api";
-import type { Allure2PluginOptions } from "./model.js";
-export declare class Allure2Plugin implements Plugin {
+import type { AllureAwesomePluginOptions } from "./model.js";
+export declare class AllureAwesomePlugin implements Plugin {
     #private;
-    readonly options: Allure2PluginOptions;
-    constructor(options?: Allure2PluginOptions);
+    readonly options: AllureAwesomePluginOptions;
+    constructor(options?: AllureAwesomePluginOptions);
+    start: (context: PluginContext) => Promise<void>;
     update: (context: PluginContext, store: AllureStore) => Promise<void>;
     done: (context: PluginContext, store: AllureStore) => Promise<void>;
 }