@qavajs/cypress-runner-adapter 1.2.0 → 1.3.0

package/CHANGELOG.md

@@ -14,6 +14,16 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 :microscope: - experimental
 
+## [1.3.0]
+- :rocket: added tags support
+- :rocket: added alternative 'it mode' to translate gherkin tests to mocha `it` instead of `describe`
+```bash
+MODE=it npx cypress open
+```
+
+## [1.2.1]
+- :pencil: updated to cypress 15.3
+
 ## [1.2.0]
 - :pencil: updated to cypress 15
 

package/README.md

@@ -1,5 +1,5 @@
 # @qavajs/cypress-runner-adapter
-Adapter to run cucumberjs tests via cypress test runner
+Adapter to run Gherkin tests via cypress test runner
 
 ## Installation
 
@@ -39,3 +39,18 @@ When('open {string} url', function (url) {
     cy.visit(url);
 });
 ```
+
+## Tags
+Test can be filtered using Cucumber tag expressions provided via environment variable `TAGS`
+```
+TAGS='@first and @second' npx cypress run
+```
+
+## Translation Mode
+Gherkin tests can be translated in different modes
+- `describe` - default mode. Scenario will be translated as `describe`, each step will be translated as `it`
+- `it` - Scenario will be translated as `it`
+
+```bash
+MODE=it npx cypress open
+```

package/adapter/index.js

@@ -1,149 +1,32 @@
-const {
-    ensureFileSync,
-    writeFileSync,
-    readFileSync,
-} = require('fs-extra');
+const { ensureFileSync, writeFileSync, readFileSync } = require('fs-extra');
 const { randomUUID } = require('node:crypto');
 const { AstBuilder, compile, GherkinClassicTokenMatcher, Parser } = require('@cucumber/gherkin');
 const webpackPreprocessor = require('@cypress/webpack-preprocessor')();
+const tagExpressionParser = require('@cucumber/tag-expressions').default;
+const makeMochaTestDescribe = require('./make_mocha_tests_describe');
+const makeMochaTestIt = require('./make_mocha_tests_it');
 
 const uuidFn = () => randomUUID();
-const builder = new AstBuilder(uuidFn)
+const builder = new AstBuilder(uuidFn);
 const matcher = new GherkinClassicTokenMatcher();
-const parser = new Parser(builder, matcher)
+const parser = new Parser(builder, matcher);
 
-function adapter(testCases) {
-    return `
-        const tests = ${JSON.stringify(testCases)};
+const makeMochaTest = process.env.MODE === 'it' ? makeMochaTestIt : makeMochaTestDescribe;
 
