@allurereport/core 3.0.0-beta.3

package/README.md

@@ -0,0 +1,25 @@
+# Core
+
+[<img src="https://allurereport.org/public/img/allure-report.svg" height="85px" alt="Allure Report logo" align="right" />](https://allurereport.org "Allure Report")
+
+- Learn more about Allure Report at https://allurereport.org
+- 📚 [Documentation](https://allurereport.org/docs/) – discover official documentation for Allure Report
+- ❓ [Questions and Support](https://github.com/orgs/allure-framework/discussions/categories/questions-support) – get help from the team and community
+- 📢 [Official announcements](https://github.com/orgs/allure-framework/discussions/categories/announcements) – be in touch with the latest updates
+- 💬 [General Discussion ](https://github.com/orgs/allure-framework/discussions/categories/general-discussion) – engage in casual conversations, share insights and ideas with the community
+
+---
+
+## Overview
+
+The package includes a collection of utilities which are used across all Allure packages.
+
+## Install
+
+Use your favorite package manager to install the package:
+
+```shell
+npm add @allurereport/core
+yarn add @allurereport/core
+pnpm add @allurereport/core
+```

package/dist/api.d.ts

@@ -0,0 +1,22 @@
+import type { HistoryDataPoint, KnownTestFailure } from "@allurereport/core-api";
+import type { Plugin, QualityGateConfig, ReportFiles } from "@allurereport/plugin-api";
+import type { ResultsReader } from "@allurereport/reader-api";
+export interface FullConfig {
+    name: string;
+    output: string;
+    reportFiles: ReportFiles;
+    readers?: ResultsReader[];
+    plugins?: PluginInstance[];
+    history?: HistoryDataPoint[];
+    historyPath?: string;
+    appendHistory?: boolean;
+    known?: KnownTestFailure[];
+    qualityGate?: QualityGateConfig;
+    realTime?: any;
+}
+export interface PluginInstance {
+    id: string;
+    enabled: boolean;
+    plugin: Plugin;
+    options: Record<string, any>;
+}

package/dist/api.js

@@ -0,0 +1 @@
+export {};

package/dist/config.d.ts

@@ -0,0 +1,22 @@
+import type { Config } from "@allurereport/plugin-api";
+import type { QualityGateConfig } from "@allurereport/plugin-api";
+import type { FullConfig, PluginInstance } from "./api.js";
+export { defineConfig } from "@allurereport/plugin-api";
+export declare const createConfig: (opts: {
+    reportName?: string;
+    output?: string;
+    historyPath?: string;
+    knownIssuesPath?: string;
+    plugins?: PluginInstance[];
+    qualityGate?: QualityGateConfig;
+    cwd?: string;
+}) => Promise<FullConfig>;
+export declare const getPluginId: (key: string) => string;
+export declare const findRuntimeConfigPath: (cwd?: string) => Promise<string | undefined>;
+export declare const readRuntimeConfig: (configPath?: string, cwd?: string, output?: string, name?: string) => Promise<FullConfig>;
+export declare const loadConfig: (configPath: string) => Promise<Config>;
+export declare const resolveConfig: (config: Config, override?: {
+    name?: string;
+    output?: string;
+}) => Promise<FullConfig>;
+export declare const resolvePlugin: (path: string) => Promise<any>;

package/dist/config.js

@@ -0,0 +1,92 @@
+import { readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import * as process from "node:process";
+import { readHistory } from "./history.js";
+import { readKnownIssues } from "./known.js";
+import { FileSystemReportFiles } from "./plugin.js";
+import { importWrapper } from "./utils/module.js";
+export { defineConfig } from "@allurereport/plugin-api";
+export const createConfig = async (opts) => {
+    const { reportName = "Allure Report", output = "allure-report", historyPath, knownIssuesPath, qualityGate, cwd, } = opts;
+    const workingDirectory = cwd ?? process.cwd();
+    const target = resolve(workingDirectory, output);
+    const history = historyPath ? await readHistory(resolve(workingDirectory, historyPath)) : [];
+    const known = knownIssuesPath ? await readKnownIssues(resolve(workingDirectory, knownIssuesPath)) : [];
+    return {
+        name: reportName,
+        history,
+        historyPath,
+        known,
+        qualityGate,
+        plugins: opts.plugins ?? [],
+        reportFiles: new FileSystemReportFiles(target),
+        output: target,
+    };
+};
+const defaultRuntimeConfig = {};
+export const getPluginId = (key) => {
+    return key.replace(/^@.*\//, "").replace(/[/\\]/g, "-");
+};
+export const findRuntimeConfigPath = async (cwd = process.cwd()) => {
+    const files = await readdir(cwd);
+    if (files.includes("allurerc.js")) {
+        return join(cwd, "allurerc.js");
+    }
+    if (files.includes("allurerc.mjs")) {
+        return join(cwd, "allurerc.mjs");
+    }
+    return undefined;
+};
+export const readRuntimeConfig = async (configPath, cwd, output, name) => {
+    const runtimeConfigPath = !configPath ? await findRuntimeConfigPath(cwd) : resolve(cwd ?? process.cwd(), configPath);
+    const runtimeConfig = runtimeConfigPath ? await loadConfig(runtimeConfigPath) : defaultRuntimeConfig;
+    return await resolveConfig(runtimeConfig, { output, name });
+};
+export const loadConfig = async (configPath) => {
+    return (await import(configPath)).default;
+};
+export const resolveConfig = async (config, override = {}) => {
+    const { plugins = {}, name, output, historyPath, ...rest } = config;
+    const pluginInstances = await resolvePlugins(plugins);
+    const out = resolve(override.output ?? output ?? "./allure-report");
+    const history = historyPath ? await readHistory(historyPath) : [];
+    return {
+        ...rest,
+        name: override.name ?? name ?? "Allure Report",
+        reportFiles: new FileSystemReportFiles(out),
+        plugins: pluginInstances,
+        output: out,
+        history,
+        historyPath,
+    };
+};
+export const resolvePlugin = async (path) => {
+    if (!path.startsWith("@allurereport/plugin-")) {
+        try {
+            const module = await importWrapper(`@allurereport/plugin-${path}`);
+            return module.default;
+        }
+        catch (err) { }
+    }
+    try {
+        const module = await importWrapper(path);
+        return module.default;
+    }
+    catch (err) {
+        throw new Error(`Cannot resolve plugin: ${path}`);
+    }
+};
+const resolvePlugins = async (plugins) => {
+    const pluginInstances = [];
+    for (const id in plugins) {
+        const pluginConfig = plugins[id];
+        const Plugin = await resolvePlugin(pluginConfig.import ?? id);
+        pluginInstances.push({
+            id: getPluginId(id),
+            enabled: pluginConfig.enabled ?? true,
+            options: pluginConfig.options ?? {},
+            plugin: new Plugin(pluginConfig.options),
+        });
+    }
+    return pluginInstances;
+};

package/dist/history.d.ts

@@ -0,0 +1,4 @@
+import type { HistoryDataPoint, TestCase, TestResult } from "@allurereport/core-api";
+export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[]) => HistoryDataPoint;
+export declare const readHistory: (historyPath: string) => Promise<HistoryDataPoint[]>;
+export declare const writeHistory: (historyPath: string, data: HistoryDataPoint) => Promise<void>;

package/dist/history.js

@@ -0,0 +1,58 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { isFileNotFoundError } from "./utils/misc.js";
+const createHistoryItems = (testResults) => {
+    return testResults
+        .filter((tr) => tr.historyId)
+        .map(({ id, name, fullName, historyId, status, message, trace, start, stop, duration }) => {
+        return {
+            id,
+            name,
+            fullName,
+            status,
+            message,
+            trace,
+            start,
+            stop,
+            duration,
+            historyId: historyId,
+            reportLinks: [],
+        };
+    })
+        .reduce((previousValue, currentValue) => {
+        previousValue[currentValue.historyId] = currentValue;
+        return previousValue;
+    }, {});
+};
+export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults) => {
+    const knownTestCaseIds = testCases.map((tc) => tc.id);
+    return {
+        uuid: reportUuid,
+        name: reportName,
+        timestamp: new Date().getTime(),
+        knownTestCaseIds,
+        testResults: createHistoryItems(testResults),
+        metrics: {},
+    };
+};
+export const readHistory = async (historyPath) => {
+    const path = resolve(historyPath);
+    try {
+        return (await readFile(path, { encoding: "utf-8" }))
+            .split("\n")
+            .filter((line) => line && line.trim() !== "")
+            .map((line) => JSON.parse(line));
+    }
+    catch (e) {
+        if (isFileNotFoundError(e)) {
+            return [];
+        }
+        throw e;
+    }
+};
+export const writeHistory = async (historyPath, data) => {
+    const path = resolve(historyPath);
+    const parentDir = dirname(path);
+    await mkdir(parentDir, { recursive: true });
+    await writeFile(path, JSON.stringify(data) + "\n", { encoding: "utf-8", flag: "a+" });
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./api.js";
+export * from "./utils/misc.js";
+export * from "./utils/crypto.js";
+export * from "./history.js";
+export * from "./known.js";
+export * from "./config.js";
+export * from "./report.js";
+export * from "./plugin.js";
+export * from "./qualityGate.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./api.js";
+export * from "./utils/misc.js";
+export * from "./utils/crypto.js";
+export * from "./history.js";
+export * from "./known.js";
+export * from "./config.js";
+export * from "./report.js";
+export * from "./plugin.js";
+export * from "./qualityGate.js";

package/dist/known.d.ts

@@ -0,0 +1,4 @@
+import type { KnownTestFailure } from "@allurereport/core-api";
+import type { AllureStore } from "@allurereport/plugin-api";
+export declare const readKnownIssues: (knownIssuePath: string) => Promise<KnownTestFailure[]>;
+export declare const writeKnownIssues: (store: AllureStore, knownIssuesPath?: string) => Promise<void>;

package/dist/known.js

@@ -0,0 +1,32 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { isFileNotFoundError } from "./utils/misc.js";
+const failedStatuses = new Set(["failed", "broken"]);
+export const readKnownIssues = async (knownIssuePath) => {
+    const path = resolve(knownIssuePath);
+    try {
+        const content = await readFile(path, { encoding: "utf-8" });
+        return JSON.parse(content);
+    }
+    catch (e) {
+        if (isFileNotFoundError(e)) {
+            return [];
+        }
+        throw e;
+    }
+};
+export const writeKnownIssues = async (store, knownIssuesPath) => {
+    if (!knownIssuesPath) {
+        return;
+    }
+    const testResults = await store.allTestResults();
+    const knownIssues = testResults
+        .filter((tr) => failedStatuses.has(tr.status))
+        .filter((tr) => tr.historyId)
+        .map(({ historyId, links }) => ({
+        historyId: historyId,
+        issues: links.filter((l) => l.type === "issue"),
+        comment: "automatically generated from failure by allure known-issue command",
+    }));
+    await writeFile(knownIssuesPath, JSON.stringify(knownIssues));
+};

package/dist/plugin.d.ts

@@ -0,0 +1,22 @@
+import { PluginState, ReportFiles } from "@allurereport/plugin-api";
+export declare class DefaultPluginState implements PluginState {
+    #private;
+    constructor(state: Record<string, any>);
+    set: (key: string, value: any) => Promise<void>;
+    get: (key: string) => Promise<void>;
+    unset: (key: string) => Promise<void>;
+}
+export declare class PluginFiles implements ReportFiles {
+    #private;
+    constructor(parent: ReportFiles, pluginId: string);
+    addFile: (key: string, data: Buffer) => Promise<void>;
+}
+export declare class InMemoryReportFiles implements ReportFiles {
+    #private;
+    addFile: (path: string, data: Buffer) => Promise<void>;
+}
+export declare class FileSystemReportFiles implements ReportFiles {
+    #private;
+    constructor(output: string);
+    addFile: (path: string, data: Buffer) => Promise<void>;
+}

package/dist/plugin.js

@@ -0,0 +1,64 @@
+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 _DefaultPluginState_state, _PluginFiles_parent, _PluginFiles_pluginId, _InMemoryReportFiles_state, _FileSystemReportFiles_output;
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+export class DefaultPluginState {
+    constructor(state) {
+        _DefaultPluginState_state.set(this, void 0);
+        this.set = async (key, value) => {
+            __classPrivateFieldGet(this, _DefaultPluginState_state, "f")[key] = value;
+        };
+        this.get = async (key) => {
+            return __classPrivateFieldGet(this, _DefaultPluginState_state, "f")[key];
+        };
+        this.unset = async (key) => {
+            delete __classPrivateFieldGet(this, _DefaultPluginState_state, "f")[key];
+        };
+        __classPrivateFieldSet(this, _DefaultPluginState_state, state, "f");
+    }
+}
+_DefaultPluginState_state = new WeakMap();
+export class PluginFiles {
+    constructor(parent, pluginId) {
+        _PluginFiles_parent.set(this, void 0);
+        _PluginFiles_pluginId.set(this, void 0);
+        this.addFile = async (key, data) => {
+            await __classPrivateFieldGet(this, _PluginFiles_parent, "f").addFile(join(__classPrivateFieldGet(this, _PluginFiles_pluginId, "f"), key), data);
+        };
+        __classPrivateFieldSet(this, _PluginFiles_parent, parent, "f");
+        __classPrivateFieldSet(this, _PluginFiles_pluginId, pluginId, "f");
+    }
+}
+_PluginFiles_parent = new WeakMap(), _PluginFiles_pluginId = new WeakMap();
+export class InMemoryReportFiles {
+    constructor() {
+        _InMemoryReportFiles_state.set(this, {});
+        this.addFile = async (path, data) => {
+            __classPrivateFieldGet(this, _InMemoryReportFiles_state, "f")[path] = data;
+        };
+    }
+}
+_InMemoryReportFiles_state = new WeakMap();
+export class FileSystemReportFiles {
+    constructor(output) {
+        _FileSystemReportFiles_output.set(this, void 0);
+        this.addFile = async (path, data) => {
+            const targetPath = resolve(__classPrivateFieldGet(this, _FileSystemReportFiles_output, "f"), path);
+            const targetDirPath = dirname(targetPath);
+            await mkdir(targetDirPath, { recursive: true });
+            await writeFile(targetPath, data, { encoding: "utf-8" });
+        };
+        __classPrivateFieldSet(this, _FileSystemReportFiles_output, resolve(output), "f");
+    }
+}
+_FileSystemReportFiles_output = new WeakMap();

package/dist/qualityGate.d.ts

@@ -0,0 +1,25 @@
+import type { AllureStore, QualityGateConfig, QualityGateRulesMeta, QualityGateValidationResult, QualityGateValidator } from "@allurereport/plugin-api";
+export declare abstract class AbstractQualityGateValidator implements QualityGateValidator {
+    readonly limit: number;
+    readonly meta?: QualityGateRulesMeta | undefined;
+    constructor(limit: number, meta?: QualityGateRulesMeta | undefined);
+    getTestResultsFilteredByMeta(store: AllureStore): Promise<import("@allurereport/core-api").TestResult[]>;
+    abstract validate(store: AllureStore): Promise<QualityGateValidationResult>;
+}
+export declare class MaxFailuresValidator extends AbstractQualityGateValidator {
+    validate(store: AllureStore): Promise<QualityGateValidationResult>;
+}
+export declare class MinTestsCountValidator extends AbstractQualityGateValidator {
+    validate(store: AllureStore): Promise<QualityGateValidationResult>;
+}
+export declare class SuccessRateValidator extends AbstractQualityGateValidator {
+    validate(store: AllureStore): Promise<QualityGateValidationResult>;
+}
+export declare class QualityGate {
+    #private;
+    readonly config?: QualityGateConfig | undefined;
+    result: QualityGateValidationResult[];
+    constructor(config?: QualityGateConfig | undefined);
+    get exitCode(): 0 | 1;
+    validate: (store: AllureStore) => Promise<void>;
+}

package/dist/qualityGate.js

@@ -0,0 +1,116 @@
+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 _QualityGate_instances, _QualityGate_mappedValidators_get, _QualityGate_createRulesValidator;
+import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
+export class AbstractQualityGateValidator {
+    constructor(limit, meta) {
+        this.limit = limit;
+        this.meta = meta;
+    }
+    async getTestResultsFilteredByMeta(store) {
+        const allTrs = await store.allTestResults();
+        if (!this.meta) {
+            return allTrs;
+        }
+        return allTrs.filter((tr) => {
+            switch (this.meta?.type) {
+                case "label":
+                    return tr.labels.some((label) => label.name === this.meta.name && label.value === this.meta.value);
+                case "parameter":
+                    return tr.parameters.some((parameter) => parameter.name === this.meta.name && parameter.value === this.meta.value);
+                default:
+                    return tr;
+            }
+        });
+    }
+}
+export class MaxFailuresValidator extends AbstractQualityGateValidator {
+    async validate(store) {
+        const trs = (await this.getTestResultsFilteredByMeta(store)).filter((tr) => !tr.hidden).filter(filterUnsuccessful);
+        return {
+            success: trs.length <= this.limit,
+            rule: "maxFailures",
+            meta: this.meta,
+            expected: this.limit,
+            actual: trs.length,
+        };
+    }
+}
+export class MinTestsCountValidator extends AbstractQualityGateValidator {
+    async validate(store) {
+        const trs = (await this.getTestResultsFilteredByMeta(store)).filter((tr) => !tr.hidden);
+        return {
+            success: trs.length >= this.limit,
+            rule: "minTestsCount",
+            meta: this.meta,
+            expected: this.limit,
+            actual: trs.length,
+        };
+    }
+}
+export class SuccessRateValidator extends AbstractQualityGateValidator {
+    async validate(store) {
+        const knownIssues = await store.allKnownIssues();
+        const trs = (await this.getTestResultsFilteredByMeta(store)).filter((tr) => !tr.hidden);
+        const knownIssuesHistoryIds = knownIssues.map((ki) => ki.historyId);
+        const unknown = trs.filter((tr) => !tr.historyId || !knownIssuesHistoryIds.includes(tr.historyId));
+        const passed = unknown.filter(filterSuccessful);
+        const rate = passed.length === 0 ? 0 : passed.length / unknown.length;
+        return {
+            success: rate >= this.limit,
+            rule: "successRate",
+            meta: this.meta,
+            expected: this.limit,
+            actual: rate,
+        };
+    }
+}
+export class QualityGate {
+    constructor(config) {
+        _QualityGate_instances.add(this);
+        this.config = config;
+        this.result = [];
+        _QualityGate_createRulesValidator.set(this, (rules, meta) => {
+            const validators = [];
+            Object.keys(rules).forEach((rule) => {
+                const Validator = __classPrivateFieldGet(this, _QualityGate_instances, "a", _QualityGate_mappedValidators_get)[rule];
+                if (!Validator) {
+                    return;
+                }
+                const validator = new Validator(rules[rule], meta);
+                validators.push(validator);
+            });
+            return validators;
+        });
+        this.validate = async (store) => {
+            const { rules, enforce = [] } = this.config ?? {};
+            const validators = [];
+            const result = [];
+            if (rules) {
+                validators.push(...__classPrivateFieldGet(this, _QualityGate_createRulesValidator, "f").call(this, rules));
+            }
+            enforce.forEach((enforceConfig) => {
+                const { rules: enforceRules, ...meta } = enforceConfig;
+                validators.push(...__classPrivateFieldGet(this, _QualityGate_createRulesValidator, "f").call(this, enforceRules, meta));
+            });
+            for (const validator of validators) {
+                result.push(await validator.validate(store));
+            }
+            this.result = result;
+        };
+    }
+    get exitCode() {
+        return this.result.some((res) => !res.success) ? 1 : 0;
+    }
+}
+_QualityGate_createRulesValidator = new WeakMap(), _QualityGate_instances = new WeakSet(), _QualityGate_mappedValidators_get = function _QualityGate_mappedValidators_get() {
+    return {
+        maxFailures: MaxFailuresValidator,
+        minTestsCount: MinTestsCountValidator,
+        successRate: SuccessRateValidator,
+        ...this.config?.validators,
+    };
+};

package/dist/report.d.ts

@@ -0,0 +1,16 @@
+import type { ResultFile } from "@allurereport/plugin-api";
+import type { FullConfig } from "./api.js";
+import { DefaultAllureStore } from "./store/store.js";
+export declare class AllureReport {
+    #private;
+    constructor(opts: FullConfig);
+    get store(): DefaultAllureStore;
+    get exitCode(): 0 | 1;
+    get validationResults(): import("@allurereport/plugin-api").QualityGateValidationResult[];
+    readDirectory: (resultsDir: string) => Promise<void>;
+    readFile: (resultsFile: string) => Promise<void>;
+    readResult: (data: ResultFile) => Promise<void>;
+    start: () => Promise<void>;
+    done: () => Promise<void>;
+    validate: () => Promise<void>;
+}