@wdio/cucumber-framework 7.17.0 → 7.19.0

package/build/index.js

@@ -0,0 +1,328 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.World = exports.When = exports.Then = exports.setWorldConstructor = exports.setDefinitionFunctionWrapper = exports.setDefaultTimeout = exports.Given = exports.defineStep = exports.defineParameterType = exports.DataTable = exports.BeforeStep = exports.BeforeAll = exports.Before = exports.AfterStep = exports.AfterAll = exports.After = exports.adapterFactory = exports.CucumberAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const events_1 = require("events");
+const mockery_1 = __importDefault(require("mockery"));
+const is_glob_1 = __importDefault(require("is-glob"));
+const glob_1 = __importDefault(require("glob"));
+const Cucumber = __importStar(require("@cucumber/cucumber"));
+const cucumber_1 = require("@cucumber/cucumber");
+Object.defineProperty(exports, "After", { enumerable: true, get: function () { return cucumber_1.After; } });
+Object.defineProperty(exports, "AfterAll", { enumerable: true, get: function () { return cucumber_1.AfterAll; } });
+Object.defineProperty(exports, "AfterStep", { enumerable: true, get: function () { return cucumber_1.AfterStep; } });
+Object.defineProperty(exports, "Before", { enumerable: true, get: function () { return cucumber_1.Before; } });
+Object.defineProperty(exports, "BeforeAll", { enumerable: true, get: function () { return cucumber_1.BeforeAll; } });
+Object.defineProperty(exports, "BeforeStep", { enumerable: true, get: function () { return cucumber_1.BeforeStep; } });
+Object.defineProperty(exports, "DataTable", { enumerable: true, get: function () { return cucumber_1.DataTable; } });
+Object.defineProperty(exports, "defineParameterType", { enumerable: true, get: function () { return cucumber_1.defineParameterType; } });
+Object.defineProperty(exports, "defineStep", { enumerable: true, get: function () { return cucumber_1.defineStep; } });
+Object.defineProperty(exports, "Given", { enumerable: true, get: function () { return cucumber_1.Given; } });
+Object.defineProperty(exports, "setDefaultTimeout", { enumerable: true, get: function () { return cucumber_1.setDefaultTimeout; } });
+Object.defineProperty(exports, "setDefinitionFunctionWrapper", { enumerable: true, get: function () { return cucumber_1.setDefinitionFunctionWrapper; } });
+Object.defineProperty(exports, "setWorldConstructor", { enumerable: true, get: function () { return cucumber_1.setWorldConstructor; } });
+Object.defineProperty(exports, "World", { enumerable: true, get: function () { return cucumber_1.World; } });
+Object.defineProperty(exports, "Then", { enumerable: true, get: function () { return cucumber_1.Then; } });
+Object.defineProperty(exports, "When", { enumerable: true, get: function () { return cucumber_1.When; } });
+const gherkin_streams_1 = require("@cucumber/gherkin-streams");
+const event_data_collector_1 = __importDefault(require("@cucumber/cucumber/lib/formatter/helpers/event_data_collector"));
+const messages_1 = require("@cucumber/messages");
+const utils_1 = require("@wdio/utils");
+const reporter_1 = __importDefault(require("./reporter"));
+const constants_1 = require("./constants");
+const utils_2 = require("./utils");
+const { incrementing } = messages_1.IdGenerator;
+function getResultObject(world) {
+    var _a, _b, _c, _d, _e;
+    return {
+        passed: (((_a = world.result) === null || _a === void 0 ? void 0 : _a.status) === Cucumber.Status.PASSED || ((_b = world.result) === null || _b === void 0 ? void 0 : _b.status) === Cucumber.Status.SKIPPED),
+        error: (_c = world.result) === null || _c === void 0 ? void 0 : _c.message,
+        duration: ((_e = (_d = world.result) === null || _d === void 0 ? void 0 : _d.duration) === null || _e === void 0 ? void 0 : _e.nanos) / 10e6 // convert into ms
+    };
+}
+class CucumberAdapter {
+    constructor(_cid, _config, _specs, _capabilities, _reporter) {
+        this._cid = _cid;
+        this._config = _config;
+        this._specs = _specs;
+        this._capabilities = _capabilities;
+        this._reporter = _reporter;
+        this._cwd = process.cwd();
+        this._newId = incrementing();
+        this._cucumberOpts = Object.assign({}, constants_1.DEFAULT_OPTS, this._config.cucumberOpts);
+        this._hasTests = true;
+        this._cucumberFeaturesWithLineNumbers = this._config.cucumberFeaturesWithLineNumbers || [];
+        this._eventBroadcaster = new events_1.EventEmitter();
+        this._eventDataCollector = new event_data_collector_1.default(this._eventBroadcaster);
+        const featurePathsToRun = this._cucumberFeaturesWithLineNumbers.length > 0 ? this._cucumberFeaturesWithLineNumbers : this._specs;
+        this._pickleFilter = new Cucumber.PickleFilter({
+            cwd: this._cwd,
+            featurePaths: featurePathsToRun,
+            names: this._cucumberOpts.names,
+            tagExpression: this._cucumberOpts.tagExpression
+        });
+        const reporterOptions = {
+            capabilities: this._capabilities,
+            ignoreUndefinedDefinitions: Boolean(this._cucumberOpts.ignoreUndefinedDefinitions),
+            failAmbiguousDefinitions: Boolean(this._cucumberOpts.failAmbiguousDefinitions),
+            tagsInTitle: Boolean(this._cucumberOpts.tagsInTitle),
+            scenarioLevelReporter: Boolean(this._cucumberOpts.scenarioLevelReporter)
+        };
+        this._cucumberReporter = new reporter_1.default(this._eventBroadcaster, this._pickleFilter, reporterOptions, this._cid, this._specs, this._reporter);
+    }
+    async init() {
+        try {
+            const gherkinMessageStream = gherkin_streams_1.GherkinStreams.fromPaths(this._specs, {
+                defaultDialect: this._cucumberOpts.featureDefaultLanguage,
+                newId: this._newId
+            });
+            await Cucumber.parseGherkinMessageStream({
+                cwd: this._cwd,
+                eventBroadcaster: this._eventBroadcaster,
+                gherkinMessageStream,
+                eventDataCollector: this._eventDataCollector,
+                order: this._cucumberOpts.order,
+                pickleFilter: this._pickleFilter
+            });
+            this._hasTests = this._cucumberReporter.eventListener.getPickleIds(this._capabilities).length > 0;
+        }
+        catch (runtimeError) {
+            await (0, utils_1.executeHooksWithArgs)('after', this._config.after, [runtimeError, this._capabilities, this._specs]);
+            throw runtimeError;
+        }
+        /**
+         * import and set options for `expect-webdriverio` assertion lib once
+         * the framework was initiated so that it can detect the environment
+         */
+        const { setOptions } = require('expect-webdriverio');
+        setOptions({
+            wait: this._config.waitforTimeout,
+            interval: this._config.waitforInterval, // interval between attempts
+        });
+        return this;
+    }
+    hasTests() {
+        return this._hasTests;
+    }
+    async run() {
+        let runtimeError;
+        let result;
+        try {
+            this.registerRequiredModules();
+            Cucumber.supportCodeLibraryBuilder.reset(this._cwd, this._newId);
+            /**
+             * wdio hooks should be added before spec files are loaded
+             */
+            this.addWdioHooks(this._config);
+            this.loadSpecFiles();
+            this.wrapSteps(this._config);
+            /**
+             * we need to somehow identify is function is step or hook
+             * so we wrap every user hook function
+             */
+            (0, utils_2.setUserHookNames)(Cucumber.supportCodeLibraryBuilder);
+            Cucumber.setDefaultTimeout(this._cucumberOpts.timeout);
+            const supportCodeLibrary = Cucumber.supportCodeLibraryBuilder.finalize();
+            /**
+             * gets current step data: `{ uri, feature, scenario, step, sourceLocation }`
+             * or `null` for some hooks.
+             */
+            this.getHookParams = this._cucumberReporter
+                .eventListener
+                .getHookParams
+                .bind(this._cucumberReporter.eventListener);
+            const runtime = new Cucumber.Runtime({
+                newId: this._newId,
+                eventBroadcaster: this._eventBroadcaster,
+                options: this._cucumberOpts,
+                supportCodeLibrary,
+                eventDataCollector: this._eventDataCollector,
+                pickleIds: this._cucumberReporter.eventListener.getPickleIds(this._capabilities)
+            });
+            result = await runtime.start() ? 0 : 1;
+            /**
+             * if we ignore undefined definitions we trust the reporter
+             * with the fail count
+             */
+            if (this._cucumberOpts.ignoreUndefinedDefinitions && result) {
+                result = this._cucumberReporter.failedCount;
+            }
+        }
+        catch (err) {
+            runtimeError = err;
+            result = 1;
+        }
+        await (0, utils_1.executeHooksWithArgs)('after', this._config.after, [runtimeError || result, this._capabilities, this._specs]);
+        /**
+         * in case the spec has a runtime error throw after the wdio hook
+         */
+        if (runtimeError) {
+            throw runtimeError;
+        }
+        return result;
+    }
+    /**
+     * Transpilation https://github.com/cucumber/cucumber-js/blob/master/docs/cli.md#transpilation
+     * Usage: `['module']`
+     * we extend it a bit with ability to init and pass configuration to modules.
+     * Pass an array with path to module and its configuration instead:
+     * Usage: `[['module', {}]]`
+     * Or pass your own function
+     * Usage: `[() => { require('@babel/register')({ ignore: [] }) }]`
+     */
+    registerRequiredModules() {
+        this._cucumberOpts.requireModule.map(requiredModule => {
+            if (Array.isArray(requiredModule)) {
+                require(requiredModule[0])(requiredModule[1]);
+            }
+            else if (typeof requiredModule === 'function') {
+                requiredModule();
+            }
+            else {
+                require(requiredModule);
+            }
+        });
+    }
+    requiredFiles() {
+        return this._cucumberOpts.require.reduce((files, requiredFile) => files.concat((0, is_glob_1.default)(requiredFile)
+            ? glob_1.default.sync(requiredFile)
+            : [requiredFile]), []);
+    }
+    loadSpecFiles() {
+        // we use mockery to allow people to import 'our' cucumber even though their spec files are in their folders
+        // because of that we don't have to attach anything to the global object, and the current cucumber spec files
+        // should just work with no changes with this framework
+        mockery_1.default.enable({
+            useCleanCache: false,
+            warnOnReplace: false,
+            warnOnUnregistered: false
+        });
+        mockery_1.default.registerMock('@cucumber/cucumber', Cucumber);
+        this.requiredFiles().forEach((codePath) => {
+            const filepath = path_1.default.isAbsolute(codePath)
+                ? codePath
+                : path_1.default.join(process.cwd(), codePath);
+            // This allows rerunning a stepDefinitions file
+            delete require.cache[require.resolve(filepath)];
+            require(filepath);
+        });
+        mockery_1.default.disable();
+    }
+    /**
+     * set `beforeFeature`, `afterFeature`, `beforeScenario`, `afterScenario`, 'beforeStep', 'afterStep'
+     * @param {object} config config
+     */
+    addWdioHooks(config) {
+        var _a;
+        const eventListener = (_a = this._cucumberReporter) === null || _a === void 0 ? void 0 : _a.eventListener;
+        Cucumber.BeforeAll(async function wdioHookBeforeFeature() {
+            const params = eventListener === null || eventListener === void 0 ? void 0 : eventListener.getHookParams();
+            await (0, utils_1.executeHooksWithArgs)('beforeFeature', config.beforeFeature, [params === null || params === void 0 ? void 0 : params.uri, params === null || params === void 0 ? void 0 : params.feature]);
+        });
+        Cucumber.AfterAll(async function wdioHookAfterFeature() {
+            const params = eventListener === null || eventListener === void 0 ? void 0 : eventListener.getHookParams();
+            await (0, utils_1.executeHooksWithArgs)('afterFeature', config.afterFeature, [params === null || params === void 0 ? void 0 : params.uri, params === null || params === void 0 ? void 0 : params.feature]);
+        });
+        Cucumber.Before(async function wdioHookBeforeScenario(world) {
+            await (0, utils_1.executeHooksWithArgs)('beforeScenario', config.beforeScenario, [world, this]);
+        });
+        Cucumber.After(async function wdioHookAfterScenario(world) {
+            await (0, utils_1.executeHooksWithArgs)('afterScenario', config.afterScenario, [world, getResultObject(world), this]);
+        });
+        Cucumber.BeforeStep(async function wdioHookBeforeStep() {
+            const params = eventListener === null || eventListener === void 0 ? void 0 : eventListener.getHookParams();
+            await (0, utils_1.executeHooksWithArgs)('beforeStep', config.beforeStep, [params === null || params === void 0 ? void 0 : params.step, params === null || params === void 0 ? void 0 : params.scenario, this]);
+        });
+        Cucumber.AfterStep(async function wdioHookAfterStep(world) {
+            const params = eventListener === null || eventListener === void 0 ? void 0 : eventListener.getHookParams();
+            await (0, utils_1.executeHooksWithArgs)('afterStep', config.afterStep, [params === null || params === void 0 ? void 0 : params.step, params === null || params === void 0 ? void 0 : params.scenario, getResultObject(world), this]);
+        });
+    }
+    /**
+     * wraps step definition code with sync/async runner with a retry option
+     * @param {object} config
+     */
+    wrapSteps(config) {
+        const wrapStep = this.wrapStep;
+        const cid = this._cid;
+        const getHookParams = () => this.getHookParams && this.getHookParams();
+        Cucumber.setDefinitionFunctionWrapper((fn, options = { retry: 0 }) => {
+            /**
+             * hooks defined in wdio.conf are already wrapped
+             */
+            if (fn.name.startsWith('wdioHook')) {
+                return fn;
+            }
+            /**
+             * this flag is used to:
+             * - avoid hook retry
+             * - avoid wrap hooks with beforeStep and afterStep
+             */
+            const isStep = !fn.name.startsWith('userHook');
+            return wrapStep(fn, isStep, config, cid, options, getHookParams);
+        });
+    }
+    /**
+     * wrap step definition to enable retry ability
+     * @param   {Function}  code            step definition
+     * @param   {boolean}   isStep
+     * @param   {object}    config
+     * @param   {string}    cid             cid
+     * @param   {StepDefinitionOptions} options
+     * @param   {Function}  getHookParams  step definition
+     * @return  {Function}                  wrapped step definition for sync WebdriverIO code
+     */
+    wrapStep(code, isStep, config, cid, options, getHookParams) {
+        return function (...args) {
+            const hookParams = getHookParams();
+            const retryTest = isStep && isFinite(options.retry) ? options.retry : 0;
+            /**
+             * wrap user step/hook with wdio before/after hooks
+             */
+            const beforeFn = config.beforeHook;
+            const afterFn = config.afterHook;
+            return utils_1.testFnWrapper.call(this, isStep ? 'Step' : 'Hook', { specFn: code, specFnArgs: args }, { beforeFn: beforeFn, beforeFnArgs: (context) => [hookParams === null || hookParams === void 0 ? void 0 : hookParams.step, context] }, { afterFn: afterFn, afterFnArgs: (context) => [hookParams === null || hookParams === void 0 ? void 0 : hookParams.step, context] }, cid, retryTest);
+        };
+    }
+}
+exports.CucumberAdapter = CucumberAdapter;
+const _CucumberAdapter = CucumberAdapter;
+const adapterFactory = {};
+exports.adapterFactory = adapterFactory;
+/**
+ * tested by smoke tests
+ */
+/* istanbul ignore next */
+adapterFactory.init = async function (...args) {
+    // @ts-ignore just passing through args
+    const adapter = new _CucumberAdapter(...args);
+    const instance = await adapter.init();
+    return instance;
+};
+exports.default = adapterFactory;

