feat: use history hash for history

Author: vdvukhzhilov

packages/core-api/src/categories.ts

@@ -141,7 +141,9 @@ export type CategoryNodeItem = {
   name: string;
   key?: string;
   value?: string;
+  /** @deprecated Prefer `historyHash` for copy/group identity. */
   historyId?: string;
+  historyHash?: string;
   retriesCount?: number;
   transition?: TestStatusTransition;
   tooltips?: Record<string, string>;

packages/core-api/src/history.ts

@@ -22,7 +22,10 @@ export interface HistoryTestResult {
 
   url: string;
 
-  historyId?: string; // TODO: double check the necessity to have historyId in the history test result
+  /** @deprecated Legacy map key / field without environment in the hash. Prefer `historyHash`. */
+  historyId?: string;
+  /** Primary key in history `testResults` maps for new history entries. */
+  historyHash?: string;
   reportLinks?: any[]; // TODO: add the correct type for previously missing report links
 }
 

packages/core-api/src/known.ts

@@ -2,7 +2,9 @@ import type { TestLink } from "./metadata.js";
 import type { TestError } from "./model.js";
 
 export interface KnownTestFailure {
-  historyId: string;
+  /** @deprecated Prefer `historyHash`. */
+  historyId?: string;
+  historyHash?: string;
   issues?: TestLink[];
   comment?: string;
   error?: TestError;

packages/core-api/src/model.ts

@@ -43,7 +43,12 @@ export interface TestResult {
   environment?: string;
 
   fullName?: string;
+  /** @deprecated Use `historyHash`. Legacy key without environment in the hash. */
   historyId?: string;
+  /**
+   * Stable key for history storage and lookup: md5(`${testCaseId}:${parametersHash}:${environmentId ?? "default"}`).
+   */
+  historyHash?: string;
 
   description?: string;
   descriptionHtml?: string;

packages/core-api/src/utils/history.ts

@@ -44,10 +44,31 @@ export const getFallbackHistoryId = (tr: Pick<TestResult, "labels" | "parameters
   return `${fallbackTestCaseId}.${md5(stringifyHistoryParams(tr.parameters ?? []))}`;
 };
 
-export const getHistoryIdCandidates = (tr: Pick<TestResult, "historyId" | "labels" | "parameters">): string[] => {
+/**
+ * Same formula as retry grouping: md5(`${testCaseId}:${parametersHash}:${environmentId ?? "default"}`).
+ */
+export const calculateHistoryHash = (
+  testCaseId: string | undefined,
+  parametersHash: string,
+  environmentId: string | undefined,
+): string | undefined => {
+  if (!testCaseId) {
+    return undefined;
+  }
+
+  return md5(`${testCaseId}:${parametersHash}:${environmentId ?? "default"}`);
+};
+
+export const getHistoryHashCandidates = (
+  tr: Pick<TestResult, "historyHash" | "historyId" | "labels" | "parameters">,
+): string[] => {
   const result: string[] = [];
 
-  if (tr.historyId) {
+  if (tr.historyHash) {
+    result.push(tr.historyHash);
+  }
+
+  if (tr.historyId && !result.includes(tr.historyId)) {
     result.push(tr.historyId);
   }
 
@@ -60,18 +81,37 @@ export const getHistoryIdCandidates = (tr: Pick<TestResult, "historyId" | "label
   return result;
 };
 
+/**
+ * @deprecated Use {@link getHistoryHashCandidates}.
+ */
+export const getHistoryIdCandidates = getHistoryHashCandidates;
+
+const getHistoryTestResultKeyCandidates = (htr: HistoryTestResult): string[] => {
+  const result: string[] = [];
+
+  if (htr.historyHash) {
+    result.push(htr.historyHash);
+  }
+
+  if (htr.historyId && !result.includes(htr.historyId)) {
+    result.push(htr.historyId);
+  }
+
+  return result;
+};
+
 export const filterUnknownByKnownIssues = (
   trs: TestResult[],
   knownIssueHistoryIds: ReadonlySet<string>,
 ): TestResult[] => {
   return trs.filter((tr) => {
-    const historyIdCandidates = getHistoryIdCandidates(tr);
+    const historyKeyCandidates = getHistoryHashCandidates(tr);
 
-    if (historyIdCandidates.length === 0) {
+    if (historyKeyCandidates.length === 0) {
       return true;
     }
 
-    return historyIdCandidates.every((historyId) => !knownIssueHistoryIds.has(historyId));
+    return historyKeyCandidates.every((historyKey) => !knownIssueHistoryIds.has(historyKey));
   });
 };
 
@@ -120,15 +160,19 @@ export const normalizeHistoryDataPointUrls = (historyDataPoint: HistoryDataPoint
 
 export const selectHistoryTestResults = (
   historyDataPoints: HistoryDataPoint[],
-  historyIdCandidates: readonly string[],
+  historyKeyCandidates: readonly string[],
 ): HistoryTestResult[] => {
-  if (historyIdCandidates.length === 0) {
+  if (historyKeyCandidates.length === 0) {
     return [];
   }
 
   return historyDataPoints.reduce((acc, historyDataPoint) => {
-    for (const historyId of historyIdCandidates) {
-      const historyTestResult = historyDataPoint.testResults?.[historyId];
+    if (!historyDataPoint.testResults) {
+      return acc;
+    }
+
+    for (const historyKey of historyKeyCandidates) {
+      const historyTestResult = historyDataPoint.testResults[historyKey];
 
       if (!historyTestResult) {
         continue;
@@ -149,9 +193,8 @@ export const selectHistoryTestResults = (
  * @returns The history test results array.
  */
 export const htrsByTr = (hdps: HistoryDataPoint[], tr: TestResult | HistoryTestResult): HistoryTestResult[] => {
-  if (!tr?.historyId) {
-    return [];
-  }
+  const candidates =
+    "parameters" in tr ? getHistoryHashCandidates(tr) : getHistoryTestResultKeyCandidates(tr as HistoryTestResult);
 
-  return selectHistoryTestResults(hdps, [tr.historyId]);
+  return selectHistoryTestResults(hdps, candidates);
 };

packages/core/src/history.ts

@@ -17,14 +17,15 @@ import { isFileNotFoundError } from "./utils/misc.js";
 
 const createHistoryItems = (testResults: TestResult[], remoteUrl: string) => {
   return testResults
-    .filter((tr) => tr.historyId)
+    .filter((tr) => tr.historyHash || tr.historyId)
     .map(
       ({
         id,
         name,
         fullName,
         environment,
         historyId,
+        historyHash,
         status,
         error: { message, trace } = {},
         start,
@@ -45,14 +46,21 @@ const createHistoryItems = (testResults: TestResult[], remoteUrl: string) => {
           duration,
           labels,
           url: remoteUrl,
-          historyId: historyId!,
+          historyId,
+          historyHash,
           reportLinks: [],
         } as HistoryTestResult;
       },
     )
     .reduce(
       (acc, item) => {
-        acc[item.historyId!] = item;
+        const historyKey = item.historyHash ?? item.historyId;
+
+        if (!historyKey) {
+          return acc;
+        }
+
+        acc[historyKey] = item;
 
         return acc;
       },

packages/core/src/known.ts

@@ -32,9 +32,9 @@ export const writeKnownIssues = async (store: AllureStore, knownIssuesPath?: str
   const testResults = await store.allTestResults();
   const knownIssues: KnownTestFailure[] = testResults
     .filter((tr) => failedStatuses.has(tr.status))
-    .filter((tr) => tr.historyId)
-    .map(({ historyId, links }) => ({
-      historyId: historyId!,
+    .filter((tr) => tr.historyHash)
+    .map(({ historyHash, links }) => ({
+      historyHash,
       issues: links.filter((l) => l.type === "issue"),
       comment: "automatically generated from failure by allure known-issue command",
     }));

packages/core/src/qualityGate/rules.ts

@@ -7,7 +7,9 @@ export const maxFailuresRule: QualityGateRule<number> = {
   message: ({ actual, expected }) =>
     `The number of failed tests ${bold(String(actual))} exceeds the allowed threshold value ${bold(String(expected))}`,
   validate: async ({ trs, knownIssues, expected, state }) => {
-    const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
+    const knownIssuesHistoryIds = new Set(
+      knownIssues.map(({ historyHash, historyId }) => historyHash ?? historyId).filter((k): k is string => Boolean(k)),
+    );
     const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
     const failedTrs = unknown.filter(filterUnsuccessful);
     const actual = failedTrs.length + (state.getResult() ?? 0);
@@ -42,7 +44,9 @@ export const successRateRule: QualityGateRule<number> = {
   message: ({ actual, expected }) =>
     `Success rate ${bold(String(actual))} is less, than expected ${bold(String(expected))}`,
   validate: async ({ trs, knownIssues, expected }) => {
-    const knownIssuesHistoryIds = new Set(knownIssues.map(({ historyId }) => historyId));
+    const knownIssuesHistoryIds = new Set(
+      knownIssues.map(({ historyHash, historyId }) => historyHash ?? historyId).filter((k): k is string => Boolean(k)),
+    );
     const unknown = filterUnknownByKnownIssues(trs, knownIssuesHistoryIds);
     const passedTrs = unknown.filter(filterSuccessful);
     const rate = passedTrs.length === 0 ? 0 : passedTrs.length / unknown.length;

packages/core/src/report.ts

@@ -594,11 +594,11 @@ export class AllureReport {
       globalAttachmentIds = [],
       globalErrors = [],
       indexAttachmentByTestResult = {},
-      indexTestResultByHistoryId = {},
+      indexTestResultByHistoryHash = {},
       indexTestResultByTestCase = {},
       indexAttachmentByFixture = {},
       indexFixturesByTestResult = {},
-      indexKnownByHistoryId = {},
+      indexKnownByHistoryHash = {},
       qualityGateResults = [],
       testResultIdsIngestOrder = [],
     }: AllureStoreDump): [AllureStoreDumpFiles, unknown][] => [
@@ -612,11 +612,11 @@ export class AllureReport {
       [AllureStoreDumpFiles.GlobalAttachments, globalAttachmentIds],
       [AllureStoreDumpFiles.GlobalErrors, globalErrors],
       [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
-      [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryId],
+      [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryHash],
       [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
       [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
       [AllureStoreDumpFiles.IndexFixturesByTestResult, indexFixturesByTestResult],
-      [AllureStoreDumpFiles.IndexKnownByHistoryId, indexKnownByHistoryId],
+      [AllureStoreDumpFiles.IndexKnownByHistoryId, indexKnownByHistoryHash],
       [AllureStoreDumpFiles.QualityGateResults, qualityGateResults],
       [AllureStoreDumpFiles.TestResultIngestOrder, testResultIdsIngestOrder],
     ];
@@ -812,6 +812,8 @@ export class AllureReport {
                     });
                 }
               }, {});
+              const indexTestResultByHistoryHash = JSON.parse(indexTestResultsByHistoryId.toString("utf8"));
+              const indexKnownByHistoryHash = JSON.parse(indexKnownByHistoryIdEntry.toString("utf8"));
               const dumpState: AllureStoreDump = {
                 testResults: JSON.parse(testResultsEntry.toString("utf8")),
                 testCases: JSON.parse(testCasesEntry.toString("utf8")),
@@ -823,11 +825,13 @@ 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")),
+                indexTestResultByHistoryHash,
+                indexTestResultByHistoryId: indexTestResultByHistoryHash,
                 indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
                 indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
                 indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
-                indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
+                indexKnownByHistoryHash,
+                indexKnownByHistoryId: indexKnownByHistoryHash,
                 qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
                 testResultIdsIngestOrder: testResultIngestOrderEntry
                   ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))