vitest-cucumber-plugin 0.1.8 → 0.5.1

package/README.md

@@ -24,12 +24,19 @@ export default defineConfig({
     test: {
         include : [ '**/*.feature' ],
         cucumber : {
-           tags : "<tags boolean expression>"
+           tags : "<tags boolean expression>", // Use this to filter the test via boolean tags expression
+           log : { 
+              level : "<'fatal', 'error', 'warn', 'info', 'debug', 'trace' or 'silent'>",
+              file : "<log path>", // Write the logs to a file instead of stdio (the default)
+           }
         }
     },
 })
 ```
 
+Setting the log level to 'info' will cause the plugin to generate logs useful for tracking the state through
+the steps.  You can pipe the logs through pino-pretty to make them more human readable.
+
 ### Writing tests
 
 Put feature files into the 'features/' directory and step definitions into the 'features/step_definitions/' directory.
@@ -106,9 +113,3 @@ Then('I should be told {string}', function (state,[ answer ], dataTable) {
 
 Currently, all step definition files must be in ECMAScript module format.  CommonJS files might
 work, but this configuration isn't tested.
-
-
-### Not yet implemented
-
-This plugin is not yet feature complete.  Here is the list of features from Cucumber which aren't yet implemented:
-* Doc strings

package/RELEASE_NOTES.md

@@ -1,3 +1,5 @@
+* 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.
 * v0.1.8 : Implemented Rule keyword
 * v0.1.7 : Implemented Hooks API
 * v0.1.6 : Implemented tags boolean expression support

package/package.json

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

package/src/generate/feature.js

@@ -38,9 +38,9 @@ import {
     applyAfterStepHooks,
 } from 'vitest-cucumber-plugin';
 import { readdir } from 'node:fs/promises';
-import { log, setLogLevel } from 'vitest-cucumber-plugin';
+import { log, logConfig } from 'vitest-cucumber-plugin';
 
-setLogLevel('${config.logLevel}');
+logConfig(${JSON.stringify(config.log)});
 
 const importDirectory = async (directory) => {
     log.debug('importDirectory directory: '+directory);

package/src/gherkin.js

@@ -26,6 +26,7 @@ var gherkin_umd$1 = {exports: {}};
 	  escapedNewline : '\\n',
 	  escapedBackSlash : '\\\\',
 	  scenarioOutline : ['Scenario Outline','Scenario Template'],
+	  docString : ['```','"""'],
 	  word : {
 	    match : /[^ \t\n\:\|\@\*]+/,
 	    type : moo.keywords({
@@ -38,6 +39,13 @@ var gherkin_umd$1 = {exports: {}};
 	    }),
 	  },
 	});
+
+	const trimWhitespace = (cols,str) => {
+	  const lines = str.split('\n').slice(0,-1);
+	  return fp.reduce((s,line) => {
+	    return s+line.slice(cols)+'\n'
+	},'')(lines);
+	};
 	var grammar = {
 	    Lexer: lexer,
 	    ParserRules: [
@@ -95,7 +103,7 @@ var gherkin_umd$1 = {exports: {}};
 	        (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": ["dataTableRow"], "postprocess": data => [data[0]]},
 	    {"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 => []},
@@ -108,12 +116,14 @@ 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": ["stepAndTable", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
+	    {"name": "steps", "symbols": ["step", "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", "step"], "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": "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": "text", "symbols": [], "postprocess": data => ''},
 	    {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
@@ -137,6 +147,18 @@ var gherkin_umd$1 = {exports: {}};
 	        }
 	        },
 	    {"name": "freeform", "symbols": ["freeform", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'},
+	    {"name": "docString", "symbols": ["docStringStatement", "docText", "docStringStatement"], "postprocess": 
+	        data => fp.set('text',trimWhitespace(data[0].ws.length,data[1]),data[0])
+	        },
+	    {"name": "docStringStatement", "symbols": ["_", (lexer.has("docString") ? {type: "docString"} : docString), "contentType", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'docString', name : data[1].value }, ws : data[0], contentType : data[2] } }
+	        },
+	    {"name": "contentType", "symbols": [], "postprocess": data => null},
+	    {"name": "contentType", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => null},
+	    {"name": "contentType", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
+	    {"name": "docText", "symbols": [], "postprocess": data => ''},
+	    {"name": "docText", "symbols": ["docText", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[0]+data[1]+data[2].value},
+	    {"name": "docText", "symbols": ["docText", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+data[1].value},
 	    {"name": "_", "symbols": [], "postprocess": data => ''},
 	    {"name": "_", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0].value},
 	    {"name": "emptyLines", "symbols": [], "postprocess": data => ''},

package/src/gherkin.ne

@@ -13,6 +13,7 @@ const lexer = moo.compile({
   escapedNewline : '\\n',
   escapedBackSlash : '\\\\',
   scenarioOutline : ['Scenario Outline','Scenario Template'],
+  docString : ['```','"""'],
   word : {
     match : /[^ \t\n\:\|\@\*]+/,
     type : moo.keywords({
@@ -25,6 +26,13 @@ const lexer = moo.compile({
     }),
   },
 });
