vitest-cucumber-plugin 0.5.2 → 0.5.4

package/RELEASE_NOTES.md

@@ -1,3 +1,5 @@
+* v0.5.4 : Added vue test
+* v0.5.3 : Provide code snippets when a step definition is not found
 * v0.5.2 : Throw an error if a step file import fails instead of logging it
 * v0.5.1 : Added info level logging for tracing state through steps.  Also added a log file option.
 * v0.5.0 : Implemented Doc Strings.  Plugin is now feature complete.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "vitest-cucumber-plugin",
-    "version": "0.5.2",
+    "version": "0.5.4",
     "description": "Plugin for Vitest which allows for tests to be written in Cucumber format.",
     "keywords": [
         "vite",

package/src/gherkin.js

@@ -20,7 +20,7 @@ var gherkin_umd$1 = {exports: {}};
 	  ws : /[ \t]+/,
 	  at : '@',
 	  colon : ':',
-	  step : '*',
+	  repeatStep : '*',
 	  pipe : '|',
 	  escapedPipe : '\\|',
 	  escapedNewline : '\\n',
@@ -32,7 +32,10 @@ var gherkin_umd$1 = {exports: {}};
 	    type : moo.keywords({
 	      feature : 'Feature',
 	      examples : ['Examples','Scenarios'],
-	      step : ['Given','When','Then','And','But'],
+	      given : 'Given',
+	      when : 'When',
+	      then : 'Then',
+	      repeatStep : ['And','But'],
 	      example : ['Example','Scenario'],
 	      background : 'Background',
 	      rule : 'Rule',
@@ -44,8 +47,18 @@ var gherkin_umd$1 = {exports: {}};
 	  const lines = str.split('\n').slice(0,-1);
 	  return fp.reduce((s,line) => {
 	    return s+line.slice(cols)+'\n'
-	},'')(lines);
+	  },'')(lines);
 	};
+
+	const setRepeatStepTypesReducer = (steps,step) => {
+	    if (!fp.has('type.type',step)) {
+	        step = fp.set('type.type',fp.last(steps).type.type,step);
+	    }
+	    return fp.concat(steps,step);
+	};
+
+	const setRepeatStepTypes = (steps) => fp.reduce(setRepeatStepTypesReducer,[],steps);
+
 	var grammar = {
 	    Lexer: lexer,
 	    ParserRules: [
@@ -116,15 +129,25 @@ var gherkin_umd$1 = {exports: {}};
 	    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => '|'},
 	    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => '\\'},
 	    {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => '\n'},
