fix cypress origin serialization (fix #1306) (#1360)

Author: todti

packages/allure-cypress/src/browser/runtime.ts

@@ -1,8 +1,8 @@
-import { Status } from "allure-js-commons";
 import type { AttachmentOptions, Label, Link, ParameterMode, ParameterOptions } from "allure-js-commons";
+import { Status } from "allure-js-commons";
 import { getMessageAndTraceFromError } from "allure-js-commons/sdk";
-import { getGlobalTestRuntime, setGlobalTestRuntime } from "allure-js-commons/sdk/runtime";
 import type { TestRuntime } from "allure-js-commons/sdk/runtime";
+import { getGlobalTestRuntime, setGlobalTestRuntime } from "allure-js-commons/sdk/runtime";
 import type { AllureCypressTaskArgs, CypressMessage } from "../types.js";
 import { enqueueRuntimeMessage, getRuntimeMessages, setRuntimeMessages } from "./state.js";
 import { ALLURE_STEP_CMD_SUBJECT, startAllureApiStep, stopCurrentAllureApiStep } from "./steps.js";
@@ -126,7 +126,13 @@ class AllureCypressTestRuntime implements TestRuntime {
     });
   }
 
-  logStep(name: string, status: Status = Status.PASSED, error?: Error) {
+  logStep(name: string, status: Status = Status.PASSED, error?: Error): PromiseLike<void> {
+    if (this.#isInOriginContext()) {
+      startAllureApiStep(name);
+      stopCurrentAllureApiStep(status, error ? getMessageAndTraceFromError(error) : undefined);
+      return Cypress.Promise.resolve();
+    }
+
     return cy
       .wrap(ALLURE_STEP_CMD_SUBJECT, { log: false })
       .then(() => {
@@ -203,4 +209,44 @@ class AllureCypressTestRuntime implements TestRuntime {
     this.#resetMessages();
     return messages;
   }
+
+  #isInOriginContext(): boolean {
+    try {
+      const hasOriginContext = !!(window as any).cypressOriginContext;
+      const hasOriginWindow = !!(window as any).cypressOriginWindow;
+
+      if (hasOriginContext || hasOriginWindow) {
+        return true;
+      }
+
+      const baseUrl = Cypress.config("baseUrl");
+      const currentOrigin = window.location.origin;
+
+      if (baseUrl && currentOrigin !== baseUrl) {
+        return true;
+      }
+
+      const cypressInstance = (window as any).Cypress;
+
+      if (cypressInstance && cypressInstance.state && cypressInstance.state("origin")) {
+        return true;
+      }
+
+      try {
+        const cyExists = typeof cy !== "undefined";
+        const cyTaskExists = typeof cy.task !== "undefined";
+
+        // In cy.origin context, cy.task may not be available or may throw
+        if (!cyExists || !cyTaskExists) {
+          return true;
+        }
+      } catch (error) {
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      return true;
+    }
+  }
 }

packages/allure-cypress/src/browser/serialize.ts

@@ -1,8 +1,43 @@
 import { serialize } from "allure-js-commons/sdk";
 import { getConfig } from "./state.js";
 
-export default (value: unknown) =>
-  isDomObject(value) ? stringifyAsDom(value) : serialize(value, getSerializeOptions());
+export default (value: unknown) => {
+  return isDomObject(value) ? stringifyAsDom(value) : serializeAsObject(value);
+};
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const stripAncestorRefs = (value: unknown, ancestors: object[] = []): unknown => {
+  if (!isPlainObject(value)) {
+    return value;
+  }
+
+  const result: Record<string, unknown> = {};
+  ancestors.push(value);
+
+  for (const [key, prop] of Object.entries(value)) {
+    if (typeof prop === "object" && prop !== null) {
+      if (ancestors.includes(prop)) {
+        continue;
+      }
+      result[key] = stripAncestorRefs(prop, ancestors);
+    } else {
+      result[key] = prop;
+    }
+  }
+
+  ancestors.pop();
+  return result;
+};
+
+export const serializeAsObject = (value: unknown) => {
+  if (isPlainObject(value)) {
+    const cleaned = stripAncestorRefs(value);
+    return serialize({ ...(cleaned as object) }, getSerializeOptions());
+  }
+  return serialize(value, getSerializeOptions());
+};
 
 const getSerializeOptions = () => {
   const {

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

@@ -211,60 +211,46 @@ describe("parameter serialization", () => {
       `,
     });
 
-    expect(tests).toEqual([
-      expect.objectContaining({
-        steps: [
-          expect.objectContaining({
-            parameters: [
-              {
-                name: "Yielded",
-                value: JSON.stringify({}),
-              },
-            ],
-          }),
-          expect.objectContaining({
-            parameters: [
-              {
-                name: "Yielded",
-                value: JSON.stringify({ ref: { foo: {}, bar: {} } }),
-              },
-            ],
-          }),
-          expect.objectContaining({
-            parameters: [
-              {
-                name: "Yielded",
-                value: JSON.stringify({ ref: {} }),
-              },
-            ],
-          }),
-          expect.objectContaining({
-            parameters: [
-              {
-                name: "Yielded",
-                value: `${"A".repeat(128)}...`,
-              },
-            ],
-          }),
-          expect.objectContaining({
-            parameters: [
-              {
-                name: "Yielded",
-                value: `[${String.raw`"A",`.repeat(31)}"A"...`,
-              },
-            ],
-          }),
-          expect.objectContaining({
-            parameters: [
-              {
-                name: "Yielded",
-                value: JSON.stringify({ foo: { bar: { qux: "qut" } } }),
-              },
-            ],
-          }),
-        ],
-      }),
-    ]);
+    expect(tests).toHaveLength(1);
+    const steps = tests[0].steps;
+    expect(steps).toHaveLength(6);
+
+    const [step1, step2, step3, step4, step5, step6] = steps;
+
+    expect(step1).toMatchObject({
+      parameters: [{ name: "Yielded", value: JSON.stringify({}) }],
+    });
+    expect(step1.parameters).toHaveLength(1);
+
+    expect(step2).toMatchObject({
+      parameters: [{ name: "Yielded", value: JSON.stringify({ ref: { foo: {}, bar: {} } }) }],
+    });
+    expect(step2.parameters).toHaveLength(1);
+
+    expect(step3).toMatchObject({
+      parameters: [{ name: "Yielded", value: JSON.stringify({ ref: {} }) }],
+    });
+    expect(step3.parameters).toHaveLength(1);
+
+    expect(step4).toMatchObject({
+      parameters: [{ name: "Yielded", value: `${"A".repeat(128)}...` }],
+    });
+    expect(step4.parameters).toHaveLength(1);
+
+    expect(step5).toMatchObject({
+      parameters: [
+        {
+          name: "Yielded",
+          value: `[${`"A",`.repeat(31)}"A"...`,
+        },
+      ],
+    });
+    expect(step5.parameters).toHaveLength(1);
+
+    expect(step6).toMatchObject({
+      parameters: [{ name: "Yielded", value: JSON.stringify({ foo: { bar: { qux: "qut" } } }) }],
+    });
+    expect(step6.parameters).toHaveLength(1);
   });
 
   it("should take the limits from the config", async () => {
@@ -1021,7 +1007,7 @@ it("should support commands in hooks", async () => {
   ]);
 });
 
-it("should log cy.origin commands correctly in cross-origin testing", async () => {
+it("should log cy.origin commands correctly in cross-origin testing without hanging", async () => {
   issue("1280");
   const { tests } = await runCypressInlineTest({
     "cypress/e2e/sample.cy.js": () => `
@@ -1061,3 +1047,37 @@ it("should log cy.origin commands correctly in cross-origin testing", async () =
     }),
   ]);
 });
+
+it("should not hang when using cy.origin with allure steps", async () => {
+  const { tests } = await runCypressInlineTest({
+    "cypress/e2e/origin-hang-test.cy.js": () => `
+        it("should complete cy.origin without hanging", () => {
+          cy.origin("https://example.com", () => {
+            cy.log("inside origin");
+            cy.wrap("test").should("eq", "test");
+          });
+          cy.log("outside origin");
+        });
+      `,
+  });
+
+  expect(tests).toEqual([
+    expect.objectContaining({
+      name: "should complete cy.origin without hanging",
+      status: Status.PASSED,
+      stage: Stage.FINISHED,
+      steps: [
+        expect.objectContaining({
+          name: "origin https://example.com",
+          status: Status.PASSED,
+          stage: Stage.FINISHED,
+        }),
+        expect.objectContaining({
+          name: "log outside origin",
+          status: Status.PASSED,
+          stage: Stage.FINISHED,
+        }),
+      ],
+    }),
+  ]);
+});