@allurereport/core 3.0.0-beta.3

package/dist/report.js

@@ -0,0 +1,188 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AllureReport_instances, _AllureReport_reportUuid, _AllureReport_reportName, _AllureReport_store, _AllureReport_readers, _AllureReport_plugins, _AllureReport_reportFiles, _AllureReport_eventEmitter, _AllureReport_events, _AllureReport_qualityGate, _AllureReport_appendHistory, _AllureReport_historyPath, _AllureReport_realTime, _AllureReport_state, _AllureReport_stage, _AllureReport_update, _AllureReport_eachPlugin, _AllureReport_getPluginState;
+import { allure1, allure2, attachments, junitXml } from "@allurereport/reader";
+import { PathResultFile } from "@allurereport/reader-api";
+import console from "node:console";
+import { randomUUID } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { readFileSync } from "node:fs";
+import { opendir, realpath } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { createHistory, writeHistory } from "./history.js";
+import { DefaultPluginState, PluginFiles } from "./plugin.js";
+import { QualityGate } from "./qualityGate.js";
+import { DefaultAllureStore } from "./store/store.js";
+import { Events } from "./utils/event.js";
+const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+const initRequired = "report is not initialised. Call the start() method first.";
+export class AllureReport {
+    constructor(opts) {
+        _AllureReport_instances.add(this);
+        _AllureReport_reportUuid.set(this, void 0);
+        _AllureReport_reportName.set(this, void 0);
+        _AllureReport_store.set(this, void 0);
+        _AllureReport_readers.set(this, void 0);
+        _AllureReport_plugins.set(this, void 0);
+        _AllureReport_reportFiles.set(this, void 0);
+        _AllureReport_eventEmitter.set(this, void 0);
+        _AllureReport_events.set(this, void 0);
+        _AllureReport_qualityGate.set(this, void 0);
+        _AllureReport_appendHistory.set(this, void 0);
+        _AllureReport_historyPath.set(this, void 0);
+        _AllureReport_realTime.set(this, void 0);
+        _AllureReport_state.set(this, void 0);
+        _AllureReport_stage.set(this, "init");
+        this.readDirectory = async (resultsDir) => {
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+                throw new Error(initRequired);
+            }
+            const resultsDirPath = resolve(resultsDir);
+            const dir = await opendir(resultsDirPath);
+            try {
+                for await (const dirent of dir) {
+                    if (dirent.isFile()) {
+                        const path = await realpath(join(dirent.parentPath, dirent.name));
+                        await this.readResult(new PathResultFile(path, dirent.name));
+                    }
+                }
+            }
+            catch (e) {
+                console.error("can't read directory", e);
+            }
+        };
+        this.readFile = async (resultsFile) => {
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+                throw new Error(initRequired);
+            }
+            await this.readResult(new PathResultFile(resultsFile));
+        };
+        this.readResult = async (data) => {
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+                throw new Error(initRequired);
+            }
+            for (const reader of __classPrivateFieldGet(this, _AllureReport_readers, "f")) {
+                try {
+                    const processed = await reader.read(__classPrivateFieldGet(this, _AllureReport_store, "f"), data);
+                    if (processed) {
+                        return;
+                    }
+                }
+                catch (ignored) { }
+            }
+        };
+        this.start = async () => {
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") === "running") {
+                throw new Error("the report is already started");
+            }
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") === "done") {
+                throw new Error("the report is already stopped, the restart isn't supported at the moment");
+            }
+            __classPrivateFieldSet(this, _AllureReport_stage, "running", "f");
+            await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, true, async (plugin, context) => {
+                await plugin.start?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"), __classPrivateFieldGet(this, _AllureReport_events, "f"));
+            });
+            if (__classPrivateFieldGet(this, _AllureReport_realTime, "f")) {
+                await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
+                __classPrivateFieldGet(this, _AllureReport_events, "f").onAll(async () => {
+                    await __classPrivateFieldGet(this, _AllureReport_update, "f").call(this);
+                });
+            }
+        };
+        _AllureReport_update.set(this, async () => {
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+                return;
+            }
+            await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
+                await plugin.update?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
+            });
+        });
+        this.done = async () => {
+            if (__classPrivateFieldGet(this, _AllureReport_stage, "f") !== "running") {
+                throw new Error(initRequired);
+            }
+            __classPrivateFieldGet(this, _AllureReport_events, "f").offAll();
+            __classPrivateFieldSet(this, _AllureReport_stage, "done", "f");
+            await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
+                await plugin.done?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
+            });
+            if (__classPrivateFieldGet(this, _AllureReport_appendHistory, "f")) {
+                const testResults = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestResults();
+                const testCases = await __classPrivateFieldGet(this, _AllureReport_store, "f").allTestCases();
+                const historyDataPoint = createHistory(__classPrivateFieldGet(this, _AllureReport_reportUuid, "f"), __classPrivateFieldGet(this, _AllureReport_reportName, "f"), testCases, testResults);
+                await writeHistory(__classPrivateFieldGet(this, _AllureReport_historyPath, "f"), historyDataPoint);
+            }
+        };
+        _AllureReport_eachPlugin.set(this, async (initState, consumer) => {
+            if (initState) {
+                __classPrivateFieldSet(this, _AllureReport_state, {}, "f");
+            }
+            for (let descriptor of __classPrivateFieldGet(this, _AllureReport_plugins, "f")) {
+                if (!descriptor.enabled) {
+                    continue;
+                }
+                const id = descriptor.id;
+                const plugin = descriptor.plugin;
+                const pluginState = __classPrivateFieldGet(this, _AllureReport_instances, "m", _AllureReport_getPluginState).call(this, initState, id);
+                if (!pluginState) {
+                    console.error("plugin error: state is empty");
+                    continue;
+                }
+                const pluginFiles = new PluginFiles(__classPrivateFieldGet(this, _AllureReport_reportFiles, "f"), id);
+                const pluginContext = {
+                    allureVersion: version,
+                    reportUuid: __classPrivateFieldGet(this, _AllureReport_reportUuid, "f"),
+                    reportName: __classPrivateFieldGet(this, _AllureReport_reportName, "f"),
+                    state: pluginState,
+                    reportFiles: pluginFiles,
+                };
+                try {
+                    await consumer.call(this, plugin, pluginContext);
+                    if (initState) {
+                        __classPrivateFieldGet(this, _AllureReport_state, "f")[id] = pluginState;
+                    }
+                }
+                catch (e) {
+                    console.error(`plugin ${id} error`, e);
+                }
+            }
+        });
+        this.validate = async () => {
+            await __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate(__classPrivateFieldGet(this, _AllureReport_store, "f"));
+        };
+        const { name, readers = [allure1, allure2, junitXml, attachments], plugins = [], history, known, reportFiles, qualityGate, realTime, appendHistory, historyPath, } = opts;
+        __classPrivateFieldSet(this, _AllureReport_reportUuid, randomUUID(), "f");
+        __classPrivateFieldSet(this, _AllureReport_reportName, name, "f");
+        __classPrivateFieldSet(this, _AllureReport_eventEmitter, new EventEmitter(), "f");
+        __classPrivateFieldSet(this, _AllureReport_events, new Events(__classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
+        __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
+        __classPrivateFieldSet(this, _AllureReport_appendHistory, appendHistory ?? true, "f");
+        __classPrivateFieldSet(this, _AllureReport_historyPath, historyPath ?? "./.allure/history.jsonl", "f");
+        __classPrivateFieldSet(this, _AllureReport_store, new DefaultAllureStore(history, known, __classPrivateFieldGet(this, _AllureReport_eventEmitter, "f")), "f");
+        __classPrivateFieldSet(this, _AllureReport_readers, [...readers], "f");
+        __classPrivateFieldSet(this, _AllureReport_plugins, [...plugins], "f");
+        __classPrivateFieldSet(this, _AllureReport_reportFiles, reportFiles, "f");
+        __classPrivateFieldSet(this, _AllureReport_qualityGate, new QualityGate(qualityGate), "f");
+    }
+    get store() {
+        return __classPrivateFieldGet(this, _AllureReport_store, "f");
+    }
+    get exitCode() {
+        return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").exitCode;
+    }
+    get validationResults() {
+        return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").result;
+    }
+}
+_AllureReport_reportUuid = new WeakMap(), _AllureReport_reportName = new WeakMap(), _AllureReport_store = new WeakMap(), _AllureReport_readers = new WeakMap(), _AllureReport_plugins = new WeakMap(), _AllureReport_reportFiles = new WeakMap(), _AllureReport_eventEmitter = new WeakMap(), _AllureReport_events = new WeakMap(), _AllureReport_qualityGate = new WeakMap(), _AllureReport_appendHistory = new WeakMap(), _AllureReport_historyPath = new WeakMap(), _AllureReport_realTime = new WeakMap(), _AllureReport_state = new WeakMap(), _AllureReport_stage = new WeakMap(), _AllureReport_update = new WeakMap(), _AllureReport_eachPlugin = new WeakMap(), _AllureReport_instances = new WeakSet(), _AllureReport_getPluginState = function _AllureReport_getPluginState(init, id) {
+    return init ? new DefaultPluginState({}) : __classPrivateFieldGet(this, _AllureReport_state, "f")?.[id];
+};

