@qavajs/playwright-runner-adapter 2.2.0 → 2.3.1

package/src/PlaywrightWorld.ts

@@ -1,52 +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;
-    }
-
-    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,381 +0,0 @@
-import {load} from './loader';
-import type {TestInfo, TestType} from '@playwright/test';
-import type {ITestCaseHookParameter} from '@cucumber/cucumber';
-
-// Constants
-const ANNOTATION_TYPES = {
-    TEST_ID: '_testId',
-    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 HookResult {
-    duration: number | { nanos: number; seconds: number };
-    message?: string;
-    status: string;
-    exception?: Error;
-}
-
-/**
- * Extracts the test ID from TestInfo annotations
- */
-function getTestId(testInfo: TestInfo): string {
-    const annotation = testInfo.annotations
-        .find((annotation) => annotation.type === ANNOTATION_TYPES.TEST_ID);
-    
-    if (!annotation?.description) {
-        throw new Error('Test ID annotation not found');
-    }
-    
-    return annotation.description;
-}
-
-/**
- * Converts TestInfo to HookResult format
- */
-function getResult(testInfo: TestInfo): HookResult {
-    const message = testInfo.errors.length > 0
-        ? testInfo.errors.map((err) => err.message).join('\n')
-        : undefined;
-    
-    return {
-        duration: testInfo.duration,
-        message,
-        status: testInfo.status?.toUpperCase() ?? 'UNKNOWN',
-        exception: testInfo.error as any
-    };
-}
-
-/**
- * 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;
-}
-
-/**
- * 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
-            );
-        }
-    });
-}
-
-/**
- * Creates test annotations from test case data
- */
-function createTestAnnotations(testCase: any): any[] {
-    const tags = [...new Set(testCase.tags.map((tag: { name: string }) => tag.name))];
-    
-    return [
-        { type: ANNOTATION_TYPES.NAME, description: testCase.name },
-        { type: ANNOTATION_TYPES.URI, description: testCase.uri },
-        { type: ANNOTATION_TYPES.TAGS, description: JSON.stringify(tags) },
-        { type: ANNOTATION_TYPES.TEST_ID, description: testCase.id }
-    ];
-}
-
-/**
- * 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);
-
-    const worlds = new Map<string, any>();
-
-    for (const feature of features) {
-        const tests = feature.tests;
-
-        test.describe(feature.feature as string, async () => {
-            /**
-             * Factory function to create and register world instances
-             */
-            const worldFactory = (fixtures: any): void => {
-                const world = new supportCodeLibrary.World({
-                    log,
-                    attach,
-                    supportCodeLibrary,
-                    config
-                });
-                world.init(fixtures);
-                worlds.set(getTestId(test.info()), world);
-            };
-
-            worldFactory.toString = (): string => fixture.init.toString();
-
-            test.beforeEach(HOOK_NAMES.WORLD, worldFactory);
-
-            test.beforeEach(HOOK_NAMES.BEFORE_HOOKS, async () => {
-                const testId = getTestId(test.info());
-                const world = worlds.get(testId);
-                const testCase = tests.find((t: any) => t.id === testId);
-                
-                if (!testCase) {
-                    throw new Error(`Test case with ID ${testId} not found`);
-                }
-                
-                for (const beforeHook of supportCodeLibrary.beforeTestCaseHookDefinitions) {
-                    if (beforeHook.appliesToTestCase(testCase)) {
-                        const hookName = beforeHook.name ?? HOOK_NAMES.BEFORE;
-                        const location = getLine(beforeHook);
-                        await test.step(
-                            hookName,
-                            () => beforeHook.code.apply(world, [{
-                                gherkinDocument: feature.gherkinDocument,
-                                pickle: testCase
-                            } as ITestCaseHookParameter]),
-                            location
-                        );
-                    }
-                }
-            });
-
-            for (const testCase of tests) {
-                const tag = [...new Set(testCase.tags.map((tag: { name: string }) => tag.name))];
-                const annotation = createTestAnnotations(testCase);
-
-                test(testCase.name, {tag, annotation}, async () => {
-                    const world = worlds.get(testCase.id);
-                    const result: TestResult = { status: 'passed' };
-                    
-                    for (const pickleStep of testCase.steps) {
-                        if (result.status !== 'passed') {
-                            break;
-                        }
-                        
-                        const matchingSteps = supportCodeLibrary.stepDefinitions
-                            .filter((stepDef: any) => stepDef.matchesStepName(pickleStep.text));
-                        
-                        if (matchingSteps.length === 0) {
-                            throw new Error(
-                                `Step definition not found for: "${pickleStep.text}"`
-                            );
-                        }
-                        
-                        if (matchingSteps.length > 1) {
-                            throw new Error(
-                                `Ambiguous step "${pickleStep.text}" matches ${matchingSteps.length} definitions`
-                            );
-                        }
-                        
-                        const [step] = matchingSteps;
-                        const location = getLine(step);
-                        await test.step(stepName(pickleStep), async () => {
-                            for (const beforeStep of supportCodeLibrary.beforeTestStepHookDefinitions) {
-                                if (beforeStep.appliesToTestCase(testCase)) {
-                                    const location = getLine(beforeStep);
-                                    await test.step(
-                                        HOOK_NAMES.BEFORE_STEP,
-                                        () => beforeStep.code.apply(world, [{
-                                            gherkinDocument: feature.gherkinDocument,
-                                            pickle: testCase,
-                                            pickleStep
-                                        }]),
-                                        location
-                                    );
-                                }
-                            }
-                            const {parameters} = await step.getInvocationParameters({
-                                step: {
-                                    text: pickleStep.text,
-                                    argument: pickleStep.argument
-                                },
-                                world
-                            } as any);
-                            
-                            try {
-                                await step.code.apply(world, parameters);
-                            } catch (err) {
-                                result.status = 'failed';
-                                result.error = err as Error;
-                                throw err;
-                            } finally {
-                                for (const afterStep of supportCodeLibrary.afterTestStepHookDefinitions) {
-                                    if (afterStep.appliesToTestCase(testCase)) {
-                                        const location = getLine(afterStep);
-                                        await test.step(
-                                            HOOK_NAMES.AFTER_STEP,
-                                            () => afterStep.code.apply(world, [{
-                                                gherkinDocument: feature.gherkinDocument,
-                                                testCaseStartedId: DEFAULT_VALUES.TEST_CASE_ID,
-                                                testStepId: DEFAULT_VALUES.TEST_STEP_ID,
-                                                pickle: testCase,
-                                                pickleStep,
-                                                result: {
-                                                    duration: 0 as any,
-                                                    message: result.error?.message,
-                                                    status: result.status.toUpperCase(),
-                                                    exception: result.error
-                                                }
-                                            } as any]),
-                                            location
-                                        );
-                                    }
-                                }
-                            }
-                        }, location);
-                    }
-                })
-            }
-
-            test.afterEach(HOOK_NAMES.AFTER_HOOKS, async () => {
-                const testInfo = test.info();
-                const testId = getTestId(testInfo);
-                const world = worlds.get(testId);
-                const testCase = tests.find((t) => t.id === testId);
-                
-                if (!testCase) {
-                    throw new Error(`Test case with ID ${testId} not found`);
-                }
-                
-                for (const afterHook of supportCodeLibrary.afterTestCaseHookDefinitions) {
-                    if (afterHook.appliesToTestCase(testCase)) {
-                        const hookName = afterHook.name ?? HOOK_NAMES.AFTER;
-                        const location = getLine(afterHook);
-                        await test.step(
-                            hookName,
-                            () => afterHook.code.apply(world, [{
-                                gherkinDocument: feature.gherkinDocument,
-                                testCaseStartedId: DEFAULT_VALUES.TEST_CASE_ID,
-                                pickle: testCase,
-                                result: getResult(testInfo)
-                            } as any]),
-                            location
-                        );
-                    }
-                }
-            });
-
-            test.afterEach(HOOK_NAMES.WORLD, async () => {
-                const testId = getTestId(test.info());
-                worlds.delete(testId);
-            });
-
-        });
-    }
-
-    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"
-    ]
-  }
-}