package/build/reporter.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { PickleFilter } from '@cucumber/cucumber';
+import { Feature, Pickle, PickleStep, TestStep, TestStepResult } from '@cucumber/messages';
+import CucumberEventListener from './cucumberEventListener';
+import type { ReporterOptions } from './types';
+import { ReporterScenario } from './constants';
+declare class CucumberReporter {
+    private _options;
+    private _cid;
+    private _specs;
+    private _reporter;
+    eventListener: CucumberEventListener;
+    failedCount: number;
+    private _tagsInTitle;
+    private _scenarioLevelReport;
+    private _featureStart?;
+    private _scenarioStart?;
+    private _testStart?;
+    constructor(eventBroadcaster: EventEmitter, pickleFilter: PickleFilter, _options: ReporterOptions, _cid: string, _specs: string[], _reporter: EventEmitter);
+    handleBeforeFeature(uri: string, feature: Feature): void;
+    handleBeforeScenario(uri: string, feature: Feature, scenario: ReporterScenario): void;
+    handleBeforeStep(uri: string, feature: Feature, scenario: Pickle, step: PickleStep | TestStep): void;
+    handleAfterStep(uri: string, feature: Feature, scenario: Pickle, step: PickleStep | TestStep, result: TestStepResult): void;
+    afterHook(uri: string, feature: Feature, scenario: Pickle, step: TestStep, result: TestStepResult): void;
+    afterTest(uri: string, feature: Feature, scenario: Pickle, step: PickleStep, result: TestStepResult): void;
+    handleAfterScenario(uri: string, feature: Feature, scenario: Pickle, result: TestStepResult): void;
+    handleAfterFeature(uri: string, feature: Feature): void;
+    emit(event: string, payload: any): void;
+    getTitle(featureOrScenario: Feature | Pickle): string;
+}
+export default CucumberReporter;
+//# sourceMappingURL=reporter.d.ts.map

