vitest-cucumber-plugin 0.5.6 → 0.6.2

package/src/generate/rule.js

@@ -1,22 +0,0 @@
-import _ from 'lodash/fp.js';
-import { generateExample } from './index.js';
-import { escape, shouldSkip } from './util.js';
-import { log } from '../logger.js';
-
-export const generateRule = (config,rule) => {
-    log.debug('generateRule config: '+JSON.stringify(config)+' rule: '+JSON.stringify(rule));
-    
-    const examplesCode = _.reduce((examplesCode,example) => {
-        return examplesCode + generateExample(config,example);
-    },'')(rule.examples);
-
-    const skip = shouldSkip(config,rule.tags) ? '.skip' : '';
-    const tagsStr = JSON.stringify(rule.tags);
-
-    const code = `  // tags : ${tagsStr}
-  describe${skip}('${escape(rule.type.name)}: ${escape(rule.name)}', () => {
-${examplesCode}});
-`;
-
-    return code;
-}

package/src/generate/scenario-outline.js

@@ -1,21 +0,0 @@
-import _ from 'lodash/fp.js';
-import { generateExamples } from './examples.js';
-import { escape, shouldSkip } from './util.js';
-
-export const generateScenarioOutline = (config,scenarioOutline) => {
-    const examplesStatements = _.reduce((examplesStatements,examplesStatement) => {
-        examplesStatement = _.set('tags',_.concat(scenarioOutline.tags,examplesStatement.tags),examplesStatement);
-        
-        return examplesStatements + generateExamples(config,scenarioOutline.steps,examplesStatement);
-    },'')(scenarioOutline.examples);
-
-    const skip = shouldSkip(config,scenarioOutline.tags) ? '.skip' : '';
-
-    const code = `  // tags : ${JSON.stringify(scenarioOutline.tags)}
-  describe${skip}('${escape(scenarioOutline.type.name)}: ${escape(scenarioOutline.name)}', () => {
-${examplesStatements}
-  });
-`;
-
-    return code;
-}

package/src/generate/util.js

