@allurereport/core 3.18.0 → 3.19.0

package/dist/config.js

@@ -91,6 +91,7 @@ export const validateConfig = (config) => {
         "historyPath",
         "historyBaseUrl",
         "historyLimit",
+        "flakyDetection",
         "resolutions",
         "plugins",
         "defaultLabels",
@@ -184,12 +185,25 @@ const resolveConfigEnvironments = (config) => {
         allowedEnvironments,
     };
 };
+const validateFlakyDetectionConfig = (config) => {
+    if (config === undefined) {
+        return;
+    }
+    const { historyDepth, includePassedTests } = config;
+    if (historyDepth !== undefined && (!Number.isInteger(historyDepth) || historyDepth < -1)) {
+        throw new Error("flakyDetection.historyDepth must be an integer greater than or equal to -1");
+    }
+    if (includePassedTests !== undefined && typeof includePassedTests !== "boolean") {
+        throw new TypeError("flakyDetection.includePassedTests must be a boolean");
+    }
+};
 export const resolveConfig = async (config, override = {}) => {
     const validationResult = validateConfig(config);
     if (!validationResult.valid) {
         throw new Error(`The provided Allure config contains unsupported fields: ${validationResult.fields.join(", ")}`);
     }
     validateResolutionsConfig(config.resolutions);
+    validateFlakyDetectionConfig(config.flakyDetection);
     const { environments, environment, allowedEnvironments } = resolveConfigEnvironments(config);
     const name = override.name ?? config.name ?? "Allure Report";
     const open = override.open ?? config.open ?? false;
@@ -246,6 +260,7 @@ export const resolveConfig = async (config, override = {}) => {
         environments,
         appendHistory,
         historyLimit,
+        flakyDetection: config.flakyDetection,
         historyPath: historyPath ? resolve(historyPath) : undefined,
         historyBaseUrl,
         dump,

package/dist/history.js

@@ -19,8 +19,8 @@ import { normalizeHistoryDataPointUrls, } from "@allurereport/core-api";
 import { isFileNotFoundError } from "./utils/misc.js";
 const createHistoryItems = (testResults, remoteUrl) => {
     return testResults
-        .filter((tr) => tr.historyId)
-        .map(({ id, name, fullName, environment, historyId, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
+        .filter((tr) => tr.retryHash)
+        .map(({ id, name, fullName, environment, retryHash, status, error: { message, trace } = {}, start, stop, duration, labels, }) => {
         return {
             id,
             name,
@@ -34,12 +34,12 @@ const createHistoryItems = (testResults, remoteUrl) => {
             duration,
             labels,
             url: remoteUrl,
-            historyId: historyId,
+            retryHash: retryHash,
             reportLinks: [],
         };
     })
         .reduce((acc, item) => {
-        acc[item.historyId] = item;
+        acc[item.retryHash] = item;
         return acc;
     }, {});
 };
@@ -228,7 +228,9 @@ export class AllureLocalHistory {
         }
         finally {
             const closing = historyFile.close();
-            dst?.destroy();
+            if (historyFile.fd !== -1) {
+                dst?.destroy();
+            }
             await closing;
             if (limit !== 0) {
                 __classPrivateFieldGet(this, _AllureLocalHistory_cachedHistory, "f").push(normalizedData);

package/dist/qualityGate/qualityGate.js

@@ -71,7 +71,7 @@ export class QualityGate {
             }
             trsToValidateById.set(tr.id, tr);
         }
-        const trsToValidate = trsToValidateById.values().toArray();
+        const trsToValidate = [...trsToValidateById.values()];
         const { rules, use = [...qualityGateDefaultRules] } = this.config;
         const results = [];
         let fastFailed = false;

package/dist/qualityGate/rules.js

@@ -41,12 +41,17 @@ const metricActual = (metrics, key, value) => {
         ...(sample?.unit ? { unit: sample.unit } : {}),
     };
 };
+const formatQualityGateNumber = (value) => {
+    if (!Number.isFinite(value)) {
+        return String(value);
+    }
+    return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(3)));
+};
 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)));
+    const formatted = formatQualityGateNumber(value);
     return unit ? `${formatted} ${unit}` : formatted;
 };
 const metricRuleTitle = (actual) => actual.title ?? actual.key;
