@lynxwall/cucumber-tsflow 4.1.6 → 5.0.2

package/lib/cli/argv-parser.js

@@ -0,0 +1,117 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "commander", "lodash.merge", "path", "@cucumber/gherkin", "@cucumber/cucumber/lib/formatter/helpers/formatters", "../version"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const commander_1 = require("commander");
+    const lodash_merge_1 = __importDefault(require("lodash.merge"));
+    const path_1 = __importDefault(require("path"));
+    const gherkin_1 = require("@cucumber/gherkin");
+    const formatters_1 = __importDefault(require("@cucumber/cucumber/lib/formatter/helpers/formatters"));
+    const version_1 = require("../version");
+    const ArgvParser = {
+        collect(val, memo = []) {
+            if (val) {
+                return [...memo, val];
+            }
+            return undefined;
+        },
+        mergeJson(option) {
+            return function (str, memo = {}) {
+                let val;
+                try {
+                    val = JSON.parse(str);
+                }
+                catch (error) {
+                    const e = error;
+                    throw new Error(`${option} passed invalid JSON: ${e.message}: ${str}`);
+                }
+                if (typeof val !== 'object' || Array.isArray(val)) {
+                    throw new Error(`${option} must be passed JSON of an object: ${str}`);
+                }
+                return (0, lodash_merge_1.default)(memo, val);
+            };
+        },
+        mergeTags(value, memo) {
+            return memo ? `${memo} and (${value})` : `(${value})`;
+        },
+        validateCountOption(value, optionName) {
+            const numericValue = parseInt(value);
+            if (isNaN(numericValue) || numericValue < 0) {
+                throw new Error(`${optionName} must be a non negative integer`);
+            }
+            return numericValue;
+        },
+        validateLanguage(value) {
+            if (!Object.keys(gherkin_1.dialects).includes(value)) {
+                throw new Error(`Unsupported ISO 639-1: ${value}`);
+            }
+            return value;
+        },
+        parse(argv) {
+            const program = new commander_1.Command(path_1.default.basename(argv[1]));
+            program
+                .storeOptionsAsProperties(false)
+                .usage('[options] [<GLOB|DIR|FILE[:LINE]>...]')
+                .version(version_1.version, '-v, --version')
+                .option('-b, --backtrace', 'show full backtrace for errors')
+                .option('-c, --config <PATH>', 'specify configuration file')
+                .option('-d, --dry-run', 'invoke formatters without executing steps')
+                .option('--debug-file <STRING>', 'path to a file with steps for debugging')
+                .option('--exit, --force-exit', 'force shutdown of the event loop when the test run has finished: cucumber will call process.exit')
+                .option('--fail-fast', 'abort the run on first failure')
+                .option('-f, --format <TYPE[:PATH]>', 'specify the output format, optionally supply PATH to redirect formatter output (repeatable).  Available formats:\n' +
+                formatters_1.default.buildFormattersDocumentationString(), ArgvParser.collect)
+                .option('--format-options <JSON>', 'provide options for formatters (repeatable)', ArgvParser.mergeJson('--format-options'))
+                .option('--i18n-keywords <ISO 639-1>', 'list language keywords', ArgvParser.validateLanguage)
+                .option('--i18n-languages', 'list languages')
+                .option('-i, --import <GLOB|DIR|FILE>', 'import files before executing features (repeatable)', ArgvParser.collect)
+                .option('--language <ISO 639-1>', 'provide the default language for feature files')
+                .option('--name <REGEXP>', 'only execute the scenarios with name matching the expression (repeatable)', ArgvParser.collect)
+                .option('--order <TYPE[:SEED]>', 'run scenarios in the specified order. Type should be `defined` or `random`')
+                .option('-p, --profile <NAME>', 'specify the profile to use (repeatable)', ArgvParser.collect, [])
+                .option('--parallel <NUMBER_OF_WORKERS>', 'run in parallel with the given number of workers', val => ArgvParser.validateCountOption(val, '--parallel'))
+                .option('--publish', 'Publish a report to https://reports.cucumber.io')
+                .option('--publish-quiet', "Don't print information banner about publishing reports")
+                .option('-r, --require <GLOB|DIR|FILE>', 'require files before executing features (repeatable)', ArgvParser.collect)
+                .option('--require-module <NODE_MODULE>', 'require node modules before requiring files (repeatable)', ArgvParser.collect)
+                .option('--retry <NUMBER_OF_RETRIES>', 'specify the number of times to retry failing test cases (default: 0)', val => ArgvParser.validateCountOption(val, '--retry'))
+                .option('--retry-tag-filter <EXPRESSION>', `only retries the features or scenarios with tags matching the expression (repeatable).
+        This option requires '--retry' to be specified.`, ArgvParser.mergeTags)
+                .option('--strict', 'fail if there are pending steps')
+                .option('--no-strict', 'succeed even if there are pending steps')
+                .option('-t, --tags <EXPRESSION>', 'only execute the features or scenarios with tags matching the expression (repeatable)', ArgvParser.mergeTags)
+                .option('--transpiler <ESNODE|TSNODE|ESVUE|TSVUE>', `built-in transpiler to use. ESxxx transpilers use esbuild and TSxxx transpilers use typescript.\n
+				Vue versions of the transpilers add a hook for .vue transforms and initialize jsdom globally.\n
+				Default: ESNODE (esbuild without Vue support)`)
+                .option('--world-parameters <JSON>', 'provide parameters that will be passed to the world constructor (repeatable)', ArgvParser.mergeJson('--world-parameters'));
+            program.addHelpText('afterAll', 'For more details please visit https://github.com/cucumber/cucumber-js/blob/main/docs/cli.md');
+            program.parse(argv);
+            const { config, i18nKeywords, i18nLanguages, profile, ...regularStuff } = program.opts();
+            const configuration = regularStuff;
+            if (program.args.length > 0) {
+                configuration.paths = program.args;
+            }
+            return {
+                options: {
+                    config,
+                    i18nKeywords,
+                    i18nLanguages,
+                    profile
+                },
+                configuration
+            };
+        }
+    };
+    exports.default = ArgvParser;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/index.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { IFormatterStream } from '@cucumber/cucumber/lib/formatter';
+export interface ICliRunResult {
+    shouldAdvertisePublish: boolean;
+    shouldExitImmediately: boolean;
+    success: boolean;
+}
+export default class Cli {
+    private readonly argv;
+    private readonly cwd;
+    private readonly stdout;
+    private readonly stderr;
+    private readonly env;
+    constructor({ argv, cwd, stdout, stderr, env }: {
+        argv: string[];
+        cwd: string;
+        stdout: IFormatterStream;
+        stderr: IFormatterStream;
+        env: NodeJS.ProcessEnv;
+    });
+    run(): Promise<ICliRunResult>;
+}

