@allurereport/core 3.16.1 → 3.18.0

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { CategoriesConfig, ResolvedAllureServiceConfig } from "@allurereport/core-api";
+import type { CategoriesConfig, PerformanceConfig, ResolvedAllureServiceConfig } from "@allurereport/core-api";
 import type { Plugin, ReportFiles, Config } from "@allurereport/plugin-api";
 import type { ResultsReader } from "@allurereport/reader-api";
 export interface PluginInstance {
@@ -16,9 +16,11 @@ export interface FullConfig extends Omit<Config, "name" | "output" | "open" | "a
     plugins?: PluginInstance[];
     realTime?: any;
     qualityGate?: Config["qualityGate"];
+    performance?: PerformanceConfig;
     allureService?: ResolvedAllureServiceConfig;
     categories?: CategoriesConfig;
     globalAttachments?: string[];
+    cwd?: string;
     resultsDir?: string[];
 }
 export {};

package/dist/config.d.ts

@@ -2,17 +2,18 @@ import type { Config, Plugin, PluginConstructorContext, PluginDescriptor } from
 import type { FullConfig, PluginInstance } from "./api.js";
 type PluginConstructor = new (options?: Record<string, any>, context?: PluginConstructorContext) => Plugin;
 export interface ConfigOverride {
+    cwd?: string;
     name?: Config["name"];
     output?: Config["output"];
     open?: Config["open"];
     port?: Config["port"];
     hideLabels?: Config["hideLabels"];
     historyPath?: Config["historyPath"];
+    historyBaseUrl?: Config["historyBaseUrl"];
     historyLimit?: Config["historyLimit"];
     resolutions?: Pick<NonNullable<Config["resolutions"]>, "knownIssuesPath">;
     plugins?: Config["plugins"];
 }
-export declare const parseIntegerConfigValue: (value: unknown, defaultValue: number, minValue: number) => number;
 export declare const isAgentDescriptor: (value: string | undefined) => value is "agent" | "@allurereport/plugin-agent";
 export declare const hasConfiguredAgent: (plugins: Record<string, PluginDescriptor>) => boolean;
 export declare const assertValidPluginId: (id: string) => void;

package/dist/config.js

@@ -1,7 +1,7 @@
 import { readFile, stat } from "node:fs/promises";
 import { extname, resolve } from "node:path";
 import * as process from "node:process";
-import { validateEnvironmentName } from "@allurereport/core-api";
+import { parseIntegerConfigValue, validateEnvironmentName } from "@allurereport/core-api";
 import { createJiti } from "jiti";
 import { parse } from "yaml";
 import { FileSystemReportFiles } from "./plugin.js";
@@ -23,16 +23,8 @@ const CONFIG_FILENAMES = [
     "allurerc.yml",
 ];
 const DEFAULT_CONFIG = {};
-const DEFAULT_ALLURE_SERVICE_UPLOAD_CONCURRENCY = 100;
 const DEFAULT_ALLURE_SERVICE_UPLAOD_MAX_ATTEMPTS = 5;
 const DEFAULT_ALLURE_SERVICE_UPLOAD_MAX_SIMULTANEOUS_FAILURES = 5;
-export const parseIntegerConfigValue = (value, defaultValue, minValue) => {
-    if (typeof value !== "number" || !Number.isFinite(value)) {
-        return defaultValue;
-    }
-    const normalized = Math.floor(value);
-    return normalized >= minValue ? normalized : defaultValue;
-};
 export const isAgentDescriptor = (value) => {
     return value === "agent" || value === "@allurereport/plugin-agent";
 };