package/dist/store/convert.d.ts

@@ -0,0 +1,10 @@
+import { AttachmentLink, TestCase, TestFixtureResult, TestResult } from "@allurereport/core-api";
+import { RawFixtureResult, RawTestResult, ReaderContext } from "@allurereport/reader-api";
+export declare const __unknown = "#___unknown_value___#";
+export type StateData = {
+    testCases: Map<string, TestCase>;
+    attachments: Map<string, AttachmentLink>;
+    visitAttachmentLink: (link: AttachmentLink) => void;
+};
+export declare const testFixtureResultRawToState: (stateData: Pick<StateData, "attachments" | "visitAttachmentLink">, raw: RawFixtureResult, context: ReaderContext) => TestFixtureResult;
+export declare const testResultRawToState: (stateData: StateData, raw: RawTestResult, context: ReaderContext) => TestResult;

package/dist/store/convert.js

@@ -0,0 +1,254 @@
+import { notNull, } from "@allurereport/core-api";
+import { findByLabelName } from "@allurereport/core-api";
+import { md5 } from "@allurereport/plugin-api";
+import MarkdownIt from "markdown-it";
+import { randomUUID } from "node:crypto";
+import { extname } from "node:path";
+const defaultStatus = "unknown";
+export const __unknown = "#___unknown_value___#";
+export const testFixtureResultRawToState = (stateData, raw, context) => {
+    const name = raw.name || "Unknown test";
+    return {
+        id: md5(raw.uuid || randomUUID()),
+        testResultIds: raw.testResults?.filter(notNull).map(md5) ?? [],
+        type: raw.type,
+        name,
+        status: raw.status ?? defaultStatus,
+        message: raw.message,
+        trace: raw.trace,
+        ...processTimings(raw),
+        steps: convertSteps(stateData, raw.steps),
+        sourceMetadata: {
+            readerId: context.readerId,
+            metadata: context.metadata ?? {},
+        },
+    };
+};
+export const testResultRawToState = (stateData, raw, context) => {
+    const labels = convertLabels(raw.labels);
+    const hostId = findByLabelName(labels, "host");
+    const threadId = findByLabelName(labels, "thread");
+    const name = raw.name || "Unknown test";
+    const testCase = processTestCase(stateData, raw);
+    const parameters = convertParameters(raw.parameters);
+    return {
+        id: md5(raw.uuid || randomUUID()),
+        name,
+        testCase,
+        fullName: raw.fullName,
+        historyId: calculateHistoryId(testCase, parameters),
+        status: raw.status ?? defaultStatus,
+        message: raw.message,
+        trace: raw.trace,
+        ...processTimings(raw),
+        description: raw.description,
+        descriptionHtml: raw.descriptionHtml ?? markdownToHtml(raw.description),
+        precondition: raw.precondition,
+        preconditionHtml: raw.preconditionHtml ?? markdownToHtml(raw.precondition),
+        expectedResult: raw.expectedResult,
+        expectedResultHtml: raw.expectedResultHtml ?? markdownToHtml(raw.expectedResult),
+        flaky: raw.flaky ?? false,
+        muted: raw.muted ?? false,
+        known: raw.known ?? false,
+        hidden: false,
+        labels,
+        steps: convertSteps(stateData, raw.steps),
+        parameters,
+        links: convertLinks(raw.links),
+        hostId,
+        threadId,
+        sourceMetadata: {
+            readerId: context.readerId,
+            metadata: context.metadata ?? {},
+        },
+    };
+};
+const processTestCase = ({ testCases }, raw) => {
+    const [id, allureId] = calculateTestId(raw);
+    if (id) {
+        const maybeTestCase = testCases.get(id);
+        if (maybeTestCase) {
+            return maybeTestCase;
+        }
+        const testCase = {
+            id,
+            allureId,
+            name: raw.testCaseName ?? raw.name ?? __unknown,
+            fullName: raw.fullName,
+        };
+        testCases.set(id, testCase);
+        return testCase;
+    }
+    return undefined;
+};
+const createAttachmentStep = (link) => {
+    return {
+        link,
+        type: "attachment",
+    };
+};
+const processAttachmentLink = ({ attachments, visitAttachmentLink }, attach) => {
+    if (!attach.originalFileName) {
+        return createAttachmentStep({
+            id: randomUUID(),
+            originalFileName: undefined,
+            contentType: attach.contentType,
+            ext: "",
+            name: attach.name ?? __unknown,
+            missed: true,
+            used: true,
+        });
+    }
+    const id = md5(attach.originalFileName);
+    let previous = attachments.get(id);
+    if (!previous) {
+        const link = {
+            id,
+            originalFileName: attach.originalFileName,
+            ext: extname(attach.originalFileName),
+            name: attach.name ?? attach.originalFileName,
+            contentType: attach.contentType,
+            used: true,
+            missed: true,
+        };
+        attachments.set(id, link);
+        visitAttachmentLink(link);
+        return createAttachmentStep(link);
+    }
+    if (previous.used) {
+        return createAttachmentStep({
+            id: randomUUID(),
+            originalFileName: undefined,
+            ext: "",
+            name: attach.name ?? attach.originalFileName ?? __unknown,
+            contentType: attach.contentType,
+            missed: true,
+            used: true,
+        });
+    }
+    const link = {
+        ...previous,
+        id,
+        name: attach.name ?? previous.originalFileName,
+        contentType: attach.contentType ?? previous.contentType,
+        contentLength: previous.contentLength,
+        used: true,
+        missed: false,
+    };
+    attachments.set(id, link);
+    visitAttachmentLink(link);
+    return createAttachmentStep(link);
+};
+const processTimings = ({ start, stop, duration, }) => {
+    const effectiveDuration = duration ? Math.max(0, duration) : 0;
+    if (start !== undefined) {
+        if (stop !== undefined) {
+            if (stop < start) {
+                return { start, stop: start, duration: 0 };
+            }
+            return { start, stop, duration: stop - start };
+        }
+        return { start, stop: start + effectiveDuration, duration: effectiveDuration };
+    }
+    if (stop !== undefined) {
+        return { start: stop - effectiveDuration, stop, duration: effectiveDuration };
+    }
+    return { start: undefined, stop: undefined, duration };
+};
+const convertLabels = (labels) => {
+    return labels?.filter(notNull)?.map(convertLabel)?.flatMap(processTagLabels) ?? [];
+};
+const convertLabel = (label) => {
+    return {
+        name: label.name ?? __unknown,
+        value: label.value,
+    };
+};
+const convertSteps = (stateData, steps) => steps?.filter(notNull)?.map((step) => convertStep(stateData, step)) ?? [];
+const convertStep = (stateData, step) => {
+    if (step.type === "step") {
+        return {
+            name: step.name ?? __unknown,
+            status: step.status ?? defaultStatus,
+            steps: convertSteps(stateData, step.steps),
+            parameters: convertParameters(step.parameters),
+            ...processTimings(step),
+            type: "step",
+        };
+    }
+    return {
+        ...processAttachmentLink(stateData, step),
+    };
+};
+const convertParameters = (parameters) => parameters
+    ?.filter(notNull)
+    ?.filter((p) => p.name)
+    ?.map(convertParameter) ?? [];
+const convertParameter = (param) => ({
+    name: param.name ?? __unknown,
+    value: param.value ?? __unknown,
+    hidden: param.hidden ?? false,
+    excluded: param.excluded ?? false,
+    masked: param.masked ?? false,
+});
+const convertLinks = (links) => links
+    ?.filter(notNull)
+    ?.filter((l) => l.url)
+    ?.map(convertLink) ?? [];
+const convertLink = (link) => ({
+    name: link.name,
+    url: link.url ?? __unknown,
+    type: link.type,
+});
+const markdownToHtml = (value) => (value ? new MarkdownIt().render(value) : undefined);
+const calculateTestId = (raw) => {
+    const maybeAllureId = raw.labels?.find((label) => label.name === "ALLURE_ID" || label.name === "AS_ID")?.value;
+    if (maybeAllureId) {
+        return [md5(`ALLURE_ID=${maybeAllureId}`), maybeAllureId];
+    }
+    if (raw.testId) {
+        return [md5(raw.testId), undefined];
+    }
+    if (raw.fullName) {
+        return [md5(raw.fullName), undefined];
+    }
+    return [undefined, undefined];
+};
+const calculateHistoryId = (testCase, parameters) => {
+    if (!testCase) {
+        return undefined;
+    }
+    const paramsPart = stringifyParams(parameters);
+    return `${testCase.id}.${md5(paramsPart)}`;
+};
+const parametersCompare = (a, b) => {
+    return (a.name ?? "").localeCompare(b.name) || a.value.localeCompare(b.value ?? "");
+};
+const stringifyParams = (parameters) => {
+    if (!parameters) {
+        return "";
+    }
+    return parameters
+        .filter((p) => !p?.excluded)
+        .sort(parametersCompare)
+        .map((p) => `${p.name}:${p.value}`)
+        .join(",");
+};
+const idLabelMatcher = new RegExp("^@?allure\\.id[:=](?<id>.+)$");
+const tagLabelMatcher = new RegExp("^@?allure\\.label\\.(?<name>.+)[:=](?<value>.+)$");
+const processTagLabels = (label) => {
+    if (label.name === "tag" && label.value) {
+        const matchTag = label.value.match(idLabelMatcher);
+        if (matchTag) {
+            const id = matchTag?.groups?.["id"];
+            return id ? [{ name: "ALLURE_ID", value: id }] : [];
+        }
+        const matchLabel = label.value.match(tagLabelMatcher);
+        if (matchLabel) {
+            const name = matchLabel?.groups?.["name"];
+            const value = matchLabel?.groups?.["value"];
+            return name && value ? [{ name, value }] : [];
+        }
+    }
+    return label.name ? [{ name: label.name, value: label.value }] : [];
+};

