fix(allure-cypress): don't reset spec context on duplicate cypress_run_start

When a spec navigates to a cross-origin URL via cy.visit, Cypress can
re-initialise the browser-side support code in the secondary origin
context. If the Allure env is not yet present there, initializeAllure()
re-registers Mocha event listeners and the Mocha runner fires another
"start" event, which enqueues a second cypress_run_start message for
the same spec path.

Previously #startRun always called #initializeSpecContext, throwing
away the live context and all accumulated test state. This left
in-progress tests without a corresponding stop message, resulting in
duplicate or pending/skipped result files in the Allure report even
though the tests actually passed in Cypress.

Fix: skip re-initialisation when the context already exists.  In
cypress open the spec context is deleted by endSpec before the user
can trigger a re-run, so the guard does not affect that mode.

Fixes: #1329

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: todti

packages/allure-cypress/src/reporter.ts

@@ -219,12 +219,19 @@ export class AllureCypress {
   };
 
   #startRun = (absolutePath: string) => {
-    // This function is executed once on `cypress run`, but it can be executed
-    // multiple times during an interactive session (`cypress open`). Ideally,
-    // in that case, we should remove previous result objects that haven't been
-    // written yet, but it would've required support in ReporterRuntime.
-    // Currently, we're discarding the entire spec context.
-    this.#initializeSpecContext(absolutePath);
+    // In `cypress run` this fires exactly once per spec. In `cypress open`
+    // it may fire again when the user re-runs a spec; by then `endSpec` has
+    // already deleted the context, so the `has` check is false and we start
+    // fresh as expected.
+    // If a spec triggers a secondary browser context (e.g. cross-origin
+    // cy.visit), Cypress may re-fire the Mocha "start" event mid-run, sending
+    // a second cypress_run_start for the same spec path while the first
+    // context is still live. Reinitialising in that case would discard all
+    // in-progress state and produce duplicate / pending result files, so we
+    // skip the initialisation when the context already exists.
+    if (!this.specContextByAbsolutePath.has(absolutePath)) {
+      this.#initializeSpecContext(absolutePath);
+    }
   };
 
   #startSuite = (context: SpecContext, { data: { id, name, root } }: CypressSuiteStartMessage) => {

packages/allure-cypress/test/spec/doubleRunStart.test.ts

@@ -0,0 +1,93 @@
+import { Stage, Status } from "allure-js-commons";
+import { InMemoryWriter, ReporterRuntime } from "allure-js-commons/sdk/reporter";
+import { expect, it } from "vitest";
+
+import { AllureCypress } from "../../src/reporter.js";
+import type { AllureCypressTaskArgs, CypressMessage } from "../../src/types.js";
+
+const SPEC_PATH = "/cypress/e2e/sample.cy.js";
+
+const makeReporter = () => {
+  const writer = new InMemoryWriter();
+  const reporter = new AllureCypress({});
+  reporter.allureRuntime = new ReporterRuntime({ writer });
+  return { reporter, writer };
+};
+
+const captureTaskHandlers = (reporter: AllureCypress) => {
+  const tasks: Record<string, (args: AllureCypressTaskArgs) => null> = {};
+  reporter.attachToCypress(((event: string, handlers: Record<string, (args: AllureCypressTaskArgs) => null>) => {
+    if (event === "task") {
+      Object.assign(tasks, handlers);
+    }
+  }) as any);
+  return tasks;
+};
+
+const sendMessages = (
+  tasks: Record<string, (args: AllureCypressTaskArgs) => null>,
+  messages: CypressMessage[],
+  { isFinal = false } = {},
+) => {
+  const args: AllureCypressTaskArgs = { absolutePath: SPEC_PATH, messages, isInteractive: false };
+  if (isFinal) {
+    tasks.reportFinalAllureCypressSpecMessages(args);
+  } else {
+    tasks.reportAllureCypressSpecMessages(args);
+  }
+};
+
+const makeRunMessages = (): CypressMessage[] => [
+  { type: "cypress_run_start", data: {} },
+  { type: "cypress_suite_start", data: { id: "root", name: "", root: true, start: 0 } },
+  { type: "cypress_suite_start", data: { id: "s1", name: "Suite", root: false, start: 0 } },
+];
+
+const makeTestMessages = (name: string): CypressMessage[] => [
+  { type: "cypress_test_start", data: { name, fullNameSuffix: name, start: 0, labels: [] } },
+  { type: "cypress_test_pass", data: {} },
+  { type: "cypress_test_end", data: { duration: 1, retries: 0 } },
+];
+
+const makeEndMessages = (): CypressMessage[] => [
+  { type: "cypress_suite_end", data: { root: false, stop: 1 } },
+  { type: "cypress_suite_end", data: { root: true, stop: 1 } },
+];
+
+it("preserves spec context when cypress_run_start is received a second time", () => {
+  const { reporter } = makeReporter();
+  const tasks = captureTaskHandlers(reporter);
+
+  sendMessages(tasks, makeRunMessages());
+
+  const contextAfterFirstStart = reporter.specContextByAbsolutePath.get(SPEC_PATH);
+  expect(contextAfterFirstStart).toBeDefined();
+
+  // Simulate a second cypress_run_start for the same spec (e.g. from a cross-origin cy.visit
+  // causing the browser-side support code to re-initialise mid-run).
+  sendMessages(tasks, [{ type: "cypress_run_start", data: {} }]);
+
+  const contextAfterSecondStart = reporter.specContextByAbsolutePath.get(SPEC_PATH);
+  expect(contextAfterSecondStart).toBe(contextAfterFirstStart);
+});
+
+it("produces exactly the expected test results when cypress_run_start is duplicated mid-run", () => {
+  const { reporter, writer } = makeReporter();
+  const tasks = captureTaskHandlers(reporter);
+
+  // Batch 1: run starts, first test runs and completes.
+  sendMessages(tasks, [...makeRunMessages(), ...makeTestMessages("test one")]);
+
+  // Batch 2: spurious second cypress_run_start (cross-origin scenario), then second test.
+  sendMessages(tasks, [{ type: "cypress_run_start", data: {} }, ...makeTestMessages("test two"), ...makeEndMessages()]);
+
+  // Finalise (non-interactive: endSpec is called via after:spec, simulate it directly).
+  reporter.endSpec(SPEC_PATH);
+
+  expect(writer.tests).toHaveLength(2);
+  for (const test of writer.tests) {
+    expect(test.status).toBe(Status.PASSED);
+    expect(test.stage).toBe(Stage.FINISHED);
+  }
+  expect(writer.tests.map((t) => t.name)).toEqual(expect.arrayContaining(["test one", "test two"]));
+});