fix mr issues

Author: formaceft-93

packages/allure-codeceptjs/test/spec/runtime/modern/globals.test.ts

@@ -1,7 +1,7 @@
 import { expect, it } from "vitest";
 import { runCodeceptJsInlineTest } from "../../../utils.js";
 
-it("writes globals payload from runtime API calls", async () => {
+it("writes globals payload from scenario body", async () => {
   const { globals, attachments } = await runCodeceptJsInlineTest({
     "login.test.js": `
       const { globalAttachment, globalError } = require("allure-js-commons");
@@ -17,20 +17,66 @@ it("writes globals payload from runtime API calls", async () => {
   const globalsEntries = Object.entries(globals ?? {});
   expect(globalsEntries).toHaveLength(1);
 
-  const [globalsFileName, globalInfo] = globalsEntries[0];
-  expect(globalsFileName).toMatch(/.+-globals\.json/);
-  expect(globalInfo.errors).toEqual([
-    {
-      message: "global setup failed",
-      trace: "stack",
-    },
-  ]);
+  const [, globalInfo] = globalsEntries[0];
+  expect(globalInfo.errors).toEqual(
+    expect.arrayContaining([
+      {
+        message: "global setup failed",
+        trace: "stack",
+      },
+    ]),
+  );
+
+  const scenarioAttachment = globalInfo.attachments.find((a) => a.name === "global-log");
+  expect(scenarioAttachment?.type).toBe("text/plain");
+  const encodedScenarioAttachment = attachments[scenarioAttachment!.source] as string;
+  expect(Buffer.from(encodedScenarioAttachment, "base64").toString("utf-8")).toBe("hello");
+});
+
+it("writes globals payload from suite hooks", async () => {
+  const { globals, attachments } = await runCodeceptJsInlineTest({
+    "login.test.js": `
+      const { globalAttachment, globalError } = require("allure-js-commons");
+
+      Feature("sample-feature");
+      BeforeSuite(async () => {
+        await globalAttachment("before-suite-log", "before", { contentType: "text/plain" });
+      });
+
+      AfterSuite(async () => {
+        await globalError({ message: "after suite error" });
+      });
+
+      Scenario("sample-scenario", async () => {});
+    `,
+  });
+
+  const globalsEntries = Object.entries(globals ?? {});
+  expect(globalsEntries).toHaveLength(1);
+
+  const [, globalInfo] = globalsEntries[0];
+  expect(globalInfo.errors).toEqual(expect.arrayContaining([{ message: "after suite error" }]));
   expect(globalInfo.attachments).toHaveLength(1);
 
-  const [globalAttachmentRef] = globalInfo.attachments;
-  expect(globalAttachmentRef.name).toBe("global-log");
-  expect(globalAttachmentRef.type).toBe("text/plain");
+  const beforeSuiteAttachment = globalInfo.attachments.find((a) => a.name === "before-suite-log");
+  expect(beforeSuiteAttachment?.type).toBe("text/plain");
+  const encodedBeforeSuiteAttachment = attachments[beforeSuiteAttachment!.source] as string;
+  expect(Buffer.from(encodedBeforeSuiteAttachment, "base64").toString("utf-8")).toBe("before");
+});
+
+it("does not collect globals from module scope", async () => {
+  const { globals, stdout } = await runCodeceptJsInlineTest({
+    "login.test.js": `
+      const { globalError } = require("allure-js-commons");
 
-  const encodedAttachment = attachments[globalAttachmentRef.source] as string;
-  expect(Buffer.from(encodedAttachment, "base64").toString("utf-8")).toBe("hello");
+      void globalError({ message: "module scope error" });
+
+      Feature("sample-feature");
+      Scenario("sample-scenario", async () => {});
+    `,
+  });
+
+  const globalsEntries = Object.entries(globals ?? {});
+  expect(globalsEntries).toHaveLength(0);
+  expect(stdout.join("\n")).toContain("no test runtime is found");
 });

packages/allure-cucumberjs/src/reporter.ts

@@ -574,13 +574,13 @@ export default class AllureCucumberReporter extends Formatter {
       return;
     }
 
-    this.allureRuntime.applyRuntimeMessages(undefined, globalMessages);
+    this.allureRuntime.applyGlobalRuntimeMessages(globalMessages);
   }
 
   private onTestRunFinished() {
     this.allureRuntime.writeCategoriesDefinitions();
     this.allureRuntime.writeEnvironmentInfo();
-    this.allureRuntime.writeGlobalInfo();
+    this.allureRuntime.writeGlobals();
   }
 
   private exceptionToError(message?: string, exception?: messages.Exception): Error | undefined {

packages/allure-cucumberjs/test/samples/support/runtime/modern/globals.cjs

@@ -1,14 +1,7 @@
-const { Before } = require("@cucumber/cucumber");
+const { Given } = require("@cucumber/cucumber");
 const { globalAttachment, globalError } = require("allure-js-commons");
 
-let isSent = false;
-
-Before(async () => {
-  if (isSent) {
-    return;
-  }
-
-  isSent = true;
+Given("a passed step", async () => {
   await globalAttachment("global-log", "hello", { contentType: "text/plain" });
   await globalError({ message: "global setup failed", trace: "stack" });
 });

packages/allure-cucumberjs/test/samples/support/runtime/modern/globalsContexts.cjs

@@ -0,0 +1,12 @@
+const { Before, After } = require("@cucumber/cucumber");
+const { globalAttachment, globalError } = require("allure-js-commons");
+
+void globalError({ message: "module scope error" });
+
+Before(async () => {
+  await globalAttachment("before-log", "before", { contentType: "text/plain" });
+});
+
+After(async () => {
+  await globalError({ message: "after hook error" });
+});

packages/allure-cucumberjs/test/spec/runtime/modern/globals.test.ts

@@ -2,7 +2,7 @@ import { expect, it } from "vitest";
 import { runCucumberInlineTest } from "../../../utils.js";
 
 it("writes globals payload from runtime API calls", async () => {
-  const { globals, attachments } = await runCucumberInlineTest(["hooks"], ["hooks", "runtime/modern/globals"], {
+  const { globals, attachments } = await runCucumberInlineTest(["hooks"], ["runtime/modern/globals"], {
     parallel: false,
   });
 
@@ -26,3 +26,32 @@ it("writes globals payload from runtime API calls", async () => {
   const encodedAttachment = attachments[globalAttachmentRef.source] as string;
   expect(Buffer.from(encodedAttachment, "base64").toString("utf-8")).toBe("hello");
 });
+
+it("supports globals from hooks", async () => {
+  const { globals, attachments } = await runCucumberInlineTest(["hooks"], ["hooks", "runtime/modern/globalsContexts"], {
+    parallel: false,
+  });
+
+  const globalsEntries = Object.entries(globals ?? {});
+  expect(globalsEntries).toHaveLength(1);
+
+  const [, globalInfo] = globalsEntries[0];
+  expect(globalInfo.errors).toEqual(expect.arrayContaining([{ message: "after hook error" }]));
+
+  const beforeAttachmentRef = globalInfo.attachments.find((a) => a.name === "before-log");
+  expect(beforeAttachmentRef?.type).toBe("text/plain");
+  const encodedAttachment = attachments[beforeAttachmentRef!.source] as string;
+  expect(Buffer.from(encodedAttachment, "base64").toString("utf-8")).toBe("before");
+});
+
+it("does not collect globals from support module scope", async () => {
+  const { globals } = await runCucumberInlineTest(["hooks"], ["hooks", "runtime/modern/globalsContexts"], {
+    parallel: false,
+  });
+
+  const globalsEntries = Object.entries(globals ?? {});
+  expect(globalsEntries).toHaveLength(1);
+
+  const [, globalInfo] = globalsEntries[0];
+  expect(globalInfo.errors).not.toEqual(expect.arrayContaining([{ message: "module scope error" }]));
+});

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

@@ -146,6 +146,18 @@ class AllureCypressTestRuntime implements TestRuntime {
     });
   }
 
+  globalAttachmentFromPath(name: string, path: string, options: Omit<AttachmentOptions, "encoding">) {
+    return this.#enqueueMessageAsync({
+      type: "global_attachment_path",
+      data: {
+        name,
+        path,
+        contentType: options.contentType,
+        fileExtension: options.fileExtension,
+      },
+    });
+  }
+
   globalError(details: StatusDetails) {
     return this.#enqueueMessageAsync({
       type: "global_error",

packages/allure-cypress/src/reporter.ts

@@ -139,7 +139,7 @@ export class AllureCypress {
     this.#endAllSpecs();
     this.allureRuntime.writeEnvironmentInfo();
     this.allureRuntime.writeCategoriesDefinitions();
-    this.allureRuntime.writeGlobalInfo();
+    this.allureRuntime.writeGlobals();
   };
 
   endSpec = (specAbsolutePath: string, cypressVideoPath?: string) => {
@@ -464,6 +464,10 @@ export class AllureCypress {
     if (!rootUuid && !isGlobalRuntimeMessage(message)) {
       return;
     }
+    if (!rootUuid) {
+      this.allureRuntime.applyGlobalRuntimeMessages([message]);
+      return;
+    }
     this.allureRuntime.applyRuntimeMessages(rootUuid, [message]);
   };
 

packages/allure-jasmine/src/index.ts

@@ -84,6 +84,10 @@ export default class AllureJasmineReporter implements jasmine.CustomReporter {
     if (!rootUuid && !isGlobalRuntimeMessage(message)) {
       return;
     }
+    if (!rootUuid) {
+      this.allureRuntime.applyGlobalRuntimeMessages([message]);
+      return;
+    }
     this.allureRuntime.applyRuntimeMessages(rootUuid, [message]);
   }
 
@@ -204,7 +208,7 @@ export default class AllureJasmineReporter implements jasmine.CustomReporter {
   jasmineDone(): void {
     this.allureRuntime.writeEnvironmentInfo();
     this.allureRuntime.writeCategoriesDefinitions();
-    this.allureRuntime.writeGlobalInfo();
+    this.allureRuntime.writeGlobals();
     // write global container (or any remaining scopes)
     this.scopesStack.forEach((scopeUuid) => {
       this.allureRuntime.writeScope(scopeUuid);

packages/allure-jasmine/test/spec/runtime/modern/globals.test.ts

@@ -37,3 +37,41 @@ it("writes globals payload from runtime API calls", async () => {
   const encodedAttachment = attachments[globalAttachmentRef.source] as string;
   expect(Buffer.from(encodedAttachment, "base64").toString("utf-8")).toBe("hello");
 });
+
+it("collects globals from setup-only file without tests", async () => {
+  const { globals, attachments } = await runJasmineInlineTest({
+    "spec/test/sample.spec.js": `
+      const { writeFileSync } = require("node:fs");
+      const { join } = require("node:path");
+      const { globalAttachment, globalAttachmentPath, globalError } = require("allure-js-commons");
+
+      const filePath = join(process.cwd(), "setup-only.log");
+      writeFileSync(filePath, "from-path", "utf8");
+
+      void globalAttachment("setup-inline-log", "from-inline", { contentType: "text/plain" });
+      void globalAttachmentPath("setup-file-log", filePath, { contentType: "text/plain" });
+      void globalError({ message: "setup-only error", trace: "setup stack" });
+    `,
+  });
+
+  const globalsEntries = Object.entries(globals ?? {});
+  expect(globalsEntries).toHaveLength(1);
+
+  const [, globalInfo] = globalsEntries[0];
+  expect(globalInfo.errors).toEqual(
+    expect.arrayContaining([
+      {
+        message: "setup-only error",
+        trace: "setup stack",
+      },
+    ]),
+  );
+
+  const inlineRef = globalInfo.attachments.find((a) => a.name === "setup-inline-log");
+  const pathRef = globalInfo.attachments.find((a) => a.name === "setup-file-log");
+
+  expect(inlineRef?.type).toBe("text/plain");
+  expect(pathRef?.type).toBe("text/plain");
+  expect(Buffer.from(attachments[inlineRef!.source] as string, "base64").toString("utf-8")).toBe("from-inline");
+  expect(Buffer.from(attachments[pathRef!.source] as string, "base64").toString("utf-8")).toBe("from-path");
+});

packages/allure-jest/src/environmentFactory.ts

@@ -79,7 +79,10 @@ const createJestEnvironment = <T extends typeof JestEnvironment>(Base: T): T =>
       if (!executableUuid && !isGlobalRuntimeMessage(message)) {
         return;
       }
-
+      if (!executableUuid) {
+        this.runtime.applyGlobalRuntimeMessages([message]);
+        return;
+      }
       this.runtime.applyRuntimeMessages(executableUuid, [message]);
     }
 
@@ -362,7 +365,7 @@ const createJestEnvironment = <T extends typeof JestEnvironment>(Base: T): T =>
     #handleRunFinish() {
       this.runtime.writeEnvironmentInfo();
       this.runtime.writeCategoriesDefinitions();
-      this.runtime.writeGlobalInfo();
+      this.runtime.writeGlobals();
     }
 
     #currentExecutable() {