@qavajs/playwright-runner-adapter 2.1.0 → 2.3.0

package/adapter/js/cucumberAdapter.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = defineConfig;
+const loader_1 = require("./loader");
+// Constants
+const ANNOTATION_TYPES = {
+    NAME: 'name',
+    URI: 'uri',
+    TAGS: 'tags'
+};
+const HOOK_NAMES = {
+    BEFORE_ALL: 'Before All',
+    AFTER_ALL: 'After All',
+    BEFORE: 'Before',
+    AFTER: 'After',
+    BEFORE_STEP: 'Before Step',
+    AFTER_STEP: 'After Step',
+    WORLD: 'World',
+    BEFORE_HOOKS: 'Before Hooks',
+    AFTER_HOOKS: 'After Hooks'
+};
+const DEFAULT_VALUES = {
+    ATTACHMENT_FILENAME: 'attachment',
+    CONTENT_TYPE: 'text/plain',
+    COLUMN: 1,
+    TEST_CASE_ID: '0',
+    TEST_STEP_ID: '0'
+};
+const STEP_ARGUMENT_LABELS = {
+    DOC_STRING: ' [MultiLine]',
+    DATA_TABLE: ' [DataTable]'
+};
+/**
+ * Creates a location object from step definition
+ */
+function getLine(step) {
+    return {
+        location: {
+            column: DEFAULT_VALUES.COLUMN,
+            file: step.uri,
+            line: step.line
+        }
+    };
+}
+/**
+ * Logs data to console
+ */
+function log(data) {
+    console.log(data);
+}
+/**
+ * Attaches content to test report
+ */
+function attach(body, details) {
+    const fileName = details?.fileName ?? DEFAULT_VALUES.ATTACHMENT_FILENAME;
+    const contentType = details?.mediaType ?? DEFAULT_VALUES.CONTENT_TYPE;
+    return this.test.info().attach(fileName, { body, contentType });
+}
+/**
+ * Generates a human-readable step name with argument type indicator
+ */
+function stepName(pickleStep) {
+    let step = pickleStep.text;
+    if (pickleStep.argument) {
+        step += pickleStep.argument.docString
+            ? STEP_ARGUMENT_LABELS.DOC_STRING
+            : STEP_ARGUMENT_LABELS.DATA_TABLE;
+    }
+    return step;
+}
+function createTestExecutionResult() {
+    return {
+        status: 'passed',
+        start: Date.now()
+    };
+}
+function createHookResult(result) {
+    return {
+        duration: (Date.now() - result.start),
+        message: result.error?.message,
+        status: result.status.toUpperCase(),
+        exception: result.error
+    };
+}
+function createScenarioAnnotation(testCase) {
+    const tag = [...new Set(testCase.tags.map((item) => item.name))];
+    return [
+        { type: ANNOTATION_TYPES.NAME, description: testCase.name },
+        { type: ANNOTATION_TYPES.URI, description: testCase.uri },
+        { type: ANNOTATION_TYPES.TAGS, description: JSON.stringify(tag) }
+    ];
+}
+function createScenarioTags(testCase) {
+    return [...new Set(testCase.tags.map((item) => item.name))];
+}
+function createCaseHookPayload(feature, testCase) {
+    return {
+        gherkinDocument: feature.gherkinDocument,
+        pickle: testCase
+    };
+}
+async function executeCaseHooks(test, hooks, world, testCase, defaultHookName, createPayload) {
+    for (const hook of hooks) {
+        if (!hook.appliesToTestCase(testCase)) {
+            continue;
+        }
+        const hookName = hook.name ?? defaultHookName;
+        const location = getLine(hook);
+        await test.step(hookName, () => hook.code.apply(world, [createPayload(hook)]), location);
+    }
+}
+async function executeStepHooks(test, hooks, world, testCase, hookName, createPayload) {
+    for (const hook of hooks) {
+        if (!hook.appliesToTestCase(testCase)) {
+            continue;
+        }
+        const location = getLine(hook);
+        await test.step(hookName, () => hook.code.apply(world, [createPayload(hook)]), location);
+    }
+}
+function createStepHookParameter(feature, testCase, pickleStep, result) {
+    return {
+        gherkinDocument: feature.gherkinDocument,
+        testCaseStartedId: DEFAULT_VALUES.TEST_CASE_ID,
+        testStepId: DEFAULT_VALUES.TEST_STEP_ID,
+        pickle: testCase,
+        pickleStep,
+        result: createHookResult(result)
+    };
+}
+function createCaseHookParameter(feature, testCase, result) {
+    return {
+        gherkinDocument: feature.gherkinDocument,
+        testCaseStartedId: DEFAULT_VALUES.TEST_CASE_ID,
+        pickle: testCase,
+        result: createHookResult(result)
+    };
+}
+function findSingleStepDefinition(supportCodeLibrary, pickleStep) {
+    const matchingSteps = supportCodeLibrary.stepDefinitions
+        .filter((stepDefinition) => stepDefinition.matchesStepName(pickleStep.text));
+    if (matchingSteps.length === 0) {
+        throw new Error(`Step '${pickleStep.text}' is not defined`);
+    }
+    if (matchingSteps.length > 1) {
+        throw new Error(`Step '${pickleStep.text}' matches multiple step definitions`);
+    }
+    return matchingSteps[0];
+}
+/**
+ * Executes before all hooks
+ */
+function executeBeforeAllHooks(test, hooks) {
+    if (hooks.length === 0)
+        return;
+    test.beforeAll(async () => {
+        for (const hook of hooks) {
+            const location = getLine(hook);
+            await test.step(HOOK_NAMES.BEFORE_ALL, () => hook.code.apply({}), location);
+        }
+    });
+}
+/**
+ * Executes after all hooks
+ */
+function executeAfterAllHooks(test, hooks) {
+    if (hooks.length === 0)
+        return;
+    test.afterAll(async () => {
+        for (const hook of hooks) {
+            const location = getLine(hook);
+            await test.step(HOOK_NAMES.AFTER_ALL, () => hook.code.apply({}), location);
+        }
+    });
+}
+/**
+ * Main configuration function that sets up Cucumber adapter for Playwright
+ */
+function defineConfig(config) {
+    const { features, supportCodeLibrary } = (0, loader_1.load)(config);
+    const fixture = new supportCodeLibrary.World({ config });
+    const test = fixture.test;
+    executeBeforeAllHooks(test, supportCodeLibrary.beforeTestRunHookDefinitions);
+    for (const feature of features) {
+        const tests = feature.tests;
+        test.describe(feature.feature, () => {
+            for (const testCase of tests) {
+                const tag = createScenarioTags(testCase);
+                const annotation = createScenarioAnnotation(testCase);
+                const testBody = async (fixtures) => {
+                    const world = new supportCodeLibrary.World({
+                        log,
+                        attach,
+                        supportCodeLibrary,
+                        config
+                    });
+                    world.init(fixtures);
+                    const result = createTestExecutionResult();
+                    await executeCaseHooks(test, supportCodeLibrary.beforeTestCaseHookDefinitions, world, testCase, HOOK_NAMES.BEFORE, () => createCaseHookPayload(feature, testCase));
+                    try {
+                        for (const pickleStep of testCase.steps) {
+                            if (result.status !== 'passed') {
+                                break;
+                            }
+                            const step = findSingleStepDefinition(supportCodeLibrary, pickleStep);
+                            const location = getLine(step);
+                            await test.step(stepName(pickleStep), async () => {
+                                await executeStepHooks(test, supportCodeLibrary.beforeTestStepHookDefinitions, world, testCase, HOOK_NAMES.BEFORE_STEP, () => ({
+                                    gherkinDocument: feature.gherkinDocument,
+                                    pickle: testCase,
+                                    pickleStep
+                                }));
+                                const { parameters } = await step.getInvocationParameters({
+                                    step: {
+                                        text: pickleStep.text,
+                                        argument: pickleStep.argument
+                                    },
+                                    world
+                                });
+                                try {
+                                    await step.code.apply(world, parameters);
+                                }
+                                catch (err) {
+                                    result.status = 'failed';
+                                    result.error = err;
+                                    throw err;
+                                }
+                                finally {
+                                    await executeStepHooks(test, supportCodeLibrary.afterTestStepHookDefinitions, world, testCase, HOOK_NAMES.AFTER_STEP, () => createStepHookParameter(feature, testCase, pickleStep, result));
+                                }
+                            }, location);
+                        }
+                    }
+                    finally {
+                        await executeCaseHooks(test, supportCodeLibrary.afterTestCaseHookDefinitions, world, testCase, HOOK_NAMES.AFTER, () => createCaseHookParameter(feature, testCase, result));
+                    }
+                };
+                testBody.toString = () => fixture.init.toString();
+                test(testCase.name, { tag, annotation }, testBody);
+            }
+        });
+    }
+    executeAfterAllHooks(test, supportCodeLibrary.afterTestRunHookDefinitions);
+}

package/adapter/js/filter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Translate cucumber tag expression to playwright grep
+ * @param {string} tagExpression
+ * @example
+ * import { tags } from '@qavajs/playwright-runner-adapter';
+ * export default defineConfig({
+ *     grep: tags('@oneTag and @anotherTag')
+ * });
+ */
+export declare function tags(tagExpression: string): RegExp;
+/**
+ * Filter test cases by name
+ * @param {(testName: string) => boolean} predicate
+ * import { filter } from '@qavajs/playwright-runner-adapter';
+ * export default defineConfig({
+ *     grep: filter(name => name.includes('login test'))
+ * });
+ */
+export declare function filter(predicate: (testName: string) => boolean): RegExp;

package/adapter/js/filter.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tags = tags;
+exports.filter = filter;
+const tag_expressions_1 = __importDefault(require("@cucumber/tag-expressions"));
+class TagExpression extends RegExp {
+    tagExpression;
+    expressionNode;
+    constructor(tagExpression) {
+        super('');
+        this.tagExpression = tagExpression;
+        this.expressionNode = (0, tag_expressions_1.default)(this.tagExpression);
+    }
+    test(testName) {
+        const tokens = testName.split(/\s+/);
+        return this.expressionNode.evaluate(tokens);
+    }
+}
+/**
+ * Translate cucumber tag expression to playwright grep
+ * @param {string} tagExpression
+ * @example
+ * import { tags } from '@qavajs/playwright-runner-adapter';
+ * export default defineConfig({
+ *     grep: tags('@oneTag and @anotherTag')
+ * });
+ */
+function tags(tagExpression) {
+    return new TagExpression(tagExpression);
+}
+class Filter extends RegExp {
+    predicate;
+    constructor(predicate) {
+        super('');
+        this.predicate = predicate;
+        this.predicate = predicate;
+    }
+    test(testName) {
+        return this.predicate(testName);
+    }
+}
+/**
+ * Filter test cases by name
+ * @param {(testName: string) => boolean} predicate
+ * import { filter } from '@qavajs/playwright-runner-adapter';
+ * export default defineConfig({
+ *     grep: filter(name => name.includes('login test'))
+ * });
+ */
+function filter(predicate) {
+    return new Filter(predicate);
+}

