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

package/README.md

@@ -12,7 +12,7 @@
 
 ## Overview
 
-The plugin generates a classic Allure Report.
+The plugin generates brand new Allure Report with modern design and new features.
 
 ## Install
 
@@ -51,4 +51,7 @@ The plugin accepts the following options:
 |------------------|-------------------------------------------------|--------------------------------------------------------------|-----------------|
 | `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`     |

package/dist/categories.d.ts

@@ -1,7 +1,8 @@
-import type { Allure2Category, Allure2Status } from "./model.js";
-export declare const matchCategories: (categories: Allure2Category[], result: {
-    statusMessage?: string;
-    statusTrace?: string;
-    status: Allure2Status;
+import type { TestStatus } from "@allurereport/core-api";
+import type { ClassicCategory } from "./model.js";
+export declare const matchCategories: (categories: ClassicCategory[], result: {
+    message?: string;
+    trace?: string;
+    status: TestStatus;
     flaky: boolean;
-}) => Allure2Category[];
+}) => ClassicCategory[];

package/dist/converters.d.ts

@@ -1,11 +1,5 @@
-import type { HistoryTestResult, TestFixtureResult, TestResult } from "@allurereport/core-api";
-import type { Allure2Category, Allure2TestResult } from "./model.js";
-type ConvertContext = {
-    attachmentMap: Map<string, string>;
-    fixtures: TestFixtureResult[];
-    categories: Allure2Category[];
-    retries: TestResult[];
-    history: HistoryTestResult[];
-};
-export declare const convertTestResult: (context: ConvertContext, test: TestResult) => Allure2TestResult;
-export {};
+import type { TestFixtureResult, TestResult, TestStepResult } from "@allurereport/core-api";
+import type { ClassicFixtureResult, ClassicTestResult, ClassicTestStepResult } from "@allurereport/web-classic";
+export declare const convertTestResult: (tr: TestResult) => ClassicTestResult;
+export declare const convertTestStepResult: (tsr: TestStepResult) => ClassicTestStepResult;
+export declare const convertFixtureResult: (fr: TestFixtureResult) => ClassicFixtureResult;

package/dist/converters.js