-	    {"name": "steps", "symbols": ["step", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
+	    {"name": "steps", "symbols": ["step", "moreSteps"], "postprocess": data => setRepeatStepTypes(fp.concat(data[0],data[1]))},
 	    {"name": "moreSteps", "symbols": [], "postprocess": data => []},
 	    {"name": "moreSteps", "symbols": ["moreSteps", "step"], "postprocess": data => fp.concat(data[0],data[1])},
+	    {"name": "moreSteps", "symbols": ["moreSteps", "repeatStep"], "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": ["stepStatement"]},
 	    {"name": "step", "symbols": ["stepStatement", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
 	    {"name": "step", "symbols": ["stepStatement", "docString"], "postprocess": data => fp.set('docString',data[1],data[0])},
 	    {"name": "stepStatement", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
-	    {"name": "stepKeyword", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": (data) => { return { type : 'step', name : data[0].value } }},
+	    {"name": "stepKeyword", "symbols": [(lexer.has("given") ? {type: "given"} : given)], "postprocess": (data) => { return { type : 'given', name : data[0].value } }},
+	    {"name": "stepKeyword", "symbols": [(lexer.has("when") ? {type: "when"} : when)], "postprocess": (data) => { return { type : 'when', name : data[0].value } }},
+	    {"name": "stepKeyword", "symbols": [(lexer.has("then") ? {type: "then"} : then)], "postprocess": (data) => { return { type : 'then', name : data[0].value } }},
+	    {"name": "repeatStep", "symbols": ["repeatStepStatement"]},
+	    {"name": "repeatStep", "symbols": ["repeatStepStatement", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+	    {"name": "repeatStep", "symbols": ["repeatStepStatement", "docString"], "postprocess": data => fp.set('docString',data[1],data[0])},
+	    {"name": "repeatStepStatement", "symbols": ["_", "repeatStepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        data => { return { type : data[1], text : data[2].trim() } }
+	        },
+	    {"name": "repeatStepKeyword", "symbols": [(lexer.has("repeatStep") ? {type: "repeatStep"} : repeatStep)], "postprocess": (data) => { return { 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},
@@ -133,7 +156,10 @@ var gherkin_umd$1 = {exports: {}};
 	    {"name": "text", "symbols": ["text", (lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => data[0]+data[1].value},
 	    {"name": "text", "symbols": ["text", (lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => data[0]+data[1].value},
 	    {"name": "text", "symbols": ["text", (lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => data[0]+data[1].value},
-	    {"name": "keywords", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("given") ? {type: "given"} : given)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("when") ? {type: "when"} : when)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("then") ? {type: "then"} : then)], "postprocess": data => data[0].value},
+	    {"name": "keywords", "symbols": [(lexer.has("repeatStep") ? {type: "repeatStep"} : repeatStep)], "postprocess": data => data[0].value},
 	    {"name": "keywords", "symbols": [(lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0].value},
 	    {"name": "keywords", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
 	    {"name": "keywords", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},

package/src/gherkin.ne

@@ -7,7 +7,7 @@ const lexer = moo.compile({
   ws : /[ \t]+/,
   at : '@',
   colon : ':',
-  step : '*',
+  repeatStep : '*',
   pipe : '|',
   escapedPipe : '\\|',
   escapedNewline : '\\n',
@@ -19,7 +19,10 @@ const lexer = moo.compile({
     type : moo.keywords({
       feature : 'Feature',
       examples : ['Examples','Scenarios'],
-      step : ['Given','When','Then','And','But'],
+      given : 'Given',
+      when : 'When',
+      then : 'Then',
+      repeatStep : ['And','But'],
       example : ['Example','Scenario'],
       background : 'Background',
       rule : 'Rule',
@@ -31,8 +34,18 @@ const trimWhitespace = (cols,str) => {
   const lines = str.split('\n').slice(0,-1);
   return fp.reduce((s,line) => {
     return s+line.slice(cols)+'\n'
-},'')(lines);
+  },'')(lines);
 };
+
+const setRepeatStepTypesReducer = (steps,step) => {
+    if (!fp.has('type.type',step)) {
+        step = fp.set('type.type',fp.last(steps).type.type,step);
+    }
+    return fp.concat(steps,step);
+};
+
+const setRepeatStepTypes = (steps) => fp.reduce(setRepeatStepTypesReducer,[],steps);
+
 %}
 
 @lexer lexer
@@ -124,10 +137,11 @@ escapedColumnCharaters -> %escapedPipe {% data => '|' %}
   | %escapedBackSlash {% data => '\\' %}
   | %escapedNewline {% data => '\n' %}
 
-steps -> step moreSteps {% data => fp.concat(data[0],data[1]) %}
+steps -> step moreSteps {% data => setRepeatStepTypes(fp.concat(data[0],data[1])) %}
 
 moreSteps -> null {% data => [] %}
   | moreSteps step {% data => fp.concat(data[0],data[1]) %}
+  | moreSteps repeatStep {% data => fp.concat(data[0],data[1]) %}
   | moreSteps %emptyLine {% data => data[0] %}
 
 step -> stepStatement
@@ -136,7 +150,19 @@ step -> stepStatement
 
 stepStatement -> _ stepKeyword text %newline {% data => { return { type : data[1], text : data[2].trim() } } %}
 
-stepKeyword -> %step {% (data) => { return { type : 'step', name : data[0].value } } %}
+stepKeyword -> %given {% (data) => { return { type : 'given', name : data[0].value } } %}
+  | %when {% (data) => { return { type : 'when', name : data[0].value } } %}
+  | %then {% (data) => { return { type : 'then', name : data[0].value } } %}
+
+repeatStep -> repeatStepStatement
+  | repeatStepStatement dataTable {% data => fp.set('dataTable',data[1],data[0]) %}
+  | repeatStepStatement docString {% data => fp.set('docString',data[1],data[0]) %}
+
+repeatStepStatement -> _ repeatStepKeyword text %newline {%
+  data => { return { type : data[1], text : data[2].trim() } }
+%}
+
+repeatStepKeyword -> %repeatStep {% (data) => { return { name : data[0].value } } %}
 
 text -> null {% data => '' %}
   | text %word {% data => data[0]+data[1].value %}
@@ -147,7 +173,10 @@ text -> null {% data => '' %}
   | text %escapedNewline {% data => data[0]+data[1].value %}
   | text %escapedBackSlash {% data => data[0]+data[1].value %}
 
-keywords -> %step {% data => data[0].value %}
+keywords -> %given {% data => data[0].value %}
+  | %when {% data => data[0].value %}
+  | %then {% data => data[0].value %}
+  | %repeatStep {% data => data[0].value %}
   | %colon {% data => data[0].value %}
   | %example {% data => data[0].value %}
   | %examples {% data => data[0].value %}

package/src/gherkin.umd.js

@@ -11,7 +11,7 @@ const lexer = moo.compile({
   ws : /[ \t]+/,
   at : '@',
   colon : ':',
-  step : '*',
+  repeatStep : '*',
   pipe : '|',
   escapedPipe : '\\|',
   escapedNewline : '\\n',
@@ -23,7 +23,10 @@ const lexer = moo.compile({
     type : moo.keywords({
       feature : 'Feature',
       examples : ['Examples','Scenarios'],
-      step : ['Given','When','Then','And','But'],
+      given : 'Given',
+      when : 'When',
+      then : 'Then',
+      repeatStep : ['And','But'],
       example : ['Example','Scenario'],
       background : 'Background',
       rule : 'Rule',
@@ -35,8 +38,18 @@ const trimWhitespace = (cols,str) => {
   const lines = str.split('\n').slice(0,-1);
   return fp.reduce((s,line) => {
     return s+line.slice(cols)+'\n'
-},'')(lines);
+  },'')(lines);
 };
+
+const setRepeatStepTypesReducer = (steps,step) => {
+    if (!fp.has('type.type',step)) {
+        step = fp.set('type.type',fp.last(steps).type.type,step);
+    }
+    return fp.concat(steps,step);
+};
+
+const setRepeatStepTypes = (steps) => fp.reduce(setRepeatStepTypesReducer,[],steps);
+
 var grammar = {
     Lexer: lexer,
     ParserRules: [
@@ -107,15 +120,25 @@ var grammar = {
     {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => '|'},
     {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => '\\'},
     {"name": "escapedColumnCharaters", "symbols": [(lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => '\n'},
-    {"name": "steps", "symbols": ["step", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
+    {"name": "steps", "symbols": ["step", "moreSteps"], "postprocess": data => setRepeatStepTypes(fp.concat(data[0],data[1]))},
     {"name": "moreSteps", "symbols": [], "postprocess": data => []},
     {"name": "moreSteps", "symbols": ["moreSteps", "step"], "postprocess": data => fp.concat(data[0],data[1])},
+    {"name": "moreSteps", "symbols": ["moreSteps", "repeatStep"], "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": ["stepStatement"]},
     {"name": "step", "symbols": ["stepStatement", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
     {"name": "step", "symbols": ["stepStatement", "docString"], "postprocess": data => fp.set('docString',data[1],data[0])},
     {"name": "stepStatement", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
-    {"name": "stepKeyword", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": (data) => { return { type : 'step', name : data[0].value } }},
+    {"name": "stepKeyword", "symbols": [(lexer.has("given") ? {type: "given"} : given)], "postprocess": (data) => { return { type : 'given', name : data[0].value } }},
+    {"name": "stepKeyword", "symbols": [(lexer.has("when") ? {type: "when"} : when)], "postprocess": (data) => { return { type : 'when', name : data[0].value } }},
+    {"name": "stepKeyword", "symbols": [(lexer.has("then") ? {type: "then"} : then)], "postprocess": (data) => { return { type : 'then', name : data[0].value } }},
+    {"name": "repeatStep", "symbols": ["repeatStepStatement"]},
+    {"name": "repeatStep", "symbols": ["repeatStepStatement", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+    {"name": "repeatStep", "symbols": ["repeatStepStatement", "docString"], "postprocess": data => fp.set('docString',data[1],data[0])},
+    {"name": "repeatStepStatement", "symbols": ["_", "repeatStepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        data => { return { type : data[1], text : data[2].trim() } }
+        },
+    {"name": "repeatStepKeyword", "symbols": [(lexer.has("repeatStep") ? {type: "repeatStep"} : repeatStep)], "postprocess": (data) => { return { 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},
@@ -124,7 +147,10 @@ var grammar = {
     {"name": "text", "symbols": ["text", (lexer.has("escapedPipe") ? {type: "escapedPipe"} : escapedPipe)], "postprocess": data => data[0]+data[1].value},
     {"name": "text", "symbols": ["text", (lexer.has("escapedNewline") ? {type: "escapedNewline"} : escapedNewline)], "postprocess": data => data[0]+data[1].value},
     {"name": "text", "symbols": ["text", (lexer.has("escapedBackSlash") ? {type: "escapedBackSlash"} : escapedBackSlash)], "postprocess": data => data[0]+data[1].value},
-    {"name": "keywords", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("given") ? {type: "given"} : given)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("when") ? {type: "when"} : when)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("then") ? {type: "then"} : then)], "postprocess": data => data[0].value},
+    {"name": "keywords", "symbols": [(lexer.has("repeatStep") ? {type: "repeatStep"} : repeatStep)], "postprocess": data => data[0].value},
     {"name": "keywords", "symbols": [(lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0].value},
     {"name": "keywords", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
     {"name": "keywords", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},

package/src/steps.js

@@ -4,6 +4,12 @@ import { log } from './logger.js';
 
 var steps = [];
 
+const typeName = {
+    given : 'Given',
+    then : 'Then',
+    when : 'When',
+};
+
 const expressionFactory = new ExpressionFactory(new ParameterTypeRegistry());
 
 export const addStepDefinition = (expression,f) => {
@@ -31,7 +37,14 @@ export const findStepDefinitionMatch = (step) => {
     const stepDefinitionMatches = findStepDefinitionMatches(step);
     
     if (!stepDefinitionMatches || (stepDefinitionMatches.length == 0)) {
-        throw new Error('Step not defined: \''+step.type.name+' '+step.text+'\'');
+        throw new Error(`Undefined.  Implement with the following snippet:
+
+    ${typeName[step.type.type]}('${step.text}', (state,params,data) => {
+        // Write code here that turns the phrase above into concrete actions
+        throw new Error('Not yet implemented!');
+        return state;
+    });
+`);
     }
 
     if (stepDefinitionMatches.length > 1) {

package/tests/background/vite.config.js

@@ -1,9 +1,13 @@
 import { defineConfig } from 'vitest/config'
 import vitestCucumberPlugin from 'vitest-cucumber-plugin';
 
-export default defineConfig({
-    plugins: [vitestCucumberPlugin()],
-    test: {
-        include : [ '**/*.feature' ],
-    },
-})
+export default defineConfig(({ mode }) => {
+    const level = (mode === 'test-debug') ? 'debug' : 'warn';
+    return {
+        plugins: [vitestCucumberPlugin()],
+        test: {
+            include : [ '**/*.feature' ],
+            cucumber : { log : { level } },
+        },
+    }
+});

package/tests/vue/features/step_definitions/test.js

@@ -0,0 +1,25 @@
+import { Given, When, Then } from 'vitest-cucumber-plugin';
+import Test from '../../src/test.vue';
+import { mount, get } from '../support/components.js';
+import { expect } from 'vitest';
+import _ from 'lodash/fp.js';
+
+Given('I have a test component', (state,params,data) => {
+    return _.set('test',mount(Test),state);
+});
+
+When('I do nothing', (state,params,data) => state);
+
+Then('the test component text is {string}', (state,[ text ],data) => {
+    const testComponent = get(state.test);
+    const textElement = testComponent.get('.text');
+    expect(textElement.text()).toBe(text);
+    return state;
+});
+
+When('I push the button', (state,params,data) => {
+    const testComponent = get(state.test);
+    const buttonElement = testComponent.get('button');
+    buttonElement.trigger('click');
+    return state;
+});

package/tests/vue/features/support/components.js

@@ -0,0 +1,19 @@
+import * as testUtils from '@vue/test-utils';
+import { v4 as uuid } from 'uuid';
+import _ from 'lodash/fp.js';
+
+const components = {};
+
+const mount = (vue,options) => {
+    const id = uuid();
+    const mountOptions = {};
+    components[id] = testUtils.mount(vue,mountOptions);
+    return { id, options };
+};
+
+const get = (component) => components[component.id];
+
+export {
+    mount,
+    get,
+};

package/tests/vue/features/test.feature

@@ -0,0 +1,10 @@
+Feature: Vue component tests example
+  Scenario: Initial state
+    Given I have a test component
+    When I do nothing
+    Then the test component text is "Hello World!"
+
+  Scenario: Button pressed
+    Given I have a test component
+    When I push the button
+    Then the test component text is "Button pressed!"