@qavajs/cypress-runner-adapter 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Change Log
+
+All notable changes to the "@qavajs/cypress-runner-adapter" will be documented in this file.
+
+Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
+
+:rocket: - new feature
+:beetle: - bugfix
+:x: - deprecation/removal
+:pencil: - chore
+:microscope: - experimental
+
+## [0.1.0]
+- :rocket: initial implementation

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 @qavajs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# @qavajs/cypress-runner-adapter
+Adapter to run cucumberjs tests via cypress test runner
+
+## Installation
+
+`npm install @qavajs/cypress-runner-adapter`
+
+## Basic Configuration
+
+```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.js',
+        setupNodeEvents(on, config) {
+            on('file:preprocessor', cucumber)
+        },
+    },
+});
+```
+
+`support/e2e.js` is entry point with step definition;
+
+```javascript
+import { When, setWorldConstructor } from '@qavajs/cypress-runner-adapter';
+
+class World {
+    
+}
+setWorldConstructor(World);
+
+When('open {string} url', function (url) {
+    cy.visit(url);
+});
+```

package/adapter/index.js

@@ -0,0 +1,128 @@
+const {
+    ensureFileSync,
+    writeFileSync,
+    readFileSync,
+} = require('fs-extra');
+const { randomUUID } = require('node:crypto');
+const { AstBuilder, compile, GherkinClassicTokenMatcher, Parser } = require('@cucumber/gherkin');
+const cyBrowserify = require('@cypress/browserify-preprocessor')()
+
+const uuidFn = () => randomUUID();
+const builder = new AstBuilder(uuidFn)
+const matcher = new GherkinClassicTokenMatcher();
+const parser = new Parser(builder, matcher)
+
+function adapter(testCases) {
+    return `
+        const tests = ${JSON.stringify(testCases)};
+
+        function keyword(step) {
+            switch (step.type) {
+                case 'Context': return 'Given';
+                case 'Action': return 'When';
+                case 'Outcome': return 'Then';
+                default: return 'Step';
+            }
+        }
+        
+        function executeStep(pickle, world) {
+            if (pickle.argument && pickle.argument.dataTable) {
+                Cypress.log({ displayName: 'DataTable', message: pickle.argument.dataTable })
+            }
+            if (pickle.argument && pickle.argument.docString) {
+                Cypress.log({ displayName: 'Multiline', message: pickle.argument.docString.content })
+            }
+            const steps = supportCodeLibrary.stepDefinitions
+                .filter(stepDefinition => stepDefinition.matchesStepName(pickle.text));
+            if (steps.length === 0) throw new Error(\`Step '\${pickle.text}' is not defined\`);
+            if (steps.length > 1) throw new Error(\`'\${pickle.text}' matches multiple step definitions\`);
+            const [step] = steps;
+            const { parameters } = step.getInvocationParameters({
+                step: {
+                    text: pickle.text,
+                    argument: pickle.argument
+                },
+                world
+            }); 
+            step.code.apply(world, parameters);
+        }
+        for (const test of tests) {
+            describe('Scenario: ' + test.name, { testIsolation: false }, function () {
+                const world = new supportCodeLibrary.World();
+                let skip = false;
+                let result = 'passed';
+                afterEach(function() {
+                    if (this.step) {
+                        for (const afterStep of supportCodeLibrary.afterTestStepHookDefinitions) {
+                            if (afterStep.appliesToTestCase(this.step)) {
+                                afterStep.code.apply(world, [{
+                                    pickle: test, 
+                                    pickleStep: this.step,
+                                    gherkinDocument: tests,
+                                    result: this.currentTest.state
+                                }]) 
+                            }
+                        }  
+                    }
+                    if (this.currentTest.state !== 'passed') {
+                        skip = true;
+                    }
+                    result = this.currentTest.state;
+                });
+                for (const beforeTest of supportCodeLibrary.beforeTestCaseHookDefinitions) {
+                    if (beforeTest.appliesToTestCase(test)) {
+                        it(beforeTest.name, function () {
+                            if (skip) return this.skip(); 
+                            beforeTest.code.apply(world, [{
+                                pickle: test,
+                                gherkinDocument: tests,
+                                willBeRetried: false
+                            }]); 
+                        });
+                    }
+                }
+                for (const step of test.steps) {
+                    it(keyword(step) + ': ' + step.text, function () {
+                        this.step = step;
+                        if (skip) return this.skip();
+                        for (const beforeStep of supportCodeLibrary.beforeTestStepHookDefinitions) {
+                            if (beforeStep.appliesToTestCase(step)) {
+                                beforeStep.code.apply(world, [{
+                                    pickle: test, 
+                                    pickleStep: step,
+                                    gherkinDocument: tests
+                                }]); 
+                            }
+                        } 
+                        executeStep(step, world);
+                    })
+                }
+                for (const afterTest of supportCodeLibrary.afterTestCaseHookDefinitions) {
+                    if (afterTest.appliesToTestCase(test)) {
+                        it(afterTest.name, function () {
+                            afterTest.code.apply(world, [{
+                                pickle: test,
+                                result,
+                                gherkinDocument: tests,
+                                willBeRetried: false
+                            }])
+                        });
+                    }
+                }
+            });
+        }      
+    `;
+}
+
+module.exports = async function cucumber(file) {
+    const { filePath, outputPath, shouldWatch } = file;
+    if (!filePath.endsWith('.feature')) {
+        return cyBrowserify(file)
+    }
+    const gherkinDocument = parser.parse(readFileSync(filePath, 'utf-8'));
+    const testCases = compile(gherkinDocument, filePath, uuidFn);
+    ensureFileSync(outputPath);
+    writeFileSync(outputPath, adapter(testCases), 'utf-8');
+
+    return outputPath
+}