-        function keyword(step) {
-            switch (step.type) {
-                case 'Context': return 'Given';
-                case 'Action': return 'When';
-                case 'Outcome': return 'Then';
-                default: return 'Step';
-            }
-        }
-        
-        function executeStepByText(text, argument) {
-            const steps = supportCodeLibrary.stepDefinitions
-                .filter(stepDefinition => stepDefinition.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;
-            const { parameters } = step.getInvocationParameters({
-                step: { text, argument },
-                world: this
-            }); 
-            step.code.apply(this, parameters);
-        }
-        
-        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 })
-            }
-            executeStepByText.call(world, pickle.text, pickle.argument);
-        }
-        
-        if (supportCodeLibrary.beforeTestRunHookDefinitions.length > 0) {
-            describe('Before All', function () {
-                for (const beforeRun of supportCodeLibrary.beforeTestRunHookDefinitions) {
-                    it('Before All', function () {
-                        beforeRun.code.apply();
-                    });
-                }  
-            })
-        }
-        for (const test of tests) {
-            describe('Scenario: ' + test.name, { testIsolation: false }, function () {
-                const world = new supportCodeLibrary.World();
-                world.executeStep = executeStepByText;
-                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
-                            }]);
-                        });
-                    }
-                }
-            });
-        }
-        if (supportCodeLibrary.afterTestRunHookDefinitions.length > 0) {
-            describe('After All', function () {
-                for (const afterRun of supportCodeLibrary.afterTestRunHookDefinitions) {
-                    it('After All', function () {
-                        afterRun.code.apply();
-                    });
-                }  
-            })
-        }      
-    `;
+function adapter(testCases) {
+    return `(${makeMochaTest.toString()})(${JSON.stringify(testCases)});`;
 }
 
 module.exports = async function cucumber(file) {
     const { filePath, outputPath, shouldWatch } = file;
     if (!filePath.endsWith('.feature')) {
-        return webpackPreprocessor(file)
+        return webpackPreprocessor(file);
     }
     const gherkinDocument = parser.parse(readFileSync(filePath, 'utf-8'));
-    const testCases = compile(gherkinDocument, filePath, uuidFn);
+    const tagExpression = tagExpressionParser(process.env.TAGS || '');
+    const testCases = compile(gherkinDocument, filePath, uuidFn)
+        .filter(test => tagExpression.evaluate(test.tags.map(tag => tag.name)));
     ensureFileSync(outputPath);
     writeFileSync(outputPath, adapter(testCases), 'utf-8');
-
-    return outputPath
+    return outputPath;
 }

package/adapter/make_mocha_tests_describe.js

@@ -0,0 +1,119 @@
+module.exports = function makeMochaTest(tests) {
+    function keyword(step) {
+        switch (step.type) {
+            case 'Context': return 'Given';
+            case 'Action': return 'When';
+            case 'Outcome': return 'Then';
+            default: return 'Step';
+        }
+    }
+
+    function executeStepByText(text, argument) {
+        const steps = supportCodeLibrary.stepDefinitions
+            .filter(stepDefinition => stepDefinition.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;
+        const { parameters } = step.getInvocationParameters({
+            step: { text, argument },
+            world: this
+        });
+        step.code.apply(this, parameters);
+    }
+
+    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 });
+        }
+        executeStepByText.call(world, pickle.text, pickle.argument);
+    }
+
+    if (supportCodeLibrary.beforeTestRunHookDefinitions.length > 0) {
+        describe('Before All', function () {
+            for (const beforeRun of supportCodeLibrary.beforeTestRunHookDefinitions) {
+                it('Before All', function () {
+                    beforeRun.code.apply();
+                });
+            }
+        })
+    }
+
+    for (const test of tests) {
+        describe('Scenario: ' + test.name, { testIsolation: false }, function () {
+            const world = new supportCodeLibrary.World();
+            world.executeStep = executeStepByText;
+            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
+                        }]);
+                    });
+                }
+            }
+        });
+    }
+    if (supportCodeLibrary.afterTestRunHookDefinitions.length > 0) {
+        describe('After All', function () {
+            for (const afterRun of supportCodeLibrary.afterTestRunHookDefinitions) {
+                it('After All', function () {
+                    afterRun.code.apply();
+                });
+            }
+        });
+    }
+}

package/adapter/make_mocha_tests_it.js

@@ -0,0 +1,135 @@
+module.exports = function makeMochaTest(tests) {
+    function keyword(step) {
+        switch (step.type) {
+            case 'Context':
+                return 'Given';
+            case 'Action':
+                return 'When';
+            case 'Outcome':
+                return 'Then';
+            default:
+                return 'Step';
+        }
+    }
+
+    function executeStepByText(text, argument) {
+        const steps = supportCodeLibrary.stepDefinitions
+            .filter(stepDefinition => stepDefinition.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;
+        const { parameters } = step.getInvocationParameters({
+            step: {text, argument},
+            world: this
+        });
+        step.code.apply(this, parameters);
+    }
+
+    function executeStep(pickle, world) {
+        cy.then(() => {
+            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});
+            }
+        });
+        executeStepByText.call(world, pickle.text, pickle.argument);
+    }
+
+    supportCodeLibrary.World.prototype.executeStep = executeStepByText;
+
+    function runStep(name, callback) {
+        cy.then(() => {
+            Cypress.log({displayName: name, message: ''});
+        })
+        callback();
+    }
+
+    function findTest(tests, name) {
+        const testName = name.replace(/Scenario:\s+/, '');
+        return tests.find(test => test.name === testName);
+    }
+
+    if (supportCodeLibrary.beforeTestRunHookDefinitions.length > 0) {
+        before(function () {
+            for (const beforeRun of supportCodeLibrary.beforeTestRunHookDefinitions) {
+                beforeRun.code.apply();
+            }
+        })
+    }
+
+    beforeEach(function () {
+        const test = findTest(tests, this.currentTest.title);
+        const world = this.world = new supportCodeLibrary.World();
+        for (const beforeTest of supportCodeLibrary.beforeTestCaseHookDefinitions) {
+            if (beforeTest.appliesToTestCase(test)) {
+                runStep(beforeTest.name, function () {
+                    beforeTest.code.apply(world, [{
+                        pickle: test,
+                        gherkinDocument: tests,
+                        willBeRetried: false
+                    }]);
+                });
+            }
+        }
+    });
+
+    afterEach( function () {
+        const test = findTest(tests, this.currentTest.title);
+        const world = this.world;
+        for (const afterTest of supportCodeLibrary.afterTestCaseHookDefinitions) {
+            if (afterTest.appliesToTestCase(test)) {
+                runStep(afterTest.name, function () {
+                    afterTest.code.apply(world, [{
+                        pickle: test,
+                        result: null,
+                        gherkinDocument: tests,
+                        willBeRetried: false
+                    }]);
+                });
+            }
+        }
+    });
+
+    for (const test of tests) {
+        it('Scenario: ' + test.name, function () {
+            const world = this.world;
+            for (const step of test.steps) {
+                const stepName = keyword(step) + ': ' + step.text;
+                runStep(stepName, function () {
+                    this.step = step;
+                    this.currentTest = { state: 'passed' };
+                    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 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 (supportCodeLibrary.afterTestRunHookDefinitions.length > 0) {
+        after(function () {
+            for (const afterRun of supportCodeLibrary.afterTestRunHookDefinitions) {
+                afterRun.code.apply();
+            }
+        });
+    }
+}

package/package.json

@@ -1,22 +1,44 @@
 {
   "name": "@qavajs/cypress-runner-adapter",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "main": "index.js",
   "scripts": {
     "debug": "cypress open --config-file test/cypress.config.js",
-    "test": "cypress run --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"
   },
-  "author": "Alexandr Galichenko",
   "license": "MIT",
   "description": "feature file preprocessor",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qavajs/cypress-runner-adapter.git"
+  },
+  "authors": [
+    "Alexandr Galichenko"
+  ],
+  "bugs": {
+    "url": "https://github.com/qavajs/cypress-runner-adapter/issues"
+  },
+  "homepage": "https://github.com/qavajs/cypress-runner-adaptert#readme",
   "dependencies": {
     "@cucumber/cucumber-expressions": "^18.0.1",
-    "@cucumber/gherkin": "^34.0.0",
-    "@cucumber/tag-expressions": "^6.2.0",
+    "@cucumber/gherkin": "^35.1.0",
+    "@cucumber/tag-expressions": "^7.0.0",
     "@cypress/webpack-preprocessor": "^7.0.1",
-    "fs-extra": "^11.3.1"
+    "fs-extra": "^11.3.2"
   },
   "devDependencies": {
-    "cypress": "^15.1.0"
-  }
+    "cypress": "^15.3.0"
+  },
+  "keywords": [
+    "cypress",
+    "cypress-plugin",
+    "cypress-preprocessor",
+    "qavajs",
+    "cucumber",
+    "gherkin",
+    "test",
+    "test-automation"
+  ]
 }