@allurereport/core 3.15.0 → 3.16.1

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { CategoriesConfig, KnownTestFailure, ResolvedAllureServiceConfig } from "@allurereport/core-api";
+import type { CategoriesConfig, 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,18 +8,17 @@ 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">, 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"];
     allureService?: ResolvedAllureServiceConfig;
     categories?: CategoriesConfig;
     globalAttachments?: string[];
+    resultsDir?: string[];
 }
 export {};

package/dist/config.d.ts

@@ -9,7 +9,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,11 +4,12 @@ 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";
+import { normalizeResultsDir } from "./utils/resultsDir.js";
 import { assertValidPluginIdForWindows, isWindows } from "./utils/windows.js";
 const CONFIG_FILENAMES = [
     "allurerc.js",
@@ -97,8 +98,7 @@ export const validateConfig = (config) => {
         "hideLabels",
         "historyPath",
         "historyLimit",
-        "knownIssuesPath",
-        "knownIssues",
+        "resolutions",
         "plugins",
         "defaultLabels",
         "variables",
@@ -110,6 +110,7 @@ export const validateConfig = (config) => {
         "allureService",
         "categories",
         "globalAttachments",
+        "resultsDir",
     ];
     const unsupportedFields = Object.keys(config).filter((key) => !supportedFields.includes(key));
     return {
@@ -193,6 +194,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;
@@ -201,12 +203,15 @@ 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 variables = config.variables ?? {};
+    const resultsDir = normalizeResultsDir(config.resultsDir);
     let pluginInstances = [];
     const hasPluginsOverride = override.plugins !== undefined;
     if (!hasPluginsOverride || Object.keys(override.plugins ?? {}).length > 0) {
@@ -234,9 +239,7 @@ export const resolveConfig = async (config, override = {}) => {
         open,
         port,
         hideLabels,
-        knownIssuesPath,
-        known,
-        knownIssues: config.knownIssues,
+        resolutions,
         environment,
         allowedEnvironments,
         variables,
@@ -259,6 +262,7 @@ export const resolveConfig = async (config, override = {}) => {
             : undefined,
         categories: config.categories,
         globalAttachments: config.globalAttachments,
+        ...(resultsDir.length ? { resultsDir } : {}),
     };
 };
 export const readConfig = async (cwd = process.cwd(), configPath, override) => {

package/dist/index.d.ts

@@ -5,8 +5,9 @@ export * from "./utils/path.js";
 export * from "./utils/new.js";
 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";

package/dist/index.js

@@ -4,8 +4,9 @@ export * from "./utils/path.js";
 export * from "./utils/new.js";
 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";

package/dist/qualityGate/qualityGate.d.ts

@@ -1,4 +1,4 @@
-import { type KnownTestFailure, type TestError, type TestResult } from "@allurereport/core-api";
+import { type TestError, type 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[];
@@ -16,7 +16,6 @@ export declare class QualityGate {
     validate(payload: {
         state?: QualityGateState;
         trs: TestResult[];
-        knownIssues: KnownTestFailure[];
         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, 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,6 @@ export class QualityGate {
                         setResult: (value, testResults) => state?.setResult?.(ruleId, value, testResults),
                     },
                     expected,
-                    knownIssues,
                     environment,
                 });
                 if (result.success) {

package/dist/qualityGate/rules.d.ts

@@ -3,7 +3,6 @@ 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 maxDurationRule: QualityGateRule<number>;
@@ -11,6 +10,5 @@ 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[]>)[];

package/dist/qualityGate/rules.js

@@ -5,8 +5,7 @@ export const maxFailuresRule = {
     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 failedTrs = trs.filter(filterUnsuccessful);
         const testResults = failedTrs.map((tr) => tr.id);
         const actual = previous + failedTrs.length;
         state.setResult(actual, testResults);
@@ -34,16 +33,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 = 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 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,

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<{

package/dist/report.js

@@ -31,9 +31,9 @@ import ZipReadStream from "node-stream-zip";
 import pLimit from "p-limit";
 import ZipWriteStream from "zip-stream";
 import { AllureLocalHistory, createHistory } from "./history.js";
-import { writeKnownIssues } from "./known.js";
 import { DefaultPluginState, PluginFiles } from "./plugin.js";
 import { QualityGate } from "./qualityGate/index.js";
+import { writeKnownIssues } from "./resolutions.js";
 import { DefaultAllureStore } from "./store/store.js";
 import { environmentIdentityById, environmentIdentityByName } from "./utils/environment.js";
 import { measurePerf, PERF_METRIC_NAMES, PERF_METRIC_PREFIXES, startPerfSpan, writePerfMetrics } from "./utils/perf.js";
@@ -141,6 +141,7 @@ export class AllureReport {
                 message: uploadProgressMessage,
                 unitLabel: "files uploaded",
                 prefix: "[AllureReport]",
+                silent: !!__classPrivateFieldGet(this, _AllureReport_realTime, "f"),
             });
             const endPublishPerfSpan = startPerfSpan(PERF_METRIC_NAMES.publishUploadTotal);
             const logUploadProgress = progressLogger.log;
@@ -282,12 +283,7 @@ export class AllureReport {
             }
         };
         this.validate = async (params) => {
-            const { trs, knownIssues, state, environment } = params;
-            const currentKnownIssues = await __classPrivateFieldGet(this, _AllureReport_store, "f").allKnownIssues();
-            const effectiveKnownIssues = new Map();
-            [...knownIssues, ...currentKnownIssues].forEach((issue) => {
-                effectiveKnownIssues.set(issue.historyId, issue);
-            });
+            const { trs, state, environment } = params;
             const qualityGateEnvironment = environment === undefined
                 ? undefined
                 : (environmentIdentityById(__classPrivateFieldGet(this, _AllureReport_environments, "f"), environment)?.name ??
@@ -295,7 +291,6 @@ export class AllureReport {
                     environment);
             return __classPrivateFieldGet(this, _AllureReport_qualityGate, "f").validate({
                 trs: trs.filter(Boolean),
-                knownIssues: [...effectiveKnownIssues.values()],
                 state,
                 environment: qualityGateEnvironment,
             });
@@ -392,7 +387,7 @@ export class AllureReport {
             const addJsonDumpEntry = async (entryName, value) => {
                 await addRequiredDumpEntry(Buffer.from(JSON.stringify(value)), entryName);
             };
-            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, knownIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], }) => [
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], }) => [
                 [AllureStoreDumpFiles.TestResults, testResults],
                 [AllureStoreDumpFiles.TestCases, testCases],
                 [AllureStoreDumpFiles.Fixtures, fixtures],
@@ -400,12 +395,13 @@ export class AllureReport {
                 [AllureStoreDumpFiles.CheckResults, checkResults],
                 [AllureStoreDumpFiles.Environments, environments],
                 [AllureStoreDumpFiles.ReportVariables, reportVariables],
-                [AllureStoreDumpFiles.KnownIssues, knownIssues],
+                [AllureStoreDumpFiles.ResolutionIssues, resolutionIssues],
                 [AllureStoreDumpFiles.GlobalAttachments, globalAttachmentIds],
                 [AllureStoreDumpFiles.GlobalErrors, globalErrors],
                 [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
                 [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryId],
                 [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
+                [AllureStoreDumpFiles.IndexTestResultsByResolutionIssue, indexTestResultByResolutionIssue],
                 [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
                 [AllureStoreDumpFiles.IndexFixturesByTestResult, indexFixturesByTestResult],
                 [AllureStoreDumpFiles.QualityGateResults, qualityGateResults],
@@ -532,9 +528,10 @@ export class AllureReport {
                             const indexAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByTestResults);
                             const indexTestResultsByHistoryId = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByHistoryId);
                             const indexTestResultsByTestCaseEntry = await requiredEntryData(AllureStoreDumpFiles.IndexTestResultsByTestCase);
+                            const indexTestResultsByResolutionIssueEntry = await optionalEntryData(AllureStoreDumpFiles.IndexTestResultsByResolutionIssue);
                             const indexAttachmentsByFixtureEntry = await requiredEntryData(AllureStoreDumpFiles.IndexAttachmentsByFixture);
                             const indexFixturesByTestResultEntry = await requiredEntryData(AllureStoreDumpFiles.IndexFixturesByTestResult);
-                            const knownIssuesEntry = await requiredEntryData(AllureStoreDumpFiles.KnownIssues);
+                            const resolutionIssuesEntry = await optionalEntryData(AllureStoreDumpFiles.ResolutionIssues);
                             const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
                             const testResultIngestOrderEntry = await optionalEntryData(AllureStoreDumpFiles.TestResultIngestOrder);
                             const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8"));
@@ -547,12 +544,13 @@ export class AllureReport {
                                     case AllureStoreDumpFiles.Fixtures:
                                     case AllureStoreDumpFiles.Environments:
                                     case AllureStoreDumpFiles.ReportVariables:
-                                    case AllureStoreDumpFiles.KnownIssues:
+                                    case AllureStoreDumpFiles.ResolutionIssues:
                                     case AllureStoreDumpFiles.GlobalAttachments:
                                     case AllureStoreDumpFiles.GlobalErrors:
                                     case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
                                     case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
                                     case AllureStoreDumpFiles.IndexTestResultsByTestCase:
+                                    case AllureStoreDumpFiles.IndexTestResultsByResolutionIssue:
                                     case AllureStoreDumpFiles.IndexAttachmentsByFixture:
                                     case AllureStoreDumpFiles.IndexFixturesByTestResult:
                                     case AllureStoreDumpFiles.QualityGateResults:
@@ -580,9 +578,12 @@ export class AllureReport {
                                 indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
                                 indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
                                 indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
+                                indexTestResultByResolutionIssue: indexTestResultsByResolutionIssueEntry
+                                    ? JSON.parse(indexTestResultsByResolutionIssueEntry.toString("utf8"))
+                                    : {},
                                 indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
                                 indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
-                                knownIssues: JSON.parse(knownIssuesEntry.toString("utf8")),
+                                resolutionIssues: resolutionIssuesEntry ? JSON.parse(resolutionIssuesEntry.toString("utf8")) : {},
                                 qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
                                 testResultIdsIngestOrder: testResultIngestOrderEntry
                                     ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))
@@ -892,7 +893,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], known, knownIssues, knownIssuesPath, reportFiles, realTime, historyPath, historyLimit, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, dump, categories, allureService, globalAttachments, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyLimit, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, dump, categories, allureService, globalAttachments, } = opts;
         const allureServiceAccessToken = allureService?.accessToken;
         if (allureServiceAccessToken) {
             const allureServiceClientConfig = {
@@ -917,7 +918,7 @@ export class AllureReport {
         __classPrivateFieldSet(this, _AllureReport_environments, environments ?? {}, "f");
         __classPrivateFieldSet(this, _AllureReport_globalAttachments, globalAttachments, "f");
         __classPrivateFieldSet(this, _AllureReport_appendHistory, appendHistory ?? true, "f");
-        __classPrivateFieldSet(this, _AllureReport_knownIssuesPath, knownIssuesPath, "f");
+        __classPrivateFieldSet(this, _AllureReport_knownIssuesPath, resolutions?.knownIssuesPath, "f");
         if (qualityGate) {
             __classPrivateFieldSet(this, _AllureReport_qualityGate, new QualityGate(qualityGate), "f");
         }
@@ -941,8 +942,7 @@ export class AllureReport {
             reportVariables: variables,
             environmentsConfig: environments,
             history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
-            known,
-            knownIssuesConfig: knownIssues,
+            resolutionsConfig: resolutions,
             defaultLabels,
             environment,
             allowedEnvironments,

package/dist/resolutions.d.ts

@@ -0,0 +1,8 @@
+import type { ResolutionRule, ResolutionsConfig, TestResult } from "@allurereport/core-api";
+import type { AllureStore } from "@allurereport/plugin-api";
+export declare const DEFAULT_KNOWN_ISSUES_PATH = "known-issues.json";
+export declare const validateResolutionsConfig: (config?: ResolutionsConfig) => void;
+export declare const getResolutionByRules: (testResult: TestResult, config?: ResolutionsConfig) => ResolutionRule | undefined;
+export declare const isIgnoredFailure: (testResult: TestResult) => boolean;
+export declare const resolveExactIssuesFilePath: (pathOrDir: string | undefined, label: string) => Promise<string | undefined>;
+export declare const writeKnownIssues: (store: AllureStore, knownIssuesPath?: string) => Promise<void>;

package/dist/resolutions.js

@@ -0,0 +1,181 @@
+import { mkdir, stat, writeFile } from "node:fs/promises";
+import { dirname, extname, resolve } from "node:path";
+import { isFileNotFoundError } from "./utils/misc.js";
+export const DEFAULT_KNOWN_ISSUES_PATH = "known-issues.json";
+const nonEmpty = (value) => typeof value === "string" && value.trim().length > 0;
+const validateStringList = (value, path, errors) => {
+    if (value === undefined) {
+        return;
+    }
+    if (!Array.isArray(value) || value.length === 0 || value.some((entry) => !nonEmpty(entry))) {
+        errors.push(`${path} must be a non-empty array of non-empty strings`);
+    }
+};
+const placeholderCount = (value) => (typeof value === "string" ? (value.match(/%s/g)?.length ?? 0) : 0);
+const validateLinkTemplate = (type, template, errors) => {
+    if (!nonEmpty(type)) {
+        errors.push("resolutions.links keys must be non-empty strings");
+    }
+    if (!nonEmpty(template?.urlTemplate) || placeholderCount(template.urlTemplate) !== 1) {
+        errors.push(`resolutions.links.${type}.urlTemplate must contain exactly one %s`);
+    }
+    if (template?.nameTemplate === undefined) {
+        return;
+    }
+    if (!nonEmpty(template.nameTemplate) || placeholderCount(template.nameTemplate) !== 1) {
+        errors.push(`resolutions.links.${type}.nameTemplate must contain exactly one %s`);
+    }
+};
+const validateMessageRegexp = (value, path, errors) => {
+    if (value === undefined) {
+        return;
+    }
+    try {
+        new RegExp(value);
+    }
+    catch {
+        errors.push(`${path}.messageRegexp must be a valid regular expression`);
+    }
+};
+const validateMatcher = (matcher, path, errors) => {
+    validateStringList(matcher.testCaseId, `${path}.testCaseId`, errors);
+    validateStringList(matcher.retryHash, `${path}.retryHash`, errors);
+    validateStringList(matcher.environment, `${path}.environment`, errors);
+    if (![matcher.messageRegexp, matcher.testCaseId, matcher.retryHash, matcher.environment].some((value) => value !== undefined)) {
+        errors.push(`${path} must contain at least one matcher`);
+    }
+    validateMessageRegexp(matcher.messageRegexp, path, errors);
+};
+const validateIssueUrl = (rule, template, errors) => {
+    if (!nonEmpty(template.urlTemplate) || placeholderCount(template.urlTemplate) !== 1) {
+        return;
+    }
+    let url;
+    try {
+        url = new URL(template.urlTemplate.replace("%s", encodeURIComponent(rule.issue.id)));
+    }
+    catch {
+        errors.push(`resolutions.links.${rule.issue.type}.urlTemplate must resolve to an absolute URL`);
+        return;
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        errors.push(`resolutions.links.${rule.issue.type}.urlTemplate must resolve to an HTTP(S) URL`);
+    }
+};
+const validateIssueRule = (rule, path, config, issueIds, errors) => {
+    if (!nonEmpty(rule.issue?.id) || !nonEmpty(rule.issue?.type)) {
+        errors.push(`${path}.issue.id and ${path}.issue.type must be non-empty strings`);
+        return;
+    }
+    if (issueIds.has(rule.issue.id)) {
+        errors.push(`${path}.issue.id must be unique`);
+    }
+    issueIds.add(rule.issue.id);
+    const template = config.links?.[rule.issue.type];
+    if (!template) {
+        errors.push(`${path}.issue.type must reference resolutions.links`);
+        return;
+    }
+    validateIssueUrl(rule, template, errors);
+};
+const validateIgnoredRule = (rule, path, errors) => {
+    if (!nonEmpty(rule.comment)) {
+        errors.push(`${path}.comment must be a non-empty string`);
+    }
+};
+export const validateResolutionsConfig = (config) => {
+    if (!config) {
+        return;
+    }
+    const errors = [];
+    if (!Array.isArray(config.rules)) {
+        throw new Error("The provided resolutions config is invalid: resolutions.rules must be an array");
+    }
+    for (const [type, template] of Object.entries(config.links ?? {})) {
+        validateLinkTemplate(type, template, errors);
+    }
+    const issueIds = new Set();
+    config.rules.forEach((rule, index) => {
+        const path = `resolutions.rules[${index}]`;
+        const matcher = rule;
+        validateMatcher(matcher, path, errors);
+        if (matcher.resolution === "issue") {
+            validateIssueRule(matcher, path, config, issueIds, errors);
+            return;
+        }
+        if (matcher.resolution === "muted" || matcher.resolution === "accepted") {
+            validateIgnoredRule(matcher, path, errors);
+            return;
+        }
+        errors.push(`${path}.resolution must be issue, muted, or accepted`);
+    });
+    if (errors.length > 0) {
+        throw new Error(`The provided resolutions config is invalid: ${errors.join("; ")}`);
+    }
+};
+const matches = (rule, testResult) => {
+    const { id, allureId, externalId } = testResult.testCase ?? {};
+    const testCaseIds = [id, allureId, externalId].filter((value) => typeof value === "string");
+    return ((!rule.messageRegexp || new RegExp(rule.messageRegexp).test(testResult.error?.message ?? "")) &&
+        (!rule.testCaseId || rule.testCaseId.some((id) => testCaseIds.includes(id))) &&
+        (!rule.retryHash || (!!testResult.retryHash && rule.retryHash.includes(testResult.retryHash))) &&
+        (!rule.environment || (!!testResult.environment && rule.environment.includes(testResult.environment))));
+};
+export const getResolutionByRules = (testResult, config) => {
+    if ((testResult.status !== "failed" && testResult.status !== "broken") || !config?.rules.length) {
+        return undefined;
+    }
+    for (const resolution of ["issue", "muted", "accepted"]) {
+        const rule = config.rules.find((candidate) => candidate.resolution === resolution && matches(candidate, testResult));
+        if (rule) {
+            return rule;
+        }
+    }
+    return undefined;
+};
+export const isIgnoredFailure = (testResult) => testResult.resolution === "muted" || testResult.resolution === "accepted";
+export const resolveExactIssuesFilePath = async (pathOrDir, label) => {
+    if (!pathOrDir)
+        return undefined;
+    const path = resolve(pathOrDir);
+    if (extname(path).toLowerCase() !== ".json") {
+        throw new Error(`Invalid ${label} path ${JSON.stringify(pathOrDir)}: expected exact .json file path`);
+    }
+    try {
+        if ((await stat(path)).isDirectory()) {
+            throw new Error(`Invalid ${label} path ${JSON.stringify(pathOrDir)}: expected file, got directory`);
+        }
+    }
+    catch (e) {
+        if (!isFileNotFoundError(e))
+            throw e;
+    }
+    return path;
+};
+export const writeKnownIssues = async (store, knownIssuesPath) => {
+    const path = await resolveExactIssuesFilePath(knownIssuesPath, "known issues");
+    if (!path)
+        return;
+    const records = new Map();
+    for (const testResult of await store.allTestResults()) {
+        if (testResult.resolution !== "issue" || testResult.isRetry || !testResult.retryHash) {
+            continue;
+        }
+        const issue = await store.resolutionIssueByTestResultId(testResult.id);
+        if (!issue || (testResult.status !== "failed" && testResult.status !== "broken")) {
+            continue;
+        }
+        const record = records.get(issue.id) ?? { ...issue, testResults: {} };
+        record.testResults[testResult.retryHash] = {
+            name: testResult.name,
+            fullName: testResult.fullName,
+            environment: testResult.environment,
+            status: testResult.status,
+            error: testResult.error,
+        };
+        records.set(issue.id, record);
+    }
+    const file = { resolutionIssues: [...records.values()].sort((a, b) => a.id.localeCompare(b.id)) };
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(file)}\n`, "utf-8");
+};

package/dist/store/convert.js

@@ -53,7 +53,6 @@ export const testResultRawToState = (stateData, raw, context) => {
         expectedResultHtml: raw.expectedResultHtml,
         flaky: raw.flaky ?? false,
         muted: raw.muted ?? false,
-        known: raw.known ?? false,
         isRetry: false,
         labels,
         steps: convertSteps(stateData, raw.steps).convertedSteps,

package/dist/store/store.d.ts

@@ -1,11 +1,10 @@
-import { type AllureCheckResult, type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type GlobalAttachmentLink, type HistoryDataPoint, type HistoryTestResult, type KnownIssuesConfig, type KnownTestFailure, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
+import { type AllureCheckResult, type AllureHistory, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type GlobalAttachmentLink, type HistoryDataPoint, type HistoryTestResult, type ResolutionIssue, type ResolutionsConfig, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
 import { type AllureStore, type AllureStoreDump, type ExitCode, type PluginGlobalError, type QualityGateValidationResult, type RealtimeEventsDispatcher, type RealtimeSubscriber, type ResultFile, type TestResultFilter } from "@allurereport/plugin-api";
 import type { RawFixtureResult, RawGlobals, RawMetadata, RawTestResult, ReaderContext, ResultsVisitor } from "@allurereport/reader-api";
 export declare const mapToObject: <K extends string | number | symbol, T = any>(map: Map<K, T>) => Record<K, T>;
 export declare const updateMapWithRecord: <K extends string | number | symbol, T = any>(map: Map<K, T>, record: Record<K, T>) => Map<K, T>;
 export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     #private;
-    readonly known: Map<string, KnownTestFailure>;
     readonly indexTestResultByTestCase: Map<string, TestResult[]>;
     readonly indexTestResultByEnvironmentId: Map<string, TestResult[]>;
     readonly indexTestResultByHistoryId: Map<string, TestResult[]>;
@@ -14,8 +13,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     readonly indexFixturesByTestResult: Map<string, TestFixtureResult[]>;
     constructor(params?: {
         history?: AllureHistory;
-        known?: KnownTestFailure[];
-        knownIssuesConfig?: KnownIssuesConfig;
+        resolutionsConfig?: ResolutionsConfig;
         realtimeDispatcher?: RealtimeEventsDispatcher;
         realtimeSubscriber?: RealtimeSubscriber;
         defaultLabels?: DefaultLabelsConfig;
@@ -56,7 +54,9 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     allHistoryDataPoints(): Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironment(environment: string): Promise<HistoryDataPoint[]>;
     allHistoryDataPointsByEnvironmentId(environmentId: string): Promise<HistoryDataPoint[]>;
-    allKnownIssues(): Promise<KnownTestFailure[]>;
+    allResolutionIssues(): Promise<ResolutionIssue[]>;
+    resolutionIssueByTestResultId(trId: string): Promise<ResolutionIssue | undefined>;
+    testResultsByResolutionIssueId(resolutionIssueId: string): Promise<TestResult[]>;
     allNewTestResults(filter?: TestResultFilter, history?: HistoryDataPoint[]): Promise<TestResult[]>;
     testCaseById(tcId: string): Promise<TestCase | undefined>;
     testResultById(trId: string): Promise<TestResult | undefined>;

package/dist/store/store.js

@@ -9,11 +9,11 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_knownIssuesConfig, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_retrySubstore, _DefaultAllureStore_testResultIdsByEnvironmentId, _DefaultAllureStore_cachedEnvironmentEntries, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResultsById, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_historyIdMatches, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_assignRetryHash, _DefaultAllureStore_setKnownIssue, _DefaultAllureStore_classifyKnownIssue, _DefaultAllureStore_rebuildRetrySubstore, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps, _DefaultAllureStore_retriesByTr, _DefaultAllureStore_historyByTr;
+var _DefaultAllureStore_instances, _DefaultAllureStore_testResults, _DefaultAllureStore_environmentDisplayNames, _DefaultAllureStore_environmentNameToId, _DefaultAllureStore_attachments, _DefaultAllureStore_attachmentContents, _DefaultAllureStore_testCases, _DefaultAllureStore_metadata, _DefaultAllureStore_history, _DefaultAllureStore_resolutionsConfig, _DefaultAllureStore_resolutionIssues, _DefaultAllureStore_testResultIdsByResolutionIssueId, _DefaultAllureStore_resolutionIssueIdByTestResultId, _DefaultAllureStore_fixtures, _DefaultAllureStore_defaultLabels, _DefaultAllureStore_environment, _DefaultAllureStore_environmentsConfig, _DefaultAllureStore_reportVariables, _DefaultAllureStore_realtimeDispatcher, _DefaultAllureStore_realtimeSubscriber, _DefaultAllureStore_allowedEnvironmentIds, _DefaultAllureStore_retrySubstore, _DefaultAllureStore_testResultIdsByEnvironmentId, _DefaultAllureStore_cachedEnvironmentEntries, _DefaultAllureStore_globalAttachmentIds, _DefaultAllureStore_globalAttachmentIdsByEnv, _DefaultAllureStore_globalErrors, _DefaultAllureStore_globalErrorsByEnv, _DefaultAllureStore_globalExitCode, _DefaultAllureStore_checkResultsById, _DefaultAllureStore_qualityGateResults, _DefaultAllureStore_historyPoints, _DefaultAllureStore_environments, _DefaultAllureStore_mergeEnvironmentIdentity, _DefaultAllureStore_environmentIdForLookup, _DefaultAllureStore_addEnvironments, _DefaultAllureStore_environmentIdByName, _DefaultAllureStore_setTestResultEnvironmentId, _DefaultAllureStore_assertAllowedEnvironmentId, _DefaultAllureStore_assertAllowedStoredEnvironment, _DefaultAllureStore_environmentIdByTestResult, _DefaultAllureStore_assignRetryHash, _DefaultAllureStore_classifyResolution, _DefaultAllureStore_associateResolutionIssue, _DefaultAllureStore_removeResolutionIssueAssociation, _DefaultAllureStore_rebuildRetrySubstore, _DefaultAllureStore_resolveGlobalEnvironmentIdentity, _DefaultAllureStore_globalAttachmentId, _DefaultAllureStore_indexGlobalError, _DefaultAllureStore_addGlobalError, _DefaultAllureStore_indexGlobalAttachment, _DefaultAllureStore_addGlobalAttachment, _DefaultAllureStore_restoreAttachmentContent, _DefaultAllureStore_relinkRestoredAttachmentSteps, _DefaultAllureStore_retriesByTr, _DefaultAllureStore_historyByTr;
 import { extname } from "node:path";
 import { DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IDENTITY, compareBy, createDictionary, getHistoryIdCandidates, getWorstStatus, normalizeHistoryDataPoint, ordinal, reverse, selectHistoryTestResults, validateEnvironmentId, validateEnvironmentName, } from "@allurereport/core-api";
 import { md5, } from "@allurereport/plugin-api";
-import { getKnownIssueByRules } from "../known.js";
+import { getResolutionByRules, isIgnoredFailure } from "../resolutions.js";
 import { environmentIdentityById, normalizeEnvironmentDescriptorMap, resolveEnvironmentIdentity, resolveStoredEnvironmentIdentity, validateAllowedEnvironmentId, } from "../utils/environment.js";
 import { isFlaky } from "../utils/flaky.js";
 import { getStatusTransition } from "../utils/new.js";
@@ -64,8 +64,10 @@ export class DefaultAllureStore {
         _DefaultAllureStore_testCases.set(this, void 0);
         _DefaultAllureStore_metadata.set(this, void 0);
         _DefaultAllureStore_history.set(this, void 0);
-        _DefaultAllureStore_knownIssuesConfig.set(this, void 0);
-        this.known = new Map();
+        _DefaultAllureStore_resolutionsConfig.set(this, void 0);
+        _DefaultAllureStore_resolutionIssues.set(this, new Map());
+        _DefaultAllureStore_testResultIdsByResolutionIssueId.set(this, new Map());
+        _DefaultAllureStore_resolutionIssueIdByTestResultId.set(this, new Map());
         _DefaultAllureStore_fixtures.set(this, void 0);
         _DefaultAllureStore_defaultLabels.set(this, {});
         _DefaultAllureStore_environment.set(this, void 0);
@@ -92,7 +94,7 @@ export class DefaultAllureStore {
         _DefaultAllureStore_qualityGateResults.set(this, []);
         _DefaultAllureStore_historyPoints.set(this, []);
         _DefaultAllureStore_environments.set(this, []);
-        const { history, known = [], knownIssuesConfig, realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, allowedEnvironments, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
+        const { history, resolutionsConfig, realtimeDispatcher, realtimeSubscriber, defaultLabels = {}, environment, allowedEnvironments, environmentsConfig = {}, reportVariables = {}, } = params ?? {};
         const errors = [];
         const { normalized: normalizedEnvironmentsConfig, identities, errors: configErrors, } = normalizeEnvironmentDescriptorMap(environmentsConfig, "environmentsConfig");
         errors.push(...configErrors);
@@ -117,8 +119,7 @@ export class DefaultAllureStore {
         __classPrivateFieldSet(this, _DefaultAllureStore_metadata, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_fixtures, new Map(), "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_history, history, "f");
-        __classPrivateFieldSet(this, _DefaultAllureStore_knownIssuesConfig, knownIssuesConfig, "f");
-        known.forEach((ktf) => this.known.set(ktf.historyId, ktf));
+        __classPrivateFieldSet(this, _DefaultAllureStore_resolutionsConfig, resolutionsConfig, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_realtimeDispatcher, realtimeDispatcher, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_realtimeSubscriber, realtimeSubscriber, "f");
         __classPrivateFieldSet(this, _DefaultAllureStore_defaultLabels, defaultLabels, "f");
@@ -330,7 +331,7 @@ export class DefaultAllureStore {
             testResult.transition = getStatusTransition(testResult, trHistory);
             testResult.flaky = isFlaky(testResult, trHistory);
         }
-        testResult.known = __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyKnownIssue).call(this, testResult, environmentIdentity.id);
+        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyResolution).call(this, testResult);
         __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_setTestResultEnvironmentId).call(this, testResult, environmentIdentity.id);
         __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").recordIngestOrder(testResult.id);
@@ -512,8 +513,21 @@ export class DefaultAllureStore {
             return result;
         }, []);
     }
-    async allKnownIssues() {
-        return [...this.known.values()].flat();
+    async allResolutionIssues() {
+        return [...__classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f").values()];
+    }
+    async resolutionIssueByTestResultId(trId) {
+        const issueId = __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssueIdByTestResultId, "f").get(trId);
+        return issueId ? __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f").get(issueId) : undefined;
+    }
+    async testResultsByResolutionIssueId(resolutionIssueId) {
+        const testResultIds = __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").get(resolutionIssueId);
+        if (!testResultIds) {
+            return [];
+        }
+        return [...testResultIds]
+            .map((testResultId) => __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").get(testResultId))
+            .filter(Boolean);
     }
     async allNewTestResults(filter, history) {
         if (!__classPrivateFieldGet(this, _DefaultAllureStore_history, "f") && !history) {
@@ -631,7 +645,7 @@ export class DefaultAllureStore {
     }
     async blockingFailedTestResults() {
         const failedTestResults = await this.failedTestResults();
-        return failedTestResults.filter((tr) => !tr.known);
+        return failedTestResults.filter((tr) => !isIgnoredFailure(tr));
     }
     async unknownFailedTestResults() {
         return this.blockingFailedTestResults();
@@ -792,9 +806,10 @@ export class DefaultAllureStore {
             indexAttachmentByTestResult: {},
             indexTestResultByHistoryId: {},
             indexTestResultByTestCase: {},
+            indexTestResultByResolutionIssue: {},
             indexAttachmentByFixture: {},
             indexFixturesByTestResult: {},
-            knownIssues: {},
+            resolutionIssues: mapToObject(__classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f")),
             qualityGateResults: __classPrivateFieldGet(this, _DefaultAllureStore_qualityGateResults, "f"),
             testResultIdsIngestOrder: __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").ingestOrderIdsForDump(),
         };
@@ -810,16 +825,16 @@ export class DefaultAllureStore {
         this.indexTestResultByTestCase.forEach((trs, tcId) => {
             storeDump.indexTestResultByTestCase[tcId] = trs.map((tr) => tr.id);
         });
+        __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").forEach((trIds, resolutionIssueId) => {
+            storeDump.indexTestResultByResolutionIssue[resolutionIssueId] = [...trIds];
+        });
         this.indexFixturesByTestResult.forEach((fixtures, trId) => {
             storeDump.indexFixturesByTestResult[trId] = fixtures.map((f) => f.id);
         });
-        this.known.forEach((known, historyId) => {
-            storeDump.knownIssues[historyId] = known;
-        });
         return storeDump;
     }
     async restoreState(stateDump, attachmentsContents = {}) {
-        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, knownIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], } = stateDump;
+        const { testResults, attachments, testCases, fixtures, reportVariables, environments, globalAttachmentIds = [], globalErrors = [], checkResults, indexAttachmentByTestResult = {}, indexTestResultByHistoryId = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], } = stateDump;
         const storedEnvironmentAliases = environments.flatMap((environmentValue) => {
             if (typeof environmentValue === "string") {
                 return [{ id: environmentValue, name: environmentValue }];
@@ -869,7 +884,7 @@ export class DefaultAllureStore {
             envNameToId.set(id, id);
         }
         Object.values(testResults).forEach((testResult) => {
-            testResult.known ?? (testResult.known = false);
+            __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_removeResolutionIssueAssociation).call(this, testResult.id);
             __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").set(testResult.id, testResult);
             const storedEnvKey = typeof testResult.environment === "string" ? testResult.environment : undefined;
             const envId = (storedEnvKey ? envNameToId.get(storedEnvKey) : undefined) ?? __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByTestResult).call(this, testResult);
@@ -885,7 +900,18 @@ export class DefaultAllureStore {
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_attachments, "f"), attachments);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_testCases, "f"), testCases);
         updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_fixtures, "f"), fixtures);
-        updateMapWithRecord(this.known, knownIssues);
+        updateMapWithRecord(__classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f"), resolutionIssues);
+        Object.entries(indexTestResultByResolutionIssue).forEach(([resolutionIssueId, testResultIds]) => {
+            const resolutionIssue = __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f").get(resolutionIssueId);
+            if (!resolutionIssue) {
+                return;
+            }
+            testResultIds.forEach((testResultId) => {
+                if (__classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").has(testResultId)) {
+                    __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_associateResolutionIssue).call(this, resolutionIssue, testResultId);
+                }
+            });
+        });
         Object.entries(attachmentsContents).forEach(([id, content]) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_restoreAttachmentContent).call(this, id, content);
         });
@@ -975,8 +1001,13 @@ export class DefaultAllureStore {
             existingFixtures.push(...fxs);
         });
         __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_rebuildRetrySubstore).call(this);
-        for (const testResult of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values()) {
-            testResult.known = __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyKnownIssue).call(this, testResult, __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByTestResult).call(this, testResult));
+        if (__classPrivateFieldGet(this, _DefaultAllureStore_resolutionsConfig, "f")) {
+            __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f").clear();
+            __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").clear();
+            __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssueIdByTestResultId, "f").clear();
+            for (const testResult of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f").values()) {
+                __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_classifyResolution).call(this, testResult);
+            }
         }
         qualityGateResults.forEach((result, index) => {
             __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_assertAllowedStoredEnvironment).call(this, {
@@ -989,9 +1020,7 @@ export class DefaultAllureStore {
         });
     }
 }
-_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environmentDisplayNames = new WeakMap(), _DefaultAllureStore_environmentNameToId = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_knownIssuesConfig = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_allowedEnvironmentIds = new WeakMap(), _DefaultAllureStore_retrySubstore = new WeakMap(), _DefaultAllureStore_testResultIdsByEnvironmentId = new WeakMap(), _DefaultAllureStore_cachedEnvironmentEntries = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_checkResultsById = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_historyIdMatches = function _DefaultAllureStore_historyIdMatches(historyIdCandidates, indexByHistoryId) {
-    return historyIdCandidates.find((historyId) => indexByHistoryId.has(historyId));
-}, _DefaultAllureStore_mergeEnvironmentIdentity = function _DefaultAllureStore_mergeEnvironmentIdentity(existingEnvironment, incomingEnvironment) {
+_DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environmentDisplayNames = new WeakMap(), _DefaultAllureStore_environmentNameToId = new WeakMap(), _DefaultAllureStore_attachments = new WeakMap(), _DefaultAllureStore_attachmentContents = new WeakMap(), _DefaultAllureStore_testCases = new WeakMap(), _DefaultAllureStore_metadata = new WeakMap(), _DefaultAllureStore_history = new WeakMap(), _DefaultAllureStore_resolutionsConfig = new WeakMap(), _DefaultAllureStore_resolutionIssues = new WeakMap(), _DefaultAllureStore_testResultIdsByResolutionIssueId = new WeakMap(), _DefaultAllureStore_resolutionIssueIdByTestResultId = new WeakMap(), _DefaultAllureStore_fixtures = new WeakMap(), _DefaultAllureStore_defaultLabels = new WeakMap(), _DefaultAllureStore_environment = new WeakMap(), _DefaultAllureStore_environmentsConfig = new WeakMap(), _DefaultAllureStore_reportVariables = new WeakMap(), _DefaultAllureStore_realtimeDispatcher = new WeakMap(), _DefaultAllureStore_realtimeSubscriber = new WeakMap(), _DefaultAllureStore_allowedEnvironmentIds = new WeakMap(), _DefaultAllureStore_retrySubstore = new WeakMap(), _DefaultAllureStore_testResultIdsByEnvironmentId = new WeakMap(), _DefaultAllureStore_cachedEnvironmentEntries = new WeakMap(), _DefaultAllureStore_globalAttachmentIds = new WeakMap(), _DefaultAllureStore_globalAttachmentIdsByEnv = new WeakMap(), _DefaultAllureStore_globalErrors = new WeakMap(), _DefaultAllureStore_globalErrorsByEnv = new WeakMap(), _DefaultAllureStore_globalExitCode = new WeakMap(), _DefaultAllureStore_checkResultsById = new WeakMap(), _DefaultAllureStore_qualityGateResults = new WeakMap(), _DefaultAllureStore_historyPoints = new WeakMap(), _DefaultAllureStore_environments = new WeakMap(), _DefaultAllureStore_instances = new WeakSet(), _DefaultAllureStore_mergeEnvironmentIdentity = function _DefaultAllureStore_mergeEnvironmentIdentity(existingEnvironment, incomingEnvironment) {
     const configuredEnvironment = environmentIdentityById(__classPrivateFieldGet(this, _DefaultAllureStore_environmentsConfig, "f"), incomingEnvironment.id);
     if (configuredEnvironment) {
         return configuredEnvironment;
@@ -1093,23 +1122,35 @@ _DefaultAllureStore_testResults = new WeakMap(), _DefaultAllureStore_environment
     const environmentId = options?.environmentId ?? __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_environmentIdByTestResult).call(this, testResult);
     const parametersHash = options?.parametersHash ?? calculateParametersHash(testResult.parameters);
     testResult.retryHash = calculateRetryHash(testResult.testCase?.id, parametersHash, environmentId);
-}, _DefaultAllureStore_setKnownIssue = function _DefaultAllureStore_setKnownIssue(knownIssue) {
-    this.known.set(knownIssue.historyId, knownIssue);
-}, _DefaultAllureStore_classifyKnownIssue = function _DefaultAllureStore_classifyKnownIssue(testResult, environmentId) {
-    if (testResult.status !== "failed" && testResult.status !== "broken") {
-        return false;
+}, _DefaultAllureStore_classifyResolution = function _DefaultAllureStore_classifyResolution(testResult) {
+    const rule = getResolutionByRules(testResult, __classPrivateFieldGet(this, _DefaultAllureStore_resolutionsConfig, "f"));
+    testResult.resolution = rule?.resolution;
+    __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_removeResolutionIssueAssociation).call(this, testResult.id);
+    if (rule?.resolution !== "issue") {
+        return;
     }
-    const historyIdCandidates = getHistoryIdCandidates(testResult);
-    if (historyIdCandidates.length === 0) {
-        return false;
+    const resolutionIssue = { ...rule.issue, comment: rule.comment };
+    __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_associateResolutionIssue).call(this, resolutionIssue, testResult.id);
+}, _DefaultAllureStore_associateResolutionIssue = function _DefaultAllureStore_associateResolutionIssue(resolutionIssue, testResultId) {
+    __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_removeResolutionIssueAssociation).call(this, testResultId);
+    __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f").set(resolutionIssue.id, resolutionIssue);
+    const testResultIds = __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").get(resolutionIssue.id) ?? new Set();
+    testResultIds.add(testResultId);
+    __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").set(resolutionIssue.id, testResultIds);
+    __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssueIdByTestResultId, "f").set(testResultId, resolutionIssue.id);
+}, _DefaultAllureStore_removeResolutionIssueAssociation = function _DefaultAllureStore_removeResolutionIssueAssociation(testResultId) {
+    const resolutionIssueId = __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssueIdByTestResultId, "f").get(testResultId);
+    if (!resolutionIssueId) {
+        return;
     }
-    const ruleKnownIssue = getKnownIssueByRules(testResult, __classPrivateFieldGet(this, _DefaultAllureStore_knownIssuesConfig, "f"), environmentId);
-    if (ruleKnownIssue) {
-        __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_setKnownIssue).call(this, ruleKnownIssue);
-        return true;
+    __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssueIdByTestResultId, "f").delete(testResultId);
+    const testResultIds = __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").get(resolutionIssueId);
+    testResultIds?.delete(testResultId);
+    if (testResultIds?.size) {
+        return;
     }
-    const knownHistoryId = __classPrivateFieldGet(this, _DefaultAllureStore_instances, "m", _DefaultAllureStore_historyIdMatches).call(this, historyIdCandidates, this.known);
-    return !!knownHistoryId;
+    __classPrivateFieldGet(this, _DefaultAllureStore_testResultIdsByResolutionIssueId, "f").delete(resolutionIssueId);
+    __classPrivateFieldGet(this, _DefaultAllureStore_resolutionIssues, "f").delete(resolutionIssueId);
 }, _DefaultAllureStore_rebuildRetrySubstore = function _DefaultAllureStore_rebuildRetrySubstore() {
     __classPrivateFieldGet(this, _DefaultAllureStore_retrySubstore, "f").reset();
     for (const [, testResult] of __classPrivateFieldGet(this, _DefaultAllureStore_testResults, "f")) {

package/dist/utils/resultsDir.d.ts

@@ -0,0 +1 @@
+export declare const normalizeResultsDir: (value?: string | string[]) => string[];

package/dist/utils/resultsDir.js

@@ -0,0 +1,7 @@
+export const normalizeResultsDir = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    const values = Array.isArray(value) ? value : [value];
+    return values.filter((entry) => entry.length > 0);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/core",
-  "version": "3.15.0",
+  "version": "3.16.1",
   "description": "Collection of generic Allure utilities used across the entire project",
   "keywords": [
     "allure"
@@ -25,26 +25,26 @@
     "lint:fix": "oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/ci": "3.15.0",
-    "@allurereport/cli-commons": "3.15.0",
-    "@allurereport/core-api": "3.15.0",
-    "@allurereport/plugin-agent": "3.15.0",
-    "@allurereport/plugin-allure2": "3.15.0",
-    "@allurereport/plugin-api": "3.15.0",
-    "@allurereport/plugin-awesome": "3.15.0",
-    "@allurereport/plugin-classic": "3.15.0",
-    "@allurereport/plugin-csv": "3.15.0",
-    "@allurereport/plugin-dashboard": "3.15.0",
-    "@allurereport/plugin-jira": "3.15.0",
-    "@allurereport/plugin-log": "3.15.0",
-    "@allurereport/plugin-progress": "3.15.0",
-    "@allurereport/plugin-slack": "3.15.0",
-    "@allurereport/plugin-testops": "3.15.0",
-    "@allurereport/plugin-testplan": "3.15.0",
-    "@allurereport/reader": "3.15.0",
-    "@allurereport/reader-api": "3.15.0",
-    "@allurereport/service": "3.15.0",
-    "@allurereport/summary": "3.15.0",
+    "@allurereport/ci": "3.16.1",
+    "@allurereport/cli-commons": "3.16.1",
+    "@allurereport/core-api": "3.16.1",
+    "@allurereport/plugin-agent": "3.16.1",
+    "@allurereport/plugin-allure2": "3.16.1",
+    "@allurereport/plugin-api": "3.16.1",
+    "@allurereport/plugin-awesome": "3.16.1",
+    "@allurereport/plugin-classic": "3.16.1",
+    "@allurereport/plugin-csv": "3.16.1",
+    "@allurereport/plugin-dashboard": "3.16.1",
+    "@allurereport/plugin-jira": "3.16.1",
+    "@allurereport/plugin-log": "3.16.1",
+    "@allurereport/plugin-progress": "3.16.1",
+    "@allurereport/plugin-slack": "3.16.1",
+    "@allurereport/plugin-testops": "3.16.1",
+    "@allurereport/plugin-testplan": "3.16.1",
+    "@allurereport/reader": "3.16.1",
+    "@allurereport/reader-api": "3.16.1",
+    "@allurereport/service": "3.16.1",
+    "@allurereport/summary": "3.16.1",
     "glob": "^13.0.6",
     "handlebars": "^4.7.9",
     "jiti": "^2.5.1",

package/dist/known.d.ts

@@ -1,8 +0,0 @@
-import type { KnownIssuesConfig, KnownTestFailure, TestResult } from "@allurereport/core-api";
-import type { AllureStore } from "@allurereport/plugin-api";
-export declare const DEFAULT_KNOWN_ISSUES_PATH = "known-issues.json";
-export declare const hasKnownIssueRules: (knownIssues?: KnownIssuesConfig) => boolean;
-export declare const getKnownIssueByRules: (testResult: TestResult, knownIssues: KnownIssuesConfig | undefined, environmentId?: string) => KnownTestFailure | undefined;
-export declare const resolveExactIssuesFilePath: (pathOrDir: string | undefined, label: string) => Promise<string | undefined>;
-export declare const readKnownIssues: (knownIssuePath: string) => Promise<KnownTestFailure[]>;
-export declare const writeKnownIssues: (store: AllureStore, knownIssuesPath?: string) => Promise<void>;

package/dist/known.js

@@ -1,86 +0,0 @@
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { dirname, extname, resolve } from "node:path";
-import { isFileNotFoundError } from "./utils/misc.js";
-export const DEFAULT_KNOWN_ISSUES_PATH = "known-issues.json";
-export const hasKnownIssueRules = (knownIssues) => (knownIssues?.rules?.length ?? 0) > 0;
-const messageMatches = (rule, testResult) => {
-    if (!rule.messageRegexp) {
-        return true;
-    }
-    const message = testResult.error?.message;
-    return typeof message === "string" && new RegExp(rule.messageRegexp).test(message);
-};
-const testCaseIdMatches = (rule, testResult) => {
-    const { id, allureId, externalId } = testResult.testCase ?? {};
-    return !rule.testCaseId || [id, allureId, externalId].includes(rule.testCaseId);
-};
-const retryHashMatches = (rule, testResult) => {
-    return !rule.retryHash || rule.retryHash === testResult.retryHash;
-};
-const environmentMatches = (rule, testResult) => {
-    return !rule.environmentId || rule.environmentId === testResult.environment;
-};
-export const getKnownIssueByRules = (testResult, knownIssues, environmentId) => {
-    if (!testResult.historyId || !hasKnownIssueRules(knownIssues)) {
-        return undefined;
-    }
-    const matchedRule = knownIssues.rules.find((rule) => [messageMatches, testCaseIdMatches, environmentMatches, retryHashMatches].every((matcher) => matcher(rule, testResult)));
-    if (!matchedRule) {
-        return undefined;
-    }
-    return {
-        historyId: testResult.historyId,
-        reason: matchedRule.decision.reason,
-        links: matchedRule.decision.links,
-        error: testResult.error,
-    };
-};
-export const resolveExactIssuesFilePath = async (pathOrDir, label) => {
-    if (!pathOrDir) {
-        return undefined;
-    }
-    const path = resolve(pathOrDir);
-    if (extname(path).toLowerCase() !== ".json") {
-        throw new Error(`Invalid ${label} path ${JSON.stringify(pathOrDir)}: expected exact .json file path`);
-    }
-    try {
-        const pathStats = await stat(path);
-        if (pathStats.isDirectory()) {
-            throw new Error(`Invalid ${label} path ${JSON.stringify(pathOrDir)}: expected file, got directory`);
-        }
-    }
-    catch (e) {
-        if (!isFileNotFoundError(e)) {
-            throw e;
-        }
-    }
-    return path;
-};
-export const readKnownIssues = async (knownIssuePath) => {
-    const path = await resolveExactIssuesFilePath(knownIssuePath, "known issues");
-    if (!path) {
-        return [];
-    }
-    try {
-        const content = await readFile(path, { encoding: "utf-8" });
-        return JSON.parse(content);
-    }
-    catch (e) {
-        if (isFileNotFoundError(e)) {
-            return [];
-        }
-        throw e;
-    }
-};
-const writeKnownIssueRecords = async (knownIssues, knownIssuesPath) => {
-    const path = await resolveExactIssuesFilePath(knownIssuesPath, "known issues");
-    if (!path) {
-        return;
-    }
-    await mkdir(dirname(path), { recursive: true });
-    await writeFile(path, `${JSON.stringify(knownIssues)}\n`, "utf-8");
-};
-export const writeKnownIssues = async (store, knownIssuesPath) => {
-    const knownIssues = await store.allKnownIssues();
-    await writeKnownIssueRecords(knownIssues, knownIssuesPath);
-};