@allurereport/core 3.0.0-beta.8 → 3.0.0

package/dist/api.d.ts

@@ -1,24 +1,34 @@
-import type { HistoryDataPoint, KnownTestFailure } from "@allurereport/core-api";
-import type { DefaultLabelsConfig, Plugin, QualityGateConfig, ReportFiles } from "@allurereport/plugin-api";
+import type { DefaultLabelsConfig, EnvironmentsConfig, KnownTestFailure, ReportVariables } from "@allurereport/core-api";
+import type { Plugin, QualityGateConfig, ReportFiles } from "@allurereport/plugin-api";
 import type { ResultsReader } from "@allurereport/reader-api";
+export interface PluginInstance {
+    id: string;
+    enabled: boolean;
+    plugin: Plugin;
+    options: Record<string, any>;
+}
 export interface FullConfig {
     name: string;
     output: string;
+    open: boolean;
+    port: string | undefined;
+    historyPath?: string;
+    knownIssuesPath: string;
+    defaultLabels?: DefaultLabelsConfig;
+    stage?: string;
+    environment?: string;
+    environments?: EnvironmentsConfig;
+    variables?: ReportVariables;
     reportFiles: ReportFiles;
     readers?: ResultsReader[];
     plugins?: PluginInstance[];
-    history: HistoryDataPoint[];
-    historyPath: string;
     appendHistory?: boolean;
-    knownIssuesPath: string;
     known?: KnownTestFailure[];
-    qualityGate?: QualityGateConfig;
-    defaultLabels?: DefaultLabelsConfig;
     realTime?: any;
-}
-export interface PluginInstance {
-    id: string;
-    enabled: boolean;
-    plugin: Plugin;
-    options: Record<string, any>;
+    qualityGate?: QualityGateConfig;
+    allureService?: {
+        url?: string;
+        project?: string;
+        accessToken?: string;
+    };
 }

package/dist/config.d.ts

@@ -1,18 +1,24 @@
 import type { Config } from "@allurereport/plugin-api";
-import type { FullConfig } from "./api.js";
-export declare const getPluginId: (key: string) => string;
-export declare const findConfig: (cwd: string, configPath?: string) => Promise<string | undefined>;
+import type { FullConfig, PluginInstance } from "./api.js";
 export interface ConfigOverride {
-    name?: string;
-    output?: string;
-    historyPath?: string;
-    knownIssuesPath?: string;
+    name?: Config["name"];
+    output?: Config["output"];
+    open?: Config["open"];
+    port?: Config["port"];
+    historyPath?: Config["historyPath"];
+    knownIssuesPath?: Config["knownIssuesPath"];
+    plugins?: Config["plugins"];
 }
+export declare const getPluginId: (key: string) => string;
+export declare const findConfig: (cwd: string, configPath?: string) => Promise<string | undefined>;
 export declare const validateConfig: (config: Config) => {
     valid: boolean;
     fields: string[];
 };
-export declare const loadConfig: (configPath: string) => Promise<Config>;
+export declare const loadYamlConfig: (configPath: string) => Promise<Config>;
+export declare const loadJsonConfig: (configPath: string) => Promise<Config>;
+export declare const loadJsConfig: (configPath: string) => Promise<Config>;
 export declare const resolveConfig: (config: Config, override?: ConfigOverride) => Promise<FullConfig>;
 export declare const readConfig: (cwd?: string, configPath?: string, override?: ConfigOverride) => Promise<FullConfig>;
+export declare const getPluginInstance: (config: FullConfig, predicate: (plugin: PluginInstance) => boolean) => PluginInstance | undefined;
 export declare const resolvePlugin: (path: string) => Promise<any>;

package/dist/config.js

@@ -1,17 +1,24 @@
 import * as console from "node:console";
-import { stat } from "node:fs/promises";
-import { resolve } from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { extname, resolve } from "node:path";
 import * as process from "node:process";