+
+const trimWhitespace = (cols,str) => {
+  const lines = str.split('\n').slice(0,-1);
+  return fp.reduce((s,line) => {
+    return s+line.slice(cols)+'\n'
+},'')(lines);
+};
 %}
 
 @lexer lexer
@@ -98,7 +106,7 @@ examplesStatement -> _ examplesKeyword _ %colon text %newline {%
 %}
 examplesKeyword -> %examples {% data => data[0].value %}
 
-dataTable -> null {% data => [] %}
+dataTable -> dataTableRow {% data => [data[0]] %}
   | dataTable dataTableRow {% data => fp.concat(data[0],[data[1]]) %}
 
 dataTableRow -> _ %pipe dataTableColumns %newline {% data => data[2] %}
@@ -116,14 +124,17 @@ escapedColumnCharaters -> %escapedPipe {% data => '|' %}
   | %escapedBackSlash {% data => '\\' %}
   | %escapedNewline {% data => '\n' %}
 
-steps -> stepAndTable moreSteps {% data => fp.concat(data[0],data[1]) %}
+steps -> step moreSteps {% data => fp.concat(data[0],data[1]) %}
 
 moreSteps -> null {% data => [] %}
-  | moreSteps stepAndTable {% data => fp.concat(data[0],data[1]) %}
+  | moreSteps step {% 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]) %}
+step -> stepStatement
+  | stepStatement dataTable {% data => fp.set('dataTable',data[1],data[0]) %}
+  | stepStatement docString {% data => fp.set('docString',data[1],data[0]) %}
+
+stepStatement -> _ stepKeyword text %newline {% data => { return { type : data[1], text : data[2].trim() } } %}
 
 stepKeyword -> %step {% (data) => { return { type : 'step', name : data[0].value } } %}
 
@@ -153,6 +164,21 @@ freeform -> null {% data => '' %}
 %}
   | freeform %emptyLine {% data => data[0]+'\n' %}
 
+docString -> docStringStatement docText docStringStatement {%
+  data => fp.set('text',trimWhitespace(data[0].ws.length,data[1]),data[0])
+%}
+docStringStatement -> _ %docString contentType %newline {%
+  (data) => { return { type : { type : 'docString', name : data[1].value }, ws : data[0], contentType : data[2] } }
+%}
+
+contentType -> null {% data => null %}
+  | %ws {% data => null %}
+  | %word {% data => data[0].value %}
+
+docText -> null {% data => '' %}
+  | docText text %newline {% data => data[0]+data[1]+data[2].value %}
+  | docText %emptyLine {% data => data[0]+data[1].value %}
+
 _ -> null {% data => '' %}
   | %ws {% data => data[0].value %}
 

package/src/gherkin.umd.js