package/dist/store/store.d.ts

@@ -0,0 +1,49 @@
+import { AttachmentLink, HistoryDataPoint, HistoryTestResult, KnownTestFailure, Statistic, TestCase, TestFixtureResult, TestResult } from "@allurereport/core-api";
+import { AllureStore, ResultFile } from "@allurereport/plugin-api";
+import type { RawFixtureResult, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
+import { EventEmitter } from "node:events";
+import { AllureStoreEvents } from "../utils/event.js";
+export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
+    #private;
+    readonly indexTestResultByTestCase: Map<string, TestResult[]>;
+    readonly indexLatestTestResultByHistoryId: Map<string, TestResult>;
+    readonly indexTestResultByHistoryId: Map<string, TestResult[]>;
+    readonly indexAttachmentByTestResult: Map<string, AttachmentLink[]>;
+    readonly indexAttachmentByFixture: Map<string, AttachmentLink[]>;
+    readonly indexFixturesByTestResult: Map<string, TestFixtureResult[]>;
+    readonly indexKnownByHistoryId: Map<string, KnownTestFailure[]>;
+    constructor(history?: HistoryDataPoint[], known?: KnownTestFailure[], eventEmitter?: EventEmitter<AllureStoreEvents>);
+    visitTestResult(raw: RawTestResult, context: ReaderContext): Promise<void>;
+    visitTestFixtureResult(result: RawFixtureResult, context: ReaderContext): Promise<void>;
+    visitAttachmentFile(resultFile: ResultFile, context: ReaderContext): Promise<void>;
+    visitMetadata(metadata: RawMetadata, context: ReaderContext): Promise<void>;
+    allTestCases(): Promise<TestCase[]>;
+    allTestResults(options?: {
+        includeHidden: boolean;
+    }): Promise<TestResult[]>;
+    allAttachments(options?: {
+        includeMissed?: boolean;
+        includeUnused?: boolean;
+    }): Promise<AttachmentLink[]>;
+    allMetadata(): Promise<Record<string, any>>;
+    allFixtures(): Promise<TestFixtureResult[]>;
+    allHistoryDataPoints(): Promise<HistoryDataPoint[]>;
+    allKnownIssues(): Promise<KnownTestFailure[]>;
+    testCaseById(tcId: string): Promise<TestCase | undefined>;
+    testResultById(trId: string): Promise<TestResult | undefined>;
+    attachmentById(attachmentId: string): Promise<AttachmentLink | undefined>;
+    attachmentContentById(attachmentId: string): Promise<ResultFile | undefined>;
+    metadataByKey<T>(key: string): Promise<T | undefined>;
+    testResultsByTcId(tcId: string): Promise<TestResult[]>;
+    attachmentsByTrId(trId: string): Promise<AttachmentLink[]>;
+    retriesByTrId(trId: string): Promise<TestResult[]>;
+    historyByTrId(trId: string): Promise<HistoryTestResult[]>;
+    fixturesByTrId(trId: string): Promise<TestFixtureResult[]>;
+    failedTestResults(): Promise<TestResult[]>;
+    unknownFailedTestResults(): Promise<TestResult[]>;
+    testResultsByLabel(labelName: string): Promise<{
+        [x: string]: TestResult[];
+        _: TestResult[];
+    }>;
+    testsStatistic(): Promise<Statistic>;
+}