improved BeforeStep/AfterStep logging and fixed BeforeAll/AfterAll behavior (#21)

improved BeforeStep/AfterStep logging and fixed BeforeAll/AfterAll behavior

Author: AlexGalichenko

CHANGELOG.md

@@ -10,6 +10,10 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 :pencil: - chore
 :microscope: - experimental
 
+## [1.1.0]
+- :rocket: improved BeforeStep/AfterStep logging
+- :beetle: fixed BeforeAll/AfterAll behavior
+
 ## [1.0.1]
 - :pencil: updated dependencies
 - :rocket: renamed adapter spec to cucumber.spec.ts

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@qavajs/playwright-runner-adapter",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "adapter for playwright test runner",
   "scripts": {
     "build": "tsc",
@@ -16,7 +16,7 @@
   "devDependencies": {
     "@cucumber/cucumber": "^11.1.1",
     "@playwright/test": "^1.49.1",
-    "@types/node": "^22.10.2",
+    "@types/node": "^22.10.5",
     "typescript": "^5.7.2"
   }
 }

package.json

@@ -15,15 +15,13 @@ function attach(this: { test: any }, body: any, details: any) {
 const fixture = new supportCodeLibrary.World({});
 const test = fixture.test;
 
+for (const beforeAllHook of supportCodeLibrary.beforeTestRunHookDefinitions) {
+    test.beforeAll(() => beforeAllHook.code.apply({}));
+}
+
 for (const feature of features) {
     const tests = feature.tests;
     test.describe(feature.feature as string, async () => {
-        for (const beforeAllHook of supportCodeLibrary.beforeTestRunHookDefinitions) {
-            test.beforeAll(async () => {
-                await beforeAllHook.code.apply({});
-            });
-        }
-
         const world = new supportCodeLibrary.World({
             log,
             attach,
@@ -39,28 +37,26 @@ for (const feature of features) {
                 for (const beforeHook of supportCodeLibrary.beforeTestCaseHookDefinitions) {
                     if (beforeHook.appliesToTestCase(testCase)) {
                         const hookName = beforeHook.name ?? 'Before';
-                        await test.step(hookName, async () => {
-                            await beforeHook.code.apply(world, [{
-                                pickle: testCase
-                            }]);
-                        });
+                        await test.step(hookName, () => beforeHook.code.apply(world, [{
+                            pickle: testCase
+                        }]));
                     }
                 }
                 for (const pickleStep of testCase.steps) {
                     await test.step(pickleStep.text, async () => {
                         for (const beforeStep of supportCodeLibrary.beforeTestStepHookDefinitions) {
                             if (beforeStep.appliesToTestCase(testCase)) {
-                                await beforeStep.code.apply(world, [{
+                                await test.step('Before Step', () => beforeStep.code.apply(world, [{
                                     pickle: testCase,
                                     pickleStep
-                                }]);
+                                }]));
                             }
                         }
                         const steps = supportCodeLibrary.stepDefinitions
                             .filter(stepDefinition => stepDefinition.matchesStepName(pickleStep.text));
                         if (steps.length === 0) throw new Error(`Step '${pickleStep.text}' is not defined`);
                         if (steps.length > 1) throw new Error(`'${pickleStep.text}' matches multiple step definitions`);
-                        const [step] = steps;
+                        const [ step ] = steps;
                         const { parameters} = await step.getInvocationParameters({
                             step: {
                                 text: pickleStep.text,
@@ -76,11 +72,11 @@ for (const feature of features) {
                         }
                         for (const afterStep of supportCodeLibrary.afterTestStepHookDefinitions) {
                             if (afterStep.appliesToTestCase(testCase)) {
-                                await afterStep.code.apply(world, [{
+                                await test.step('After Step', () => afterStep.code.apply(world, [{
                                     pickle: testCase,
                                     pickleStep,
                                     result
-                                }]);
+                                }]));
                             }
                         }
                         if (result.error) throw result.error;
@@ -89,19 +85,16 @@ for (const feature of features) {
                 for (const afterHook of supportCodeLibrary.afterTestCaseHookDefinitions) {
                     if (afterHook.appliesToTestCase(testCase)) {
                         const hookName = afterHook.name ?? 'After';
-                        await test.step(hookName, async () => {
-                            await afterHook.code.apply(world, [{
-                                pickle: testCase, result
-                            }]);
-                        });
+                        await test.step(hookName, () => afterHook.code.apply(world, [{
+                            pickle: testCase, result
+                        }]));
                     }
                 }
             })
         }
-        for (const afterAllHook of supportCodeLibrary.afterTestRunHookDefinitions) {
-            test.afterAll(async function () {
-                await afterAllHook.code.apply({});
-            });
-        }
     });
 }
+
+for (const afterAllHook of supportCodeLibrary.afterTestRunHookDefinitions) {
+    test.afterAll(() => afterAllHook.code.apply({}));
+}

src/cucumber.spec.ts

@@ -7,6 +7,8 @@ import {
     After,
     BeforeStep,
     AfterStep,
+    BeforeAll,
+    AfterAll,
     ITestCaseHookParameter, ITestStepHookParameter
 } from '@cucumber/cucumber';
 import { test as base, expect as baseExpect, Page, Locator } from '@playwright/test';
@@ -114,4 +116,14 @@ Before({name: 'Named Before'}, async function (this: ExtendedPlaywrightWorld, te
 After({name: 'Named After'}, async function (this: ExtendedPlaywrightWorld, testCase: ITestCaseHookParameter) {
     this.expect(testCase.pickle).toBeTruthy();
     this.expect(testCase.result).toBeTruthy();
+});
+
+BeforeAll(async function () {
+   console.log('Before All');
+   customExpect(1).toEqual(1);
+});
+
+AfterAll(async function () {
+    console.log('After All');
+    customExpect(2).toEqual(2);
 });