vitest-cucumber-plugin 0.1.3

package/src/gherkin.ne

@@ -0,0 +1,130 @@
+@{%
+const fp = require('lodash/fp.js');
+const moo = require('moo');
+const log = require('./logger.js').log;
+const lexer = moo.compile({
+  emptyLine : { match: /^[ \t]*(?:\#[^\n]+)?\n/, lineBreaks : true },
+  newline : { match : '\n', lineBreaks : true },
+  ws : /[ \t]+/,
+  at : '@',
+  colon : ':',
+  step : '*',
+  pipe : '|',
+  backSlash : '\\',
+  scenarioOutline : ['Scenario Outline','Scenario Template'],
+  word : {
+    match : /[^ \t\n:|\\]+/,
+    type : moo.keywords({
+      feature : 'Feature',
+      examples : ['Examples','Scenarios'],
+      step : ['Given','When','Then','And','But'],
+      example : ['Example','Scenario'],
+      background : 'Background',
+    }),
+  },
+});
+%}
+
+@lexer lexer
+
+main -> emptyLines tags feature {% data => fp.set('tags',data[1],data[2]) %}
+
+feature -> featureStatement freeform background statements {%
+  (data) => fp.assign(data[0],{ description : data[1].trim(), background : data[2], statements : data[3] })
+%}
+featureStatement -> _ %feature _ %colon text %newline {%
+  (data) => { return { type : { type : 'feature', name : data[1].value.trim() }, name : data[4].trim() } }
+%}
+
+tags -> null {% data => [] %}
+  | _ tag tagList %newline {% data => fp.concat(data[1],data[2]) %}
+
+tagList -> null {% data => [] %}
+  | tagList %ws tag {% data => fp.concat(data[0],data[2]) %}
+
+tag -> %at %word {% data => data[1].value.trim() %}
+
+background -> null {% data => null %}
+  | backgroundStatement freeform steps {%
+  data => fp.assign(data[0],{ description : data[1].trim(), steps : data[2] })
+%}
+
+backgroundStatement -> _ %background _ %colon text %newline {%
+  (data) => { return { type : { type : 'background', name : data[1].value }, name : data[4].trim() } }
+%}
+
+statement -> example {% data => data[0] %}
+  | scenarioOutline {% data => data[0] %}
+
+statements -> null {% data => [] %}
+  | statements statement {% data => fp.concat(data[0],data[1]) %}
+
+example -> tags exampleStatement steps {% (data) => fp.assign(data[1],{ tags : data[0], steps : data[2] }) %}
+exampleStatement -> _ exampleKeyword _ %colon text %newline {%
+  (data) => { return { type : { type : 'example', name : data[1] }, name : data[4].trim() } }
+%}
+exampleKeyword -> %example {% data => data[0].value %}
+
+scenarioOutline -> tags scenarioOutlineStatement steps examplesList {%
+  data => fp.assign(data[1],{ tags : data[0], steps : data[2], examples : data[3] })
+%}
+scenarioOutlineStatement -> _ scenarioOutlineKeyword _ %colon text %newline {%
+  (data) => { return { type : { type : 'scenarioOutline', name : data[1] }, name : data[4].trim() } }
+%}
+scenarioOutlineKeyword -> %scenarioOutline {% data => data[0].value %}
+
+examplesList -> null {% data => [] %}
+  | examplesList examples {% data => fp.concat(data[0],data[1]) %}
+
+examples -> tags examplesStatement dataTable emptyLines {%
+  data => fp.assign(data[1],{ tags : data[0], dataTable : data[2] })
+%}
+examplesStatement -> _ examplesKeyword _ %colon text %newline {%
+  (data) => { return { type : { type : 'examples', name : data[1] }, name : data[4] } }
+%}
+examplesKeyword -> %examples {% data => data[0].value %}
+
+dataTable -> null {% data => [] %}
+  | dataTable dataTableRow {% data => fp.concat(data[0],[data[1]]) %}
+
+dataTableRow -> _ %pipe dataTableColumns %newline {% data => data[2] %}
+
+dataTableColumns -> null {% data => [] %}
+  | dataTableColumns text %pipe {% data => fp.concat(data[0],data[1].trim()) %}
+
+steps -> stepAndTable moreSteps {% data => fp.concat(data[0],data[1]) %}
+
+moreSteps -> null {% data => [] %}
+  | moreSteps stepAndTable {% data => fp.concat(data[0],data[1]) %}
+  | moreSteps %emptyLine {% data => data[0] %}
+
+step -> _ stepKeyword text %newline {% data => { return { type : data[1], text : data[2].trim() } } %}
+stepAndTable -> step dataTable {% data => fp.set('dataTable',data[1],data[0]) %}
+
+stepKeyword -> %step {% (data) => { return { type : 'step', name : data[0].value } } %}
+
+text -> null {% data => '' %}
+  | text %word {% data => data[0]+data[1].value %}
+  | text %ws {% data => data[0]+data[1].value %}
+  | text %step {% data => data[0]+data[1].value %}
+  | text %colon {% data => data[0]+data[1].value %}
+  | text %example {% data => data[0]+data[1].value %}
+  | text %examples {% data => data[0]+data[1].value %}
+  | text %scenarioOutline {% data => data[0]+data[1].value %}
+  | text %background {% data => data[0]+data[1].value %}
+
+bolText -> %ws %word {% data => data[1].value %}
+  | %word {% data => data[0].value %}
+
+freeform -> null {% data => '' %}
+  | freeform bolText text %newline {% (data) => {
+  return data[0]+data[1]+data[2]+'\n'
+}
+%}
+  | freeform %emptyLine {% data => data[0]+'\n' %}
+
+_ -> null {% data => '' %}
+  | %ws {% data => data[0].value %}
+
+emptyLines -> null {% data => '' %}
+  | emptyLines %emptyLine {% data => data[0]+'\n' %}

package/src/gherkin.umd.js

@@ -0,0 +1,118 @@
+// Generated automatically by nearley, version 2.20.1
+// http://github.com/Hardmath123/nearley
+(function () {
+function id(x) { return x[0]; }
+
+const fp = require('lodash/fp.js');
+const moo = require('moo');
+const log = require('./logger.js').log;
+const lexer = moo.compile({
+  emptyLine : { match: /^[ \t]*(?:\#[^\n]+)?\n/, lineBreaks : true },
+  newline : { match : '\n', lineBreaks : true },
+  ws : /[ \t]+/,
+  at : '@',
+  colon : ':',
+  step : '*',
+  pipe : '|',
+  backSlash : '\\',
+  scenarioOutline : ['Scenario Outline','Scenario Template'],
+  word : {
+    match : /[^ \t\n:|\\]+/,
+    type : moo.keywords({
+      feature : 'Feature',
+      examples : ['Examples','Scenarios'],
+      step : ['Given','When','Then','And','But'],
+      example : ['Example','Scenario'],
+      background : 'Background',
+    }),
+  },
+});
+var grammar = {
+    Lexer: lexer,
+    ParserRules: [
+    {"name": "main", "symbols": ["emptyLines", "tags", "feature"], "postprocess": data => fp.set('tags',data[1],data[2])},
+    {"name": "feature", "symbols": ["featureStatement", "freeform", "background", "statements"], "postprocess": 
+        (data) => fp.assign(data[0],{ description : data[1].trim(), background : data[2], statements : data[3] })
+        },
+    {"name": "featureStatement", "symbols": ["_", (lexer.has("feature") ? {type: "feature"} : feature), "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'feature', name : data[1].value.trim() }, name : data[4].trim() } }
+        },
+    {"name": "tags", "symbols": [], "postprocess": data => []},
+    {"name": "tags", "symbols": ["_", "tag", "tagList", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => fp.concat(data[1],data[2])},
+    {"name": "tagList", "symbols": [], "postprocess": data => []},
+    {"name": "tagList", "symbols": ["tagList", (lexer.has("ws") ? {type: "ws"} : ws), "tag"], "postprocess": data => fp.concat(data[0],data[2])},
+    {"name": "tag", "symbols": [(lexer.has("at") ? {type: "at"} : at), (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[1].value.trim()},
+    {"name": "background", "symbols": [], "postprocess": data => null},
+    {"name": "background", "symbols": ["backgroundStatement", "freeform", "steps"], "postprocess": 
+        data => fp.assign(data[0],{ description : data[1].trim(), steps : data[2] })
+        },
+    {"name": "backgroundStatement", "symbols": ["_", (lexer.has("background") ? {type: "background"} : background), "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'background', name : data[1].value }, name : data[4].trim() } }
+        },
+    {"name": "statement", "symbols": ["example"], "postprocess": data => data[0]},
+    {"name": "statement", "symbols": ["scenarioOutline"], "postprocess": data => data[0]},
+    {"name": "statements", "symbols": [], "postprocess": data => []},
+    {"name": "statements", "symbols": ["statements", "statement"], "postprocess": data => fp.concat(data[0],data[1])},
+    {"name": "example", "symbols": ["tags", "exampleStatement", "steps"], "postprocess": (data) => fp.assign(data[1],{ tags : data[0], steps : data[2] })},
+    {"name": "exampleStatement", "symbols": ["_", "exampleKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'example', name : data[1] }, name : data[4].trim() } }
+        },
+    {"name": "exampleKeyword", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
+    {"name": "scenarioOutline", "symbols": ["tags", "scenarioOutlineStatement", "steps", "examplesList"], "postprocess": 
+        data => fp.assign(data[1],{ tags : data[0], steps : data[2], examples : data[3] })
+        },
+    {"name": "scenarioOutlineStatement", "symbols": ["_", "scenarioOutlineKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'scenarioOutline', name : data[1] }, name : data[4].trim() } }
+        },
+    {"name": "scenarioOutlineKeyword", "symbols": [(lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0].value},
+    {"name": "examplesList", "symbols": [], "postprocess": data => []},
+    {"name": "examplesList", "symbols": ["examplesList", "examples"], "postprocess": data => fp.concat(data[0],data[1])},
+    {"name": "examples", "symbols": ["tags", "examplesStatement", "dataTable", "emptyLines"], "postprocess": 
+        data => fp.assign(data[1],{ tags : data[0], dataTable : data[2] })
+        },
+    {"name": "examplesStatement", "symbols": ["_", "examplesKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'examples', name : data[1] }, name : data[4] } }
+        },
+    {"name": "examplesKeyword", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},
+    {"name": "dataTable", "symbols": [], "postprocess": data => []},
+    {"name": "dataTable", "symbols": ["dataTable", "dataTableRow"], "postprocess": data => fp.concat(data[0],[data[1]])},
+    {"name": "dataTableRow", "symbols": ["_", (lexer.has("pipe") ? {type: "pipe"} : pipe), "dataTableColumns", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[2]},
+    {"name": "dataTableColumns", "symbols": [], "postprocess": data => []},
+    {"name": "dataTableColumns", "symbols": ["dataTableColumns", "text", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => fp.concat(data[0],data[1].trim())},
+    {"name": "steps", "symbols": ["stepAndTable", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
+    {"name": "moreSteps", "symbols": [], "postprocess": data => []},
+    {"name": "moreSteps", "symbols": ["moreSteps", "stepAndTable"], "postprocess": data => fp.concat(data[0],data[1])},
+    {"name": "moreSteps", "symbols": ["moreSteps", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]},
+    {"name": "step", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
+    {"name": "stepAndTable", "symbols": ["step", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+    {"name": "stepKeyword", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": (data) => { return { type : 'step', name : data[0].value } }},
+    {"name": "text", "symbols": [], "postprocess": data => ''},
+    {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0]+data[1].value},
+    {"name": "text", "symbols": ["text", (lexer.has("background") ? {type: "background"} : background)], "postprocess": data => data[0]+data[1].value},
+    {"name": "bolText", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws), (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[1].value},
+    {"name": "bolText", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
+    {"name": "freeform", "symbols": [], "postprocess": data => ''},
+    {"name": "freeform", "symbols": ["freeform", "bolText", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess":  (data) => {
+          return data[0]+data[1]+data[2]+'\n'
+        }
+        },
+    {"name": "freeform", "symbols": ["freeform", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'},
+    {"name": "_", "symbols": [], "postprocess": data => ''},
+    {"name": "_", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0].value},
+    {"name": "emptyLines", "symbols": [], "postprocess": data => ''},
+    {"name": "emptyLines", "symbols": ["emptyLines", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'}
+]
+  , ParserStart: "main"
+}
+if (typeof module !== 'undefined'&& typeof module.exports !== 'undefined') {
+   module.exports = grammar;
+} else {
+   window.grammar = grammar;
+}
+})();

package/src/index.js

@@ -0,0 +1,65 @@
+import _ from 'lodash/fp.js';
+import { addStepDefinition, findStepDefinitionMatch } from './steps.js';
+import { parameterizeText } from './parameterize.js';
+import { generateFeature } from './generate/index.js';
+import { log, setLogLevel } from './logger.js';
+import { parse } from './parse.js';
+
+const featureRegex = /\.feature$/;
+
+const compileFeatureToJS = (config,featureSrc) => {
+    const feature = parse(featureSrc);
+
+    const code = generateFeature(config,feature);
+
+    log.debug(code);
+
+    return code;
+}
+
+export const Given = addStepDefinition;
+export const When = addStepDefinition;
+export const Then = addStepDefinition;
+
+export const Test = (state,step) => {
+    log.debug('Test step: '+JSON.stringify(step)+' state:'+JSON.stringify(state));
+    const stepDefinitionMatch = findStepDefinitionMatch(step);
+
+    const newState = stepDefinitionMatch.stepDefinition.f(state,stepDefinitionMatch.parameters,step.dataTable);
+    log.debug('Test newState: '+JSON.stringify(newState));
+
+    return newState;
+};
+
+export const DataTable = (dataTable) => {
+    const parameters = _.first(dataTable);
+    const rows = _.tail(dataTable);
+
+    return _.map((row) => _.zipObject(parameters,row))(rows);
+}
+
+export default function vitestCucumberPlugin() {
+    let config;
+    
+    return {
+        name : 'vitest-cucumber-transform',
+        configResolved : (resolvedConfig) => {
+            if (_.has('test.cucumber.logLevel',resolvedConfig)) {
+                setLogLevel(resolvedConfig.test.cucumber.logLevel);
+            }
+            log.debug('config: resolvedConfig:'+JSON.stringify(resolvedConfig,null,2));
+            config = _.get('test.cucumber',resolvedConfig);
+            config = _.set('root',resolvedConfig.root,config);
+            log.debug('config: '+JSON.stringify(config));
+        },
+        transform : async (src,id) => {
+            if (featureRegex.test(id)) {
+                const code = compileFeatureToJS(config,src);
+
+                return {
+                    code
+                }
+            }
+        }
+    }
+}

package/src/logger.js

@@ -0,0 +1,7 @@
+import pino from 'pino';
+
+export const log = pino();
+
+log.level = 'warn';
+
+export const setLogLevel = (logLevel) => { log.level = logLevel };

package/src/parameterize.js

@@ -0,0 +1,7 @@
+import _ from 'lodash/fp.js';
+
+export const parameterizeText = (text,parameterMap) => {
+    return _.reduce((text,parameter) => {
+        return text.replaceAll('<'+parameter+'>',parameterMap[parameter]);
+    },text)(_.keys(parameterMap));
+};

package/src/parse.js

@@ -0,0 +1,21 @@
+import nearley from 'nearley';
+import gherkin from './gherkin.js';
+import { log } from './logger.js';
+
+export const parse = (src) => {
+    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(gherkin));
+
+    log.debug('parsing src: '+src);
+    parser.feed(src);
+
+    if (parser.results.length == 0) {
+        throw new Error('Unexpected end of file');
+    }
+    log.debug('parsing result: '+JSON.stringify(parser.results,null,2));
+    if (parser.results.length > 1) {
+        throw new Error('Ambiguous parsing: '+parser.results.length);
+    }
+    
+    const results = parser.results;
+    return results[0];
+}

package/src/steps.js

@@ -0,0 +1,42 @@
+import { ExpressionFactory, ParameterTypeRegistry } from '@cucumber/cucumber-expressions';
+import _ from 'lodash/fp.js';
+import { log } from './logger.js';
+
+var steps = [];
+
+const expressionFactory = new ExpressionFactory(new ParameterTypeRegistry());
+
+export const addStepDefinition = (expression,f) => {
+    log.debug('addStepDefinition expression: '+JSON.stringify(expression));
+    const cucumberExpression = expressionFactory.createExpression(expression);
+    steps = _.concat(steps,{ expression, f, cucumberExpression });
+}
+
+const findStepDefinitionMatches = (step) => {
+    const matchesMapper = _.map((match) => match.getValue());
+    const reducer = _.reduce((accumulator,stepDefinition) => {
+        const matches = stepDefinition.cucumberExpression.match(step.text);
+        if (matches) {
+            //console.log(accumulator,stepDefinition,matches);
+            return _.concat(accumulator,{ stepDefinition, parameters : matchesMapper(matches) });
+        } else {
+            return accumulator;
+        }
+    });
+
+    return reducer([])(steps);
+};
+
+export const findStepDefinitionMatch = (step) => {
+    const stepDefinitionMatches = findStepDefinitionMatches(step);
+    
+    if (!stepDefinitionMatches || (stepDefinitionMatches.length == 0)) {
+        throw new Error('Step not defined: \''+step.type.name+' '+step.text+'\'');
+    }
+
+    if (stepDefinitionMatches.length > 1) {
+        throw new Error('More than one step which matches: \''+step.type.name+' '+step.text+'\'');
+    }
+
+    return stepDefinitionMatches[0];
+};

package/tests/background/features/background.feature

@@ -0,0 +1,25 @@
+Feature: The Background keyword behaviors
+  The Background keyword allow you to add context to scenarios that follow it.
+
+  # This is the background.
+  Background: Set up some background data
+    It's the cool thing to do.
+    
+    Given I have a "orange"
+    And I have a "grape"
+    
+  Scenario: What's the scenario?
+    Given I have a "apple"
+    When I get a "pea"
+    Then I have the following items:
+      | orange |
+      | grape  |
+      | apple  |
+      | pea    |
+
+  Scenario: It's another scenario!
+    When I get a "pea"
+    Then I have the following items:
+      | orange |
+      | grape  |
+      | pea    |

package/tests/background/features/step_definitions/steps.js

@@ -0,0 +1,30 @@
+import { Given, When, Then, DataTable } from 'vitest-cucumber-plugin';
+import { expect } from 'vitest'
+import _ from 'lodash/fp';
+
+const addItem = (state,[ item ],data) => { return { items : _.concat(state.items ? state.items : [],item) } };
+
+Given('I have a {string}',addItem);
+Then('I get a {string}',addItem);
+Then('I have the following items:',(state,params,data) => {
+    const items = _.flatten(data);
+    expect(state.items).toEqual(items);
+    return state;
+});
+Then('I don\'t have a {string}',(state,[ item ],data) => {
+    expect(state.items).not.toContain(item);
+    return state;
+});
+
+Given('there are {int} cucumbers',(state,[ count ],data) => {
+    return _.set('cucumbers',count,state);
+});
+
+When('I eat {int} cucumbers',(state,[ count ],data) => {
+    return _.set('cucumbers',state.cucumbers - count,state);
+});
+
+Then('I should have {int} cucumbers',(state,[ count ],data) => {
+    expect(state.cucumbers).toEqual(count);
+    return state;
+});