package/adapter.d.ts

@@ -0,0 +1 @@
+export default function (file: any): void;

package/adapter.js

@@ -0,0 +1 @@
+module.exports = require('./adapter/index');

package/index.d.ts

@@ -0,0 +1,29 @@
+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
+}
+declare interface IWorld {}
+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 setWorldConstructor(world: IWorld): void;
+export function defineParameterType(option: ParameterTypeOption): void;

package/index.js

@@ -0,0 +1 @@
+module.exports = require('./supportCodeLibrary');

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@qavajs/cypress-runner-adapter",
+  "version": "0.1.0",
+  "main": "index.js",
+  "scripts": {
+    "debug": "cypress open --config-file test/cypress.config.js",
+    "test": "cypress run --config-file test/cypress.config.js"
+  },
+  "author": "Alexandr Galichenko",
+  "license": "MIT",
+  "description": "feature file preprocessor",
+  "dependencies": {
+    "@cucumber/cucumber-expressions": "^17.1.0",
+    "@cucumber/gherkin": "^28.0.0",
+    "@cucumber/tag-expressions": "^6.1.0",
+    "@cypress/browserify-preprocessor": "^3.0.2",
+    "fs-extra": "^11.2.0"
+  },
+  "devDependencies": {
+    "cypress": "^13.11.0"
+  }
+}

package/supportCodeLibrary/build_parameter_type.js

@@ -0,0 +1,14 @@
+import {ParameterType} from '@cucumber/cucumber-expressions'
+
+export function buildParameterType({ name, regexp, transformer, useForSnippets, preferForRegexpMatch }) {
+    if (typeof useForSnippets !== 'boolean') useForSnippets = true
+    if (typeof preferForRegexpMatch !== 'boolean') preferForRegexpMatch = false
+    return new ParameterType(
+        name,
+        regexp,
+        null,
+        transformer,
+        useForSnippets,
+        preferForRegexpMatch
+    )
+}

package/supportCodeLibrary/data_table.js

@@ -0,0 +1,52 @@
+export default class Data_table {
+    constructor(sourceTable) {
+        if (sourceTable instanceof Array) {
+            this.rawTable = sourceTable
+        } else {
+            this.rawTable = sourceTable.rows.map((row) =>
+                row.cells.map((cell) => cell.value)
+            )
+        }
+    }
+
+    hashes() {
+        const copy = this.raw()
+        const keys = copy[0]
+        const valuesArray = copy.slice(1)
+        return valuesArray.map((values) => {
+            const rowObject = {}
+            keys.forEach((key, index) => (rowObject[key] = values[index]))
+            return rowObject
+        })
+    }
+
+    raw() {
+        return this.rawTable.slice(0)
+    }
+
+    rows() {
+        const copy = this.raw()
+        copy.shift()
+        return copy
+    }
+
+    rowsHash() {
+        const rows = this.raw()
+        const everyRowHasTwoColumns = rows.every((row) => row.length === 2)
+        if (!everyRowHasTwoColumns) {
+            throw new Error(
+                'rowsHash can only be called on a data table where all rows have exactly two columns'
+            )
+        }
+        const result = {}
+        rows.forEach((x) => (result[x[0]] = x[1]))
+        return result
+    }
+
+    transpose() {
+        const transposed = this.rawTable[0].map((x, i) =>
+            this.rawTable.map((y) => y[i])
+        )
+        return new Data_table(transposed)
+    }
+}