@@ -1,9 +0,0 @@
-import _ from 'lodash/fp.js';
-import { log } from '../logger.js';
-
-export const escape = (str) => str.replace(/'/g,"\\'");
-export const shouldSkip = (config,tags) => {
-    const result = !config.tagsFunction(tags);
-    log.debug('shouldSkip? '+result+' tags: '+JSON.stringify(tags));
-    return result;
-}

package/src/gherkin.ne

@@ -1,217 +0,0 @@
-@{%
-const fp = require('lodash/fp.js');
-const moo = require('moo');
-const lexer = moo.compile({
-  emptyLine : { match: /^[ \t]*(?:\#[^\n]+)?\n/, lineBreaks : true },
-  newline : { match : '\n', lineBreaks : true },
-  ws : /[ \t]+/,
-  at : '@',
-  colon : ':',
-  repeatStep : '*',
-  pipe : '|',
-  escapedPipe : '\\|',
-  escapedNewline : '\\n',
-  escapedBackSlash : '\\\\',
-  scenarioOutline : ['Scenario Outline','Scenario Template'],
-  docString : ['```','"""'],
-  word : {
-    match : /[^ \t\n\:\|\@\*]+/,
-    type : moo.keywords({
-      feature : 'Feature',
-      examples : ['Examples','Scenarios'],
-      given : 'Given',
-      when : 'When',
-      then : 'Then',
-      repeatStep : ['And','But'],
-      example : ['Example','Scenario'],
-      background : 'Background',
-      rule : 'Rule',
-    }),
-  },
-});
-
-const trimWhitespace = (cols,str) => {
-  const lines = str.split('\n').slice(0,-1);
-  return fp.reduce((s,line) => {
-    return s+line.slice(cols)+'\n'
-  },'')(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
-
-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] %}
-  | rule {% 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 %}
-
-exampleList -> null {% data => [] %}
-  | exampleList example {% data => fp.concat(data[0],data[1]) %}
-
-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 %}
-
-rule -> tags ruleStatement example exampleList {%
-  data => fp.assign(data[1],{ tags : data[0], examples : fp.concat(data[2],data[3]) })
-%}
-ruleStatement -> _ ruleKeyword  _ %colon text %newline {%
-  (data) => { return { type : { type : 'rule', name : data[1] }, name : data[4].trim() } }
-%}
-ruleKeyword -> %rule {% 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 -> dataTableRow {% data => [data[0]] %}
-  | dataTable dataTableRow {% data => fp.concat(data[0],[data[1]]) %}
-
-dataTableRow -> _ %pipe dataTableColumns %newline {% data => data[2] %}
-
-dataTableColumns -> null {% data => [] %}
-  | dataTableColumns dataTableColumnText %pipe {% data => fp.concat(data[0],data[1].trim()) %}
-
-dataTableColumnText -> null {% data => '' %}
-  | dataTableColumnText escapedColumnCharaters {% data => data[0]+data[1] %}
-  | dataTableColumnText keywords {% data => data[0]+data[1] %}
-  | dataTableColumnText %word {% data => data[0]+data[1].value %}
-  | dataTableColumnText %ws {% data => data[0]+data[1].value %}
-  | dataTableColumnText %at {% data => data[0]+data[1].value %}
-
-escapedColumnCharaters -> %escapedPipe {% data => '|' %}
-  | %escapedBackSlash {% data => '\\' %}
-  | %escapedNewline {% data => '\n' %}
-
-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
-  | 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 -> %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 %}
-  | text %ws {% data => data[0]+data[1].value %}
-  | text keywords {% data => data[0]+data[1] %}
-  | text %at {% data => data[0]+data[1].value %}
-  | text %pipe {% data => data[0]+data[1].value %}
-  | text %escapedPipe {% data => data[0]+data[1].value %}
-  | text %escapedNewline {% data => data[0]+data[1].value %}
-  | text %escapedBackSlash {% data => data[0]+data[1].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 %}
-  | %scenarioOutline {% data => data[0].value %}
-  | %background {% data => data[0].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' %}
-
-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 %}
-
-emptyLines -> null {% data => '' %}
-  | emptyLines %emptyLine {% data => data[0]+'\n' %}

package/src/hooks.js

@@ -1,78 +0,0 @@
-import { log } from './logger.js';
-import _ from 'lodash/fp.js';
-import { tagsFunction } from './tags.js';
-
-const allHooks = {
-    beforeAll : [],
-    before : [],
-    beforeStep : [],
-    afterAll : [],
-    after : [],
-    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));
-    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) {
-            const origState = state;
-            state = await hook.f(state);
-            log.info(hookNames[hooksName]+'(\''+hook.name+'\') ('+JSON.stringify(origState)+') => '+
-                     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

@@ -1,92 +0,0 @@
-import _ from 'lodash/fp.js';
-import { addStepDefinition, findStepDefinitionMatch } from './steps.js';
-import { parameterizeText } from './parameterize.js';
-import { generateFeature } from './generate/index.js';
-import { log, logConfig } 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$/;
-
-const compileFeatureToJS = async (config,featureSrc) => {
-    const feature = parse(featureSrc);
-
-    const code = await generateFeature(config,feature);
-
-    return code;
-}
-
-export { BeforeAll, Before, AfterAll, After, BeforeStep, AfterStep };
-
-export {
-    applyBeforeAllHooks,
-    applyBeforeHooks,
-    applyAfterAllHooks,
-    applyAfterHooks,
-    applyBeforeStepHooks,
-    applyAfterStepHooks,
-};
-
-export { log, logConfig };
-
-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 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;
-};
-
-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) => {
-            config = _.defaults({ root : resolvedConfig.root, log : { level : 'warn' } },
-                                _.get('test.cucumber',resolvedConfig))
-            logConfig(config.log);
-
-            config = _.set('tagsFunction',tagsFunction(_.get('tags',config)),config);
-
-            log.debug('config: '+JSON.stringify(config));
-        },
-        transform : async (src,id) => {
-            if (featureRegex.test(id)) {
-                const code = await compileFeatureToJS(config,src);
-
-                log.debug('transform '+id+' -> '+code);
-
-                return {
-                    code
-                }
-            }
-        }
-    }
-}

package/src/logger.js

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

package/src/parameterize.js

@@ -1,7 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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));
-    if (parser.results.length > 1) {
-        throw new Error('Ambiguous parsing: '+parser.results.length);
-    }
-    
-    const results = parser.results;
-    return results[0];
-}

package/src/tags-expression.ne

@@ -1,43 +0,0 @@
-@{%
-const fp = require('lodash/fp.js');
-const moo = require('moo');
-const lexer = moo.compile({
-  and : 'and',
-  or : 'or',
-  not : 'not',
-  openParen : '(',
-  closeParen : ')',
-  newline : { match : '\n', lineBreaks : true },
-  ws : /[ \t]+/,
-  tag : /\@[\w\.]+/,
-});
-%}
-
-@lexer lexer
-
-main -> expression %newline {% data => data[0] %}
-
-expression -> tag {% data => data[0] %}
-  | unaryOperation {% data => data[0] %}
-  | binaryOperation {% data => data[0] %}
-  | parenOperation {% data => data[0] %}
-
-parenOperation -> %openParen _ expression _ %closeParen {% data => data[2] %}
-
-unaryOperation -> %not %ws unaryExpression {% data => { return { operator : 'not', expression : data[2] } } %}
-
-unaryExpression -> tag {% id %}
-  | parenOperation {% id %}
-
-binaryOperation -> expression _ binaryOperator _ expression {%
-  data => { return { operator : data[2], left : data[0], right : data[4] } }
-%}
-
-binaryOperator -> %and {% data => data[0].value %}
-  | %or {% data => data[0].value %}
-
-tag -> %tag {% data => data[0].value.slice(1) %}
-
-_ -> null
-  | %ws
-

package/tests/background/features/background.feature

@@ -1,25 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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;
-});

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

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