package/build/reporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reporter.d.ts","sourceRoot":"","sources":["../src/reporter.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AACrC,OAAO,EAAU,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACzD,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAoC,MAAM,oBAAoB,CAAA;AAE5H,OAAO,qBAAqB,MAAM,yBAAyB,CAAA;AAE3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAC9C,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE9C,cAAM,gBAAgB;IAad,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,SAAS;IAfd,aAAa,EAAE,qBAAqB,CAAA;IACpC,WAAW,SAAI;IAEtB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,oBAAoB,CAAS;IACrC,OAAO,CAAC,aAAa,CAAC,CAAM;IAC5B,OAAO,CAAC,cAAc,CAAC,CAAM;IAC7B,OAAO,CAAC,UAAU,CAAC,CAAM;gBAGrB,gBAAgB,EAAE,YAAY,EAC9B,YAAY,EAAE,YAAY,EAClB,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EAAE,EAChB,SAAS,EAAE,YAAY;IAkBnC,mBAAmB,CAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAclD,oBAAoB,CAChB,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,gBAAgB;IAgB9B,gBAAgB,CACZ,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,GAAG,QAAQ;IAS/B,eAAe,CACX,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,GAAG,QAAQ,EAC3B,MAAM,EAAE,cAAc;IAS1B,SAAS,CACL,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,cAAc;IAkB1B,SAAS,CACL,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,cAAc;IA+F1B,mBAAmB,CACf,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,cAAc;IAiB1B,kBAAkB,CAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAWjD,IAAI,CAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG;IAUjC,QAAQ,CAAE,iBAAiB,EAAE,OAAO,GAAG,MAAM;CAMhD;AAED,eAAe,gBAAgB,CAAA"}

