@qavajs/playwright-runner-adapter 1.10.0 → 2.0.1

package/src/cucumber.spec.ts

@@ -1,219 +0,0 @@
-import { load } from './loader';
-import type { TestInfo, TestType } from '@playwright/test';
-import type { ITestCaseHookParameter, ITestStepHookParameter } from '@cucumber/cucumber';
-
-const { features, supportCodeLibrary } = load();
-
-function getTestId(testInfo: TestInfo) {
-    return testInfo
-        .annotations
-        .find((annotation: { type: string }) => annotation.type === 'testId')!
-        .description;
-}
-
-function getResult(testInfo: TestInfo) {
-    const message = testInfo.errors.length > 0
-        ? testInfo.errors.map((err: any) => err.message).join('\n')
-        : undefined;
-    return {
-        duration: testInfo.duration as any,
-        message,
-        status: testInfo.status?.toUpperCase(),
-        exception: testInfo.error
-    };
-}
-
-function getLine(step: { uri: string, line: number }) {
-    return { location: { column: 1, file: step.uri, line: step.line }}
-}
-
-function log(data: any) {
-    console.log(data);
-}
-
-function attach(this: { test: any }, body: any, details: any) {
-    const fileName = details?.fileName ?? 'attachment';
-    const contentType = details?.mediaType ?? 'text/plain';
-    this.test.info().attach(fileName, { body, contentType });
-}
-
-function stepName(pickleStep: any) {
-    let step = pickleStep.text;
-    if (pickleStep.argument) {
-        step += pickleStep.argument.docString ? ' [MultiLine]' : ' [DataTable]';
-    }
-    return step;
-}
-
-const fixture = new supportCodeLibrary.World({});
-const test: TestType<any, any> = fixture.test;
-
-test.beforeAll(async () => {
-    for (const beforeAllHook of supportCodeLibrary.beforeTestRunHookDefinitions) {
-        const location = getLine(beforeAllHook);
-        await test.step(
-            'Before All',
-            () => beforeAllHook.code.apply({}),
-            location
-        )
-    }
-});
-
-const worlds = new Map();
-
-for (const feature of features) {
-    const tests = feature.tests;
-    test.describe(feature.feature as string, async () => {
-
-        const worldFactory = (fixtures: any) => {
-            const world = new supportCodeLibrary.World({
-                log,
-                attach,
-                supportCodeLibrary
-            });
-            world.init(fixtures);
-            worlds.set(getTestId(test.info()), world);
-        };
-        worldFactory.toString = () => { return fixture.init.toString() }
-
-        test.beforeEach('World', worldFactory);
-
-        test.beforeEach('Before Hooks', async () => {
-            const testId = getTestId(test.info());
-            const world = worlds.get(testId);
-            const testCase = tests.find(test => test.id === testId)!;
-            for (const beforeHook of supportCodeLibrary.beforeTestCaseHookDefinitions) {
-                if (beforeHook.appliesToTestCase(testCase)) {
-                    const hookName = beforeHook.name ?? '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 = [
-                { type: 'name', description: testCase.name },
-                { type: 'uri', description: testCase.uri },
-                { type: 'testId', description: testCase.id },
-                { type: 'tags', description: JSON.stringify(tag) }
-            ];
-            test(testCase.name, { tag, annotation }, async () => {
-                const world = worlds.get(testCase.id);
-                const result: { status: string, error?: Error } = { status: 'passed' };
-                for (const pickleStep of testCase.steps) {
-                    if (result.status !== 'passed') {
-                        break;
-                    }
-                    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(`Step '${pickleStep.text}' matches multiple step definitions`);
-                    const [ step ] = steps;
-                    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(
-                                    '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: any) {
-                            result.status = 'failed';
-                            result.error = err;
-                            throw err;
-                        } finally {
-                            for (const afterStep of supportCodeLibrary.afterTestStepHookDefinitions) {
-                                if (afterStep.appliesToTestCase(testCase)) {
-                                    const location = getLine(afterStep);
-                                    await test.step(
-                                        'After Step',
-                                        () => afterStep.code.apply(world, [{
-                                            gherkinDocument: feature.gherkinDocument,
-                                            testCaseStartedId: '0',
-                                            testStepId: '0',
-                                            pickle: testCase,
-                                            pickleStep,
-                                            result: {
-                                                duration: 0 as any,
-                                                message: result.error?.message,
-                                                status: result.status.toUpperCase(),
-                                                exception: result.error
-                                            }
-                                        } as ITestStepHookParameter]),
-                                        location
-                                    );
-                                }
-                            }
-                        }
-                    }, location);
-                }
-            })
-        }
-
-        test.afterEach('After Hooks', async () => {
-            const testInfo = test.info();
-            const testId = getTestId(testInfo);
-            const world = worlds.get(testId);
-            const testCase = tests.find(test => test.id === testId)!;
-            for (const afterHook of supportCodeLibrary.afterTestCaseHookDefinitions) {
-                if (afterHook.appliesToTestCase(testCase)) {
-                    const hookName = afterHook.name ?? 'After';
-                    const location = getLine(afterHook);
-                    await test.step(
-                        hookName,
-                        () => afterHook.code.apply(world, [{
-                            gherkinDocument: feature.gherkinDocument,
-                            testCaseStartedId: '0',
-                            pickle: testCase,
-                            result: getResult(testInfo)
-                        } as ITestCaseHookParameter]),
-                        location
-                    );
-                }
-            }
-        });
-
-        test.afterEach('World', async () => {
-            const testId = getTestId(test.info());
-            worlds.delete(testId);
-        });
-
-    });
-}
-
-test.afterAll(async () => {
-    for (const afterAllHook of supportCodeLibrary.afterTestRunHookDefinitions) {
-        const location = getLine(afterAllHook);
-        await test.step(
-            'After All',
-            () => afterAllHook.code.apply({}),
-            location
-        )
-    }
-});

package/src/defineCucumber.ts

@@ -1,25 +0,0 @@
-import { resolve } from 'node:path';
-
-type CucumberConfig = {
-    config: string,
-    profile?: string,
-    adapter?: string
-}
-
-/**
- * Define cucumber config in playwright config
- * @param {CucumberConfig} config
- * @example
- * export default defineConfig({
- *     testDir: defineCucumber({
- *         config: 'cucumber.ts',
- *         profile: 'chrome', // optional
- *         adapter: 'path/to/adapter' // optional
- *     }),
- * })
- */
-export function defineCucumber(config: CucumberConfig): string {
-    process.env.CONFIG = config.config;
-    process.env.PROFILE = config.profile ?? 'default';
-    return config.adapter ?? resolve('./node_modules/@qavajs/playwright-runner-adapter/adapter');
-}