package/lib/cli/index.js

@@ -0,0 +1,105 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "@cucumber/messages", "@cucumber/cucumber/lib/configuration/index", "@cucumber/cucumber/lib/api/index", "./load-configuration", "@cucumber/cucumber/lib/cli/i18n", "@cucumber/cucumber/lib/cli/install_validator", "@cucumber/cucumber/lib/api/paths", "@cucumber/cucumber/lib/api/environment", "@cucumber/cucumber/lib/api/support", "../cucumber/binding-registry", "./argv-parser", "@cucumber/cucumber-expressions", "../cucumber/message-collector", "console"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    const messages_1 = require("@cucumber/messages");
+    const index_1 = require("@cucumber/cucumber/lib/configuration/index");
+    const index_2 = require("@cucumber/cucumber/lib/api/index");
+    const load_configuration_1 = require("./load-configuration");
+    const i18n_1 = require("@cucumber/cucumber/lib/cli/i18n");
+    const install_validator_1 = require("@cucumber/cucumber/lib/cli/install_validator");
+    const paths_1 = require("@cucumber/cucumber/lib/api/paths");
+    const environment_1 = require("@cucumber/cucumber/lib/api/environment");
+    const support_1 = require("@cucumber/cucumber/lib/api/support");
+    const binding_registry_1 = require("../cucumber/binding-registry");
+    const argv_parser_1 = __importDefault(require("./argv-parser"));
+    const cucumber_expressions_1 = require("@cucumber/cucumber-expressions");
+    const message_collector_1 = __importDefault(require("../cucumber/message-collector"));
+    const console_1 = require("console");
+    class Cli {
+        constructor({ argv, cwd, stdout, stderr, env }) {
+            this.argv = argv;
+            this.cwd = cwd;
+            this.stdout = stdout;
+            this.stderr = stderr;
+            this.env = env;
+        }
+        async run() {
+            await (0, install_validator_1.validateInstall)(this.cwd);
+            const { options, configuration: argvConfiguration } = argv_parser_1.default.parse(this.argv);
+            if (options.i18nLanguages) {
+                this.stdout.write((0, i18n_1.getLanguages)());
+                return {
+                    shouldAdvertisePublish: false,
+                    shouldExitImmediately: true,
+                    success: true
+                };
+            }
+            if (options.i18nKeywords) {
+                this.stdout.write((0, i18n_1.getKeywords)(options.i18nKeywords));
+                return {
+                    shouldAdvertisePublish: false,
+                    shouldExitImmediately: true,
+                    success: true
+                };
+            }
+            const environment = {
+                cwd: this.cwd,
+                stdout: this.stdout,
+                stderr: this.stderr,
+                env: this.env
+            };
+            const logger = new console_1.Console(environment.stdout, environment.stderr);
+            logger.info('Loading configuration and step definitions...');
+            const { useConfiguration: configuration, runConfiguration } = await (0, load_configuration_1.loadConfiguration)({
+                file: options.config,
+                profiles: options.profile,
+                provided: argvConfiguration
+            }, environment);
+            // get run options
+            const { cwd } = (0, environment_1.mergeEnvironment)(environment);
+            const newId = messages_1.IdGenerator.uuid();
+            const runOptions = runConfiguration;
+            const supportCoordinates = 'World' in runOptions.support ? runOptions.support.originalCoordinates : runOptions.support;
+            const { requirePaths, importPaths } = await (0, paths_1.resolvePaths)(cwd, runOptions.sources, supportCoordinates);
+            // Load the step and hook definitions
+            const supportCodeLibrary = 'World' in runOptions.support
+                ? runOptions.support
+                : await (0, support_1.getSupportCodeLibrary)({
+                    cwd,
+                    newId,
+                    requirePaths,
+                    importPaths,
+                    requireModules: supportCoordinates.requireModules
+                });
+            // Set support to the updated step and hook definitions
+            // in the supportCodeLibrary
+            runOptions.support = binding_registry_1.BindingRegistry.instance.updateSupportCodeLibrary(supportCodeLibrary);
+            // define a custom boolean type this has to be done
+            // after all of the definitions have been loaded
+            const boolParam = new cucumber_expressions_1.ParameterType('boolean', /true|false/, null, s => (s === 'true' ? true : false), true, false);
+            supportCodeLibrary.parameterTypeRegistry.defineParameterType(boolParam);
+            // now we can run cucumber
+            const { success } = await (0, index_2.runCucumber)(runOptions, environment, message_collector_1.default.parseEnvelope.bind(message_collector_1.default));
+            return {
+                shouldAdvertisePublish: !runConfiguration.formats.publish &&
+                    !configuration.publishQuiet &&
+                    !(0, index_1.isTruthyString)(this.env.CUCUMBER_PUBLISH_QUIET),
+                shouldExitImmediately: configuration.forceExit,
+                success
+            };
+        }
+    }
+    exports.default = Cli;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/load-configuration.d.ts