-import { readHistory } from "./history.js";
+import { parse } from "yaml";
 import { readKnownIssues } from "./known.js";
 import { FileSystemReportFiles } from "./plugin.js";
 import { importWrapper } from "./utils/module.js";
 import { normalizeImportPath } from "./utils/path.js";
+const CONFIG_FILENAMES = [
+    "allurerc.js",
+    "allurerc.mjs",
+    "allurerc.cjs",
+    "allurerc.json",
+    "allurerc.yaml",
+    "allurerc.yml",
+];
+const DEFAULT_CONFIG = {};
 export const getPluginId = (key) => {
     return key.replace(/^@.*\//, "").replace(/[/\\]/g, "-");
 };
-const configNames = ["allurerc.js", "allurerc.mjs"];
-const defaultConfig = {};
 export const findConfig = async (cwd, configPath) => {
     if (configPath) {
         const resolved = resolve(cwd, configPath);
@@ -26,8 +33,8 @@ export const findConfig = async (cwd, configPath) => {
         }
         throw new Error(`invalid config path ${resolved}: not a regular file`);
     }
-    for (const configName of configNames) {
-        const resolved = resolve(cwd, configName);
+    for (const configFilename of CONFIG_FILENAMES) {
+        const resolved = resolve(cwd, configFilename);
         try {
             const stats = await stat(resolved);
             if (stats.isFile()) {
@@ -42,11 +49,17 @@ export const validateConfig = (config) => {
     const supportedFields = [
         "name",
         "output",
+        "open",
+        "port",
         "historyPath",
         "knownIssuesPath",
-        "qualityGate",
         "plugins",
         "defaultLabels",
+        "variables",
+        "environments",
+        "appendHistory",
+        "qualityGate",
+        "allureService",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
     return {
@@ -54,7 +67,33 @@ export const validateConfig = (config) => {
         fields: unsupportedFields,
     };
 };
-export const loadConfig = async (configPath) => {
+export const loadYamlConfig = async (configPath) => {
+    try {
+        const rawConfig = await readFile(configPath, "utf-8");
+        const parsedConfig = parse(rawConfig);
+        return parsedConfig || DEFAULT_CONFIG;
+    }
+    catch (err) {
+        if (err?.code === "ENOENT") {
+            return DEFAULT_CONFIG;
+        }
+        throw err;
+    }
+};
+export const loadJsonConfig = async (configPath) => {
+    try {
+        const rawConfig = await readFile(configPath, "utf-8");
+        const parsedConfig = JSON.parse(rawConfig);
+        return parsedConfig || DEFAULT_CONFIG;
+    }
+    catch (err) {
+        if (err?.code === "ENOENT") {
+            return DEFAULT_CONFIG;
+        }
+        throw err;
+    }
+};
+export const loadJsConfig = async (configPath) => {
     return (await import(normalizeImportPath(configPath))).default;
 };
 export const resolveConfig = async (config, override = {}) => {
@@ -63,12 +102,16 @@ export const resolveConfig = async (config, override = {}) => {
         throw new Error(`The provided Allure config contains unsupported fields: ${validationResult.fields.join(", ")}`);
     }
     const name = override.name ?? config.name ?? "Allure Report";
-    const historyPath = resolve(override.historyPath ?? config.historyPath ?? "./.allure/history.jsonl");
+    const open = override.open ?? config.open ?? false;
+    const port = override.port ?? config.port ?? undefined;
+    const historyPath = override.historyPath ?? config.historyPath;
+    const appendHistory = config.appendHistory ?? true;
     const knownIssuesPath = resolve(override.knownIssuesPath ?? config.knownIssuesPath ?? "./allure/known.json");
     const output = resolve(override.output ?? config.output ?? "./allure-report");
-    const history = await readHistory(historyPath);
     const known = await readKnownIssues(knownIssuesPath);
-    const plugins = Object.keys(config?.plugins ?? {}).length === 0
+    const variables = config.variables ?? {};
+    const environments = config.environments ?? {};
+    const plugins = Object.keys(override?.plugins ?? config?.plugins ?? {}).length === 0
         ? {
             awesome: {
                 options: {},
@@ -78,20 +121,46 @@ export const resolveConfig = async (config, override = {}) => {
     const pluginInstances = await resolvePlugins(plugins);
     return {
         name,
-        reportFiles: new FileSystemReportFiles(output),
-        plugins: pluginInstances,
         output,
-        history,
-        historyPath,
+        open,
+        port,
         knownIssuesPath,
         known,
+        variables,
+        environments,
+        appendHistory,
+        historyPath: historyPath ? resolve(historyPath) : undefined,
+        reportFiles: new FileSystemReportFiles(output),
+        plugins: pluginInstances,
+        defaultLabels: config.defaultLabels ?? {},
         qualityGate: config.qualityGate,
+        allureService: config.allureService,
     };
 };
 export const readConfig = async (cwd = process.cwd(), configPath, override) => {
-    const cfg = await findConfig(cwd, configPath);
-    const config = cfg ? await loadConfig(cfg) : { ...defaultConfig };
-    return await resolveConfig(config, override);
+    const cfg = (await findConfig(cwd, configPath)) ?? "";
+    let config;
+    switch (extname(cfg)) {
+        case ".json":
+            config = await loadJsonConfig(cfg);
+            break;
+        case ".yaml":
+        case ".yml":
+            config = await loadYamlConfig(cfg);
+            break;
+        case ".js":
+        case ".cjs":
+        case ".mjs":
+            config = await loadJsConfig(cfg);
+            break;
+        default:
+            config = DEFAULT_CONFIG;
+    }
+    const fullConfig = await resolveConfig(config, override);
+    return fullConfig;
+};
+export const getPluginInstance = (config, predicate) => {
+    return config?.plugins?.find(predicate);
 };
 export const resolvePlugin = async (path) => {
     if (!path.startsWith("@allurereport/plugin-")) {
@@ -113,9 +182,10 @@ const resolvePlugins = async (plugins) => {
     const pluginInstances = [];
     for (const id in plugins) {
         const pluginConfig = plugins[id];
+        const pluginId = getPluginId(id);
         const Plugin = await resolvePlugin(pluginConfig.import ?? id);
         pluginInstances.push({
-            id: getPluginId(id),
+            id: pluginId,
             enabled: pluginConfig.enabled ?? true,
             options: pluginConfig.options ?? {},
             plugin: new Plugin(pluginConfig.options),

package/dist/history.d.ts

@@ -1,4 +1,9 @@
-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[]>;
+import type { AllureHistory, HistoryDataPoint, TestCase, TestResult } from "@allurereport/core-api";
+export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string) => HistoryDataPoint;
 export declare const writeHistory: (historyPath: string, data: HistoryDataPoint) => Promise<void>;
+export declare class AllureLocalHistory implements AllureHistory {
+    private readonly historyPath;
+    constructor(historyPath: string);
+    readHistory(): Promise<HistoryDataPoint[]>;
+    appendHistory(data: HistoryDataPoint): Promise<void>;
+}

package/dist/history.js

@@ -4,27 +4,30 @@ import { isFileNotFoundError } from "./utils/misc.js";
 const createHistoryItems = (testResults) => {
     return testResults
         .filter((tr) => tr.historyId)
-        .map(({ id, name, fullName, historyId, status, error: { message, trace } = {}, start, stop, duration }) => {
+        .map(({ id, name, fullName, environment, historyId, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
         return {
             id,
             name,
             fullName,
+            environment,
             status,
             message,
             trace,
             start,
             stop,
             duration,
+            labels,
+            url: "",
             historyId: historyId,
             reportLinks: [],
         };
     })
-        .reduce((previousValue, currentValue) => {
-        previousValue[currentValue.historyId] = currentValue;
-        return previousValue;
+        .reduce((acc, item) => {
+        acc[item.historyId] = item;
+        return acc;
     }, {});
 };
-export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults) => {
+export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults, remoteUrl = "") => {
     const knownTestCaseIds = testCases.map((tc) => tc.id);
     return {
         uuid: reportUuid,
@@ -33,26 +36,38 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         knownTestCaseIds,
         testResults: createHistoryItems(testResults),
         metrics: {},
+        url: remoteUrl,
     };
 };
-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+" });
 };
+export class AllureLocalHistory {
+    constructor(historyPath) {
+        this.historyPath = historyPath;
+    }
+    async readHistory() {
+        const path = resolve(this.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;
+        }
+    }
+    async appendHistory(data) {
+        const path = resolve(this.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

@@ -2,9 +2,11 @@ export type * from "./api.js";
 export * from "./utils/misc.js";
 export * from "./utils/crypto.js";
 export * from "./utils/path.js";
+export * from "./utils/new.js";
+export * from "./utils/flaky.js";
 export * from "./history.js";
 export * from "./known.js";
-export { resolveConfig, readConfig } from "./config.js";
+export { resolveConfig, readConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export * from "./qualityGate.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -1,9 +1,11 @@
 export * from "./utils/misc.js";
 export * from "./utils/crypto.js";
 export * from "./utils/path.js";
+export * from "./utils/new.js";
+export * from "./utils/flaky.js";
 export * from "./history.js";
 export * from "./known.js";
-export { resolveConfig, readConfig } from "./config.js";
+export { resolveConfig, readConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export * from "./qualityGate.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/plugin.d.ts

@@ -3,20 +3,21 @@ export declare class DefaultPluginState implements PluginState {
     #private;
     constructor(state: Record<string, any>);
     set: (key: string, value: any) => Promise<void>;
-    get: (key: string) => Promise<void>;
+    get: <T>(key: string) => Promise<T>;
     unset: (key: string) => Promise<void>;
 }
 export declare class PluginFiles implements ReportFiles {
     #private;
-    constructor(parent: ReportFiles, pluginId: string);
-    addFile: (key: string, data: Buffer) => Promise<void>;
+    readonly callback?: ((key: string, path: string) => void) | undefined;
+    constructor(parent: ReportFiles, pluginId: string, callback?: ((key: string, path: string) => void) | undefined);
+    addFile: (key: string, data: Buffer) => Promise<string>;
 }
 export declare class InMemoryReportFiles implements ReportFiles {
     #private;
-    addFile: (path: string, data: Buffer) => Promise<void>;
+    addFile: (path: string, data: Buffer) => Promise<string>;
 }
 export declare class FileSystemReportFiles implements ReportFiles {
     #private;
     constructor(output: string);
-    addFile: (path: string, data: Buffer) => Promise<void>;
+    addFile: (path: string, data: Buffer) => Promise<string>;
 }

package/dist/plugin.js

@@ -11,7 +11,8 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 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";
+import { dirname, resolve } from "node:path";
+import { join as joinPosix } from "node:path/posix";
 export class DefaultPluginState {
     constructor(state) {
         _DefaultPluginState_state.set(this, void 0);
@@ -29,11 +30,14 @@ export class DefaultPluginState {
 }
 _DefaultPluginState_state = new WeakMap();
 export class PluginFiles {
-    constructor(parent, pluginId) {
+    constructor(parent, pluginId, callback) {
+        this.callback = callback;
         _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);
+            const filepath = await __classPrivateFieldGet(this, _PluginFiles_parent, "f").addFile(joinPosix(__classPrivateFieldGet(this, _PluginFiles_pluginId, "f"), key), data);
+            this.callback?.(key, filepath);
+            return filepath;
         };
         __classPrivateFieldSet(this, _PluginFiles_parent, parent, "f");
         __classPrivateFieldSet(this, _PluginFiles_pluginId, pluginId, "f");
@@ -45,6 +49,7 @@ export class InMemoryReportFiles {
         _InMemoryReportFiles_state.set(this, {});
         this.addFile = async (path, data) => {
             __classPrivateFieldGet(this, _InMemoryReportFiles_state, "f")[path] = data;
+            return path;
         };
     }
 }
@@ -57,6 +62,7 @@ export class FileSystemReportFiles {
             const targetDirPath = dirname(targetPath);
             await mkdir(targetDirPath, { recursive: true });
             await writeFile(targetPath, data, { encoding: "utf-8" });
+            return targetPath;
         };
         __classPrivateFieldSet(this, _FileSystemReportFiles_output, resolve(output), "f");
     }

package/dist/qualityGate/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./qualityGate.js";
+export * from "./rules.js";

package/dist/qualityGate/index.js

@@ -0,0 +1,2 @@
+export * from "./qualityGate.js";
+export * from "./rules.js";

package/dist/qualityGate/qualityGate.d.ts

@@ -0,0 +1,21 @@
+import type { KnownTestFailure, TestError, TestResult } from "@allurereport/core-api";
+import type { QualityGateConfig, QualityGateValidationResult } from "@allurereport/plugin-api";
+export declare const stringifyQualityGateResults: (results: QualityGateValidationResult[]) => string;
+export declare const convertQualityGateResultsToTestErrors: (results: QualityGateValidationResult[]) => TestError[];
+export declare class QualityGateState {
+    #private;
+    setResult(rule: string, value: any): void;
+    getResult(rule: string): any;
+}
+export declare class QualityGate {
+    private readonly config;
+    constructor(config: QualityGateConfig);
+    validate(payload: {
+        state?: QualityGateState;
+        trs: TestResult[];
+        knownIssues: KnownTestFailure[];
+    }): Promise<{
+        fastFailed: boolean;
+        results: QualityGateValidationResult[];
+    }>;
+}

package/dist/qualityGate/qualityGate.js

@@ -0,0 +1,103 @@
+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 _QualityGateState_state;
+import { gray, red } from "yoctocolors";
+import { qualityGateDefaultRules } from "./rules.js";
+export const stringifyQualityGateResults = (results) => {
+    if (results.length === 0) {
+        return "";
+    }
+    const lines = [red("Quality Gate failed with following issues:")];
+    const maxMessageLength = Math.max(...results.map((r) => r.message.length));
+    lines.push("");
+    results.forEach((result) => {
+        lines.push(` ${red("⨯")} ${result.message.padEnd(maxMessageLength, " ")}    ${gray(result.rule)}`);
+    });
+    lines.push("");
+    lines.push(red(`${results.length} quality gate rules have been failed.`));
+    return lines.join("\n");
+};
+export const convertQualityGateResultsToTestErrors = (results) => {
+    return results.map((result) => ({
+        message: `Quality Gate (${result.rule}): ${result.message}`,
+        actual: result.actual,
+        expected: result.expected,
+    }));
+};
+export class QualityGateState {
+    constructor() {
+        _QualityGateState_state.set(this, {});
+    }
+    setResult(rule, value) {
+        __classPrivateFieldGet(this, _QualityGateState_state, "f")[rule] = value;
+    }
+    getResult(rule) {
+        return __classPrivateFieldGet(this, _QualityGateState_state, "f")[rule];
+    }
+}
+_QualityGateState_state = new WeakMap();
+export class QualityGate {
+    constructor(config) {
+        this.config = config;
+    }
+    async validate(payload) {
+        const { state, trs, knownIssues } = payload;
+        const { rules, use = [...qualityGateDefaultRules] } = this.config;
+        const results = [];
+        let fastFailed = false;
+        if (!rules?.length) {
+            return {
+                fastFailed: false,
+                results,
+            };
+        }
+        for (const ruleset of rules) {
+            if (fastFailed) {
+                break;
+            }
+            for (const [key, expected] of Object.entries(ruleset)) {
+                if (key === "filter" || key === "id" || key === "fastFail") {
+                    continue;
+                }
+                const rule = use.filter((r) => r.rule === key).pop();
+                if (!rule) {
+                    throw new Error(`Rule ${key} is not provided. Make sure you have provided it in the "use" field of the quality gate config!`);
+                }
+                const trsToValidate = ruleset.filter ? trs.filter(ruleset.filter) : trs;
+                const ruleId = ruleset.id ? [ruleset.id, rule.rule].join("/") : rule.rule;
+                const result = await rule.validate({
+                    trs: trsToValidate,
+                    state: {
+                        getResult: () => state?.getResult?.(ruleId),
+                        setResult: (value) => state?.setResult?.(ruleId, value),
+                    },
+                    expected,
+                    knownIssues,
+                });
+                if (result.success) {
+                    continue;
+                }
+                results.push({
+                    ...result,
+                    expected,
+                    rule: ruleset.id ? [ruleset.id, rule.rule].join("/") : rule.rule,
+                    message: rule.message({
+                        actual: result.actual,
+                        expected,
+                    }),
+                });
+                if (ruleset.fastFail) {
+                    fastFailed = true;
+                    break;
+                }
+            }
+        }
+        return {
+            fastFailed,
+            results,
+        };
+    }
+}

package/dist/qualityGate/rules.d.ts

@@ -0,0 +1,6 @@
+import { type QualityGateRule } from "@allurereport/plugin-api";
+export declare const maxFailuresRule: QualityGateRule<number>;
+export declare const minTestsCountRule: QualityGateRule<number>;
+export declare const successRateRule: QualityGateRule<number>;
+export declare const maxDurationRule: QualityGateRule<number>;
+export declare const qualityGateDefaultRules: QualityGateRule<number>[];

package/dist/qualityGate/rules.js

@@ -0,0 +1,55 @@
+import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
+import { bold } from "yoctocolors";
+export const maxFailuresRule = {
+    rule: "maxFailures",
+    message: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
+    validate: async ({ trs, knownIssues, expected, state }) => {
+        const knownIssuesHistoryIds = knownIssues.map(({ historyId }) => historyId);
+        const unknown = trs.filter((tr) => !tr.historyId || !knownIssuesHistoryIds.includes(tr.historyId));
+        const failedTrs = unknown.filter(filterUnsuccessful);
+        const actual = failedTrs.length + (state.getResult() ?? 0);
+        state.setResult(actual);
+        return {
+            success: actual <= expected,
+            actual,
+        };
+    },
+};
+export const minTestsCountRule = {
+    rule: "minTestsCount",
+    message: ({ actual, expected }) => `The total number of tests ${bold(String(actual))} is less than the expected threshold value ${bold(String(expected))}`,
+    validate: async ({ trs, expected, state }) => {
+        const actual = trs.length + (state.getResult() ?? 0);
+        state.setResult(actual);
+        return {
+            success: actual >= expected,
+            actual,
+        };
+    },
+};
+export const successRateRule = {
+    rule: "successRate",
+    message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
+    validate: async ({ trs, knownIssues, expected }) => {
+        const knownIssuesHistoryIds = knownIssues.map(({ historyId }) => historyId);
+        const unknown = trs.filter((tr) => !tr.historyId || !knownIssuesHistoryIds.includes(tr.historyId));
+        const passedTrs = unknown.filter(filterSuccessful);
+        const rate = passedTrs.length === 0 ? 0 : passedTrs.length / unknown.length;
+        return {
+            success: rate >= expected,
+            actual: rate,
+        };
+    },
+};
+export const maxDurationRule = {
+    rule: "maxDuration",
+    message: ({ actual, expected }) => `Maximum duration of some tests exceed the defined limit; actual ${bold(String(actual))}, expected ${bold(String(expected))}`,
+    validate: async ({ trs, expected }) => {
+        const actual = Math.max(...trs.map((tr) => tr.duration ?? 0));
+        return {
+            success: actual <= expected,
+            actual,
+        };
+    },
+};
+export const qualityGateDefaultRules = [maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule];