@qavajs/playwright-runner-adapter 2.3.0 → 2.3.2

package/package.json

@@ -1,13 +1,34 @@
 {
   "name": "@qavajs/playwright-runner-adapter",
-  "version": "2.3.0",
+  "version": "2.3.2",
   "description": "adapter for playwright test runner",
   "main": "adapter/index.js",
   "types": "adapter/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./adapter/index.d.ts",
+      "require": "./adapter/index.js",
+      "import": "./adapter/index.js",
+      "default": "./adapter/index.js"
+    },
+    "./js": {
+      "types": "./adapter/js/index.d.ts",
+      "require": "./adapter/js/index.js",
+      "import": "./adapter/js/index.js",
+      "default": "./adapter/js/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "adapter/**/*",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc && tsc --project tsconfig.js.json",
     "test:ui": "playwright test --config test/playwright.config.ts --ui",
-    "test:e2e": "playwright test --config test/playwright.config.ts --project parallel --project serial"
+    "test:e2e": "playwright test --config test/playwright.config.ts --project parallel --project serial --project unit"
   },
   "author": "Alexandr Galichenko",
   "license": "MIT",
@@ -19,15 +40,15 @@
     "url": "https://github.com/qavajs/playwright-runner-adapter/issues"
   },
   "dependencies": {
-    "@cucumber/gherkin": "^38.0.0",
-    "@cucumber/tag-expressions": "^9.0.0",
-    "glob": "^13.0.3",
-    "@cucumber/cucumber": "^12.6.0"
+    "@cucumber/gherkin": "^39.0.0",
+    "@cucumber/tag-expressions": "^9.1.0",
+    "glob": "^13.0.6",
+    "@cucumber/cucumber": "^12.8.1"
   },
   "devDependencies": {
-    "@playwright/test": "^1.58.2",
-    "@types/node": "^25.2.3",
-    "typescript": "^5.9.3"
+    "@playwright/test": "^1.59.1",
+    "@types/node": "^25.6.0",
+    "typescript": "^6.0.3"
   },
   "keywords": [
     "test",

package/src/PlaywrightWorld.ts

@@ -1,53 +0,0 @@
-import { APIRequestContext, Browser, BrowserContext, Page, test, expect } from '@playwright/test';
-
-/**
- * Cucumber world for playwright adapter
- */
-export class TestWorld {
-    log!: (data: any) => void;
-    attach!: (data: any, details?: { fileName?: string, mediaType: string }) => Promise<void>;
-    parameters!: string;
-    config: any;
-    supportCodeLibrary!: any;
-    test = test;
-    expect = expect;
-
-    constructor(options: any) {
-        this.log = options.log;
-        this.attach = options.attach;
-        this.parameters = options.parameters;
-        this.supportCodeLibrary = options.supportCodeLibrary;
-        this.config = options.config;
-    }
-
-    async executeStep(this: any, text: string, extraParam?: any) {
-        const steps = this.supportCodeLibrary.stepDefinitions.filter((s: any) => s.matchesStepName(text));
-        if (steps.length === 0) throw new Error(`Step "${text}" is not defined`);
-        if (steps.length > 1) throw new Error(`Step "${text}" matches multiple step definitions`);
-        const step = steps.pop() as any;
-        const { parameters } = await step.getInvocationParameters({ step: { text }, world: this } as any);
-        try {
-            await step.code.apply(this, [...parameters, extraParam]);
-        } catch (err) {
-            throw new Error(`${text}\n${err}`);
-        }
-    }
-}
-
-/**
- * Cucumber Playwright world for playwright adapter
- */
-export class PlaywrightWorld extends TestWorld {
-    page!: Page;
-    context!: BrowserContext;
-    browser!: Browser;
-    browserName!: string;
-    request!: APIRequestContext;
-
-    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;
-    }
-}

package/src/Template.ts

@@ -1,23 +0,0 @@
-/**
- * Define template step
- * @param {string} scenario - multiline string with steps
- * @example
- * When('I click {string} and verify {string}', Template((locator, expected) => `
- *     I click '${locator}'
- *     I expect '${locator} > Value' to equal '${expected}'
- * `));
- */
-export function Template(scenario: (...args: any[]) => string) {
-    return new Proxy(scenario, {
-        apply: async function (template: (...args: string[]) => string, world: { executeStep: (step: string) => Promise<void> }, args: any[]) {
-            const scenario = template(...args) ;
-            const steps = scenario
-                .split('\n')
-                .map(step => step.trim())
-                .filter(Boolean);
-            for (const step of steps) {
-                await world.executeStep(step);
-            }
-        },
-    })
-}

package/src/cucumberAdapter.ts

@@ -1,388 +0,0 @@
-import {load} from './loader';
-import type {TestInfo, TestType} from '@playwright/test';
-import type {ITestCaseHookParameter, ITestStepHookParameter} from '@cucumber/cucumber';
-
-// Constants
-const ANNOTATION_TYPES = {
-    NAME: 'name',
-    URI: 'uri',
-    TAGS: 'tags'
-} as const;
-
-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'
-} as const;
-
-const DEFAULT_VALUES = {
-    ATTACHMENT_FILENAME: 'attachment',
-    CONTENT_TYPE: 'text/plain',
-    COLUMN: 1,
-    TEST_CASE_ID: '0',
-    TEST_STEP_ID: '0'
-} as const;
-
-const STEP_ARGUMENT_LABELS = {
-    DOC_STRING: ' [MultiLine]',
-    DATA_TABLE: ' [DataTable]'
-} as const;
-
-// Type definitions
-interface Location {
-    file: string;
-    line: number;
-    column: number;
-}
-
-interface StepDefinition {
-    uri: string;
-    line: number;
-}
-
-interface TestResult {
-    status: string;
-    error?: Error;
-}
-
-interface TestExecutionResult extends TestResult {
-    start: number;
-}
-
-interface FeatureContext {
-    gherkinDocument: unknown;
-}
-
-interface PickleStep {
-    text: string;
-    argument?: { docString?: unknown };
-}
-
-/**
- * Creates a location object from step definition
- */
-function getLine(step: StepDefinition): { location: Location } {
-    return {
-        location: {
-            column: DEFAULT_VALUES.COLUMN,
-            file: step.uri,
-            line: step.line
-        }
-    };
-}
-
-/**
- * Logs data to console
- */
-function log(data: unknown): void {
-    console.log(data);
-}
-
-/**
- * Attaches content to test report
- */
-function attach(
-    this: { test: { info: () => TestInfo } },
-    body: string | Buffer,
-    details?: { fileName?: string; mediaType?: string }
-): Promise<void> {
-    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: {
-    text: string;
-    argument?: { docString?: unknown }
-}): string {
-    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(): TestExecutionResult {
-    return {
-        status: 'passed',
-        start: Date.now()
-    };
-}
-
-function createHookResult(result: TestExecutionResult): any {
-    return {
-        duration: (Date.now() - result.start) as any,
-        message: result.error?.message,
-        status: result.status.toUpperCase(),
-        exception: result.error
-    };
-}
-
-function createScenarioAnnotation(testCase: any): { type: string; description: string }[] {
-    const tag = [...new Set(testCase.tags.map((item: { name: string }) => 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: any): string[] {
-    return [...new Set<string>(testCase.tags.map((item: { name: string }) => item.name))];
-}
-
-function createCaseHookPayload(feature: FeatureContext, testCase: any): ITestCaseHookParameter {
-    return {
-        gherkinDocument: feature.gherkinDocument,
-        pickle: testCase
-    } as ITestCaseHookParameter;
-}
-
-async function executeCaseHooks(
-    test: TestType<any, any>,
-    hooks: any[],
-    world: any,
-    testCase: any,
-    defaultHookName: string,
-    createPayload: (hook: any) => any
-): Promise<void> {
-    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: TestType<any, any>,
-    hooks: any[],
-    world: any,
-    testCase: any,
-    hookName: string,
-    createPayload: (hook: any) => any
-): Promise<void> {
-    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: any,
-    testCase: any,
-    pickleStep: any,
-    result: TestExecutionResult
-): ITestStepHookParameter {
-    return {
-        gherkinDocument: feature.gherkinDocument,
-        testCaseStartedId: DEFAULT_VALUES.TEST_CASE_ID,
-        testStepId: DEFAULT_VALUES.TEST_STEP_ID,
-        pickle: testCase,
-        pickleStep,
-        result: createHookResult(result)
-    } as any;
-}
-
-function createCaseHookParameter(
-    feature: any,
-    testCase: any,
-    result: TestExecutionResult
-): ITestCaseHookParameter {
-    return {
-        gherkinDocument: feature.gherkinDocument,
-        testCaseStartedId: DEFAULT_VALUES.TEST_CASE_ID,
-        pickle: testCase,
-        result: createHookResult(result)
-    } as any;
-}
-
-function findSingleStepDefinition(
-    supportCodeLibrary: any,
-    pickleStep: PickleStep
-): any {
-    const matchingSteps = supportCodeLibrary.stepDefinitions
-        .filter((stepDefinition: any) => 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: TestType<any, any>,
-    hooks: any[]
-): void {
-    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: TestType<any, any>,
-    hooks: any[]
-): void {
-    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
- */
-export function defineConfig(config: any): any {
-    const {features, supportCodeLibrary} = load(config);
-
-    const fixture = new supportCodeLibrary.World({config});
-    const test: TestType<any, any> = fixture.test;
-    executeBeforeAllHooks(test, supportCodeLibrary.beforeTestRunHookDefinitions);
-
-    for (const feature of features) {
-        const tests = feature.tests;
-        test.describe(feature.feature as string, () => {
-
-            for (const testCase of tests) {
-                const tag = createScenarioTags(testCase);
-                const annotation = createScenarioAnnotation(testCase);
-                const testBody = async (fixtures: any) => {
-                    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
-                                } as any);
-                                try {
-                                    await step.code.apply(world, parameters);
-                                } catch (err: any) {
-                                    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/src/filter.ts

@@ -1,53 +0,0 @@
-import parse from '@cucumber/tag-expressions';
-
-class TagExpression extends RegExp {
-    private expressionNode: {
-        evaluate(variables: string[]): boolean;
-    };
-
-    constructor(private tagExpression: string) {
-        super('');
-        this.expressionNode = parse(this.tagExpression);
-    }
-
-    test(testName: string) {
-        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')
- * });
- */
-export function tags(tagExpression: string): RegExp {
-    return new TagExpression(tagExpression);
-}
-
-class Filter extends RegExp {
-    constructor(private predicate: (testName: string) => boolean) {
-        super('');
-        this.predicate = predicate;
-    }
-
-    test(testName: string) {
-        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'))
- * });
- */
-export function filter(predicate: (testName: string) => boolean): RegExp {
-    return new Filter(predicate);
-}

package/src/index.ts

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

package/src/loader.ts

@@ -1,70 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { AstBuilder, compile, GherkinClassicTokenMatcher, Parser } from '@cucumber/gherkin';
-import { supportCodeLibraryBuilder } from '@cucumber/cucumber';
-import type { Pickle, GherkinDocument } from '@cucumber/messages';
-import { globSync } from 'glob';
-import { PlaywrightWorld } from './PlaywrightWorld';
-
-const uuidFn = () => randomUUID();
-const builder = new AstBuilder(uuidFn);
-const matcher = new GherkinClassicTokenMatcher();
-const parser = new Parser(builder, matcher)
-
-function duplicates(tests: readonly Pickle[]) {
-    const counts: Record<string, number> = {};
-    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;
-    });
-}
-
-type Feature = {
-    feature?: string;
-    gherkinDocument: GherkinDocument;
-    tests: readonly Pickle[];
-    uri: string;
-}
-
-export function loadFeatures(globPattern: string[]): Feature[] {
-    const files = globSync(globPattern);
-    return files.map(file => {
-        const filePath = resolve(file);
-        const gherkinDocument = parser.parse(readFileSync(filePath, 'utf-8'));
-        return {
-            feature: gherkinDocument.feature?.name,
-            uri: filePath,
-            gherkinDocument,
-            tests: duplicates(compile(gherkinDocument, file, uuidFn))
-        }
-    });
-}
-
-export function loadStepDefinitions(globPattern: string[]) {
-    supportCodeLibraryBuilder.reset(process.cwd(), uuidFn);
-    supportCodeLibraryBuilder.methods.setWorldConstructor(PlaywrightWorld);
-    const files = globSync(globPattern);
-    for (const file of files) {
-        const filePath = resolve(file);
-        require(filePath);
-    }
-    return supportCodeLibraryBuilder.finalize();
-}
-
-export function load(config: any) {
-    const features = loadFeatures(config.paths);
-    const supportCodeLibrary = loadStepDefinitions([
-        ...(config.requireModules ?? []),
-        ...(config.require ?? []),
-        ...(config.import ?? [])
-    ]);
-    return { features, supportCodeLibrary }
-}

package/tsconfig.js.json

@@ -1,23 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "test/**/*.spec.ts"
-  ],
-  "compilerOptions": {
-    "target": "es2023",
-    "module": "node16",
-    "moduleResolution": "node16",
-    "outDir": "./adapter/js",
-    "esModuleInterop": true,
-    "sourceMap": false,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "types": [
-      "node"
-    ]
-  }
-}

package/tsconfig.json

@@ -1,23 +0,0 @@
-{
-  "include": [
-    "src/**/*.ts"
-  ],
-  "exclude": [
-    "test/**/*.spec.ts"
-  ],
-  "compilerOptions": {
-    "target": "es2023",
-    "module": "node16",
-    "moduleResolution": "node16",
-    "outDir": "./adapter",
-    "esModuleInterop": true,
-    "sourceMap": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "types": [
-      "node"
-    ]
-  }
-}