@@ -97,6 +89,7 @@ export const validateConfig = (config) => {
         "port",
         "hideLabels",
         "historyPath",
+        "historyBaseUrl",
         "historyLimit",
         "resolutions",
         "plugins",
@@ -107,10 +100,12 @@ export const validateConfig = (config) => {
         "environments",
         "appendHistory",
         "qualityGate",
+        "performance",
         "allureService",
         "categories",
         "globalAttachments",
         "resultsDir",
+        "dump",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
     return {
@@ -201,7 +196,9 @@ export const resolveConfig = async (config, override = {}) => {
     const port = override.port ?? config.port ?? undefined;
     const hideLabels = override.hideLabels ?? config.hideLabels;
     const historyPath = override.historyPath ?? config.historyPath;
+    const historyBaseUrl = override.historyBaseUrl ?? config.historyBaseUrl;
     const historyLimit = override.historyLimit ?? config.historyLimit;
+    const dump = config.dump;
     const appendHistory = config.appendHistory ?? true;
     const configuredKnownIssuesPath = override.resolutions?.knownIssuesPath ?? config.resolutions?.knownIssuesPath;
     const knownIssuesPathInput = configuredKnownIssuesPath ?? (config.resolutions ? DEFAULT_KNOWN_ISSUES_PATH : undefined);
@@ -210,6 +207,7 @@ export const resolveConfig = async (config, override = {}) => {
         ? { ...(config.resolutions ?? { rules: [] }), knownIssuesPath }
         : undefined;
     const output = resolve(override.output ?? config.output ?? "./allure-report");
+    const cwd = resolve(override.cwd ?? process.cwd());
     const variables = config.variables ?? {};
     const resultsDir = normalizeResultsDir(config.resultsDir);
     let pluginInstances = [];
@@ -233,8 +231,10 @@ export const resolveConfig = async (config, override = {}) => {
             };
         pluginInstances = await resolvePlugins(pluginsWithAgent);
     }
+    const uploadConcurrency = parseIntegerConfigValue(config.allureService?.uploadConcurrency, 1);
     return {
         name,
+        cwd,
         output,
         open,
         port,
@@ -247,17 +247,22 @@ export const resolveConfig = async (config, override = {}) => {
         appendHistory,
         historyLimit,
         historyPath: historyPath ? resolve(historyPath) : undefined,
+        historyBaseUrl,
+        dump,
         reportFiles: new FileSystemReportFiles(output),
         plugins: pluginInstances,
         defaultLabels: config.defaultLabels ?? {},
         qualityGate: config.qualityGate,
+        performance: config.performance,
         allureService: config.allureService
             ? {
                 accessToken: config.allureService.accessToken,
                 private: config.allureService.private,
-                uploadConcurrency: parseIntegerConfigValue(config.allureService.uploadConcurrency, DEFAULT_ALLURE_SERVICE_UPLOAD_CONCURRENCY, 1),
-                uploadMaxAttempts: parseIntegerConfigValue(config.allureService.uploadMaxAttempts, DEFAULT_ALLURE_SERVICE_UPLAOD_MAX_ATTEMPTS, 1),
-                uploadMaxSimultaneousFailures: parseIntegerConfigValue(config.allureService.uploadMaxSimultaneousFailures, DEFAULT_ALLURE_SERVICE_UPLOAD_MAX_SIMULTANEOUS_FAILURES, 0),
+                ...(uploadConcurrency === undefined ? {} : { uploadConcurrency }),
+                uploadMaxAttempts: parseIntegerConfigValue(config.allureService.uploadMaxAttempts, 1) ??
+                    DEFAULT_ALLURE_SERVICE_UPLAOD_MAX_ATTEMPTS,
+                uploadMaxSimultaneousFailures: parseIntegerConfigValue(config.allureService.uploadMaxSimultaneousFailures, 0) ??
+                    DEFAULT_ALLURE_SERVICE_UPLOAD_MAX_SIMULTANEOUS_FAILURES,
             }
             : undefined,
         categories: config.categories,
@@ -289,7 +294,7 @@ export const readConfig = async (cwd = process.cwd(), configPath, override) => {
         default:
             config = DEFAULT_CONFIG;
     }
-    const fullConfig = await resolveConfig(config, override);
+    const fullConfig = await resolveConfig(config, { ...override, cwd });
     return fullConfig;
 };
 export const readRawConfig = async (cwd = process.cwd(), configPath) => {

package/dist/history.d.ts

@@ -1,5 +1,7 @@
-import { type AllureHistory, type HistoryDataPoint, type TestCase, type TestResult } from "@allurereport/core-api";
-export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string) => HistoryDataPoint;
+import { type AllureHistory, type HistoryDataPoint, type MetricSample, type TestCase, type TestResult } from "@allurereport/core-api";
+export declare const normalizeHistoryBaseUrl: (historyBaseUrl: string) => string;
+export declare const setHistoryDataPointUrl: (point: HistoryDataPoint, url: string) => HistoryDataPoint;
+export declare const createHistory: (reportUuid: string, reportName: string | undefined, testCases: TestCase[], testResults: TestResult[], remoteUrl?: string, metrics?: MetricSample[]) => HistoryDataPoint;
 export declare class AllureLocalHistory implements AllureHistory {
     #private;
     private readonly params;
@@ -7,6 +9,7 @@ export declare class AllureLocalHistory implements AllureHistory {
         historyPath: string;
         limit?: number;
     });
+    resolveTestResultUrl(historyUrl: string, pluginId: string, historicalResultId: string): string;
     readHistory(): Promise<HistoryDataPoint[]>;
     appendHistory(data: HistoryDataPoint): Promise<void>;
 }

package/dist/history.js

@@ -43,7 +43,39 @@ const createHistoryItems = (testResults, remoteUrl) => {
         return acc;
     }, {});
 };
-export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults, remoteUrl = "") => {
+const metricsToHistoryValues = (metrics) => {
+    const grouped = new Map();
+    for (const metric of metrics) {
+        if (!metric.key || !Number.isFinite(metric.value)) {
+            continue;
+        }
+        grouped.set(metric.key, [...(grouped.get(metric.key) ?? []), metric.value]);
+    }
+    return Object.fromEntries([...grouped.entries()].map(([key, values]) => [key, values.reduce((acc, value) => acc + value, 0) / values.length]));
+};
+export const normalizeHistoryBaseUrl = (historyBaseUrl) => {
+    let url;
+    try {
+        url = new URL(historyBaseUrl);
+    }
+    catch (cause) {
+        throw new Error(`Invalid historyBaseUrl ${JSON.stringify(historyBaseUrl)}: expected an absolute URL`, { cause });
+    }
+    if (url.href.includes("#")) {
+        throw new Error(`Invalid historyBaseUrl ${JSON.stringify(historyBaseUrl)}: fragments are not allowed`);
+    }
+    if (/\.html\/?$/iu.test(url.pathname)) {
+        throw new Error(`Invalid historyBaseUrl ${JSON.stringify(historyBaseUrl)}: expected a base URL, not an HTML document`);
+    }
+    url.pathname = `${url.pathname.replace(/\/+$/u, "")}/`;
+    return url.toString();
+};
+export const setHistoryDataPointUrl = (point, url) => ({
+    ...point,
+    url,
+    testResults: Object.fromEntries(Object.entries(point.testResults).map(([historyId, item]) => [historyId, { ...item, url }])),
+});
+export const createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults, remoteUrl = "", metrics = []) => {
     const knownTestCaseIds = testCases.map((tc) => tc.id);
     return {
         uuid: reportUuid,
@@ -51,7 +83,7 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         timestamp: new Date().getTime(),
         knownTestCaseIds,
         testResults: createHistoryItems(testResults, remoteUrl),
-        metrics: {},
+        metrics: metricsToHistoryValues(metrics),
         url: remoteUrl,
     };
 };
@@ -128,6 +160,17 @@ export class AllureLocalHistory {
                 `doesn't match the actual number ${actualBytes}`);
         });
     }
