@allurereport/core 3.16.0 → 3.17.0

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { CategoriesConfig, KnownTestFailure, 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 {
@@ -8,19 +8,19 @@ export interface PluginInstance {
     options: Record<string, any>;
 }
 type FullConfigRequiredFromConfig = Required<Pick<Config, "name" | "output" | "open">>;
-export interface FullConfig extends Omit<Config, "name" | "output" | "open" | "allureService" | "knownIssuesPath" | "plugins" | "port" | "resultsDir">, FullConfigRequiredFromConfig {
+export interface FullConfig extends Omit<Config, "name" | "output" | "open" | "allureService" | "plugins" | "port" | "resultsDir">, FullConfigRequiredFromConfig {
     port: Config["port"] | undefined;
     allowedEnvironments?: Config["allowedEnvironments"];
     reportFiles: ReportFiles;
     readers?: ResultsReader[];
     plugins?: PluginInstance[];
-    known?: KnownTestFailure[];
-    knownIssuesPath?: Config["knownIssuesPath"];
     realTime?: any;
     qualityGate?: Config["qualityGate"];
+    performance?: PerformanceConfig;
     allureService?: ResolvedAllureServiceConfig;
     categories?: CategoriesConfig;
     globalAttachments?: string[];
+    cwd?: string;
     resultsDir?: string[];
 }
 export {};

package/dist/config.d.ts

@@ -2,6 +2,7 @@ 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"];
@@ -9,7 +10,7 @@ export interface ConfigOverride {
     hideLabels?: Config["hideLabels"];
     historyPath?: Config["historyPath"];
     historyLimit?: Config["historyLimit"];
-    knownIssuesPath?: Config["knownIssuesPath"];
+    resolutions?: Pick<NonNullable<Config["resolutions"]>, "knownIssuesPath">;
     plugins?: Config["plugins"];
 }
 export declare const parseIntegerConfigValue: (value: unknown, defaultValue: number, minValue: number) => number;

package/dist/config.js

@@ -4,8 +4,8 @@ import * as process from "node:process";
 import { validateEnvironmentName } from "@allurereport/core-api";
 import { createJiti } from "jiti";
 import { parse } from "yaml";
-import { DEFAULT_KNOWN_ISSUES_PATH, hasKnownIssueRules, readKnownIssues, resolveExactIssuesFilePath } from "./known.js";
 import { FileSystemReportFiles } from "./plugin.js";
+import { DEFAULT_KNOWN_ISSUES_PATH, resolveExactIssuesFilePath, validateResolutionsConfig } from "./resolutions.js";
 import { environmentIdentityById, environmentIdentityByName, validateAllowedEnvironmentIds, normalizeEnvironmentDescriptorMap, validateAllowedEnvironmentId, } from "./utils/environment.js";
 import { importWrapper } from "./utils/module.js";
 import { normalizeImportPath } from "./utils/path.js";
@@ -98,8 +98,7 @@ export const validateConfig = (config) => {
         "hideLabels",
         "historyPath",
         "historyLimit",
-        "knownIssuesPath",
-        "knownIssues",
+        "resolutions",
         "plugins",
         "defaultLabels",
         "variables",
@@ -108,6 +107,7 @@ export const validateConfig = (config) => {
         "environments",
         "appendHistory",
         "qualityGate",
+        "performance",
         "allureService",
         "categories",
         "globalAttachments",
@@ -195,6 +195,7 @@ export const resolveConfig = async (config, override = {}) => {
     if (!validationResult.valid) {
         throw new Error(`The provided Allure config contains unsupported fields: ${validationResult.fields.join(", ")}`);
     }
+    validateResolutionsConfig(config.resolutions);
     const { environments, environment, allowedEnvironments } = resolveConfigEnvironments(config);
     const name = override.name ?? config.name ?? "Allure Report";
     const open = override.open ?? config.open ?? false;
@@ -203,11 +204,14 @@ export const resolveConfig = async (config, override = {}) => {
     const historyPath = override.historyPath ?? config.historyPath;
     const historyLimit = override.historyLimit ?? config.historyLimit;
     const appendHistory = config.appendHistory ?? true;
-    const configuredKnownIssuesPath = override.knownIssuesPath ?? config.knownIssuesPath;
-    const knownIssuesPathInput = configuredKnownIssuesPath ?? (hasKnownIssueRules(config.knownIssues) ? DEFAULT_KNOWN_ISSUES_PATH : undefined);
+    const configuredKnownIssuesPath = override.resolutions?.knownIssuesPath ?? config.resolutions?.knownIssuesPath;
+    const knownIssuesPathInput = configuredKnownIssuesPath ?? (config.resolutions ? DEFAULT_KNOWN_ISSUES_PATH : undefined);
     const knownIssuesPath = await resolveExactIssuesFilePath(knownIssuesPathInput, "known issues");
+    const resolutions = config.resolutions || override.resolutions?.knownIssuesPath !== undefined
+        ? { ...(config.resolutions ?? { rules: [] }), knownIssuesPath }
+        : undefined;
     const output = resolve(override.output ?? config.output ?? "./allure-report");
-    const known = knownIssuesPath ? await readKnownIssues(knownIssuesPath) : undefined;
+    const cwd = resolve(override.cwd ?? process.cwd());
     const variables = config.variables ?? {};
     const resultsDir = normalizeResultsDir(config.resultsDir);
     let pluginInstances = [];
@@ -233,13 +237,12 @@ export const resolveConfig = async (config, override = {}) => {
     }
     return {
         name,
+        cwd,
         output,
         open,
         port,
         hideLabels,
-        knownIssuesPath,
-        known,
-        knownIssues: config.knownIssues,
+        resolutions,
         environment,
         allowedEnvironments,
         variables,
@@ -251,6 +254,7 @@ export const resolveConfig = async (config, override = {}) => {
         plugins: pluginInstances,
         defaultLabels: config.defaultLabels ?? {},
         qualityGate: config.qualityGate,
+        performance: config.performance,
         allureService: config.allureService
             ? {
                 accessToken: config.allureService.accessToken,
@@ -289,7 +293,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,5 @@
-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 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;

package/dist/history.js

@@ -43,7 +43,17 @@ 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 createHistory = (reportUuid, reportName = "Allure Report", testCases, testResults, remoteUrl = "", metrics = []) => {
     const knownTestCaseIds = testCases.map((tc) => tc.id);
     return {
         uuid: reportUuid,
@@ -51,7 +61,7 @@ export const createHistory = (reportUuid, reportName = "Allure Report", testCase
         timestamp: new Date().getTime(),
         knownTestCaseIds,
         testResults: createHistoryItems(testResults, remoteUrl),
-        metrics: {},
+        metrics: metricsToHistoryValues(metrics),
         url: remoteUrl,
     };
 };

package/dist/index.d.ts

@@ -7,8 +7,8 @@ export * from "./utils/flaky.js";
 export * from "./utils/environment.js";
 export * from "./utils/resultsDir.js";
 export * from "./history.js";
-export * from "./known.js";
+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, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/index.js

@@ -6,8 +6,8 @@ export * from "./utils/flaky.js";
 export * from "./utils/environment.js";
 export * from "./utils/resultsDir.js";
 export * from "./history.js";
-export * from "./known.js";
+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, stringifyQualityGateResults, } from "./qualityGate/index.js";

package/dist/qualityGate/qualityGate.d.ts

@@ -1,11 +1,11 @@
-import { type KnownTestFailure, 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 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,7 +16,8 @@ export declare class QualityGate {
     validate(payload: {
         state?: QualityGateState;
         trs: TestResult[];
-        knownIssues: KnownTestFailure[];
+        metrics?: MetricSample[];
+        previousHistory?: QualityGateMetricHistoryPoint[];
         environment?: string;
     }): Promise<{
         fastFailed: boolean;

package/dist/qualityGate/qualityGate.js

@@ -5,6 +5,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _QualityGateState_state, _QualityGateState_processedTestResultIds;
 import { gray, red } from "yoctocolors";
+import { isIgnoredFailure } from "../resolutions.js";
 import { qualityGateDefaultRules } from "./rules.js";
 export const stringifyQualityGateResults = (results) => {
     if (results.length === 0) {
@@ -58,10 +59,10 @@ export class QualityGate {
         this.config = config;
     }
     async validate(payload) {
-        const { state, trs, knownIssues, environment } = payload;
+        const { state, trs, metrics = [], previousHistory = [], environment } = payload;
         const trsToValidateById = new Map();
         for (const tr of trs) {
-            if (tr.isRetry || state?.isTestResultProcessed(tr.id)) {
+            if (tr.isRetry || isIgnoredFailure(tr) || state?.isTestResultProcessed(tr.id)) {
                 continue;
             }
             trsToValidateById.set(tr.id, tr);
@@ -97,7 +98,8 @@ export class QualityGate {
                         setResult: (value, testResults) => state?.setResult?.(ruleId, value, testResults),
                     },
                     expected,
-                    knownIssues,
+                    metrics,
+                    previousHistory,
                     environment,
                 });
                 if (result.success) {

package/dist/qualityGate/rules.d.ts

@@ -1,16 +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;
-    unknownCount: 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;
-    unknownCount: 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,12 +1,81 @@
 import { filterSuccessful, filterUnsuccessful } 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))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? 0;
-        const unknown = trs.filter((tr) => !tr.known);
-        const failedTrs = unknown.filter(filterUnsuccessful);
+        const previous = numberStateValue(state.getResult());
+        const failedTrs = trs.filter(filterUnsuccessful);
         const testResults = failedTrs.map((tr) => tr.id);
         const actual = previous + failedTrs.length;
         state.setResult(actual, testResults);
@@ -21,7 +90,7 @@ 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);
+        const actual = trs.length + numberStateValue(state.getResult());
         state.setResult(actual, []);
         return {
             success: actual >= expected,
@@ -34,16 +103,14 @@ export const successRateRule = {
     rule: "successRate",
     message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
     validate: async ({ trs, expected, state }) => {
-        const previous = state.getResult() ?? { totalCount: 0, unknownCount: 0, passedCount: 0 };
-        const unknown = trs.filter((tr) => !tr.known);
-        const passedTrs = unknown.filter(filterSuccessful);
-        const notPassedTrs = unknown.filter((tr) => !filterSuccessful(tr));
+        const previous = successRateStateValue(state.getResult());
+        const passedTrs = trs.filter(filterSuccessful);
+        const notPassedTrs = trs.filter((tr) => !filterSuccessful(tr));
         const totalCount = previous.totalCount + trs.length;
-        const unknownCount = previous.unknownCount + unknown.length;
         const passedCount = previous.passedCount + passedTrs.length;
         const testResults = notPassedTrs.map((tr) => tr.id);
-        const rate = totalCount === 0 ? 0 : unknownCount === 0 ? 1 : passedCount / unknownCount;
-        state.setResult({ totalCount, unknownCount, passedCount }, testResults);
+        const rate = totalCount === 0 ? 0 : passedCount / totalCount;
+        state.setResult({ totalCount, passedCount }, testResults);
         return {
             success: rate >= expected,
             actual: rate,
@@ -55,7 +122,7 @@ 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, 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);
@@ -69,9 +136,9 @@ 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`,
     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;
@@ -87,7 +154,7 @@ export const environmentsTestedRule = {
     rule: "environmentsTested",
     message: ({ actual, expected }) => `The following environments were not tested: "${actual.join('", "')}"; expected all of: "${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], []);
@@ -99,6 +166,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,
@@ -106,4 +229,8 @@ export const qualityGateDefaultRules = [
     maxDurationRule,
     allTestsContainEnvRule,
     environmentsTestedRule,
+    metricMaxRule,
+    metricMinRule,
+    metricMaxDeltaRule,
+    metricMaxDeltaPercentRule,
 ];

package/dist/report.d.ts

@@ -1,4 +1,4 @@
-import type { KnownTestFailure, TestResult } from "@allurereport/core-api";
+import type { 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";
@@ -19,7 +19,6 @@ export declare class AllureReport {
     readResult: (data: ResultFile) => Promise<void>;
     validate: (params: {
         trs: TestResult[];
-        knownIssues: KnownTestFailure[];
         state?: QualityGateState;
         environment?: string;
     }) => Promise<{