package/adapter/js/index.d.ts

@@ -0,0 +1,5 @@
+export * from './PlaywrightWorld';
+export * from './filter';
+export * from './Template';
+export * from '@cucumber/cucumber';
+export * from './cucumberAdapter';

package/adapter/js/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PlaywrightWorld"), exports);
+__exportStar(require("./filter"), exports);
+__exportStar(require("./Template"), exports);
+__exportStar(require("@cucumber/cucumber"), exports);
+__exportStar(require("./cucumberAdapter"), exports);

package/adapter/js/loader.d.ts

@@ -0,0 +1,14 @@
+import type { Pickle, GherkinDocument } from '@cucumber/messages';
+type Feature = {
+    feature?: string;
+    gherkinDocument: GherkinDocument;
+    tests: readonly Pickle[];
+    uri: string;
+};
+export declare function loadFeatures(globPattern: string[]): Feature[];
+export declare function loadStepDefinitions(globPattern: string[]): import("@cucumber/cucumber/lib/support_code_library_builder/types").SupportCodeLibrary;
+export declare function load(config: any): {
+    features: Feature[];
+    supportCodeLibrary: import("@cucumber/cucumber/lib/support_code_library_builder/types").SupportCodeLibrary;
+};
+export {};

package/adapter/js/loader.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFeatures = loadFeatures;
+exports.loadStepDefinitions = loadStepDefinitions;
+exports.load = load;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const gherkin_1 = require("@cucumber/gherkin");
+const cucumber_1 = require("@cucumber/cucumber");
+const glob_1 = require("glob");
+const PlaywrightWorld_1 = require("./PlaywrightWorld");
+const uuidFn = () => (0, node_crypto_1.randomUUID)();
+const builder = new gherkin_1.AstBuilder(uuidFn);
+const matcher = new gherkin_1.GherkinClassicTokenMatcher();
+const parser = new gherkin_1.Parser(builder, matcher);
+function duplicates(tests) {
+    const counts = {};
+    return tests.map(item => {
+        const name = item.name;
+        if (!(name in counts)) {
+            counts[name] = 1;
+        }
+        if (counts[name] > 1) {
+            item.name = `${item.name} ${counts[name]}`;
+        }
+        counts[name] = counts[name] + 1;
+        return item;
+    });
+}
+function loadFeatures(globPattern) {
+    const files = (0, glob_1.globSync)(globPattern);
+    return files.map(file => {
+        const filePath = (0, node_path_1.resolve)(file);
+        const gherkinDocument = parser.parse((0, node_fs_1.readFileSync)(filePath, 'utf-8'));
+        return {
+            feature: gherkinDocument.feature?.name,
+            uri: filePath,
+            gherkinDocument,
+            tests: duplicates((0, gherkin_1.compile)(gherkinDocument, file, uuidFn))
+        };
+    });
+}
+function loadStepDefinitions(globPattern) {
+    cucumber_1.supportCodeLibraryBuilder.reset(process.cwd(), uuidFn);
+    cucumber_1.supportCodeLibraryBuilder.methods.setWorldConstructor(PlaywrightWorld_1.PlaywrightWorld);
+    const files = (0, glob_1.globSync)(globPattern);
+    for (const file of files) {
+        const filePath = (0, node_path_1.resolve)(file);
+        require(filePath);
+    }
+    return cucumber_1.supportCodeLibraryBuilder.finalize();
+}
+function load(config) {
+    const features = loadFeatures(config.paths);
+    const supportCodeLibrary = loadStepDefinitions([
+        ...(config.requireModules ?? []),
+        ...(config.require ?? []),
+        ...(config.import ?? [])
+    ]);
+    return { features, supportCodeLibrary };
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@qavajs/playwright-runner-adapter",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "adapter for playwright test runner",
   "main": "adapter/index.js",
   "types": "adapter/index.d.ts",
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && tsc --project tsconfig.js.json",
     "test:ui": "playwright test --config test/playwright.config.ts --ui",
-    "test:e2e": "playwright test --config test/playwright-e2e.config.ts"
+    "test:e2e": "playwright test --config test/playwright.config.ts --project parallel --project serial"
   },
   "author": "Alexandr Galichenko",
   "license": "MIT",