@@ -17,6 +17,7 @@ const lexer = moo.compile({
   escapedNewline : '\\n',
   escapedBackSlash : '\\\\',
   scenarioOutline : ['Scenario Outline','Scenario Template'],
+  docString : ['```','"""'],
   word : {
     match : /[^ \t\n\:\|\@\*]+/,
     type : moo.keywords({
@@ -29,6 +30,13 @@ const lexer = moo.compile({
     }),
   },
 });
+
+const trimWhitespace = (cols,str) => {
+  const lines = str.split('\n').slice(0,-1);
+  return fp.reduce((s,line) => {
+    return s+line.slice(cols)+'\n'
+},'')(lines);
+};
 var grammar = {
     Lexer: lexer,
     ParserRules: [
@@ -86,7 +94,7 @@ var grammar = {
         (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": ["dataTableRow"], "postprocess": data => [data[0]]},
     {"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 => []},
@@ -99,12 +107,14 @@ 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": ["stepAndTable", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
+    {"name": "steps", "symbols": ["step", "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", "step"], "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": "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": "text", "symbols": [], "postprocess": data => ''},
     {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
@@ -128,6 +138,18 @@ var grammar = {
         }
         },
     {"name": "freeform", "symbols": ["freeform", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'},
+    {"name": "docString", "symbols": ["docStringStatement", "docText", "docStringStatement"], "postprocess": 
+        data => fp.set('text',trimWhitespace(data[0].ws.length,data[1]),data[0])
+        },
+    {"name": "docStringStatement", "symbols": ["_", (lexer.has("docString") ? {type: "docString"} : docString), "contentType", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+        (data) => { return { type : { type : 'docString', name : data[1].value }, ws : data[0], contentType : data[2] } }
+        },
+    {"name": "contentType", "symbols": [], "postprocess": data => null},
+    {"name": "contentType", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => null},
+    {"name": "contentType", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
+    {"name": "docText", "symbols": [], "postprocess": data => ''},
+    {"name": "docText", "symbols": ["docText", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[0]+data[1]+data[2].value},
+    {"name": "docText", "symbols": ["docText", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+data[1].value},
     {"name": "_", "symbols": [], "postprocess": data => ''},
     {"name": "_", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0].value},
     {"name": "emptyLines", "symbols": [], "postprocess": data => ''},

package/src/hooks.js

@@ -11,6 +11,16 @@ const allHooks = {
     afterStep : [],
 };
 
+const hookNames = {
+    beforeAll : 'BeforeAll',
+    before : 'Before',
+    beforeStep : 'BeforeStep',
+    afterAll : 'AfterAll',
+    after : 'After',
+    afterStep : 'AfterStep',
+}
+    
+
 const applyHooks = async (hooksName,state,tags) => {
     const hooks = allHooks[hooksName];
     log.debug('applyHooks: '+hooksName+' state: '+JSON.stringify(state));
@@ -23,8 +33,10 @@ const applyHooks = async (hooksName,state,tags) => {
         
         log.debug('applyHooks match? '+result+' tags: '+JSON.stringify(tags));
         if (result) {
+            const origState = state;
             state = await hook.f(state);
-            log.debug('applyHooks name: '+hook.name+' new state: '+JSON.stringify(state));
+            log.info(hookNames[hooksName]+'(\''+hook.name+'\') ('+JSON.stringify(origState)+') => '+
+                     JSON.stringify(state));
         }
     }
     return state;

package/src/index.js

@@ -2,7 +2,7 @@ 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 { log, logConfig } from './logger.js';
 import { parse } from './parse.js';
 import { tagsFunction } from './tags.js';
 import {
@@ -35,7 +35,7 @@ export {
     applyAfterStepHooks,
 };
 
-export { setLogLevel, log };
+export { log, logConfig };
 
 export const Given = addStepDefinition;
 export const When = addStepDefinition;
@@ -45,7 +45,12 @@ 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);
+    const extraData = step.dataTable ? step.dataTable : (step.docString ? step.docString.text : null );
+
+    const newState = stepDefinitionMatch.stepDefinition.f(state,stepDefinitionMatch.parameters,extraData);
+    log.info(step.type.name+'(\''+stepDefinitionMatch.stepDefinition.expression+'\') ('+
+             JSON.stringify(state)+','+JSON.stringify(stepDefinitionMatch.parameters)+','+JSON.stringify(extraData)+
+             ') => '+JSON.stringify(newState));
     log.debug('Test newState: '+JSON.stringify(newState));
 
     return newState;
@@ -64,8 +69,9 @@ export default function vitestCucumberPlugin() {
     return {
         name : 'vitest-cucumber-transform',
         configResolved : (resolvedConfig) => {
-            config = _.defaults({ root : resolvedConfig.root, logLevel : 'warn' },_.get('test.cucumber',resolvedConfig))
-            setLogLevel(config.logLevel);
+            config = _.defaults({ root : resolvedConfig.root, log : { level : 'warn' } },
+                                _.get('test.cucumber',resolvedConfig))
+            logConfig(config.log);
 
             config = _.set('tagsFunction',tagsFunction(_.get('tags',config)),config);
 

package/src/logger.js

@@ -1,7 +1,14 @@
+import _ from 'lodash/fp.js';
 import pino from 'pino';
 
-export const log = pino();
+export var log = pino();
 
 log.level = 'warn';
 
-export const setLogLevel = (logLevel) => { log.level = logLevel };
+export const logConfig = (config) => {
+    if (_.has('file',config)) {
+        log = pino(config,config.file);
+    } else {
+        log = pino(config);
+    }
+};

package/tests/comments/vite.config.js

@@ -4,6 +4,6 @@ import vitestCucumberPlugin from 'vitest-cucumber-plugin';
 export default defineConfig({
     plugins: [vitestCucumberPlugin()],
     test: {
-        include : [ '**/*.feature' ]
+        include : [ '**/*.feature' ],
     },
 })

package/tests/data-tables/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') ? 'info' : 'warn';
+    return {
+        plugins: [vitestCucumberPlugin()],
+        test: {
+            include : [ '**/*.feature' ],
+            cucumber : { log : { level } },
+        },
+    }
+});

package/tests/doc-strings/features/doc-strings.feature

@@ -0,0 +1,21 @@
+Feature: Doc Strings
+  Scenario: You should be able to use Doc Strings with Given, When and Then statements
+    Given the following doc string:
+      """markdown
+      This is some cool text.
+
+        It is fun.
+      """
+      
+    When the following doc string is appended:
+          ```
+          This is more fun.
+          ```
+
+    Then final doc string will look like this:
+   """
+   This is some cool text.
+
+     It is fun.
+   This is more fun.
+   """

package/tests/doc-strings/features/step_definitions/doc-strings.js

@@ -0,0 +1,15 @@
+import { Given, When, Then, DataTable } from 'vitest-cucumber-plugin';
+import { expect } from 'vitest'
+import _ from 'lodash/fp';
+
+Given('the following doc string:',(state,params,docString) => {
+    return _.set('docString',docString,state);
+});
+
+When('the following doc string is appended:',(state,params,docString) => {
+    return _.set('docString',_.getOr('','docString',state)+docString,state);
+});
+
+Then('final doc string will look like this:',(state,params,docString) => {
+    expect(docString).toEqual(_.get('docString',state));
+});