chore: retry logic redo

Author: vdvukhzhilov

packages/cli/src/commands/commons/run.ts

@@ -330,7 +330,7 @@ export const executeAllureRun = async (params: {
       logTests(await allureReport.store.allTestResults());
     }
 
-    const trs = await allureReport.store.allTestResults({ includeHidden: false });
+    const trs = await allureReport.store.allTestResults({ includeRetries: false });
     qualityGateResults = testProcessResult?.qualityGateResults ?? [];
 
     if (withQualityGate && !qualityGateResults.length) {

packages/cli/src/commands/qualityGate.ts

@@ -153,9 +153,9 @@ export class QualityGateCommand extends Command {
 
     allureReport.realtimeSubscriber.onTestResults(async (trsIds) => {
       const trs = await Promise.all(trsIds.map((id) => allureReport.store.testResultById(id)));
-      const notHiddenTrs = (trs as TestResult[]).filter((tr) => !tr.hidden);
+      const nonRetryTrs = (trs as TestResult[]).filter((tr) => !tr.isRetry);
       const { results, fastFailed } = await allureReport.validate({
-        trs: notHiddenTrs,
+        trs: nonRetryTrs,
         environment: resolvedEnvironment?.id,
         knownIssues,
         state,
@@ -179,7 +179,7 @@ export class QualityGateCommand extends Command {
 
     await allureReport.done();
 
-    const allTrs = await allureReport.store.allTestResults({ includeHidden: false });
+    const allTrs = await allureReport.store.allTestResults({ includeRetries: false });
     const validationResults = await allureReport.validate({
       trs: allTrs,
       knownIssues,

packages/core-api/src/model.ts

@@ -62,7 +62,8 @@ export interface TestResult {
 
   transition?: TestStatusTransition;
 
-  hidden: boolean;
+  retryHash?: string;
+  isRetry: boolean;
 
   hostId?: string;
   threadId?: string;

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

@@ -86,7 +86,7 @@ describe("history utils", () => {
         flaky: false,
         muted: false,
         known: false,
-        hidden: false,
+        isRetry: false,
         links: [],
         steps: [],
         sourceMetadata: { readerId: "", metadata: {} },
@@ -101,7 +101,7 @@ describe("history utils", () => {
         flaky: false,
         muted: false,
         known: false,
-        hidden: false,
+        isRetry: false,
         links: [],
         steps: [],
         sourceMetadata: { readerId: "", metadata: {} },

packages/core/src/report.ts

@@ -405,11 +405,11 @@ export class AllureReport {
       indexAttachmentByTestResult = {},
       indexTestResultByHistoryId = {},
       indexTestResultByTestCase = {},
-      indexLatestEnvTestResultByHistoryId = {},
       indexAttachmentByFixture = {},
       indexFixturesByTestResult = {},
       indexKnownByHistoryId = {},
       qualityGateResults = [],
+      testResultIdsIngestOrder = [],
     }: AllureStoreDump): [AllureStoreDumpFiles, unknown][] => [
       [AllureStoreDumpFiles.TestResults, testResults],
       [AllureStoreDumpFiles.TestCases, testCases],
@@ -423,11 +423,11 @@ export class AllureReport {
       [AllureStoreDumpFiles.IndexAttachmentsByTestResults, indexAttachmentByTestResult],
       [AllureStoreDumpFiles.IndexTestResultsByHistoryId, indexTestResultByHistoryId],
       [AllureStoreDumpFiles.IndexTestResultsByTestCase, indexTestResultByTestCase],
-      [AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId, indexLatestEnvTestResultByHistoryId],
       [AllureStoreDumpFiles.IndexAttachmentsByFixture, indexAttachmentByFixture],
       [AllureStoreDumpFiles.IndexFixturesByTestResult, indexFixturesByTestResult],
       [AllureStoreDumpFiles.IndexKnownByHistoryId, indexKnownByHistoryId],
       [AllureStoreDumpFiles.QualityGateResults, qualityGateResults],
+      [AllureStoreDumpFiles.TestResultIngestOrder, testResultIdsIngestOrder],
     ];
     let dumpError: unknown;
 
@@ -564,9 +564,6 @@ export class AllureReport {
           const indexTestResultsByTestCaseEntry = await requiredEntryData(
             AllureStoreDumpFiles.IndexTestResultsByTestCase,
           );
-          const indexLatestEnvTestResultsByHistoryIdEntry = await requiredEntryData(
-            AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId,
-          );
           const indexAttachmentsByFixtureEntry = await requiredEntryData(
             AllureStoreDumpFiles.IndexAttachmentsByFixture,
           );
@@ -575,6 +572,7 @@ export class AllureReport {
           );
           const indexKnownByHistoryIdEntry = await requiredEntryData(AllureStoreDumpFiles.IndexKnownByHistoryId);
           const qualityGateResultsEntry = await requiredEntryData(AllureStoreDumpFiles.QualityGateResults);
+          const testResultIngestOrderEntry = await optionalEntryData(AllureStoreDumpFiles.TestResultIngestOrder);
           const attachmentsLinks = JSON.parse(attachmentsEntry.toString("utf8")) as AllureStoreDump["attachments"];
 
           const attachmentsEntries = dumpEntriesList.reduce((acc, [entryName, entry]) => {
@@ -591,11 +589,11 @@ export class AllureReport {
               case AllureStoreDumpFiles.IndexAttachmentsByTestResults:
               case AllureStoreDumpFiles.IndexTestResultsByHistoryId:
               case AllureStoreDumpFiles.IndexTestResultsByTestCase:
-              case AllureStoreDumpFiles.IndexLatestEnvTestResultsByHistoryId:
               case AllureStoreDumpFiles.IndexAttachmentsByFixture:
               case AllureStoreDumpFiles.IndexFixturesByTestResult:
               case AllureStoreDumpFiles.IndexKnownByHistoryId:
               case AllureStoreDumpFiles.QualityGateResults:
+              case AllureStoreDumpFiles.TestResultIngestOrder:
                 return acc;
               default:
                 if (entry.isDirectory || !attachmentsLinks[entryName] || attachmentsLinks[entryName].missed) {
@@ -620,11 +618,13 @@ export class AllureReport {
             indexAttachmentByTestResult: JSON.parse(indexAttachmentsEntry.toString("utf8")),
             indexTestResultByHistoryId: JSON.parse(indexTestResultsByHistoryId.toString("utf8")),
             indexTestResultByTestCase: JSON.parse(indexTestResultsByTestCaseEntry.toString("utf8")),
-            indexLatestEnvTestResultByHistoryId: JSON.parse(indexLatestEnvTestResultsByHistoryIdEntry.toString("utf8")),
             indexAttachmentByFixture: JSON.parse(indexAttachmentsByFixtureEntry.toString("utf8")),
             indexFixturesByTestResult: JSON.parse(indexFixturesByTestResultEntry.toString("utf8")),
             indexKnownByHistoryId: JSON.parse(indexKnownByHistoryIdEntry.toString("utf8")),
             qualityGateResults: JSON.parse(qualityGateResultsEntry.toString("utf8")),
+            testResultIdsIngestOrder: testResultIngestOrderEntry
+              ? JSON.parse(testResultIngestOrderEntry.toString("utf8"))
+              : [],
           };
           const dumpTempDir = await mkdtemp(join(tmpdir(), basename(dump, ".zip")));
           const resultsAttachments: Record<string, ResultFile> = {};

packages/core/src/store/convert.ts

@@ -104,7 +104,7 @@ export const testResultRawToState = (stateData: StateData, raw: RawTestResult, c
     flaky: raw.flaky ?? false,
     muted: raw.muted ?? false,
     known: raw.known ?? false,
-    hidden: false,
+    isRetry: false,
 
     labels,
     steps: convertSteps(stateData, raw.steps).convertedSteps,

packages/core/src/store/retrySubstore.ts

@@ -0,0 +1,126 @@
+import type { TestParameter, TestResult } from "@allurereport/core-api";
+
+import { md5 } from "../utils/crypto.js";
+
+const NO_RETRIES: TestResult[] = [];
+
+const compareByNameThenValue = (first: TestParameter, second: TestParameter) =>
+  first.name.localeCompare(second.name) || first.value.localeCompare(second.value);
+
+const stringifyRetryParameters = (parameters: TestParameter[] = []): string =>
+  parameters
+    .filter((parameter) => !parameter.excluded)
+    .sort(compareByNameThenValue)
+    .map((parameter) => `${parameter.name}:${parameter.value}`)
+    .join(",");
+
+export const calculateParametersHash = (parameters: TestParameter[] = []): string =>
+  md5(stringifyRetryParameters(parameters));
+
+export const calculateRetryHash = (
+  testCaseId: string | undefined,
+  parametersHash: string,
+  environmentId: string | undefined,
+): string | undefined => {
+  if (!testCaseId) {
+    return undefined;
+  }
+
+  return md5(`${testCaseId}:${parametersHash}:${environmentId ?? "default"}`);
+};
+
+export class RetrySubstore {
+  readonly #testResultsByRetryHash = new Map<string, TestResult[]>();
+  readonly #testResultIngestIndexById = new Map<string, number>();
+
+  recordIngestOrder(testResultId: string) {
+    if (this.#testResultIngestIndexById.has(testResultId)) {
+      return;
+    }
+
+    this.#testResultIngestIndexById.set(testResultId, this.#testResultIngestIndexById.size);
+  }
+
+  restoreIngestOrder(restoredIds: string[] | undefined, hasTestResult: (testResultId: string) => boolean) {
+    this.#testResultIngestIndexById.clear();
+
+    for (const id of restoredIds ?? []) {
+      if (!hasTestResult(id) || this.#testResultIngestIndexById.has(id)) {
+        continue;
+      }
+
+      this.#testResultIngestIndexById.set(id, this.#testResultIngestIndexById.size);
+    }
+  }
+
+  ingestOrderIdsForDump(): string[] {
+    return Array.from(this.#testResultIngestIndexById.keys());
+  }
+
+  #getIngestIndex(testResultId: string): number {
+    return this.#testResultIngestIndexById.get(testResultId) ?? -1;
+  }
+
+  #compareResults(first: TestResult, second: TestResult): -1 | 0 | 1 {
+    const firstHasStart = typeof first.start === "number";
+    const secondHasStart = typeof second.start === "number";
+
+    if (firstHasStart !== secondHasStart) {
+      return firstHasStart ? 1 : -1;
+    }
+
+    if (firstHasStart && secondHasStart && first.start !== second.start) {
+      return first.start! > second.start! ? -1 : 1;
+    }
+
+    const indexA = this.#getIngestIndex(first.id);
+    const indexB = this.#getIngestIndex(second.id);
+
+    if (indexA !== indexB) {
+      return indexA > indexB ? -1 : 1;
+    }
+
+    return 0;
+  }
+
+  upsert(testResult: TestResult) {
+    testResult.isRetry = false;
+
+    if (!testResult.retryHash) {
+      return;
+    }
+
+    const results = this.#testResultsByRetryHash.get(testResult.retryHash);
+
+    if (!results) {
+      this.#testResultsByRetryHash.set(testResult.retryHash, [testResult]);
+      return;
+    }
+
+    results.push(testResult);
+    results.sort((first, second) => this.#compareResults(first, second));
+
+    results.forEach((attempt, index) => {
+      attempt.isRetry = index !== 0;
+    });
+  }
+
+  retriesByTr(testResult: TestResult): TestResult[] {
+    if (!testResult.retryHash || testResult.isRetry) {
+      return NO_RETRIES;
+    }
+
+    const attempts = this.#testResultsByRetryHash.get(testResult.retryHash) ?? [];
+    const index = attempts.findIndex((attempt) => attempt.id === testResult.id);
+
+    if (index !== 0) {
+      return NO_RETRIES;
+    }
+
+    return attempts.slice(1);
+  }
+
+  reset() {
+    this.#testResultsByRetryHash.clear();
+  }
+}