package/supportCodeLibrary/definition.js

@@ -0,0 +1,5 @@
+export default class Definition {
+    constructor(data) {
+        this.code = data.code;
+    }
+}

package/supportCodeLibrary/index.js

@@ -0,0 +1,96 @@
+import {
+    CucumberExpression,
+    RegularExpression,
+} from '@cucumber/cucumber-expressions'
+import StepDefinition from './step_definition';
+import {SourcedParameterTypeRegistry} from './sourced_parameter_type_registry';
+import TestCaseHookDefinition from './test_case_hook_definition';
+import TestStepHookDefinition from './test_step_hook_definition';
+import {buildParameterType} from './build_parameter_type';
+class World {}
+
+const supportCodeLibrary = {
+    stepDefinitions: [],
+    afterTestCaseHookDefinitions: [],
+    afterTestRunHookDefinitions: [],
+    afterTestStepHookDefinitions: [],
+    beforeTestCaseHookDefinitions: [],
+    beforeTestRunHookDefinitions: [],
+    beforeTestStepHookDefinitions: [],
+    World,
+    parameterTypeRegistry: new SourcedParameterTypeRegistry()
+};
+
+window.supportCodeLibrary = supportCodeLibrary;
+export function defineStep(keyword, pattern, code) {
+    const expression = typeof pattern === 'string'
+        ? new CucumberExpression(pattern, supportCodeLibrary.parameterTypeRegistry)
+        : new RegularExpression(pattern, supportCodeLibrary.parameterTypeRegistry);
+    supportCodeLibrary.stepDefinitions.push(new StepDefinition({
+        keyword,
+        expression,
+        pattern,
+        code
+    }));
+}
+
+export function When(pattern, code) {
+    defineStep('When', pattern, code);
+}
+
+export function Then(pattern, code) {
+    defineStep('Then', pattern, code);
+}
+
+export function Given(pattern, code) {
+    defineStep('Given', pattern, code);
+}
+
+export function Before(optionsOrCode, code) {
+    const defaultOptions = { name: 'Before' };
+    const options = code ? Object.assign(defaultOptions, optionsOrCode) : defaultOptions;
+    const handler = code ?? optionsOrCode;
+    supportCodeLibrary.beforeTestCaseHookDefinitions.push(new TestCaseHookDefinition({
+        code: handler,
+        options
+    }));
+}
+
+export function After(optionsOrCode, code) {
+    const defaultOptions = { name: 'After' };
+    const options = code ? Object.assign(defaultOptions, optionsOrCode) : defaultOptions;
+    const handler = code ?? optionsOrCode;
+    supportCodeLibrary.afterTestCaseHookDefinitions.push(new TestCaseHookDefinition({
+        code: handler,
+        options
+    }));
+}
+
+export function BeforeStep(optionsOrCode, code) {
+    const options = code ? optionsOrCode : { name: 'BeforeStep' };
+    const handler = code ?? optionsOrCode;
+    supportCodeLibrary.beforeTestStepHookDefinitions.push(new TestStepHookDefinition({
+        code: handler,
+        options
+    }));
+}
+
+export function AfterStep(optionsOrCode, code) {
+    const options = code ? optionsOrCode : { name: 'AfterStep' };
+    const handler = code ?? optionsOrCode;
+    supportCodeLibrary.afterTestStepHookDefinitions.push(new TestStepHookDefinition({
+        code: handler,
+        options
+    }));
+}
+
+export function setWorldConstructor(world) {
+    supportCodeLibrary.World = world;
+}
+
+export function defineParameterType(options) {
+    const parameterType = buildParameterType(options)
+    supportCodeLibrary.parameterTypeRegistry.defineSourcedParameterType(parameterType, {})
+}
+
+

package/supportCodeLibrary/pickle_filter.js

@@ -0,0 +1,17 @@
+import {doesHaveValue, doesNotHaveValue} from './value_checker';
+import parse from '@cucumber/tag-expressions';
+
+export class PickleTagFilter {
+    constructor(tagExpression) {
+        if (doesHaveValue(tagExpression) && tagExpression !== '') {
+            this.tagExpressionNode = parse(tagExpression)
+        }
+    }
+
+    matchesAllTagExpressions(pickle) {
+        if (doesNotHaveValue(this.tagExpressionNode)) {
+            return true
+        }
+        return this.tagExpressionNode.evaluate(pickle.tags.map((x) => x.name))
+    }
+}

package/supportCodeLibrary/sourced_parameter_type_registry.js