@@ -1,182 +1,52 @@
-import { filterIncludedInSuccessRate, isStep } from "@allurereport/core-api";
-import { matchCategories } from "./categories.js";
-import { severityValues } from "./model.js";
-import { updateStatistic } from "./utils.js";
-const sortByTime = (a, b) => a.time.start !== undefined && b.time.start !== undefined ? a.time.start - b.time.start : 0;
-const convertStatus = (status) => status;
-const convertStageResult = (context, result) => {
-    const { name, ...testStage } = convertStep(context, {
-        name: "test",
-        steps: result.steps,
-        start: result.start,
-        stop: result.stop,
-        duration: result.duration,
-        status: result.status,
-        parameters: [],
-        type: "step",
-    });
-    return testStage;
+const mapLabelsByName = (labels) => {
+    return labels.reduce((acc, { name, value }) => {
+        acc[name] = acc[name] || [];
+        if (value) {
+            acc[name].push(value);
+        }
+        return acc;
+    }, {});
 };
-const convertStep = (context, step) => {
-    if (isStep(step)) {
-        const name = step.name;
-        const steps = step.steps.map((child) => convertStep(context, child));
-        const stepsCount = steps.length;
-        const parameters = step.parameters;
-        const parametersCount = parameters.length;
-        const statusMessage = step.error?.message;
-        const shouldDisplayMessage = !!statusMessage || steps.findIndex((s) => s.statusMessage === statusMessage) > 0;
-        return {
-            name,
-            time: {
-                start: step.start,
-                stop: step.stop,
-                duration: step.duration,
-            },
-            status: step.status,
-            statusMessage,
-            statusTrace: step.error?.trace,
-            steps,
-            attachments: [],
-            parameters,
-            stepsCount,
-            attachmentsCount: 0,
-            hasContent: stepsCount + parametersCount > 0 || shouldDisplayMessage,
-            shouldDisplayMessage,
-            attachmentStep: false,
-        };
-    }
-    const stepName = step.link.name;
+export const convertTestResult = (tr) => {
     return {
-        name: stepName,
-        time: {},
-        status: "unknown",
-        steps: [],
-        attachments: [
-            {
-                ...convertAttachment(context, step),
-            },
-        ],
-        parameters: [],
-        stepsCount: 0,
-        attachmentsCount: 1,
-        hasContent: true,
-        shouldDisplayMessage: false,
-        attachmentStep: true,
+        id: tr.id,
+        name: tr.name,
+        start: tr.start,
+        stop: tr.stop,
+        duration: tr.duration,
+        status: tr.status,
+        fullName: tr.fullName,
+        historyId: tr.historyId,
+        flaky: tr.flaky,
+        muted: tr.muted,
+        known: tr.known,
+        hidden: tr.hidden,
+        labels: tr.labels,
+        groupedLabels: mapLabelsByName(tr.labels),
+        parameters: tr.parameters,
+        links: tr.links,
+        steps: tr.steps,
+        error: tr.error,
+        testCase: tr.testCase,
+        setup: [],
+        teardown: [],
+        history: [],
+        retries: [],
+        breadcrumbs: [],
+        retry: false,
+        transition: tr.transition,
     };
 };
-const convertAttachment = (context, { link }) => ({
-    uid: link.id,
-    name: link.name,
-    source: context.attachmentMap.get(link.id) ?? link.originalFileName,
-    type: link.contentType,
-    size: !link.missed ? link.contentLength : undefined,
-});
-const findAllLabels = (test, labelName) => {
-    return test.labels
-        .filter((label) => label.name === labelName)
-        .map((label) => label.value)
-        .filter((value) => value)
-        .map((value) => value);
+export const convertTestStepResult = (tsr) => {
+    return tsr;
 };
-const findLabelValue = (test, labelName) => {
-    return test.labels.find((label) => label.name === labelName)?.value;
-};
-const extractSeverity = (test) => {
-    const maybeSeverity = findLabelValue(test, "severity")?.toLowerCase();
-    return (maybeSeverity ? severityValues.find((value) => value === maybeSeverity) : undefined) ?? "normal";
-};
-const importantStatuses = ["failed", "broken", "passed"];
-export const convertTestResult = (context, test) => {
-    const testStage = convertStageResult(context, test);
-    const beforeStages = context.fixtures
-        .filter((value) => value.type === "before")
-        .map((fixture) => convertStageResult(context, fixture))
-        .sort(sortByTime);
-    const afterStages = context.fixtures
-        .filter((value) => value.type === "after")
-        .map((fixture) => convertStageResult(context, fixture))
-        .sort(sortByTime);
-    const owner = findLabelValue(test, "owner");
-    const severity = extractSeverity(test);
-    const tags = findAllLabels(test, "tag");
-    const status = convertStatus(test.status);
-    const statusMessage = test.error?.message;
-    const statusTrace = test.error?.trace;
-    const flaky = false;
-    const categories = matchCategories(context.categories, { statusMessage, statusTrace, status, flaky });
-    const retries = context.retries.map((retry) => ({
-        uid: retry.id,
-        status: convertStatus(retry.status),
-        statusDetails: retry?.error?.message,
-        time: {
-            start: retry.start,
-            stop: retry.stop,
-            duration: retry.duration,
-        },
-    }));
-    const retriesStatusChange = status in importantStatuses &&
-        retries.find((tr) => tr.status in importantStatuses && tr.status !== status) !== undefined;
-    const lastHistoryStatus = context.history.find(filterIncludedInSuccessRate)?.status;
-    const newFailed = lastHistoryStatus === "passed" && test.status === "failed";
-    const newBroken = lastHistoryStatus === "passed" && test.status === "broken";
-    const newPassed = lastHistoryStatus !== undefined && lastHistoryStatus !== "passed" && test.status === "passed";
-    const historyItems = context.history.map((htr) => ({
-        uid: htr.id,
-        status: convertStatus(htr.status),
-        reportUrl: "unsupported",
-        statusDetails: htr.error?.message,
-        time: {
-            start: htr.start,
-            stop: htr.stop,
-            duration: htr.duration,
-        },
-    }));
-    const statistic = { total: 0 };
-    historyItems.forEach((historyItem) => updateStatistic(statistic, historyItem));
-    const history = {
-        statistic,
-        items: historyItems,
-    };
+export const convertFixtureResult = (fr) => {
     return {
-        uid: test.id,
-        name: test.name,
-        fullName: test.fullName,
-        historyId: test.historyId,
-        testId: test.testCase?.id,
-        time: {
-            start: test.start,
-            stop: test.stop,
-            duration: test.duration,
-        },
-        status,
-        description: test.description,
-        descriptionHtml: test.descriptionHtml,
-        statusMessage,
-        statusTrace,
-        labels: test.labels,
-        links: test.links,
-        parameters: test.parameters,
-        afterStages,
-        beforeStages,
-        testStage: testStage,
-        flaky,
-        hidden: test.hidden,
-        newFailed,
-        newBroken,
-        newPassed,
-        retry: test.hidden,
-        retriesStatusChange,
-        retriesCount: retries.length,
-        hostId: test.hostId,
-        threadId: test.threadId,
-        extra: {
-            owner,
-            severity,
-            tags,
-            categories,
-            retries,
-            history,
-        },
+        id: fr.id,
+        type: fr.type,
+        name: fr.name,
+        status: fr.status,
+        steps: fr.steps.map(convertTestStepResult),
+        duration: fr.duration,
     };
 };

package/dist/generators.d.ts

@@ -1,37 +1,21 @@
-import type { AttachmentLink, HistoryDataPoint } from "@allurereport/core-api";
-import type { ReportFiles, ResultFile } from "@allurereport/plugin-api";
-import type { Allure2ExecutorInfo, Allure2TestResult } from "./model.js";
-import type { Allure2DataWriter, ReportFile } from "./writer.js";
-export type TemplateManifest = Record<string, string>;
+import { type AttachmentLink, type EnvironmentItem, type Statistic } from "@allurereport/core-api";
+import { type AllureStore, type ReportFiles, type ResultFile } from "@allurereport/plugin-api";
+import type { ClassicTestResult } from "@allurereport/web-classic";
+import type { ClassicOptions, TemplateManifest } from "./model.js";
+import type { ClassicDataWriter, ReportFile } from "./writer.js";
 export declare const readTemplateManifest: (singleFileMode?: boolean) => Promise<TemplateManifest>;
-export declare const readManifestEntry: (options: {
-    fileName: string;
-    singleFile?: boolean;
-    mimeType: string;
-    reportFiles: ReportFiles;
-    inserter: (content: string) => string;
-}) => Promise<string>;
-export declare const generateStaticFiles: (payload: {
+export declare const generateTestResults: (writer: ClassicDataWriter, store: AllureStore) => Promise<ClassicTestResult[]>;
+export declare const generateTree: (writer: ClassicDataWriter, treeName: string, labels: string[], tests: ClassicTestResult[]) => Promise<void>;
+export declare const generateEnvironmentJson: (writer: ClassicDataWriter, env: EnvironmentItem[]) => Promise<void>;
+export declare const generateStatistic: (writer: ClassicDataWriter, statistic: Statistic) => Promise<void>;
+export declare const generatePieChart: (writer: ClassicDataWriter, statistic: Statistic) => Promise<void>;
+export declare const generateAttachmentsFiles: (writer: ClassicDataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string> | undefined>;
+export declare const generateHistoryDataPoints: (writer: ClassicDataWriter, store: AllureStore) => Promise<Map<string, string>>;
+export declare const generateStaticFiles: (payload: ClassicOptions & {
     allureVersion: string;
-    reportName: string;
-    reportLanguage: string;
-    singleFile: boolean;
     reportFiles: ReportFiles;
     reportDataFiles: ReportFile[];
     reportUuid: string;
+    reportName: string;
 }) => Promise<void>;
-export declare const generateTree: (writer: Allure2DataWriter, name: string, labelNames: string[], tests: Allure2TestResult[]) => Promise<void>;
-export declare const generatePackagesData: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
-export declare const generateCategoriesData: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
-export declare const generateTimelineData: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
-export declare const generateTestResults: (writer: Allure2DataWriter, tests: Allure2TestResult[]) => Promise<void>;
-export declare const generateSummaryJson: (writer: Allure2DataWriter, reportName: string, tests: Allure2TestResult[]) => Promise<void>;
-export declare const generateEnvironmentJson: (writer: Allure2DataWriter, env: {
-    name: string;
-    values: string[];
-}[]) => Promise<void>;
-export declare const generateExecutorJson: (writer: Allure2DataWriter, executor?: Partial<Allure2ExecutorInfo>) => Promise<void>;
-export declare const generateDefaultWidgetData: (writer: Allure2DataWriter, tests: Allure2TestResult[], ...fileNames: string[]) => Promise<void>;
-export declare const generateEmptyTrendData: (writer: Allure2DataWriter, ...fileNames: string[]) => Promise<void>;
-export declare const generateTrendData: (writer: Allure2DataWriter, reportName: string, tests: Allure2TestResult[], historyDataPoints: HistoryDataPoint[]) => Promise<void>;
-export declare const generateAttachmentsData: (writer: Allure2DataWriter, attachmentLinks: AttachmentLink[], contentFunction: (id: string) => Promise<ResultFile | undefined>) => Promise<Map<string, string>>;
+export declare const generateTreeByCategories: (writer: ClassicDataWriter, treeName: string, tests: ClassicTestResult[]) => Promise<void>;