Fix playwright runtime metadata messages processing (#1327)

Author: epszaw

packages/allure-playwright/src/index.ts

@@ -1,3 +1,4 @@
+/* eslint max-lines: off */
 import type { FullConfig } from "@playwright/test";
 import type { TestResult as PlaywrightTestResult, Suite, TestCase, TestStep } from "@playwright/test/reporter";
 import { existsSync } from "node:fs";
@@ -304,7 +305,9 @@ export class AllureReporter implements ReporterV2 {
 
       if (["test.attach", "attach"].includes(step.category)) {
         stack.startStep(baseStep);
+
         const attachStack = isBeforeHookDescendant ? this.beforeHooksAttachmentsStack : this.afterHooksAttachmentsStack;
+
         stack.updateStep((stepResult) => {
           stepResult.name = normalizeHookTitle(stepResult.name!);
           stepResult.stage = Stage.FINISHED;
@@ -432,12 +435,19 @@ export class AllureReporter implements ReporterV2 {
         .map((hookStep) => normalizeHookTitle(hookStep.title))
         .filter(Boolean),
     );
+    const hookAttachmentNames = new Set(
+      [...attachmentsInBeforeHooks, ...attachmentsInAfterHooks]
+        .map((hookStep) => normalizeHookTitle(hookStep.title))
+        .filter(Boolean),
+    );
     const attachmentSteps = this.attachmentSteps.get(testUuid) ?? [];
     const attachmentsInSteps = result.attachments.filter((attachment) => !hookAttachmentUuids.has(attachment.name));
+    const onlyHooksAttachments = result.attachments.filter((att) => hookAttachmentNames.has(att.name));
 
     for (let i = 0; i < attachmentsInSteps.length; i++) {
       const attachment = attachmentsInSteps[i];
       const attachmentStep = attachmentSteps.length > i ? attachmentSteps[i] : undefined;
+
       await this.processAttachment(testUuid, attachmentStep, attachment);
     }
 
@@ -468,13 +478,6 @@ export class AllureReporter implements ReporterV2 {
     // FIXME: temp logic for labels override, we need it here to keep the reporter compatible with v2 API
     // in next iterations we need to implement the logic for every javascript integration
 
-    const hookAttachmentNames = new Set(
-      [...attachmentsInBeforeHooks, ...attachmentsInAfterHooks]
-        .map((hookStep) => normalizeHookTitle(hookStep.title))
-        .filter(Boolean),
-    );
-    const onlyHooksAttachments = result.attachments.filter((att) => hookAttachmentNames.has(att.name));
-
     for (const attachment of onlyHooksAttachments) {
       const matchingBeforeHookStep = attachmentsInBeforeHooks.find(
         (step) => normalizeHookTitle(step.title) === attachment.name,
@@ -485,6 +488,11 @@ export class AllureReporter implements ReporterV2 {
       const targetStack = matchingBeforeHookStep ? beforeHooksStack : afterHooksStack;
       const hookStep = matchingBeforeHookStep || matchingAfterHookStep;
 
+      if (attachment.contentType === ALLURE_RUNTIME_MESSAGE_CONTENT_TYPE) {
+        await this.processAttachment(testUuid, hookStep?.uuid, attachment);
+        continue;
+      }
+
       if (targetStack && hookStep) {
         const stepResult = targetStack?.findStepByUuid(hookStep?.uuid);
         if (stepResult) {
@@ -497,6 +505,7 @@ export class AllureReporter implements ReporterV2 {
         }
       }
     }
+
     this.allureRuntime!.updateTest(testUuid, (testResult) => {
       const mappedLabels = testResult.labels.reduce<Record<string, Label[]>>((acc, label) => {
         if (!acc[label.name]) {
@@ -533,7 +542,6 @@ export class AllureReporter implements ReporterV2 {
 
       testResult.labels = newLabels;
     });
-
     this.allureRuntime!.stopTest(testUuid, { duration: result.duration });
     this.allureRuntime!.writeTest(testUuid);
   }

packages/allure-playwright/test/spec/hooks.spec.ts

@@ -179,24 +179,27 @@ it("keeps correct hooks structure when something failed", async () => {
 it("should hook steps have attachments", async () => {
   const results = await runPlaywrightInlineTest({
     "sample.test.js": `
-        const {test} = require("@playwright/test");
+        const { test } = require("@playwright/test");
         const allure = require("allure-js-commons");
+
         test.beforeAll(async () => {
-            await allure.attachment('attachment outside step beforeAll', 'test value', 'application/json');
-            await allure.step('i am beforeAll step', async () => {
-                await allure.attachment('attachment in beforeAll step', 'test value', 'application/json');
-            });
+          await allure.attachment('attachment outside step beforeAll', 'test value', 'application/json');
+          await allure.step('i am beforeAll step', async () => {
+            await allure.attachment('attachment in beforeAll step', 'test value', 'application/json');
+          });
         });
+
         test.afterAll(async () => {
-            await allure.attachment('attachment outside step afterAll', 'test value', 'application/json');
-            await allure.step('i am afterAll', async () => {
-                await allure.attachment('test key afterall', 'test value', 'application/json');
-            });
+          await allure.attachment('attachment outside step afterAll', 'test value', 'application/json');
+          await allure.step('i am afterAll', async () => {
+            await allure.attachment('test key afterall', 'test value', 'application/json');
+          });
         });
+
         test("sample test", async () => {
-            await allure.step("step 1", async () => {
-                await allure.attachment('attach in step 1', 'test value', 'application/json');
-            });
+          await allure.step("step 1", async () => {
+            await allure.attachment('attach in step 1', 'test value', 'application/json');
+          });
         });
     `,
     "playwright.config.js": `
@@ -222,11 +225,13 @@ it("should hook steps have attachments", async () => {
     `,
   });
   const steps = results.tests[0].steps;
+
   expect(steps).toHaveLength(3);
+
   const beforeHooks = steps[0];
   const beforeAllHook = beforeHooks.steps[0];
-  expect(beforeAllHook.name).equal("beforeAll hook");
 
+  expect(beforeAllHook.name).equal("beforeAll hook");
   expect(beforeAllHook.steps).toEqual([
     expect.objectContaining({
       name: "attachment outside step beforeAll",
@@ -254,8 +259,8 @@ it("should hook steps have attachments", async () => {
   ]);
 
   const step1Attachment = steps[1];
-  expect(step1Attachment.name).toEqual("step 1");
 
+  expect(step1Attachment.name).toEqual("step 1");
   expect(step1Attachment.steps).toEqual([
     expect.objectContaining({
       name: "attach in step 1",
@@ -269,6 +274,7 @@ it("should hook steps have attachments", async () => {
   ]);
 
   const afterHooks = steps[2];
+
   expect(afterHooks.steps[0].steps).toEqual([
     expect.objectContaining({
       name: "attachment outside step afterAll",
@@ -295,3 +301,69 @@ it("should hook steps have attachments", async () => {
     }),
   ]);
 });
+
+it("should not loose tests metadata when when there are hooks in the test", async () => {
+  const results = await runPlaywrightInlineTest({
+    "sample.test.js": `
+       import test from '@playwright/test';
+       import * as allure from "allure-js-commons";
+
+       test.beforeAll(async () => {
+         await allure.label("hook", "1");
+       });
+
+       test.beforeEach(async () => {
+         await allure.label("hook", "2");
+       });
+
+       test.afterAll(async () => {
+         await allure.label("hook", "3");
+       });
+
+       test.afterEach(async () => {
+         await allure.label("hook", "4");
+       });
+
+       test("should contain label", async ({ page }) => {
+         await allure.label("hook", "5");
+       });
+     `,
+  });
+
+  expect(results.tests).toHaveLength(1);
+  expect(results.tests[0].labels).toEqual(
+    expect.arrayContaining([
+      {
+        name: "hook",
+        value: "1",
+      },
+      {
+        name: "hook",
+        value: "2",
+      },
+      {
+        name: "hook",
+        value: "3",
+      },
+      {
+        name: "hook",
+        value: "4",
+      },
+      {
+        name: "hook",
+        value: "5",
+      },
+    ]),
+  );
+  expect(results.tests[0].steps).toHaveLength(2);
+  expect(results.tests[0].steps).toEqual(
+    expect.arrayContaining([
+      expect.objectContaining({
+        name: "Before Hooks",
+      }),
+      expect.objectContaining({
+        name: "After Hooks",
+      }),
+    ]),
+  );
+});