@@ -0,0 +1,20 @@
+import { IRunEnvironment, ILoadConfigurationOptions, IRunConfiguration } from '@cucumber/cucumber/lib/api/types';
+import { ITsflowConfiguration } from './argv-parser';
+export interface ITsflowResolvedConfiguration {
+    /**
+     * The final flat configuration object resolved from the configuration file/profiles plus any extra provided.
+     */
+    useConfiguration: ITsflowConfiguration;
+    /**
+     * The format that can be passed into `runCucumber`.
+     */
+    runConfiguration: IRunConfiguration;
+}
+/**
+ * Load user-authored configuration to be used in a test run.
+ *
+ * @public
+ * @param options - Coordinates required to find configuration.
+ * @param environment - Project environment.
+ */
+export declare const loadConfiguration: (options?: ILoadConfigurationOptions, environment?: IRunEnvironment) => Promise<ITsflowResolvedConfiguration>;

package/lib/cli/load-configuration.js

@@ -0,0 +1,98 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "console", "@cucumber/cucumber/lib/configuration/locate_file", "@cucumber/cucumber/lib/configuration/index", "@cucumber/cucumber/lib/configuration/validate_configuration", "@cucumber/cucumber/lib/api/convert_configuration", "@cucumber/cucumber/lib/api/environment", "chalk", "../utils/helpers", "../gherkin/gherkin-manager"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.loadConfiguration = void 0;
+    const console_1 = require("console");
+    const locate_file_1 = require("@cucumber/cucumber/lib/configuration/locate_file");
+    const index_1 = require("@cucumber/cucumber/lib/configuration/index");
+    const validate_configuration_1 = require("@cucumber/cucumber/lib/configuration/validate_configuration");
+    const convert_configuration_1 = require("@cucumber/cucumber/lib/api/convert_configuration");
+    const environment_1 = require("@cucumber/cucumber/lib/api/environment");
+    const chalk_1 = __importDefault(require("chalk"));
+    const helpers_1 = require("../utils/helpers");
+    const gherkin_manager_1 = __importDefault(require("../gherkin/gherkin-manager"));
+    /**
+     * Load user-authored configuration to be used in a test run.
+     *
+     * @public
+     * @param options - Coordinates required to find configuration.
+     * @param environment - Project environment.
+     */
+    const loadConfiguration = async (options = {}, environment = {}) => {
+        var _a, _b, _c;
+        const { cwd, env } = (0, environment_1.mergeEnvironment)(environment);
+        const configFile = (_a = options.file) !== null && _a !== void 0 ? _a : (0, locate_file_1.locateFile)(cwd);
+        const profileConfiguration = configFile ? await (0, index_1.fromFile)(cwd, configFile, options.profiles) : {};
+        const logger = new console_1.Console(environment.stdout, environment.stderr);
+        // if a feature was passed in on command line it's added
+        // to the provided configuration as paths. We need to clear
+        // any paths from configuration so that only the feature passed
+        // in is executed.
+        if (((_b = options.provided) === null || _b === void 0 ? void 0 : _b.paths) && ((_c = options.provided.paths) === null || _c === void 0 ? void 0 : _c.length) > 0) {
+            profileConfiguration.paths = [];
+        }
+        const original = (0, index_1.mergeConfigurations)(index_1.DEFAULT_CONFIGURATION, profileConfiguration, options.provided);
+        switch (original.transpiler) {
+            case 'esvue':
+                original.requireModule.push('@lynxwall/cucumber-tsflow/lib/esvue');
+                break;
+            case 'tsvue':
+                original.requireModule.push('@lynxwall/cucumber-tsflow/lib/tsvue');
+                break;
+            case 'tsnode':
+                original.requireModule.push('@lynxwall/cucumber-tsflow/lib/tsnode');
+                break;
+            default:
+                // defaulting to esbuild
+                original.requireModule.push('@lynxwall/cucumber-tsflow/lib/esnode');
+                break;
+        }
+        // set the snippet syntax
+        if (!original.formatOptions.snippetSyntax) {
+            original.formatOptions.snippetSyntax = '@lynxwall/cucumber-tsflow/lib/snippet.js';
+        }
+        // look for behave format
+        const behaveIdx = original.format.findIndex(e => e.startsWith('behave:'));
+        if (behaveIdx >= 0) {
+            original.format[behaveIdx] = original.format[behaveIdx].replace('behave', '@lynxwall/cucumber-tsflow/lib/behave.js');
+        }
+        // check to see if a debugFile was passed in
+        if ((0, helpers_1.hasStringValue)(original.debugFile)) {
+            let featurePath = '';
+            // Initialize gherkin manager with path to feature files
+            const gherkin = new gherkin_manager_1.default(original.paths);
+            const featureInfo = gherkin.findFeatureByStepFile(original.debugFile);
+            if (featureInfo) {
+                featurePath = featureInfo.featureFile;
+            }
+            if ((0, helpers_1.hasStringValue)(featurePath)) {
+                original.paths = [];
+                original.paths.push(featurePath);
+            }
+            else {
+                // log a message if the feature path is not found
+                logger.warn(chalk_1.default.yellow(`\nUnable to find feature for debugFile: ${original.debugFile}`));
+                logger.warn(chalk_1.default.yellow('All tests will be executed\n'));
+            }
+        }
+        (0, validate_configuration_1.validateConfiguration)(original);
+        const runnable = await (0, convert_configuration_1.convertConfiguration)(original, env);
+        return {
+            useConfiguration: original,
+            runConfiguration: runnable
+        };
+    };
+    exports.loadConfiguration = loadConfiguration;
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/cli/run.d.ts