package/build/reporter.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const cucumber_1 = require("@cucumber/cucumber");
+const cucumberEventListener_1 = __importDefault(require("./cucumberEventListener"));
+const utils_1 = require("./utils");
+class CucumberReporter {
+    constructor(eventBroadcaster, pickleFilter, _options, _cid, _specs, _reporter) {
+        this._options = _options;
+        this._cid = _cid;
+        this._specs = _specs;
+        this._reporter = _reporter;
+        this.failedCount = 0;
+        this._tagsInTitle = this._options.tagsInTitle || false;
+        this._scenarioLevelReport = this._options.scenarioLevelReporter;
+        this.eventListener = new cucumberEventListener_1.default(eventBroadcaster, pickleFilter)
+            .on('before-feature', this.handleBeforeFeature.bind(this))
+            .on('before-scenario', this.handleBeforeScenario.bind(this))
+            .on('after-scenario', this.handleAfterScenario.bind(this))
+            .on('after-feature', this.handleAfterFeature.bind(this));
+        if (!this._scenarioLevelReport) {
+            this.eventListener
+                .on('before-step', this.handleBeforeStep.bind(this))
+                .on('after-step', this.handleAfterStep.bind(this));
+        }
+    }
+    handleBeforeFeature(uri, feature) {
+        this._featureStart = new Date();
+        this.emit('suite:start', {
+            uid: (0, utils_1.getFeatureId)(uri, feature),
+            title: this.getTitle(feature),
+            type: 'feature',
+            file: uri,
+            tags: feature.tags,
+            description: feature.description,
+            keyword: feature.keyword
+        });
+    }
+    handleBeforeScenario(uri, feature, scenario) {
+        this._scenarioStart = new Date();
+        this._testStart = new Date();
+        this.emit(this._scenarioLevelReport ? 'test:start' : 'suite:start', {
+            uid: scenario.id,
+            title: this.getTitle(scenario),
+            parent: (0, utils_1.getFeatureId)(uri, feature),
+            type: 'scenario',
+            file: uri,
+            tags: scenario.tags,
+            rule: scenario.rule
+        });
+    }
+    handleBeforeStep(uri, feature, scenario, step) {
+        this._testStart = new Date();
+        const type = (0, utils_1.getStepType)(step);
+        const payload = (0, utils_1.buildStepPayload)(uri, feature, scenario, step, { type });
+        this.emit(`${type}:start`, payload);
+    }
+    handleAfterStep(uri, feature, scenario, step, result) {
+        const type = (0, utils_1.getStepType)(step);
+        if (type === 'hook') {
+            return this.afterHook(uri, feature, scenario, step, result);
+        }
+        return this.afterTest(uri, feature, scenario, step, result);
+    }
+    afterHook(uri, feature, scenario, step, result) {
+        var _a;
+        let error;
+        if (result.message) {
+            error = new Error(result.message.split('\n')[0]);
+            error.stack = result.message;
+        }
+        const payload = (0, utils_1.buildStepPayload)(uri, feature, scenario, step, {
+            type: 'hook',
+            state: result.status,
+            error,
+            duration: Date.now() - ((_a = this._testStart) === null || _a === void 0 ? void 0 : _a.getTime())
+        });
+        this.emit('hook:end', payload);
+    }
+    afterTest(uri, feature, scenario, step, result) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        let state = 'undefined';
+        switch (result.status) {
+            case cucumber_1.Status.FAILED:
+            case cucumber_1.Status.UNDEFINED:
+                state = 'fail';
+                break;
+            case cucumber_1.Status.PASSED:
+                state = 'pass';
+                break;
+            case cucumber_1.Status.PENDING:
+                state = 'pending';
+                break;
+            case cucumber_1.Status.SKIPPED:
+                state = 'skip';
+                break;
+            case cucumber_1.Status.AMBIGUOUS:
+                state = 'pending';
+                break;
+        }
+        let error = result.message ? new Error(result.message) : undefined;
+        let title = step
+            ? step === null || step === void 0 ? void 0 : step.text
+            : this.getTitle(scenario);
+        if (result.status === cucumber_1.Status.UNDEFINED) {
+            if (this._options.ignoreUndefinedDefinitions) {
+                /**
+                 * mark test as pending
+                 */
+                state = 'pending';
+                title += ' (undefined step)';
+            }
+            else {
+                /**
+                 * mark test as failed
+                 */
+                this.failedCount++;
+                const err = new Error((step ? `Step "${title}" is not defined. ` : `Scenario ${title} has undefined steps. `) +
+                    'You can ignore this error by setting cucumberOpts.ignoreUndefinedDefinitions as true.');
+                err.stack = `${err.message}\n\tat Feature(${uri}):1:1\n`;
+                const featChildren = (_a = feature.children) === null || _a === void 0 ? void 0 : _a.find(c => { var _a; return scenario.astNodeIds && ((_a = c.scenario) === null || _a === void 0 ? void 0 : _a.id) === scenario.astNodeIds[0]; });
+                if (featChildren) {
+                    err.stack += `\tat Scenario(${(_b = featChildren.scenario) === null || _b === void 0 ? void 0 : _b.name}):${(_d = (_c = featChildren.scenario) === null || _c === void 0 ? void 0 : _c.location) === null || _d === void 0 ? void 0 : _d.line}:${(_f = (_e = featChildren.scenario) === null || _e === void 0 ? void 0 : _e.location) === null || _f === void 0 ? void 0 : _f.column}\n`;
+                    const featStep = (_h = (_g = featChildren.scenario) === null || _g === void 0 ? void 0 : _g.steps) === null || _h === void 0 ? void 0 : _h.find(s => step.astNodeIds && s.id === step.astNodeIds[0]);
+                    if (featStep) {
+                        err.stack += `\tat Step(${featStep.text}):${(_j = featStep.location) === null || _j === void 0 ? void 0 : _j.line}:${(_k = featStep.location) === null || _k === void 0 ? void 0 : _k.column}\n`;
+                    }
+                }
+                error = err;
+            }
+        }
+        else if (result.status === cucumber_1.Status.FAILED && !result.willBeRetried) {
+            error = new Error((_l = result.message) === null || _l === void 0 ? void 0 : _l.split('\n')[0]);
+            error.stack = result.message;
+            this.failedCount++;
+        }
+        else if (result.status === cucumber_1.Status.AMBIGUOUS && this._options.failAmbiguousDefinitions) {
+            state = 'fail';
+            this.failedCount++;
+            error = new Error((_m = result.message) === null || _m === void 0 ? void 0 : _m.split('\n')[0]);
+            error.stack = result.message;
+        }
+        else if (result.willBeRetried) {
+            state = 'retry';
+        }
+        const common = {
+            title: title,
+            state,
+            error,
+            duration: Date.now() - ((_o = this._testStart) === null || _o === void 0 ? void 0 : _o.getTime()),
+            passed: ['pass', 'skip'].includes(state),
+            file: uri
+        };
+        const payload = step
+            ? (0, utils_1.buildStepPayload)(uri, feature, scenario, step, {
+                type: 'step',
+                ...common
+            })
+            : {
+                type: 'scenario',
+                uid: scenario.id,
+                parent: (0, utils_1.getFeatureId)(uri, feature),
+                tags: scenario.tags,
+                ...common
+            };
+        this.emit('test:' + state, payload);
+    }
+    handleAfterScenario(uri, feature, scenario, result) {
+        var _a;
+        if (this._scenarioLevelReport) {
+            return this.afterTest(uri, feature, scenario, { id: scenario.id }, result);
+        }
+        this.emit('suite:end', {
+            uid: scenario.id,
+            title: this.getTitle(scenario),
+            parent: (0, utils_1.getFeatureId)(uri, feature),
+            type: 'scenario',
+            file: uri,
+            duration: Date.now() - ((_a = this._scenarioStart) === null || _a === void 0 ? void 0 : _a.getTime()),
+            tags: scenario.tags
+        });
+    }
+    handleAfterFeature(uri, feature) {
+        var _a;
+        this.emit('suite:end', {
+            uid: (0, utils_1.getFeatureId)(uri, feature),
+            title: this.getTitle(feature),
+            type: 'feature',
+            file: uri,
+            duration: Date.now() - ((_a = this._featureStart) === null || _a === void 0 ? void 0 : _a.getTime()),
+            tags: feature.tags
+        });
+    }
+    emit(event, payload) {
+        let message = (0, utils_1.formatMessage)({ payload });
+        message.cid = this._cid;
+        message.specs = this._specs;
+        message.uid = payload.uid;
+        this._reporter.emit(event, message);
+    }
+    getTitle(featureOrScenario) {
+        const name = featureOrScenario.name;
+        const tags = featureOrScenario.tags;
+        if (!this._tagsInTitle || !tags || !tags.length)
+            return name;
+        return `${tags.map((tag) => tag.name).join(', ')}: ${name}`;
+    }
+}
+exports.default = CucumberReporter;