@allurereport/core 3.0.0-beta.17 → 3.0.0-beta.19

package/dist/api.d.ts

@@ -12,8 +12,9 @@ export interface FullConfig {
     output: string;
     historyPath: string;
     knownIssuesPath: string;
-    qualityGate?: QualityGateConfig;
     defaultLabels?: DefaultLabelsConfig;
+    stage?: string;
+    environment?: string;
     environments?: EnvironmentsConfig;
     variables?: ReportVariables;
     reportFiles: ReportFiles;
@@ -22,6 +23,7 @@ export interface FullConfig {
     appendHistory?: boolean;
     known?: KnownTestFailure[];
     realTime?: any;
+    qualityGate?: QualityGateConfig;
     allureService?: {
         url?: string;
         project?: string;

package/dist/config.js

@@ -43,12 +43,12 @@ export const validateConfig = (config) => {
         "output",
         "historyPath",
         "knownIssuesPath",
-        "qualityGate",
         "plugins",
         "defaultLabels",
         "variables",
         "environments",
         "appendHistory",
+        "qualityGate",
         "allureService",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
@@ -92,6 +92,7 @@ export const resolveConfig = async (config, override = {}) => {
         appendHistory,
         reportFiles: new FileSystemReportFiles(output),
         plugins: pluginInstances,
+        defaultLabels: config.defaultLabels ?? {},
         qualityGate: config.qualityGate,
         allureService: config.allureService,
     };

package/dist/history.js

@@ -16,15 +16,13 @@ const createHistoryItems = (testResults) => {
             stop,
             duration,
             labels,
+            url: "",
             historyId: historyId,
             reportLinks: [],
         };
     })
         .reduce((acc, item) => {
-        acc[item.historyId] = {
-            ...item,
-            url: "",
-        };
+        acc[item.historyId] = item;
         return acc;
     }, {});
 };

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export * from "./known.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

@@ -10,4 +10,4 @@ export * from "./known.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/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,96 @@
+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, value] 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 ruleId = ruleset.id ? [ruleset.id, rule.rule].join("/") : rule.rule;
+                const result = await rule.validate({
+                    expected: value,
+                    trs,
+                    knownIssues,
+                    state: state?.getResult?.(ruleId),
+                });
+                state?.setResult(ruleId, result.actual);
+                if (result.success) {
+                    continue;
+                }
+                results.push({
+                    ...result,
+                    rule: ruleset.id ? [ruleset.id, rule.rule].join("/") : rule.rule,
+                    message: rule.message(result),
+                });
+                if (ruleset.fastFail) {
+                    fastFailed = true;
+                    break;
+                }
+            }
+        }
+        return {
+            fastFailed,
+            results,
+        };
+    }
+}

package/dist/qualityGate/rules.d.ts

@@ -0,0 +1,5 @@
+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 qualityGateDefaultRules: QualityGateRule<number>[];

package/dist/qualityGate/rules.js

@@ -0,0 +1,45 @@
+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 = 0 }) => {
+        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;
+        return {
+            success: actual <= expected,
+            actual,
+            expected,
+        };
+    },
+};
+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 = 0 }) => {
+        const actual = trs.length + state;
+        return {
+            success: actual >= expected,
+            actual,
+            expected,
+        };
+    },
+};
+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,
+            expected,
+        };
+    },
+};
+export const qualityGateDefaultRules = [maxFailuresRule, minTestsCountRule, successRateRule];

package/dist/report.d.ts

@@ -1,18 +1,31 @@
-import type { ResultFile } from "@allurereport/plugin-api";
+import type { KnownTestFailure, TestResult } from "@allurereport/core-api";
+import { type ResultFile } from "@allurereport/plugin-api";
 import type { FullConfig } from "./api.js";
+import { type QualityGateState } from "./qualityGate/index.js";
 import { DefaultAllureStore } from "./store/store.js";
+import { RealtimeEventsDispatcher, RealtimeSubscriber } from "./utils/event.js";
 export declare class AllureReport {
     #private;
     readonly reportUuid: string;
     reportUrl?: string;
     constructor(opts: FullConfig);
+    get hasQualityGate(): boolean;
     get store(): DefaultAllureStore;
-    get exitCode(): 0 | 1;
-    get validationResults(): import("@allurereport/plugin-api").QualityGateValidationResult[];
+    get realtimeSubscriber(): RealtimeSubscriber;
+    get realtimeDispatcher(): RealtimeEventsDispatcher;
     readDirectory: (resultsDir: string) => Promise<void>;
     readFile: (resultsFile: string) => Promise<void>;
     readResult: (data: ResultFile) => Promise<void>;
+    validate: (params: {
+        trs: TestResult[];
+        knownIssues: KnownTestFailure[];
+        state?: QualityGateState;
+    }) => Promise<{
+        fastFailed: boolean;
+        results: import("@allurereport/plugin-api").QualityGateValidationResult[];
+    }>;
     start: () => Promise<void>;
+    dumpState: () => Promise<void>;
+    restoreState: (stages: string[]) => Promise<void>;
     done: () => Promise<void>;
-    validate: () => Promise<void>;
 }