@@ -0,0 +1 @@
+export default function run(): Promise<void>;

package/lib/cli/run.js

@@ -0,0 +1,54 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./", "verror", "@cucumber/cucumber/lib/cli/validate_node_engine_version"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    /* eslint-disable no-console */
+    /* This is one rare place where we're fine to use process/console directly,
+     * but other code abstracts those to remain composable and testable. */
+    const _1 = __importDefault(require("./"));
+    const verror_1 = __importDefault(require("verror"));
+    const validate_node_engine_version_1 = require("@cucumber/cucumber/lib/cli/validate_node_engine_version");
+    function logErrorMessageAndExit(message) {
+        console.error(message);
+        process.exit(1);
+    }
+    async function run() {
+        (0, validate_node_engine_version_1.validateNodeEngineVersion)(process.version, (error) => {
+            console.error(error);
+            process.exit(1);
+        }, console.warn);
+        const cli = new _1.default({
+            argv: process.argv,
+            cwd: process.cwd(),
+            stdout: process.stdout,
+            stderr: process.stderr,
+            env: process.env
+        });
+        let result;
+        try {
+            result = await cli.run();
+        }
+        catch (error) {
+            logErrorMessageAndExit(verror_1.default.fullStack(error));
+        }
+        const exitCode = result.success ? 0 : 1;
+        if (result.shouldExitImmediately) {
+            process.exit(exitCode);
+        }
+        else {
+            process.exitCode = exitCode;
+        }
+    }
+    exports.default = run;
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicnVuLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NsaS9ydW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7SUFBQSwrQkFBK0I7SUFDL0I7MkVBQ3VFO0lBQ3ZFLDBDQUF3QztJQUN4QyxvREFBNEI7SUFDNUIsMEdBQW9HO0lBRXBHLFNBQVMsc0JBQXNCLENBQUMsT0FBZTtRQUM5QyxPQUFPLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3ZCLE9BQU8sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDakIsQ0FBQztJQUVjLEtBQUssVUFBVSxHQUFHO1FBQ2hDLElBQUEsd0RBQXlCLEVBQ3hCLE9BQU8sQ0FBQyxPQUFPLEVBQ2YsQ0FBQyxLQUFVLEVBQUUsRUFBRTtZQUNkLE9BQU8sQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDckIsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNqQixDQUFDLEVBQ0QsT0FBTyxDQUFDLElBQUksQ0FDWixDQUFDO1FBRUYsTUFBTSxHQUFHLEdBQUcsSUFBSSxVQUFHLENBQUM7WUFDbkIsSUFBSSxFQUFFLE9BQU8sQ0FBQyxJQUFJO1lBQ2xCLEdBQUcsRUFBRSxPQUFPLENBQUMsR0FBRyxFQUFFO1lBQ2xCLE1BQU0sRUFBRSxPQUFPLENBQUMsTUFBTTtZQUN0QixNQUFNLEVBQUUsT0FBTyxDQUFDLE1BQU07WUFDdEIsR0FBRyxFQUFFLE9BQU8sQ0FBQyxHQUFHO1NBQ2hCLENBQUMsQ0FBQztRQUVILElBQUksTUFBc0IsQ0FBQztRQUMzQixJQUFJO1lBQ0gsTUFBTSxHQUFHLE1BQU0sR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDO1NBQ3pCO1FBQUMsT0FBTyxLQUFVLEVBQUU7WUFDcEIsc0JBQXNCLENBQUMsZ0JBQU0sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQztTQUNoRDtRQUVELE1BQU0sUUFBUSxHQUFHLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ3hDLElBQUksTUFBTSxDQUFDLHFCQUFxQixFQUFFO1lBQ2pDLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7U0FDdkI7YUFBTTtZQUNOLE9BQU8sQ0FBQyxRQUFRLEdBQUcsUUFBUSxDQUFDO1NBQzVCO0lBQ0YsQ0FBQztJQS9CRCxzQkErQkMifQ==