+    resolveTestResultUrl(historyUrl, pluginId, historicalResultId) {
+        if (!historyUrl) {
+            return "";
+        }
+        const url = new URL(historyUrl);
+        if (url.pathname.endsWith("/")) {
+            url.pathname = `${url.pathname}${pluginId}/index.html`;
+        }
+        url.hash = historicalResultId;
+        return url.toString();
+    }
     async readHistory() {
         if (__classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").length > 0) {
             return __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f");
@@ -164,15 +207,14 @@ export class AllureLocalHistory {
         const { limit } = this.params;
         await mkdir(parentDir, { recursive: true });
         const { file: historyFile, exists: historyExists } = await __classPrivateFieldGet(this, _AllureLocalHistory_ensureFileOpenedToAppend, "f").call(this, fullPath);
+        let dst;
         try {
-            const dst = historyFile.createWriteStream({ encoding: "utf-8", start: 0, autoClose: false });
-            if (limit === 0 && historyExists) {
-                await historyFile.truncate(0);
-                return;
-            }
-            if (limit === 0 && !historyExists) {
+            if (limit === 0) {
+                if (historyExists)
+                    await historyFile.truncate(0);
                 return;
             }
+            dst = historyFile.createWriteStream({ encoding: "utf-8", start: 0, autoClose: false });
             if (historyExists) {
                 const start = await __classPrivateFieldGet(this, _AllureLocalHistory_findFirstEntryAddress, "f").call(this, historyFile, limit ? limit - 1 : undefined);
                 const src = historyFile.createReadStream({ start, autoClose: false });
@@ -185,7 +227,9 @@ export class AllureLocalHistory {
             }
         }
         finally {
-            await historyFile.close();
+            const closing = historyFile.close();
+            dst?.destroy();
+            await closing;
             if (limit !== 0) {
                 __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(normalizedData);
             }

package/dist/index.d.ts

@@ -11,4 +11,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -10,4 +10,4 @@ export * from "./resolutions.js";
 export { resolveConfig, readConfig, readRawConfig, getPluginInstance } from "./config.js";
 export * from "./report.js";
 export * from "./plugin.js";
-export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, convertQualityGateResultsToTestErrors, stringifyQualityGateResults, } from "./qualityGate/index.js";
+export { QualityGateState, qualityGateDefaultRules, maxFailuresRule, minTestsCountRule, successRateRule, maxDurationRule, allTestsContainEnvRule, environmentsTestedRule, metricMaxRule, metricMinRule, metricMaxDeltaRule, metricMaxDeltaPercentRule, convertQualityGateResultsToTestErrors, filterFailedQualityGateResults, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/qualityGate/qualityGate.d.ts

@@ -1,11 +1,12 @@
-import { type TestError, type TestResult } from "@allurereport/core-api";
-import type { QualityGateConfig, QualityGateValidationResult } from "@allurereport/plugin-api";
+import { type MetricSample, type TestError, type TestResult } from "@allurereport/core-api";
+import type { QualityGateConfig, QualityGateMetricHistoryPoint, QualityGateValidationResult } from "@allurereport/plugin-api";
+export declare const filterFailedQualityGateResults: (results: QualityGateValidationResult[]) => QualityGateValidationResult[];
 export declare const stringifyQualityGateResults: (results: QualityGateValidationResult[]) => string;
 export declare const convertQualityGateResultsToTestErrors: (results: QualityGateValidationResult[]) => TestError[];
 export declare class QualityGateState {
     #private;
-    setResult(rule: string, value: any, testResults?: string[]): void;
-    getResult(rule: string): any;
+    setResult(rule: string, value: unknown, testResults?: string[]): void;
+    getResult(rule: string): unknown;
     getTestResults(rule: string): string[];
     markTestResultsProcessed(testResults: TestResult[]): void;
     isTestResultProcessed(trId: string): boolean;
@@ -16,6 +17,8 @@ export declare class QualityGate {
     validate(payload: {
         state?: QualityGateState;
         trs: TestResult[];
+        metrics?: MetricSample[];
+        previousHistory?: QualityGateMetricHistoryPoint[];
         environment?: string;
     }): Promise<{
         fastFailed: boolean;

package/dist/qualityGate/qualityGate.js

@@ -4,25 +4,29 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _QualityGateState_state, _QualityGateState_processedTestResultIds;
-import { gray, red } from "yoctocolors";
+import { bold, gray, red } from "yoctocolors";
 import { isIgnoredFailure } from "../resolutions.js";
 import { qualityGateDefaultRules } from "./rules.js";
+export const filterFailedQualityGateResults = (results) => results.filter(({ success }) => !success);
+const formatQualityGateValue = (value) => (Array.isArray(value) ? value.join(", ") : String(value));
+const defaultSuccessMessage = ({ actual, expected }) => `The rule has been passed; actual ${bold(formatQualityGateValue(actual))}, expected ${bold(formatQualityGateValue(expected))}`;
 export const stringifyQualityGateResults = (results) => {
-    if (results.length === 0) {
+    const failedResults = filterFailedQualityGateResults(results);
+    if (failedResults.length === 0) {
         return "";
     }
     const lines = [red("Quality Gate failed with following issues:")];
-    const maxMessageLength = Math.max(...results.map((r) => r.message.length));
+    const maxMessageLength = Math.max(...failedResults.map((r) => r.message.length));
     lines.push("");
-    results.forEach((result) => {
+    failedResults.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.`));
+    lines.push(red(`${failedResults.length} quality gate rules have been failed.`));
     return lines.join("\n");
 };
 export const convertQualityGateResultsToTestErrors = (results) => {
-    return results.map((result) => ({
+    return filterFailedQualityGateResults(results).map((result) => ({
         message: `Quality Gate (${result.rule}): ${result.message}`,
         actual: result.actual,
         expected: result.expected,
@@ -59,7 +63,7 @@ export class QualityGate {
         this.config = config;
     }
     async validate(payload) {
-        const { state, trs, environment } = payload;
+        const { state, trs, metrics = [], previousHistory = [], environment } = payload;
         const trsToValidateById = new Map();
         for (const tr of trs) {
             if (tr.isRetry || isIgnoredFailure(tr) || state?.isTestResultProcessed(tr.id)) {
@@ -98,23 +102,25 @@ export class QualityGate {
                         setResult: (value, testResults) => state?.setResult?.(ruleId, value, testResults),
                     },
                     expected,
+                    metrics,
+                    previousHistory,
                     environment,
                 });
-                if (result.success) {
-                    continue;
-                }
+                const messagePayload = {
+                    actual: result.actual,
+                    expected,
+                };
                 results.push({
                     ...result,
                     expected,
                     rule: ruleId,
-                    message: rule.message({
-                        actual: result.actual,
-                        expected,
-                    }),
+                    message: result.success
+                        ? (rule.successMessage ?? defaultSuccessMessage)(messagePayload)
+                        : rule.message(messagePayload),
                     environment,
                     testResults: [...new Set([...(state?.getTestResults(ruleId) ?? []), ...result.testResults])],
                 });
-                if (ruleset.fastFail) {
+                if (!result.success && ruleset.fastFail) {
                     fastFailed = true;
                     break;
                 }

package/dist/qualityGate/rules.d.ts

@@ -1,14 +1,19 @@
 import { type QualityGateRule } from "@allurereport/plugin-api";
+type MetricRuleConfig = {
+    key: string;
+    value: number;
+    title?: string;
+    unit?: string;
+};
 export declare const maxFailuresRule: QualityGateRule<number>;
 export declare const minTestsCountRule: QualityGateRule<number>;
-export declare const successRateRule: QualityGateRule<number, {
-    totalCount: number;
-    passedCount: number;
-}>;
+export declare const successRateRule: QualityGateRule<number>;
 export declare const maxDurationRule: QualityGateRule<number>;
 export declare const allTestsContainEnvRule: QualityGateRule<string, number>;
 export declare const environmentsTestedRule: QualityGateRule<string[]>;
-export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<number, {
-    totalCount: number;
-    passedCount: number;
-}> | QualityGateRule<string, number> | QualityGateRule<string[]>)[];
+export declare const metricMaxRule: QualityGateRule<MetricRuleConfig>;
+export declare const metricMinRule: QualityGateRule<MetricRuleConfig>;
+export declare const metricMaxDeltaRule: QualityGateRule<MetricRuleConfig>;
+export declare const metricMaxDeltaPercentRule: QualityGateRule<MetricRuleConfig>;
+export declare const qualityGateDefaultRules: (QualityGateRule<number> | QualityGateRule<string, number> | QualityGateRule<string[]> | QualityGateRule<MetricRuleConfig>)[];
+export {};

package/dist/qualityGate/rules.js

@@ -1,10 +1,81 @@
-import { filterSuccessful, filterUnsuccessful } from "@allurereport/core-api";
+import { filterIncludedInSuccessRate, filterSuccessful, filterUnsuccessful, getSuccessRate, } from "@allurereport/core-api";
 import { bold } from "yoctocolors";
+const numberStateValue = (value) => (Number.isFinite(value) ? Number(value) : 0);
+const stringArrayStateValue = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+const successRateStateValue = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return { totalCount: 0, passedCount: 0 };
+    }
+    const state = value;
+    return {
+        totalCount: numberStateValue(state.totalCount),
+        passedCount: numberStateValue(state.passedCount),
+    };
+};
+const metricValues = (metrics, key) => metrics
+    .map((metric) => (metric.key === key ? metric.value : undefined))
+    .filter((value) => Number.isFinite(value));
+const metricAverage = (metrics, key) => {
+    const values = metricValues(metrics, key);
+    if (values.length === 0) {
+        return undefined;
+    }
+    return values.reduce((acc, value) => acc + value, 0) / values.length;
+};
+const previousMetricValue = (history, key) => {
+    const previousHistory = [...history].sort((a, b) => (b.timestamp ?? 0) - (a.timestamp ?? 0));
+    for (const historyPoint of previousHistory) {
+        const value = historyPoint.metrics?.[key];
+        if (Number.isFinite(value)) {
+            return value;
+        }
+    }
+    return undefined;
+};
+const metricActual = (metrics, key, value) => {
+    const sample = metrics.find((metric) => metric.key === key);
+    return {
+        key,
+        value,
+        ...(sample?.title ? { title: sample.title } : {}),
+        ...(sample?.unit ? { unit: sample.unit } : {}),
+    };
+};
+const formatMetricValue = (value, unit) => {
+    if (!Number.isFinite(value)) {
+        return "n/a";
+    }
+    const finiteValue = value;
+    const formatted = Number.isInteger(finiteValue) ? String(finiteValue) : String(Number(finiteValue.toFixed(3)));
+    return unit ? `${formatted} ${unit}` : formatted;
+};
+const metricRuleTitle = (actual) => actual.title ?? actual.key;
+const metricRuleUnit = (actual, expected) => actual.unit ?? expected.unit;
+const missingMetricResult = (actual) => ({
+    success: false,
+    actual,
+    testResults: [],
+});
+const metricRuleResult = (success, actual) => ({
+    success,
+    actual,
+    testResults: [],
+});
+const metricDeltaWithinThreshold = (delta, threshold, better) => {
+    if (better === "lower") {
+        return delta <= threshold;
+    }
+    if (better === "higher") {
+        return -delta <= threshold;
+    }
+    return Math.abs(delta) <= threshold;
+};
 export const maxFailuresRule = {
     rule: "maxFailures",
     message: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
+    successMessage: ({ actual, expected }) => `The number of failed tests ${bold(String(actual))} is within the allowed threshold value ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? 0;
+        const previous = numberStateValue(state.getResult());
         const failedTrs = trs.filter(filterUnsuccessful);
         const testResults = failedTrs.map((tr) => tr.id);
         const actual = previous + failedTrs.length;
@@ -19,8 +90,9 @@ export const maxFailuresRule = {
 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))}`,
+    successMessage: ({ actual, expected }) => `The total number of tests ${bold(String(actual))} meets the expected threshold value ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const actual = trs.length + (state.getResult() ?? 0);
+        const actual = trs.length + numberStateValue(state.getResult());
         state.setResult(actual, []);
         return {
             success: actual >= expected,
@@ -32,14 +104,16 @@ export const minTestsCountRule = {
 export const successRateRule = {
     rule: "successRate",
     message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
+    successMessage: ({ actual, expected }) => `Success rate ${bold(String(actual))} is not less, than expected ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? { totalCount: 0, passedCount: 0 };
-        const passedTrs = trs.filter(filterSuccessful);
-        const notPassedTrs = trs.filter((tr) => !filterSuccessful(tr));
-        const totalCount = previous.totalCount + trs.length;
+        const previous = successRateStateValue(state.getResult());
+        const eligibleTrs = trs.filter(filterIncludedInSuccessRate);
+        const passedTrs = eligibleTrs.filter(filterSuccessful);
+        const notPassedTrs = eligibleTrs.filter(filterUnsuccessful);
+        const totalCount = previous.totalCount + eligibleTrs.length;
         const passedCount = previous.passedCount + passedTrs.length;
         const testResults = notPassedTrs.map((tr) => tr.id);
-        const rate = totalCount === 0 ? 0 : passedCount / totalCount;
+        const rate = getSuccessRate({ passed: passedCount, failed: totalCount - passedCount });
         state.setResult({ totalCount, passedCount }, testResults);
         return {
             success: rate >= expected,
@@ -51,8 +125,9 @@ export const successRateRule = {
 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))}`,
+    successMessage: ({ actual, expected }) => `Maximum duration of the tests is within the defined limit; actual ${bold(String(actual))}, expected ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? 0;
+        const previous = numberStateValue(state.getResult());
         const actual = Math.max(previous, ...trs.map((tr) => tr.duration ?? 0));
         const tooLongTrs = trs.filter((tr) => (tr.duration ?? 0) > expected);
         const testResults = tooLongTrs.map((tr) => tr.id);
@@ -66,9 +141,10 @@ export const maxDurationRule = {
 };
 export const allTestsContainEnvRule = {
     rule: "allTestsContainEnv",
-    message: ({ actual, expected }) => `Not all tests contain the required "${bold(expected)}" environment, ${bold(actual)} tests have different or missing environment`,
+    message: ({ actual, expected }) => `Not all tests contain the required "${bold(expected)}" environment, ${bold(String(actual))} tests have different or missing environment`,
+    successMessage: ({ expected }) => `All tests contain the required "${bold(expected)}" environment`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? 0;
+        const previous = numberStateValue(state.getResult());
         const testsWithoutEnv = trs.filter((tr) => (tr.environment ?? "") !== expected);
         const testResults = testsWithoutEnv.map((tr) => tr.id);
         const actual = testsWithoutEnv.length + previous;
@@ -83,8 +159,9 @@ export const allTestsContainEnvRule = {
 export const environmentsTestedRule = {
     rule: "environmentsTested",
     message: ({ actual, expected }) => `The following environments were not tested: "${actual.join('", "')}"; expected all of: "${expected.join('", "')}"`,
+    successMessage: ({ expected }) => `All expected environments were tested: "${expected.join('", "')}"`,
     validate: async ({ trs, expected, state }) => {
-        const previouslyTested = new Set(state.getResult() ?? []);
+        const previouslyTested = new Set(stringArrayStateValue(state.getResult()));
         const batchTested = trs.map((tr) => tr.environment).filter((env) => env != null && env !== "");
         const testedEnvs = new Set([...previouslyTested, ...batchTested]);
         state.setResult([...testedEnvs], []);
@@ -96,6 +173,62 @@ export const environmentsTestedRule = {
         };
     },
 };
+export const metricMaxRule = {
+    rule: "metricMax",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} ${bold(formatMetricValue(actual.value, metricRuleUnit(actual, expected)))} exceeds the allowed maximum ${bold(formatMetricValue(expected.value, metricRuleUnit(actual, expected)))}`,
+    validate: async ({ metrics = [], expected }) => {
+        const value = metricAverage(metrics, expected.key);
+        const actual = metricActual(metrics, expected.key, value ?? Number.NaN);
+        return value === undefined ? missingMetricResult(actual) : metricRuleResult(value <= expected.value, actual);
+    },
+};
+export const metricMinRule = {
+    rule: "metricMin",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} ${bold(formatMetricValue(actual.value, metricRuleUnit(actual, expected)))} is below the required minimum ${bold(formatMetricValue(expected.value, metricRuleUnit(actual, expected)))}`,
+    validate: async ({ metrics = [], expected }) => {
+        const value = metricAverage(metrics, expected.key);
+        const actual = metricActual(metrics, expected.key, value ?? Number.NaN);
+        return value === undefined ? missingMetricResult(actual) : metricRuleResult(value >= expected.value, actual);
+    },
+};
+export const metricMaxDeltaRule = {
+    rule: "metricMaxDelta",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} changed by ${bold(formatMetricValue(actual.value, metricRuleUnit(actual, expected)))}, which exceeds ${bold(formatMetricValue(expected.value, metricRuleUnit(actual, expected)))}`,
+    validate: async ({ metrics = [], previousHistory = [], expected }) => {
+        const current = metricAverage(metrics, expected.key);
+        if (current === undefined) {
+            return missingMetricResult(metricActual(metrics, expected.key, Number.NaN));
+        }
+        const previous = previousMetricValue(previousHistory, expected.key);
+        if (previous === undefined) {
+            return metricRuleResult(true, metricActual(metrics, expected.key, 0));
+        }
+        const value = current - previous;
+        const actual = metricActual(metrics, expected.key, value);
+        const better = metrics.find((metric) => metric.key === expected.key)?.better;
+        return metricRuleResult(metricDeltaWithinThreshold(value, expected.value, better), actual);
+    },
+};
+export const metricMaxDeltaPercentRule = {
+    rule: "metricMaxDeltaPercent",
+    message: ({ actual, expected }) => `${bold(metricRuleTitle(actual))} changed by ${bold(formatMetricValue(actual.value, "%"))}, which exceeds ${bold(formatMetricValue(expected.value, "%"))}`,
+    validate: async ({ metrics = [], previousHistory = [], expected }) => {
+        const current = metricAverage(metrics, expected.key);
+        if (current === undefined) {
+            return missingMetricResult(metricActual(metrics, expected.key, Number.NaN));
+        }
+        const previous = previousMetricValue(previousHistory, expected.key);
+        if (previous === undefined) {
+            return metricRuleResult(true, metricActual(metrics, expected.key, 0));
+        }
+        const value = previous !== 0 ? ((current - previous) / Math.abs(previous)) * 100 : Number.NaN;
+        const actual = metricActual(metrics, expected.key, value);
+        const better = metrics.find((metric) => metric.key === expected.key)?.better;
+        return Number.isFinite(value)
+            ? metricRuleResult(metricDeltaWithinThreshold(value, expected.value, better), actual)
+            : missingMetricResult(actual);
+    },
+};
 export const qualityGateDefaultRules = [
     maxFailuresRule,
     minTestsCountRule,
@@ -103,4 +236,8 @@ export const qualityGateDefaultRules = [
     maxDurationRule,
     allTestsContainEnvRule,
     environmentsTestedRule,
+    metricMaxRule,
+    metricMinRule,
+    metricMaxDeltaRule,
+    metricMaxDeltaPercentRule,
 ];