@@ -103,8 +108,8 @@ export const minTestsCountRule = {
 };
 export const successRateRule = {
     rule: "successRate",
-    message: ({ actual, expected }) => `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
-    successMessage: ({ actual, expected }) => `Success rate ${bold(String(actual))} is not less, than expected ${bold(String(expected))}`,
+    message: ({ actual, expected }) => `Success rate ${bold(formatQualityGateNumber(actual))} is less, than expected ${bold(formatQualityGateNumber(expected))}`,
+    successMessage: ({ actual, expected }) => `Success rate ${bold(formatQualityGateNumber(actual))} is not less, than expected ${bold(formatQualityGateNumber(expected))}`,
     validate: async ({ trs, expected, state }) => {
         const previous = successRateStateValue(state.getResult());
         const eligibleTrs = trs.filter(filterIncludedInSuccessRate);

package/dist/report.js

@@ -299,6 +299,7 @@ export class AllureReport {
             }
             const resultsDirPath = resolve(resultsDir);
             if (await readXcResultBundle(__classPrivateFieldGet(this, _AllureReport_store, "f"), resultsDirPath)) {
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
                 return;
             }
             try {
@@ -319,12 +320,14 @@ export class AllureReport {
             catch (e) {
                 console.error("can't read directory", e);
             }
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
         });
         this.readFile = async (resultsFile) => measurePerf(PERF_METRIC_NAMES.generateReadResults, async () => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 throw new Error(INIT_REQUIRED_ERROR_MESSAGE);
             }
             await this.readResult(new PathResultFile(resultsFile));
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
         });
         this.readResult = async (data) => {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
@@ -345,6 +348,9 @@ export class AllureReport {
         };
         this.validate = async (params) => {
             const { trs, state, environment } = params;
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "done") {
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags(trs.filter(Boolean));
+            }
             const qualityGateEnvironment = environment === undefined
                 ? undefined
                 : (environmentIdentityById(__classPrivateFieldGet(this, _AllureReport_environments, "f"), environment)?.name ??
@@ -370,6 +376,7 @@ export class AllureReport {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "done") {
                 throw new Error("the report is already stopped, the restart isn't supported at the moment");
             }
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
             __classPrivateFieldSet(this, _AllureReport_executionStage, "running", "f");
             __classPrivateFieldSet(this, _AllureReport_endGeneratePerfSpan, startPerfSpan(PERF_METRIC_NAMES.generateTotal), "f");
             if (__classPrivateFieldGet(this, _AllureReport_globalAttachments, "f")?.length) {
@@ -399,6 +406,7 @@ export class AllureReport {
             if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") !== "running") {
                 return;
             }
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
             await __classPrivateFieldGet(this, _AllureReport_eachPlugin, "f").call(this, false, async (plugin, context) => {
                 await plugin.update?.(context, __classPrivateFieldGet(this, _AllureReport_store, "f"));
             });
@@ -449,7 +457,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 = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], metrics = [], }) => [
+            const dumpJsonEntries = ({ testResults, testCases, fixtures, attachments, environments, reportVariables, checkResults = {}, globalAttachmentIds = [], globalErrors = [], indexAttachmentByTestResult = {}, indexTestResultByRetryHash = {}, indexTestResultByTestCase = {}, indexTestResultByResolutionIssue = {}, indexAttachmentByFixture = {}, indexFixturesByTestResult = {}, resolutionIssues = {}, qualityGateResults = [], testResultIdsIngestOrder = [], metrics = [], }) => [
                 [AllureStoreDumpFiles.TestResults, testResults],
                 [AllureStoreDumpFiles.TestCases, testCases],
                 [AllureStoreDumpFiles.Fixtures, fixtures],
@@ -461,7 +469,7 @@ export class AllureReport {
                 [AllureStoreDumpFiles.GlobalAttachments, globalAttachmentIds],
                 [AllureStoreDumpFiles.GlobalErrors, globalErrors],
                 [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
-                [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryId],
+                [AllureStoreDumpFiles.IndexTestResultsByRetryHash, indexTestResultByRetryHash],
                 [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
                 [AllureStoreDumpFiles.IndexTestResultsByResolutionIssue, indexTestResultByResolutionIssue],
                 [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
@@ -537,6 +545,7 @@ export class AllureReport {
         this.restoreState = async (dumps) => {
             __classPrivateFieldGet(this, _AllureReport_store, "f").resetIngestOrder();
             await __classPrivateFieldGet(this, _AllureReport_restoreStateDumps, "f").call(this, dumps.map((path) => ({ artifactPath: path, path })));
+            __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
         };
         _AllureReport_recordArtifact.set(this, (filePath, name = basename(filePath)) => {
             const artifact = createReportArtifact(filePath, __classPrivateFieldGet(this, _AllureReport_getCwd, "f").call(this), name);
@@ -607,8 +616,6 @@ export class AllureReport {
                             const globalAttachmentsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalAttachments);
                             const globalErrorsEntry = await requiredEntryData(AllureStoreDumpFiles.GlobalErrors);
                             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);
@@ -630,7 +637,7 @@ export class AllureReport {
                                     case AllureStoreDumpFiles.GlobalAttachments:
                                     case AllureStoreDumpFiles.GlobalErrors:
                                     case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
-                                    case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
+                                    case AllureStoreDumpFiles.IndexTestResultsByRetryHash:
                                     case AllureStoreDumpFiles.IndexTestResultsByTestCase:
                                     case AllureStoreDumpFiles.IndexTestResultsByResolutionIssue:
                                     case AllureStoreDumpFiles.IndexAttachmentsByFixture:
@@ -659,8 +666,8 @@ export class AllureReport {
                                 globalAttachmentIds: JSON.parse(globalAttachmentsEntry.toString("utf8")),
                                 globalErrors: JSON.parse(globalErrorsEntry.toString("utf8")),
                                 indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
-                                indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
-                                indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
+                                indexTestResultByRetryHash: {},
+                                indexTestResultByTestCase: {},
                                 indexTestResultByResolutionIssue: indexTestResultsByResolutionIssueEntry
                                     ? JSON.parse(indexTestResultsByResolutionIssueEntry.toString("utf8"))
                                     : {},
@@ -840,6 +847,7 @@ export class AllureReport {
                     console.error("realtime update failed during shutdown", e);
                 }
                 __classPrivateFieldSet(this, _AllureReport_executionStage, "done", "f");
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
                 if (__classPrivateFieldGet(this, _AllureReport_dump, "f")) {
                     await this.dumpState();
                     return;
@@ -1005,7 +1013,7 @@ export class AllureReport {
                 }
             }
         });
-        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyBaseUrl, historyLimit, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, performance, dump, categories, allureService, globalAttachments, cwd, } = opts;
+        const { name, readers = [allure1, allure2, cucumberjson, junitXml, attachments], plugins = [], resolutions, reportFiles, realTime, historyPath, historyBaseUrl, historyLimit, flakyDetection, appendHistory, defaultLabels = {}, variables = {}, environment, allowedEnvironments, environments, output, hideLabels, qualityGate, performance, dump, categories, allureService, globalAttachments, cwd, } = opts;
         const allureServiceAccessToken = allureService?.accessToken;
         if (allureServiceAccessToken) {
             const allureServiceClientConfig = {
@@ -1024,7 +1032,11 @@ export class AllureReport {
         __classPrivateFieldSet(this, _AllureReport_ci, detect(), "f");
         const reportTitleSuffix = __classPrivateFieldGet(this, _AllureReport_ci, "f")?.pullRequestName ?? __classPrivateFieldGet(this, _AllureReport_ci, "f")?.jobRunName;
         this.reportName = [name, reportTitleSuffix].filter(Boolean).join(" – ");
-        __classPrivateFieldSet(this, _AllureReport_realtimeChannel, new RealtimeChannel(), "f");
+        __classPrivateFieldSet(this, _AllureReport_realtimeChannel, new RealtimeChannel(() => {
+            if (__classPrivateFieldGet(this, _AllureReport_executionStage, "f") === "running") {
+                __classPrivateFieldGet(this, _AllureReport_store, "f").updateHistoryFlags();
+            }
+        }), "f");
         __classPrivateFieldSet(this, _AllureReport_realtimeUpdateScheduler, new RealtimeUpdateScheduler(__classPrivateFieldGet(this, _AllureReport_runRealtimeUpdate, "f")), "f");
         __classPrivateFieldSet(this, _AllureReport_realTime, realTime, "f");
         __classPrivateFieldSet(this, _AllureReport_dump, dump, "f");
@@ -1057,6 +1069,7 @@ export class AllureReport {
             reportVariables: variables,
             environmentsConfig: environments,
             history: __classPrivateFieldGet(this, _AllureReport_history, "f"),
+            flakyDetection,
             resolutionsConfig: resolutions,
             defaultLabels,
             environment,

package/dist/store/convert.d.ts

@@ -1,6 +1,5 @@
 import type { AttachmentLink, TestCase, TestFixtureResult, TestResult } from "@allurereport/core-api";
 import type { RawFixtureResult, RawTestResult, ReaderContext } from "@allurereport/reader-api";
-export declare const __unknown = "#___unknown_value___#";
 export type StateData = {
     testCases: Map<string, TestCase>;
     attachments: Map<string, AttachmentLink>;

package/dist/store/convert.js

@@ -1,9 +1,19 @@
 import { randomUUID } from "node:crypto";
-import { findByLabelName, notNull } from "@allurereport/core-api";
+import { UNKNOWN_PARAMETER_VALUE, calculateParametersHash, calculateRetryHash, calculateTestCaseHash, findByLabelName, notNull, } from "@allurereport/core-api";
 import { md5 } from "@allurereport/plugin-api";
 import { extension, lookupContentType } from "@allurereport/reader-api";
 const defaultStatus = "unknown";
-export const __unknown = "#___unknown_value___#";
+const convertRawError = (raw) => ({
+    message: raw.message,
+    trace: raw.trace,
+    ...(raw.actual && raw.expected ? { expected: raw.expected, actual: raw.actual } : {}),
+});
+const convertTestErrors = (raw) => {
+    const errors = raw.errors?.filter(notNull);
+    if (errors?.length) {
+        return errors.map(convertRawError);
+    }
+};
 export const testFixtureResultRawToState = (stateData, raw, context) => {
     const name = raw.name || "Unknown test";
     return {
@@ -26,24 +36,32 @@ export const testFixtureResultRawToState = (stateData, raw, context) => {
     };
 };
 export const testResultRawToState = (stateData, raw, context) => {
+    const legacyTestCaseHash = calculateLegacyTestCaseHash(raw);
+    const allureId = raw.labels
+        ?.find((label) => (label?.name === "ALLURE_ID" || label?.name === "AS_ID") && label.value?.trim())
+        ?.value?.trim();
     const labels = convertLabels(raw.labels);
     const hostId = findByLabelName(labels, "host");
     const threadId = findByLabelName(labels, "thread");
     const name = raw.name || "Unknown test";
-    const testCase = processTestCase(stateData, raw);
     const parameters = convertParameters(raw.parameters);
+    const error = convertRawError(raw);
+    const errors = convertTestErrors(raw);
+    const testCaseHash = calculateTestCaseHash(raw.testId, raw.fullName);
+    const parametersHash = calculateParametersHash(parameters);
+    const testCase = processTestCase({ stateData, raw, allureId, testCaseHash });
     return {
         id: md5(raw.uuid || randomUUID()),
         name,
         testCase,
         fullName: raw.fullName,
-        historyId: calculateHistoryId(testCase, parameters),
+        testCaseHash,
+        parametersHash,
+        environmentHash: null,
+        retryHash: calculateRetryHash({ testCaseHash, parametersHash }),
         status: raw.status ?? defaultStatus,
-        error: {
-            message: raw.message,
-            trace: raw.trace,
-            ...(raw.actual && raw.expected ? { expected: raw.expected, actual: raw.actual } : {}),
-        },
+        error: errors?.[0] ?? error,
+        errors,
         ...processTimings(raw),
         description: raw.description,
         descriptionHtml: raw.descriptionHtml,
@@ -64,25 +82,43 @@ export const testResultRawToState = (stateData, raw, context) => {
         sourceMetadata: {
             readerId: context.readerId,
             metadata: context.metadata ?? {},
+            legacyHistoryId: raw.historyId?.length ? raw.historyId : undefined,
+            reportedFlaky: raw.flaky ?? false,
+            legacyTestCaseHash,
         },
         titlePath: raw.titlePath ?? [],
     };
 };
-const processTestCase = ({ testCases }, raw) => {
-    const [id, allureId] = calculateTestId(raw);
-    if (id) {
-        const maybeTestCase = testCases.get(id);
+const calculateLegacyTestCaseHash = (raw) => {
+    const maybeAllureId = raw.labels?.find((label) => (label?.name === "ALLURE_ID" || label?.name === "AS_ID") && label.value !== "-1")?.value;
+    if (maybeAllureId) {
+        return md5(`ALLURE_ID=${maybeAllureId}`);
+    }
+    if (raw.testId) {
+        return md5(raw.testId);
+    }
+    if (raw.fullName) {
+        return md5(raw.fullName);
+    }
+    return undefined;
+};
+const processTestCase = ({ stateData: { testCases }, raw, allureId, testCaseHash, }) => {
+    if (testCaseHash) {
+        const maybeTestCase = testCases.get(testCaseHash);
         if (maybeTestCase) {
+            if (!maybeTestCase.allureId && allureId) {
+                maybeTestCase.allureId = allureId;
+            }
             return maybeTestCase;
         }
         const testCase = {
-            id,
+            id: testCaseHash,
             allureId,
             externalId: raw.testId,
-            name: raw.testCaseName ?? raw.name ?? __unknown,
+            name: raw.testCaseName ?? raw.name ?? UNKNOWN_PARAMETER_VALUE,
             fullName: raw.fullName,
         };
-        testCases.set(id, testCase);
+        testCases.set(testCaseHash, testCase);
         return testCase;
     }
     return undefined;
@@ -100,7 +136,7 @@ const processAttachmentLink = ({ attachments, visitAttachmentLink }, attach) =>
             originalFileName: undefined,
             contentType: attach.contentType,
             ext: "",
-            name: attach.name ?? __unknown,
+            name: attach.name ?? UNKNOWN_PARAMETER_VALUE,
             missed: true,
             used: true,
         });
@@ -128,7 +164,7 @@ const processAttachmentLink = ({ attachments, visitAttachmentLink }, attach) =>
             id: randomUUID(),
             originalFileName: undefined,
             ext: "",
-            name: attach.name ?? attach.originalFileName ?? __unknown,
+            name: attach.name ?? attach.originalFileName ?? UNKNOWN_PARAMETER_VALUE,
             contentType: attach.contentType,
             missed: true,
             used: true,
@@ -165,11 +201,11 @@ const processTimings = ({ start, stop, duration, }) => {
     return { start: undefined, stop: undefined, duration };
 };
 const convertLabels = (labels) => {
-    return labels?.filter(notNull)?.map(convertLabel)?.flatMap(processTagLabels) ?? [];
+    return labels?.filter(notNull)?.map(convertLabel)?.flatMap(processTagLabels).map(normalizeAllureIdLabel) ?? [];
 };
 const convertLabel = (label) => {
     return {
-        name: label.name ?? __unknown,
+        name: label.name ?? UNKNOWN_PARAMETER_VALUE,
         value: label.value,
     };
 };
@@ -196,7 +232,7 @@ const convertStep = (stateData, step) => {
         return {
             convertedStep: {
                 stepId: md5(`${step.name}${step.start}`),
-                name: step.name ?? __unknown,
+                name: step.name ?? UNKNOWN_PARAMETER_VALUE,
                 status: step.status ?? defaultStatus,
                 steps: subSteps,
                 parameters: convertParameters(step.parameters),
@@ -217,11 +253,11 @@ const convertStep = (stateData, step) => {
 };
 const convertParameters = (parameters) => parameters
     ?.filter(notNull)
-    ?.filter((p) => p.name)
+    ?.filter((p) => typeof p.name === "string" && p.name.length > 0)
     ?.map(convertParameter) ?? [];
 const convertParameter = (param) => ({
-    name: param.name ?? __unknown,
-    value: param.value ?? __unknown,
+    name: param.name ?? UNKNOWN_PARAMETER_VALUE,
+    value: param.value ?? UNKNOWN_PARAMETER_VALUE,
     hidden: param.hidden ?? false,
     excluded: param.excluded ?? false,
     masked: param.masked ?? false,
@@ -232,42 +268,9 @@ const convertLinks = (links) => links
     ?.map(convertLink) ?? [];
 const convertLink = (link) => ({
     name: link.name,
-    url: link.url ?? __unknown,
+    url: link.url ?? UNKNOWN_PARAMETER_VALUE,
     type: link.type,
 });
-const calculateTestId = (raw) => {
-    const maybeAllureId = raw.labels?.find((label) => (label.name === "ALLURE_ID" || label.name === "AS_ID") && label.value !== "-1")?.value;
-    if (maybeAllureId) {
-        return [md5(`ALLURE_ID=${maybeAllureId}`), maybeAllureId];
-    }
-    if (raw.testId) {
-        return [md5(raw.testId), undefined];
-    }
-    if (raw.fullName) {
-        return [md5(raw.fullName), undefined];
-    }
-    return [undefined, undefined];
-};
-const calculateHistoryId = (testCase, parameters) => {
-    if (!testCase) {
-        return undefined;
-    }
-    const paramsPart = stringifyParams(parameters);
-    return `${testCase.id}.${md5(paramsPart)}`;
-};
-const parametersCompare = (a, b) => {
-    return (a.name ?? "").localeCompare(b.name) || a.value.localeCompare(b.value ?? "");
-};
-const stringifyParams = (parameters) => {
-    if (!parameters) {
-        return "";
-    }
-    return parameters
-        .filter((p) => !p?.excluded)
-        .sort(parametersCompare)
-        .map((p) => `${p.name}:${p.value}`)
-        .join(",");
-};
 const idLabelMatcher = new RegExp("^@?allure\\.id[:=](?<id>.+)$");
 const tagLabelMatcher = new RegExp("^@?allure\\.label\\.(?<name>.+)[:=](?<value>.+)$");
 const processTagLabels = (label) => {
@@ -286,3 +289,13 @@ const processTagLabels = (label) => {
     }
     return label.name ? [{ name: label.name, value: label.value }] : [];
 };
+const normalizeAllureIdLabel = (label) => {
+    if (label.name !== "ALLURE_ID" && label.name !== "AS_ID") {
+        return label;
+    }
+    const value = label.value?.trim();
+    return {
+        name: "ALLURE_ID",
+        value: value?.length ? value : undefined,
+    };
+};

package/dist/store/retrySubstore.d.ts

@@ -1,6 +1,4 @@
-import type { TestParameter, TestResult } from "@allurereport/core-api";
-export declare const calculateParametersHash: (parameters?: TestParameter[]) => string;
-export declare const calculateRetryHash: (testCaseId: string | undefined, parametersHash: string, environmentId: string | undefined) => string | undefined;
+import type { TestResult } from "@allurereport/core-api";
 export declare class RetrySubstore {
     #private;
     recordIngestOrder(testResultId: string): void;

package/dist/store/retrySubstore.js

@@ -4,21 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _RetrySubstore_instances, _RetrySubstore_testResultsByRetryHash, _RetrySubstore_testResultIngestIndexById, _RetrySubstore_getIngestIndex, _RetrySubstore_compareResults;
-import { md5 } from "../utils/crypto.js";
 const NO_RETRIES = [];
-const compareByNameThenValue = (first, second) => first.name.localeCompare(second.name) || first.value.localeCompare(second.value);
-const stringifyRetryParameters = (parameters = []) => parameters
-    .filter((parameter) => !parameter.excluded)
-    .sort(compareByNameThenValue)
-    .map((parameter) => `${parameter.name}:${parameter.value}`)
-    .join(",");
-export const calculateParametersHash = (parameters = []) => md5(stringifyRetryParameters(parameters));
-export const calculateRetryHash = (testCaseId, parametersHash, environmentId) => {
-    if (!testCaseId) {
-        return undefined;
-    }
-    return md5(`${testCaseId}:${parametersHash}:${environmentId ?? "default"}`);
-};
 export class RetrySubstore {
     constructor() {
         _RetrySubstore_instances.add(this);

package/dist/store/store.d.ts

@@ -1,4 +1,4 @@
-import { type AllureCheckResult, type AllureHistory, type AllurePerformanceResult, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type GlobalAttachmentLink, type HistoryDataPoint, type HistoryTestResult, type ResolutionIssue, type ResolutionsConfig, type MetricSample, type PerformanceConfig, type ReportVariables, type Statistic, type TestCase, type TestEnvGroup, type TestError, type TestFixtureResult, type TestResult } from "@allurereport/core-api";
+import { type AllureCheckResult, type AllureHistory, type AllurePerformanceResult, type AttachmentLink, type DefaultLabelsConfig, type EnvironmentIdentity, type EnvironmentsConfig, type FlakyDetectionConfig, type GlobalAttachmentLink, type HistoryDataPoint, type HistoryTestResult, type ResolutionIssue, type ResolutionsConfig, type MetricSample, type PerformanceConfig, 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>;
@@ -7,12 +7,13 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
     #private;
     readonly indexTestResultByTestCase: Map<string, TestResult[]>;
     readonly indexTestResultByEnvironmentId: Map<string, TestResult[]>;
-    readonly indexTestResultByHistoryId: Map<string, TestResult[]>;
+    readonly indexTestResultByRetryHash: Map<string, TestResult[]>;
     readonly indexAttachmentByTestResult: Map<string, AttachmentLink[]>;
     readonly indexAttachmentByFixture: Map<string, AttachmentLink[]>;
     readonly indexFixturesByTestResult: Map<string, TestFixtureResult[]>;
     constructor(params?: {
         history?: AllureHistory;
+        flakyDetection?: FlakyDetectionConfig;
         resolutionsConfig?: ResolutionsConfig;
         realtimeDispatcher?: RealtimeEventsDispatcher;
         realtimeSubscriber?: RealtimeSubscriber;
@@ -24,6 +25,7 @@ export declare class DefaultAllureStore implements AllureStore, ResultsVisitor {
         performance?: PerformanceConfig;
     });
     readHistory(): Promise<HistoryDataPoint[]>;
+    updateHistoryFlags(testResults?: Iterable<TestResult>): void;
     appendHistory(history: HistoryDataPoint): Promise<void>;
     addCheckResult(result: AllureCheckResult): Promise<void>;
     allCheckResults(): Promise<AllureCheckResult[]>;