@@ -0,0 +1,20 @@
+import {
+    ParameterType,
+    ParameterTypeRegistry,
+} from '@cucumber/cucumber-expressions'
+
+export class SourcedParameterTypeRegistry extends ParameterTypeRegistry {
+    parameterTypeToSource = new WeakMap()
+
+    defineSourcedParameterType(
+        parameterType,
+        source
+    ) {
+        this.defineParameterType(parameterType)
+        this.parameterTypeToSource.set(parameterType, source)
+    }
+
+    lookupSource(parameterType) {
+        return this.parameterTypeToSource.get(parameterType)
+    }
+}

package/supportCodeLibrary/step_argument.js

@@ -0,0 +1,13 @@
+import { doesHaveValue } from './value_checker';
+
+export function parseStepArgument(
+    arg,
+    mapping
+) {
+    if (doesHaveValue(arg.dataTable)) {
+        return mapping.dataTable(arg.dataTable)
+    } else if (doesHaveValue(arg.docString)) {
+        return mapping.docString(arg.docString)
+    }
+    throw new Error(`Unknown step argument: ${arg}`)
+}

package/supportCodeLibrary/step_definition.js

@@ -0,0 +1,34 @@
+import Definition from './definition';
+import { doesHaveValue } from './value_checker';
+import DataTable from './data_table';
+import { parseStepArgument } from './step_argument';
+
+export default class StepDefinition extends Definition {
+    constructor(data) {
+        super(data)
+        this.keyword = data.keyword
+        this.pattern = data.pattern
+        this.expression = data.expression
+    }
+
+    getInvocationParameters({ step, world }) {
+        const parameters = this.expression.match(step.text).map((arg) => arg.getValue(world))
+        if (doesHaveValue(step.argument)) {
+            const argumentParameter = parseStepArgument(step.argument, {
+                dataTable: (arg) => new DataTable(arg),
+                docString: (arg) => arg.content,
+            })
+            parameters.push(argumentParameter)
+        }
+        return {
+            getInvalidCodeLengthMessage: () =>
+                this.baseGetInvalidCodeLengthMessage(parameters),
+            parameters,
+            validCodeLengths: [parameters.length, parameters.length + 1],
+        }
+    }
+
+    matchesStepName(stepName) {
+        return doesHaveValue(this.expression.match(stepName))
+    }
+}

package/supportCodeLibrary/test_case_hook_definition.js

@@ -0,0 +1,25 @@
+import Definition from './definition';
+import { PickleTagFilter } from './pickle_filter';
+
+export default class TestCaseHookDefinition extends Definition {
+
+    constructor(data) {
+        super(data)
+        this.name = data.options.name
+        this.tagExpression = data.options.tags
+        this.pickleTagFilter = new PickleTagFilter(data.options.tags)
+    }
+
+    appliesToTestCase(pickle) {
+        return this.pickleTagFilter.matchesAllTagExpressions(pickle)
+    }
+
+    async getInvocationParameters({ hookParameter }) {
+        return {
+            getInvalidCodeLengthMessage: () =>
+                this.buildInvalidCodeLengthMessage('0 or 1', '2'),
+            parameters: [hookParameter],
+            validCodeLengths: [0, 1, 2],
+        }
+    }
+}

package/supportCodeLibrary/test_step_hook_definition.js

@@ -0,0 +1,23 @@
+import Definition from './definition';
+import {PickleTagFilter} from './pickle_filter';
+
+export default class TestStepHookDefinition extends Definition {
+    constructor(data) {
+        super(data)
+        this.tagExpression = data.options.tags
+        this.pickleTagFilter = new PickleTagFilter(data.options.tags)
+    }
+
+    appliesToTestCase(pickle) {
+        return this.pickleTagFilter.matchesAllTagExpressions(pickle)
+    }
+
+    async getInvocationParameters({ hookParameter }) {
+        return {
+            getInvalidCodeLengthMessage: () =>
+                this.buildInvalidCodeLengthMessage('0 or 1', '2'),
+            parameters: [hookParameter],
+            validCodeLengths: [0, 1, 2],
+        }
+    }
+}

package/supportCodeLibrary/value_checker.js

@@ -0,0 +1,14 @@
+export function doesHaveValue(value) {
+    return !doesNotHaveValue(value)
+}
+
+export function doesNotHaveValue(value) {
+    return value === null || value === undefined
+}
+
+export function valueOrDefault(value, defaultValue) {
+    if (doesHaveValue(value)) {
+        return value
+    }
+    return defaultValue
+}