@@ -21,12 +21,12 @@
   "dependencies": {
     "@cucumber/gherkin": "^38.0.0",
     "@cucumber/tag-expressions": "^9.0.0",
-    "glob": "^13.0.1",
+    "glob": "^13.0.3",
     "@cucumber/cucumber": "^12.6.0"
   },
   "devDependencies": {
-    "@playwright/test": "^1.58.1",
-    "@types/node": "^25.2.1",
+    "@playwright/test": "^1.58.2",
+    "@types/node": "^25.2.3",
     "typescript": "^5.9.3"
   },
   "keywords": [

package/src/PlaywrightWorld.ts

@@ -5,7 +5,7 @@ import { APIRequestContext, Browser, BrowserContext, Page, test, expect } from '
  */
 export class TestWorld {
     log!: (data: any) => void;
-    attach!: (data: any, details?: { fileName?: string, mediaType: string }) => void;
+    attach!: (data: any, details?: { fileName?: string, mediaType: string }) => Promise<void>;
     parameters!: string;
     config: any;
     supportCodeLibrary!: any;
@@ -17,6 +17,7 @@ export class TestWorld {
         this.attach = options.attach;
         this.parameters = options.parameters;
         this.supportCodeLibrary = options.supportCodeLibrary;
+        this.config = options.config;
     }
 
     async executeStep(this: any, text: string, extraParam?: any) {
@@ -43,9 +44,10 @@ export class PlaywrightWorld extends TestWorld {
     browserName!: string;
     request!: APIRequestContext;
 
-    init: ({ [fixture: string]: any }) = ({ browser, context, page }: { browser: Browser, context: BrowserContext, page: Page }) => {
+    init: ({ [fixture: string]: any }) = ({ browser, context, page, request }: { browser: Browser, context: BrowserContext, page: Page, request: APIRequestContext }) => {
         this.browser = browser;
         this.context = context;
         this.page = page;
+        this.request = request;
     }
 }