@qavajs/cypress-runner-adapter 1.10.0 → 1.11.0

package/README.md

@@ -30,6 +30,47 @@ module.exports = defineConfig({
 });
 ```
 
+### TypeScript
+
+TypeScript support is built-in. Point `supportFile` at a `.ts` file and the adapter will compile it automatically:
+
+```javascript
+const { defineConfig } = require('cypress');
+const cucumber = require('@qavajs/cypress-runner-adapter/adapter');
+
+module.exports = defineConfig({
+    e2e: {
+        specPattern: 'cypress/feature/**/*.feature',
+        supportFile: 'cypress/support/e2e.ts',
+        setupNodeEvents(on, config) {
+            on('file:preprocessor', cucumber);
+        },
+    },
+});
+```
+
+```typescript
+// cypress/support/e2e.ts
+import { Given, When, Then, setWorldConstructor, World, WorldOptions } from '@qavajs/cypress-runner-adapter';
+
+class CustomWorld extends World {
+    myValue: string | null;
+
+    constructor(options: WorldOptions) {
+        super(options);
+        this.myValue = null;
+    }
+}
+
+setWorldConstructor(CustomWorld);
+
+Given('I navigate to {string}', function (this: CustomWorld, url: string) {
+    cy.visit(url);
+});
+```
+
+A `tsconfig.json` is not required but recommended. The adapter uses `transpileOnly: true` so type errors will not block the test run.
+
 ## Step Definitions
 
 Define steps in your support file (e.g. `cypress/support/e2e.js`):

package/adapter/index.js

@@ -2,7 +2,26 @@ const { mkdirSync, writeFileSync, readFileSync } = require('node:fs');
 const { dirname } = require('node:path');
 const { randomUUID } = require('node:crypto');
 const { AstBuilder, compile, GherkinClassicTokenMatcher, Parser } = require('@cucumber/gherkin');
-const webpackPreprocessor = require('@cypress/webpack-preprocessor')();
+const webpackPreprocessor = require('@cypress/webpack-preprocessor')({
+    webpackOptions: {
+        mode: 'development',
+        resolve: { extensions: ['.ts', '.js'] },
+        module: {
+            rules: [
+                {
+                    test: /\.tsx?$/,
+                    exclude: [/node_modules/],
+                    use: [{ loader: 'ts-loader', options: { transpileOnly: true } }]
+                },
+                {
+                    test: /\.jsx?$/,
+                    exclude: [/node_modules/],
+                    use: [{ loader: 'babel-loader', options: { presets: ['@babel/preset-env'] } }]
+                }
+            ]
+        }
+    }
+});
 const tagExpressionParser = require('@cucumber/tag-expressions').default;
 const makeMochaTestDescribe = require('./make_mocha_tests_describe');
 const makeMochaTestIt = require('./make_mocha_tests_it');

package/adapter/make_mocha_tests_describe.js

@@ -50,7 +50,7 @@ module.exports = function makeMochaTest(tests) {
             step: { text, argument },
             world: this
         });
-        step.code.apply(this, parameters);
+        return step.code.apply(this, parameters);
     }
 
     function executeStep(pickle, world) {
@@ -60,7 +60,7 @@ module.exports = function makeMochaTest(tests) {
         if (pickle.argument && pickle.argument.docString) {
             Cypress.log({ displayName: 'Multiline', message: pickle.argument.docString.content });
         }
-        executeStepByText.call(world, pickle.text, pickle.argument);
+        return executeStepByText.call(world, pickle.text, pickle.argument);
     }
 
     if (supportCodeLibrary.beforeTestRunHookDefinitions.length > 0) {
@@ -150,7 +150,12 @@ module.exports = function makeMochaTest(tests) {
                             }]);
                         }
                     }
-                    executeStep(step, world);
+                    const stepResult = executeStep(step, world);
+                    if (stepResult === 'pending' || stepResult === 'skipped') {
+                        skip = true;
+                        status = stepResult;
+                        return this.skip();
+                    }
                 });
             }
             for (const afterTest of supportCodeLibrary.afterTestCaseHookDefinitions) {

package/adapter/make_mocha_tests_it.js

@@ -58,7 +58,7 @@ module.exports = function makeMochaTest(tests) {
             step: { text, argument },
             world: this
         });
-        step.code.apply(this, parameters);
+        return step.code.apply(this, parameters);
     }
 
     function executeStep(pickle, world) {
@@ -70,7 +70,7 @@ module.exports = function makeMochaTest(tests) {
                 Cypress.log({ displayName: 'Multiline', message: pickle.argument.docString.content });
             }
         });
-        executeStepByText.call(world, pickle.text, pickle.argument);
+        return executeStepByText.call(world, pickle.text, pickle.argument);
     }
 
     supportCodeLibrary.World.prototype.executeStep = executeStepByText;
@@ -186,7 +186,11 @@ module.exports = function makeMochaTest(tests) {
                             }]);
                         }
                     }
-                    executeStep(step, world);
+                    const stepResult = executeStep(step, world);
+                    if (stepResult === 'pending' || stepResult === 'skipped') {
+                        result.status = stepResult;
+                        return this.skip();
+                    }
                     for (const afterStep of supportCodeLibrary.afterTestStepHookDefinitions) {
                         if (afterStep.appliesToTestCase(this.step)) {
                             afterStep.code.apply(world, [{

package/index.d.ts

@@ -1,44 +1 @@
-declare type Expression = string | RegExp;
-declare type TestHookOptions = {
-    tags?: string,
-    name?: string
-};
-declare type StepHookOptions = {
-    tags?: string
-};
-declare type ParameterTypeOption = {
-    name: string,
-    preferForRegexpMatch?: boolean,
-    regexp: RegExp,
-    transformer?: Function,
-    useForSnippets?: boolean
-}
-export function defineStep(keyword: string, expression: Expression, fn: Function): void;
-export function Given(expression: Expression, fn: Function): void;
-export function When(expression: Expression, fn: Function): void;
-export function Then(expression: Expression, fn: Function): void;
-export function Before(fn: Function): void;
-export function Before(options: TestHookOptions, fn: Function): void;
-export function After(fn: Function): void;
-export function After(options: TestHookOptions, fn: Function): void;
-export function BeforeStep(fn: Function): void;
-export function BeforeStep(options: StepHookOptions, fn: Function): void;
-export function AfterStep(fn: Function): void;
-export function AfterStep(options: StepHookOptions, fn: Function): void;
-export function BeforeAll(fn: Function): void;
-export function AfterAll(fn: Function): void;
-export function setWorldConstructor(world: IWorld): void;
-export function defineParameterType(option: ParameterTypeOption): void;
-export function setDefaultTimeout(milliseconds: number): void;
-export function Template(template: (...args: any[]) => string): () => void;
-export class World {
-    log: (...args: any) => void;
-    attach: (...args: any) => void;
-    link: (...args: any) => void;
-    executeStep(text: string, argument?: any): void;
-    constructor(options: {
-        log: (...args: any) => void;
-        attach: (...args: any) => void;
-        link: (...args: any) => void;
-    });
-}
+export * from './supportCodeLibrary/index';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qavajs/cypress-runner-adapter",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "main": "supportCodeLibrary/index.js",
   "exports": {
     ".": "./supportCodeLibrary/index.js",
@@ -16,7 +16,11 @@
     "debug": "cypress open --config-file test/cypress.config.js",
     "test": "cypress run --config-file test/cypress.config.js",
     "debug:it": "MODE=it cypress open --config-file test/cypress.config.js",
-    "test:it": "MODE=it cypress run --config-file test/cypress.config.js"
+    "test:it": "MODE=it cypress run --config-file test/cypress.config.js",
+    "debug:ts": "cypress open --config-file test/cypress-ts.config.js",
+    "test:ts": "cypress run --config-file test/cypress-ts.config.js",
+    "debug:ts:it": "MODE=it cypress open --config-file test/cypress-ts.config.js",
+    "test:ts:it": "MODE=it cypress run --config-file test/cypress-ts.config.js"
   },
   "license": "MIT",
   "description": "feature file preprocessor",
@@ -35,10 +39,12 @@
     "@cucumber/cucumber-expressions": "^19.0.0",
     "@cucumber/gherkin": "^39.1.0",
     "@cucumber/tag-expressions": "^9.1.0",
-    "@cypress/webpack-preprocessor": "^7.1.0"
+    "@cypress/webpack-preprocessor": "^7.1.0",
+    "ts-loader": "^9.5.7"
   },
   "devDependencies": {
-    "cypress": "^15.14.2"
+    "cypress": "^15.14.2",
+    "typescript": "^6.0.3"
   },
   "keywords": [
     "cypress",
@@ -50,4 +56,4 @@
     "test",
     "test-automation"
   ]
-}
+}

package/supportCodeLibrary/index.d.ts

@@ -0,0 +1,112 @@
+export type Expression = string | RegExp;
+
+export class DataTable {
+    constructor(sourceTable: string[][] | { rows: { cells: { value: string }[] }[] });
+    raw(): string[][];
+    rows(): string[][];
+    hashes(): Record<string, string>[];
+    rowsHash(): Record<string, string>;
+    transpose(): DataTable;
+}
+
+export interface GherkinDocument {
+    uri?: string;
+    feature?: {
+        name: string;
+        description: string;
+        tags: { name: string }[];
+        children: object[];
+    };
+    comments: object[];
+}
+
+export interface Pickle {
+    id: string;
+    uri: string;
+    name: string;
+    language: string;
+    steps: { id: string; text: string; argument?: object }[];
+    tags: { name: string; astNodeId: string }[];
+    astNodeIds: string[];
+}
+
+export interface TestStepResult {
+    status: string;
+    duration?: { seconds: number; nanos: number };
+    message?: string;
+}
+
+export interface TestCaseHookParams {
+    gherkinDocument: GherkinDocument;
+    pickle: Pickle;
+    testCaseStartedId: string;
+    willBeRetried: boolean;
+    result?: TestStepResult;
+    error?: Error;
+}
+
+export interface TestStepHookParams {
+    gherkinDocument: GherkinDocument;
+    pickle: Pickle;
+    testCaseStartedId: string;
+    result?: TestStepResult;
+    error?: Error;
+}
+
+export interface WorldOptions {
+    log: (...args: any[]) => void;
+    attach: (data: string, mediaType?: string) => void;
+    link: (url: string, text?: string) => void;
+}
+
+export class World {
+    log(...args: any[]): void;
+    attach(data: string, mediaType?: string): void;
+    link(url: string, text?: string): void;
+    executeStep(text: string, argument?: DataTable | string): void;
+    constructor(options: WorldOptions);
+}
+
+type StepFn<W extends World = World> = (this: W, ...args: any[]) => any;
+
+export function defineStep<W extends World = World>(keyword: string, expression: Expression, fn: StepFn<W>): void;
+export function Given<W extends World = World>(expression: Expression, fn: StepFn<W>): void;
+export function When<W extends World = World>(expression: Expression, fn: StepFn<W>): void;
+export function Then<W extends World = World>(expression: Expression, fn: StepFn<W>): void;
+
+type TestCaseHookFn = (this: World, params: TestCaseHookParams) => any;
+type TestStepHookFn = (this: World, params: TestStepHookParams) => any;
+type TestRunHookFn = (this: World) => any;
+
+export interface TestCaseHookOptions {
+    tags?: string;
+    name?: string;
+}
+
+export interface TestStepHookOptions {
+    tags?: string;
+}
+
+export function Before(fn: TestCaseHookFn): void;
+export function Before(options: TestCaseHookOptions, fn: TestCaseHookFn): void;
+export function After(fn: TestCaseHookFn): void;
+export function After(options: TestCaseHookOptions, fn: TestCaseHookFn): void;
+export function BeforeStep(fn: TestStepHookFn): void;
+export function BeforeStep(options: TestStepHookOptions, fn: TestStepHookFn): void;
+export function AfterStep(fn: TestStepHookFn): void;
+export function AfterStep(options: TestStepHookOptions, fn: TestStepHookFn): void;
+export function BeforeAll(fn: TestRunHookFn): void;
+export function AfterAll(fn: TestRunHookFn): void;
+
+export interface ParameterTypeOption {
+    name: string;
+    regexp: RegExp;
+    transformer?: (...args: string[]) => any;
+    useForSnippets?: boolean;
+    preferForRegexpMatch?: boolean;
+}
+
+export function defineParameterType(option: ParameterTypeOption): void;
+export function setWorldConstructor(world: new (...args: any[]) => World): void;
+export function setDefaultTimeout(milliseconds: number): void;
+export function Template(template: (...args: any[]) => string): (...args: any[]) => void;