vitest-cucumber-plugin 0.1.6 → 0.1.7

package/README.md

@@ -22,7 +22,10 @@ import vitestCucumberPlugin from 'vitest-cucumber-plugin';
 export default defineConfig({
     plugins: [vitestCucumberPlugin()],
     test: {
-        include : [ '**/*.feature' ]
+        include : [ '**/*.feature' ],
+        cucumber : {
+           tags : "<tags boolean expression>"
+        }
     },
 })
 ```
@@ -46,8 +49,9 @@ there are a few differences in how step definitions are written.
 
 The function signatures for Given, When and Then callbacks have been modified in order to make the step definitions
 more friendly for functional programming.  Specifically, the callback functions differ in that they
-now have two parameters, a state object and array of parameters.  The callback functions then return a new state
-object which is passed to the next step definition in the chain.
+now have three parameters.  The first parameter is a state object which was returned by the previous step.  The
+second is an array of parameters values.  The third is a data table or a doc string.  The callback functions then
+return a new state object which is passed to the next step definition in the chain.
 
 For example, here is how you'd write step definitions in Cucumber:
 ```
@@ -70,7 +74,7 @@ When('I ask whether it\'s Friday yet', function () {
   this.actualAnswer = isItFriday(this.today);
 });
 
-Then('I should be told {string}', function (expectedAnswer) {
+Then('I should be told {string}', function (expectedAnswer, dataTable) {
   assert.strictEqual(this.actualAnswer, expectedAnswer);
 });
 ```
@@ -93,7 +97,7 @@ When('I ask whether it\'s Friday yet', function (state) {
     return _.set('answer',(state.today === 'Friday') ? 'TGIF' : 'Nope',state);
 });
 
-Then('I should be told {string}', function (state,[ answer ]) {
+Then('I should be told {string}', function (state,[ answer ], dataTable) {
     expect(state.answer).toBe(answer);
 });
 ```

package/RELEASE_NOTES.md

@@ -1,3 +1,4 @@
+* v0.1.7 : Implemented Hooks API
 * v0.1.6 : Implemented tags boolean expression support
 * v0.1.5 : Implemented escape characters for Data Tables
 * v0.1.4 : Changed README to point to RPM registry

package/package.json

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

package/src/generate/example.js

@@ -9,7 +9,7 @@ export const generateExample = (config,example) => {
 
     const steps = _.has('background.steps',example) ? _.concat(example.background.steps,example.steps) : example.steps;
 
-    tests += generateTests(steps);
+    tests += generateTests(steps,{},example.tags);
     
     const skip = shouldSkip(config,example.tags) ? '.skip' : '';
 

package/src/generate/examples.js

@@ -14,12 +14,12 @@ const createParameterMap = (parameters,values) => {
     return parameterMap.map;
 }
 
-const generateAllTests = (steps,parameters,parameterValues) => {
+const generateAllTests = (steps,parameters,parameterValues,tags) => {
     const allTests = _.reduce((allTests,values) => {
         const parameterMap = createParameterMap(parameters,values);
         log.debug('parameterMap : '+JSON.stringify(parameterMap));
 
-        const tests = generateTests(steps,parameterMap,'    ');
+        const tests = generateTests(steps,parameterMap,tags,'    ');
 
         return { tests : allTests.tests + `
       describe('${allTests.index}',() => {${tests}
@@ -40,7 +40,7 @@ export const generateExamples = (config,steps,examplesStatement) => {
 
     const skip = shouldSkip(config,examplesStatement.tags) ? '.skip' : '';
 
-    const allTests = generateAllTests(steps,parameters,parameterValues);
+    const allTests = generateAllTests(steps,parameters,parameterValues,examplesStatement.tags);
     const code = `
     // tags : ${JSON.stringify(examplesStatement.tags)}
     describe${skip}('${escape(examplesStatement.type.name)}: ${escape(examplesStatement.name)}', () => {${allTests}

package/src/generate/feature.js

@@ -23,23 +23,57 @@ export const generateFeature = (config,feature) => {
 
     const skip = shouldSkip(config,feature.tags) ? '.skip' : '';
     const configStr = JSON.stringify(config);
+    const tagsStr = JSON.stringify(feature.tags);
 
-    const code = `import { expect, test, describe } from 'vitest';
-import { Test } from 'vitest-cucumber-plugin';
+    const code = `import { expect, test, describe, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
+import {
+    Test,
+    applyBeforeAllHooks,
+    applyBeforeHooks,
+    applyBeforeStepHooks,
+    applyAfterAllHooks,
+    applyAfterHooks,
+    applyAfterStepHooks,
+} from 'vitest-cucumber-plugin';
 import { readdir } from 'node:fs/promises';
+import { log, setLogLevel } from 'vitest-cucumber-plugin';
 
-const importStepDefinitions = async (config) => {
-    const stepDefinitionDirectory = config.root+'/features/step_definitions';
-    const files = await readdir(stepDefinitionDirectory);
-    for (const file of files) {
-        const stepDefinition = stepDefinitionDirectory+'/'+file;
-        await import(stepDefinition);
+setLogLevel('${config.logLevel}');
+
+const importDirectory = async (directory) => {
+    log.debug('importDirectory directory: '+directory);
+    try {
+        const files = await readdir(directory);
+
+        for (const file of files) {
+            const filename = directory+'/'+file;
+            log.debug('importDirectory import: '+filename);
+            await import(filename);
+        }
+    } catch (e) {
+        log.debug('importDirectory error: '+e);
     }
 };
 
+const importSupportFiles = async (config) => importDirectory(config.root+'/features/support');
+
+await importSupportFiles(${configStr});
+
+const importStepDefinitions = async (config) => importDirectory(config.root+'/features/step_definitions');
+
 await importStepDefinitions(${configStr});
 
-// tags : ${JSON.stringify(feature.tags)}
+var state = {};
+
+beforeAll(async () => {
+    state = await applyBeforeAllHooks(state,${tagsStr});
+});
+
+afterAll(async () => {
+    state = await applyAfterAllHooks(state,${tagsStr});
+});
+
+// tags : ${tagsStr}
 describe${skip}('${escape(feature.type.name)}: ${escape(name)}', () => {
 ${testStatements}});
 `;

package/src/generate/tests.js

@@ -3,11 +3,16 @@ import { escape } from './util.js';
 import { parameterizeText } from '../parameterize.js';
 import { log } from '../logger.js';
 
-export const generateTests = (steps,parameterMap,extraIndent) => {
+export const generateTests = (steps,parameterMap,tags,extraIndent) => {
     log.debug('generateTests steps : '+JSON.stringify(steps));
+    const tagsStr = JSON.stringify(tags);
     const indent = extraIndent ? extraIndent : '';
     let tests = `
-${indent}    var state = {};`;
+${indent}    beforeAll(async () => { state = await applyBeforeHooks(state,${tagsStr}); });
+${indent}    beforeEach(async () => { state = await applyBeforeStepHooks(state,${tagsStr}); });
+${indent}    afterAll(async () => { state = await applyAfterHooks(state,${tagsStr}); });
+${indent}    afterEach(async () => { state = await applyAfterStepHooks(state,${tagsStr}); });
+`;
     
     _.forEach((step) => {
         const parameterizedText = ( parameterMap ? parameterizeText(step.text,parameterMap) : step.text);

package/src/hooks.js

@@ -0,0 +1,66 @@
+import { log } from './logger.js';
+import _ from 'lodash/fp.js';
+import { tagsFunction } from './tags.js';
+
+const allHooks = {
+    beforeAll : [],
+    before : [],
+    beforeStep : [],
+    afterAll : [],
+    after : [],
+    afterStep : [],
+};
+
+const applyHooks = async (hooksName,state,tags) => {
+    const hooks = allHooks[hooksName];
+    log.debug('applyHooks: '+hooksName+' state: '+JSON.stringify(state));
+    for (let i = 0; i < hooks.length; i++) {
+        let hook = hooks[i];
+        
+        log.debug('applyHooks name: '+hook.name+' state: '+JSON.stringify(state));
+        
+        const result = hook.tagsFunction(tags);
+        
+        log.debug('applyHooks match? '+result+' tags: '+JSON.stringify(tags));
+        if (result) {
+            state = await hook.f(state);
+            log.debug('applyHooks name: '+hook.name+' new state: '+JSON.stringify(state));
+        }
+    }
+    return state;
+};
+
+const addHook = (hooksName,opts,f) => {
+    if (_.isFunction(opts)) {
+        opts = { name : '', f : opts };
+    } else if (_.isString(opts)) {
+        opts = { name : opts, f };
+    } else if (_.isObject(opts)) {
+        opts.f = f;
+    } else {
+        throw new Error('Unknown options argument: '+JSON.stringify(opts));
+    }
+
+    opts = _.set('tagsFunction',tagsFunction(opts.tags),opts);
+    
+    log.debug('addHook hooksName: '+hooksName+' name: '+opts.name);
+    allHooks[hooksName] = _.concat(allHooks[hooksName],opts);
+};
+
+export const BeforeAll = (opts,f) => { addHook('beforeAll',opts,f) };
+export const applyBeforeAllHooks = (state,tags) => applyHooks('beforeAll',state,tags);
+
+export const Before = (opts,f) => { addHook('before',opts,f) };
+export const applyBeforeHooks = (state,tags) => applyHooks('before',state,tags);
+
+export const BeforeStep = (opts,f) => { addHook('beforeStep',opts,f) };
+export const applyBeforeStepHooks = (state,tags) => applyHooks('beforeStep',state,tags);
+
+export const AfterAll = (opts,f) => { addHook('afterAll',opts,f) };
+export const applyAfterAllHooks = (state,tags) => applyHooks('afterAll',state,tags);
+
+export const After = (opts,f) => { addHook('after',opts,f) };
+export const applyAfterHooks = (state,tags) => applyHooks('after',state,tags);
+
+export const AfterStep = (opts,f) => { addHook('afterStep',opts,f) };
+export const applyAfterStepHooks = (state,tags) => applyHooks('afterStep',state,tags);

package/src/index.js

@@ -5,6 +5,14 @@ import { generateFeature } from './generate/index.js';
 import { log, setLogLevel } from './logger.js';
 import { parse } from './parse.js';
 import { tagsFunction } from './tags.js';
+import {
+    BeforeAll, applyBeforeAllHooks,
+    Before, applyBeforeHooks,
+    AfterAll, applyAfterAllHooks,
+    After, applyAfterHooks,
+    BeforeStep, applyBeforeStepHooks,
+    AfterStep, applyAfterStepHooks,
+} from './hooks.js';
 
 const featureRegex = /\.feature$/;
 
@@ -16,6 +24,19 @@ const compileFeatureToJS = (config,featureSrc) => {
     return code;
 }
 
+export { BeforeAll, Before, AfterAll, After, BeforeStep, AfterStep };
+
+export {
+    applyBeforeAllHooks,
+    applyBeforeHooks,
+    applyAfterAllHooks,
+    applyAfterHooks,
+    applyBeforeStepHooks,
+    applyAfterStepHooks,
+};
+
+export { setLogLevel, log };
+
 export const Given = addStepDefinition;
 export const When = addStepDefinition;
 export const Then = addStepDefinition;
@@ -43,12 +64,8 @@ export default function vitestCucumberPlugin() {
     return {
         name : 'vitest-cucumber-transform',
         configResolved : (resolvedConfig) => {
-            if (_.has('test.cucumber.logLevel',resolvedConfig)) {
-                setLogLevel(resolvedConfig.test.cucumber.logLevel);
-            }
-
-            config = _.get('test.cucumber',resolvedConfig);
-            config = _.set('root',resolvedConfig.root,config);
+            config = _.defaults({ root : resolvedConfig.root, logLevel : 'warn' },_.get('test.cucumber',resolvedConfig))
+            setLogLevel(config.logLevel);
 
             config = _.set('tagsFunction',tagsFunction(_.get('tags',config)),config);
 

package/tests/background/features/support/hooks.js

@@ -0,0 +1,3 @@
+import { Before } from 'vitest-cucumber-plugin';
+
+Before('clear state before scenarios',async (state) => { return {} });

package/tests/background/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/hooks/features/after-all.feature

@@ -0,0 +1,5 @@
+Feature: AfterAll hooks
+  Scenario: AfterAll hooks should not have been run yet
+    Given nothing
+    When nothing happens
+    Then the "afterAll" property does not exist

package/tests/hooks/features/after.feature

@@ -0,0 +1,5 @@
+Feature: After hooks
+  Scenario: After hooks should not have been run yet
+    Given nothing
+    When nothing happens
+    Then the "after" property does not exist

package/tests/hooks/features/before-all.feature

@@ -0,0 +1,14 @@
+Feature: BeforeAll hooks
+  Scenario: BeforeAll hooks are run once
+    Given nothing
+    When nothing happens
+    Then the "beforeAll" property is an array with the values:
+      | beforeAll1 |
+      | beforeAll2 |
+
+  Scenario: BeforeAll hooks should be the same this time
+    Given nothing
+    When nothing happens
+    Then the "beforeAll" property is an array with the values:
+      | beforeAll1 |
+      | beforeAll2 |

package/tests/hooks/features/before-step.feature

@@ -0,0 +1,6 @@
+Feature: Before Step hook
+  Scenario: The Before Step hooks should fire
+    Given nothing
+    When nothing happens
+    Then the "beforeStep" property is an array with the integer values:
+      | 0 |

package/tests/hooks/features/before.feature

@@ -0,0 +1,14 @@
+Feature: Before hooks
+  Scenario: The Before hooks should have been run
+    Given nothing
+    When nothing happens
+    Then the "before" property is an array with the values:
+      | before1 |
+      | before2 |
+      
+  Scenario: The After hooks should have cleared out the before property
+    Given nothing
+    When nothing happens
+    Then the "before" property is an array with the values:
+      | before1 |
+      | before2 |

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

@@ -0,0 +1,28 @@
+import { Given, When, Then, DataTable } from 'vitest-cucumber-plugin';
+import { expect } from 'vitest'
+import _ from 'lodash/fp';
+
+Given('nothing',(state) => state);
+Then('nothing happens',(state) => state);
+When('the {string} property is an array with the values:',(state,[ propertyName ],dataTable) => {
+    const values = _.flatten(dataTable);
+    expect(state[propertyName]).toEqual(values);
+    return state;
+});
+
+When('the {string} property is an array with the integer values:',(state,[ propertyName ],dataTable) => {
+    let values = _.flatten(dataTable);
+    values = _.map(parseInt)(values);
+    expect(state[propertyName]).toEqual(values);
+    return state;
+});
+
+When('the {string} property does not exist',(state,[propertyName]) => {
+    expect(_.has('propertyName',state)).toBeFalsy();
+    return state;
+});
+
+When('the {string} property is an empty array',(state,[ propertyName ]) => {
+    expect(state[propertyName]).toEqual([]);
+    return state;
+});

package/tests/hooks/features/support/hooks.js

@@ -0,0 +1,75 @@
+import { BeforeAll, AfterAll, Before, After, BeforeStep, AfterStep } from 'vitest-cucumber-plugin';
+import _ from 'lodash/fp.js';
+
+BeforeAll('add beforeAll1',(state) => {
+    return _.set('beforeAll',_.concat(_.getOr([],'beforeAll',state),'beforeAll1'),state);
+});
+
+BeforeAll('add beforeAll2',(state) => {
+    return _.set('beforeAll',_.concat(_.getOr([],'beforeAll',state),'beforeAll2'),state);
+});
+
+AfterAll('check that BeforeAll happened',(state) => {
+    if (!_.isEqual(state.beforeAll,['beforeAll1','beforeAll2'])) {
+        throw new Error('beforeAll is wrong!');
+    }
+    return state;
+});
+
+AfterAll('add afterAll1',(state) => {
+    return _.set('afterAll',_.concat(_.getOr([],'afterAll',state),'afterAll1'),state);
+});
+
+AfterAll('add afterAll2',(state) => {
+    return _.set('afterAll',_.concat(_.getOr([],'afterAll',state),'afterAll2'),state);
+});
+
+AfterAll('check that AfterAll happened',(state) => {
+    if (!_.isEqual(state.afterAll,['afterAll1','afterAll2'])) {
+        throw new Error('afterAll is wrong!');
+    }
+    return state;
+});
+
+Before('add before1',(state) => {
+    return _.set('before',_.concat(_.getOr([],'before',state),'before1'),state);
+});
+
+Before('add before2',(state) => {
+    return _.set('before',_.concat(_.getOr([],'before',state),'before2'),state);
+});
+
+After('check that Before happened',(state) => {
+    if (!_.isEqual(state.before,['before1','before2'])) {
+        throw new Error('before is wrong!');
+    }
+    return state;
+});
+
+After('add after1',(state) => {
+    return _.set('after',_.concat(_.getOr([],'after',state),'after1'),state);
+});
+
+After('add after2',(state) => {
+    return _.set('after',_.concat(_.getOr([],'after',state),'after2'),state);
+});
+
+After('check that After happened',(state) => {
+    if (!_.isEqual(state.after,['after1','after2'])) {
+        throw new Error('after is wrong!');
+    }
+
+    state = _.set('after',[],state);
+    state = _.set('before',[],state);
+    return state;
+});
+
+BeforeStep('add index to beforeStep',(state) => {
+    const beforeStep = _.getOr([],'beforeStep',state);
+    return _.set('beforeStep',_.concat(beforeStep.length,beforeStep),state)
+});
+
+AfterStep('remove index from beforeStep',(state) => {
+    const beforeStep = _.getOr([],'beforeStep',state);
+    return _.set('beforeStep',_.tail(1,beforeStep),state)
+});

package/tests/hooks/features/support/tags-hooks.js

@@ -0,0 +1,11 @@
+import { BeforeAll, AfterAll, Before, After, BeforeStep, AfterStep } from 'vitest-cucumber-plugin';
+import _ from 'lodash/fp.js';
+
+Before({ tags : '@hooks and not @nobefore', name: 'add before' },(state) => {
+    return _.set('beforeTags',_.concat(_.getOr([],'beforeTags',state),'beforeTags'),state);
+});
+
+After({ tags : '@hooks', name : 'clear beforeTags' },(state) => {
+    state = _.set('beforeTags',[],state);
+    return state;
+});

package/tests/hooks/features/tags.feature

@@ -0,0 +1,14 @@
+@hooks
+Feature: Hooks can be selectively used with tags
+  Scenario: The Before hooks should have been run
+    Given nothing
+    When nothing happens
+    Then the "beforeTags" property is an array with the values:
+      | beforeTags |
+
+  # Disable the Before hook for this Scenario
+  @nobefore
+  Scenario:
+    Given nothing
+    When nothing happens
+    Then the "beforeTags" property is an empty array