@zohodesk/testinglibrary 0.1.8-exp.15 → 0.1.8-exp.16

package/build/bdd-framework/cli/commands/env.js

@@ -33,7 +33,7 @@ function showPackageVersion(packageName) {
  * to aneble using directly from /dist in tests.
  */
 function getOwnVersion() {
-  return '5.6.0';
+  return '6.0.1';
 }
 function showPlaywrightConfigPath(cliConfigPath) {
   const resolvedConfigFile = (0, _loadConfig.resolveConfigFile)(cliConfigPath);

package/build/bdd-framework/config/configDir.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightConfigDir = getPlaywrightConfigDir;
+var _path = _interopRequireDefault(require("path"));
+var _loadConfig = require("../playwright/loadConfig");
+var _options = require("../cli/options");
+/**
+ * Store playwright config dir in env to provide access to it in workers.
+ * Important that in workers there is different process.argv, that's why we save it to env.
+ * Config dir is needed to resolve all paths (features, step definitions).
+ */
+
+/**
+ * Returns Playwright config dir considering cli --config option.
+ */
+function getPlaywrightConfigDir({
+  resolveAndSave = false
+} = {}) {
+  let configDir = process.env.PLAYWRIGHT_BDD_CONFIG_DIR;
+  if (!configDir) {
+    if (resolveAndSave) {
+      const cliConfigPath = (0, _options.getCliConfigPath)();
+      const playwrightConfigFile = (0, _loadConfig.resolveConfigFile)(cliConfigPath);
+      configDir = playwrightConfigFile ? _path.default.dirname(playwrightConfigFile) : process.cwd();
+      process.env.PLAYWRIGHT_BDD_CONFIG_DIR = configDir;
+    } else {
+      throw new Error(`Something went wrong: PLAYWRIGHT_BDD_CONFIG_DIR is not set.`);
+    }
+  }
+  return configDir;
+}

package/build/bdd-framework/config/enrichReporterData.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.enableEnrichReporterData = enableEnrichReporterData;
+exports.getEnrichReporterData = getEnrichReporterData;
+function enableEnrichReporterData() {
+  process.env.PLAYWRIGHT_BDD_ENRICH_REPORTER_DATA = '1';
+}
+function getEnrichReporterData(config) {
+  const enrichReporterDataFromEnv = Boolean(process.env.PLAYWRIGHT_BDD_ENRICH_REPORTER_DATA);
+  if (config.enrichReporterData === true) {
+    return true;
+  }
+  if (config.enrichReporterData === false) {
+    if (enrichReporterDataFromEnv) {
+      throw new Error([`Cucumber reports can't work with enrichReporterData = false in bdd config.`, `Please, set enrichReporterData = true OR remove it from config`, `to let it be auto-configured.`].join(' '));
+    }
+    return false;
+  }
+  return enrichReporterDataFromEnv;
+}

package/build/bdd-framework/config/index.js

@@ -9,7 +9,7 @@ exports.defineBddConfig = defineBddConfig;
 exports.extractCucumberConfig = extractCucumberConfig;
 var _path = _interopRequireDefault(require("path"));
 var _env = require("./env");
-var _dir = require("./dir");
+var _configDir = require("./configDir");
 var _utils = require("../utils");
 /**
  * BDD Config.
@@ -23,16 +23,19 @@ const defaults = exports.defaults = {
   quotes: 'double'
 };
 function defineBddConfig(inputConfig) {
-  const config = getConfig(inputConfig);
+  const isMainProcess = !process.env.TEST_WORKER_INDEX;
+  const configDir = (0, _configDir.getPlaywrightConfigDir)({
+    resolveAndSave: isMainProcess
+  });
+  const config = getConfig(configDir, inputConfig);
   // In main process store config in env to be accessible by workers
-  if (!process.env.TEST_WORKER_INDEX) {
+  if (isMainProcess) {
     (0, _env.saveConfigToEnv)(config);
   }
   return config.outputDir;
 }
-function getConfig(inputConfig) {
+function getConfig(configDir, inputConfig) {
   const config = Object.assign({}, defaults, inputConfig);
-  const configDir = (0, _dir.getPlaywrightConfigDir)();
   const featuresRoot = config.featuresRoot ? _path.default.resolve(configDir, config.featuresRoot) : configDir;
   return {
     ...config,
@@ -53,7 +56,8 @@ function extractCucumberConfig(config) {
     examplesTitleFormat: true,
     quotes: true,
     tags: true,
-    featuresRoot: true
+    featuresRoot: true,
+    enrichReporterData: true
   };
   const keys = Object.keys(omitProps);
   const cucumberConfig = {

package/build/bdd-framework/cucumber/createTestStep.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTestStep = createTestStep;
+/**
+ * Creates partial TestStep for usage in reporter.
+ * It is partial, b/c final pickleStepId will be known only in reporter.
+ *
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/runtime/assemble_test_cases.ts#L93
+ */
+function createTestStep(stepDefinition, stepText) {
+  const result = stepDefinition.expression.match(stepText);
+  if (!result) {
+    // this should not happen as stepDefinition is already matched
+    throw Error(`Step definition didn't match step "${stepText}"`);
+  }
+  const stepMatchArguments = result.map(arg => {
+    return {
+      group: mapArgumentGroup(arg.group),
+      parameterTypeName: arg.parameterType.name
+    };
+  });
+  return {
+    // id will be generated in reporter, no need to generate it here
+    id: '',
+    // looks like it's useless to store stepDefinitionIds here
+    // b/c they will be different in reporter
+    // stepDefinitionIds: [stepDefinition.id],
+    stepMatchArgumentsLists: [{
+      stepMatchArguments
+    }]
+  };
+}
+function mapArgumentGroup(group) {
+  var _group$children;
+  return {
+    start: group.start,
+    value: group.value,
+    children: (_group$children = group.children) === null || _group$children === void 0 ? void 0 : _group$children.map(child => mapArgumentGroup(child))
+  };
+}

package/build/bdd-framework/cucumber/formatter/EventDataCollector.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var messages = _interopRequireWildcard(require("@cucumber/messages"));
+var _valueChecker = require("../valueChecker");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Groups Cucumber messages for easier access.
+ * Based on Cucumber, with some changes due to strictNullChecks errors.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/helpers/event_data_collector.ts
+ */
+
+class EventDataCollector {
+  gherkinDocumentMap = {};
+  pickleMap = {};
+  testCaseMap = {};
+  testCaseAttemptDataMap = {};
+  undefinedParameterTypes = [];
+  constructor(eventBroadcaster) {
+    eventBroadcaster.on('envelope', this.parseEnvelope.bind(this));
+  }
+  /**
+     * @public
+     */
+  getGherkinDocument(uri) {
+    return this.gherkinDocumentMap[uri];
+  }
+  /**
+     * @public
+     */
+  getPickle(pickleId) {
+    return this.pickleMap[pickleId];
+  }
+  getTestCaseAttempts() {
+    return Object.keys(this.testCaseAttemptDataMap).map(testCaseStartedId => {
+      return this.getTestCaseAttempt(testCaseStartedId);
+    });
+  }
+  getTestCaseAttempt(testCaseStartedId) {
+    const testCaseAttemptData = this.testCaseAttemptDataMap[testCaseStartedId];
+    const testCase = this.testCaseMap[testCaseAttemptData.testCaseId];
+    const pickle = this.pickleMap[testCase.pickleId];
+    return {
+      gherkinDocument: this.gherkinDocumentMap[pickle.uri],
+      pickle,
+      testCase,
+      attempt: testCaseAttemptData.attempt,
+      willBeRetried: testCaseAttemptData.willBeRetried,
+      stepAttachments: testCaseAttemptData.stepAttachments,
+      stepResults: testCaseAttemptData.stepResults,
+      worstTestStepResult: testCaseAttemptData.worstTestStepResult
+    };
+  }
+  parseEnvelope(envelope) {
+    var _envelope$gherkinDocu;
+    if ((0, _valueChecker.doesHaveValue)((_envelope$gherkinDocu = envelope.gherkinDocument) === null || _envelope$gherkinDocu === void 0 ? void 0 : _envelope$gherkinDocu.uri)) {
+      this.gherkinDocumentMap[envelope.gherkinDocument.uri] = envelope.gherkinDocument;
+    } else if ((0, _valueChecker.doesHaveValue)(envelope.pickle)) {
+      this.pickleMap[envelope.pickle.id] = envelope.pickle;
+    } else if ((0, _valueChecker.doesHaveValue)(envelope.undefinedParameterType)) {
+      this.undefinedParameterTypes.push(envelope.undefinedParameterType);
+    } else if ((0, _valueChecker.doesHaveValue)(envelope.testCase)) {
+      this.testCaseMap[envelope.testCase.id] = envelope.testCase;
+    } else if ((0, _valueChecker.doesHaveValue)(envelope.testCaseStarted)) {
+      this.initTestCaseAttempt(envelope.testCaseStarted);
+    } else if ((0, _valueChecker.doesHaveValue)(envelope.attachment)) {
+      this.storeAttachment(envelope.attachment);
+    } else if ((0, _valueChecker.doesHaveValue)(envelope.testStepFinished)) {
+      this.storeTestStepResult(envelope.testStepFinished);
+    } else if ((0, _valueChecker.doesHaveValue)(envelope.testCaseFinished)) {
+      this.storeTestCaseResult(envelope.testCaseFinished);
+    }
+  }
+  initTestCaseAttempt(testCaseStarted) {
+    this.testCaseAttemptDataMap[testCaseStarted.id] = {
+      attempt: testCaseStarted.attempt,
+      willBeRetried: false,
+      testCaseId: testCaseStarted.testCaseId,
+      stepAttachments: {},
+      stepResults: {},
+      worstTestStepResult: {
+        duration: {
+          seconds: 0,
+          nanos: 0
+        },
+        status: messages.TestStepResultStatus.UNKNOWN
+      }
+    };
+  }
+  storeAttachment(attachment) {
+    const {
+      testCaseStartedId,
+      testStepId
+    } = attachment;
+    // TODO: we shouldn't have to check if these properties have values - they are non-nullable
+    if ((0, _valueChecker.doesHaveValue)(testCaseStartedId) && (0, _valueChecker.doesHaveValue)(testStepId)) {
+      const {
+        stepAttachments
+      } = this.testCaseAttemptDataMap[testCaseStartedId];
+      if ((0, _valueChecker.doesNotHaveValue)(stepAttachments[testStepId])) {
+        stepAttachments[testStepId] = [];
+      }
+      stepAttachments[testStepId].push(attachment);
+    }
+  }
+  storeTestStepResult({
+    testCaseStartedId,
+    testStepId,
+    testStepResult
+  }) {
+    this.testCaseAttemptDataMap[testCaseStartedId].stepResults[testStepId] = testStepResult;
+  }
+  storeTestCaseResult({
+    testCaseStartedId,
+    willBeRetried
+  }) {
+    const stepResults = Object.values(this.testCaseAttemptDataMap[testCaseStartedId].stepResults);
+    this.testCaseAttemptDataMap[testCaseStartedId].worstTestStepResult = messages.getWorstTestStepResult(stepResults);
+    this.testCaseAttemptDataMap[testCaseStartedId].willBeRetried = willBeRetried;
+  }
+}
+exports.default = EventDataCollector;

package/build/bdd-framework/cucumber/formatter/GherkinDocumentParser.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getGherkinExampleRuleMap = getGherkinExampleRuleMap;
+exports.getGherkinScenarioLocationMap = getGherkinScenarioLocationMap;
+exports.getGherkinScenarioMap = getGherkinScenarioMap;
+exports.getGherkinStepMap = getGherkinStepMap;
+var _valueChecker = require("../valueChecker");
+/**
+ * Based on: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/helpers/gherkin_document_parser.ts
+ */
+
+function getGherkinStepMap(gherkinDocument) {
+  var _gherkinDocument$feat;
+  const result = {};
+  (_gherkinDocument$feat = gherkinDocument.feature) === null || _gherkinDocument$feat === void 0 || _gherkinDocument$feat.children.map(extractStepContainers).flat().forEach(x => x.steps.forEach(step => result[step.id] = step));
+  return result;
+}
+function extractStepContainers(child) {
+  if ((0, _valueChecker.doesHaveValue)(child.background)) {
+    return [child.background];
+  } else if ((0, _valueChecker.doesHaveValue)(child.rule)) {
+    return child.rule.children.map(ruleChild => (0, _valueChecker.doesHaveValue)(ruleChild.background) ? ruleChild.background : ruleChild.scenario).filter(v => !!v);
+  } else if ((0, _valueChecker.doesHaveValue)(child.scenario)) {
+    return [child.scenario];
+  } else {
+    throw new Error('Empty step container');
+  }
+}
+function getGherkinScenarioMap(gherkinDocument) {
+  var _gherkinDocument$feat2;
+  const result = {};
+  (_gherkinDocument$feat2 = gherkinDocument.feature) === null || _gherkinDocument$feat2 === void 0 || _gherkinDocument$feat2.children.map(child => {
+    if ((0, _valueChecker.doesHaveValue)(child.rule)) {
+      return child.rule.children;
+    }
+    return [child];
+  }).flat().forEach(x => {
+    if (x.scenario != null) {
+      result[x.scenario.id] = x.scenario;
+    }
+  });
+  return result;
+}
+function getGherkinExampleRuleMap(gherkinDocument) {
+  var _gherkinDocument$feat3;
+  const result = {};
+  (_gherkinDocument$feat3 = gherkinDocument.feature) === null || _gherkinDocument$feat3 === void 0 || _gherkinDocument$feat3.children.filter(x => x.rule != null).forEach(x => {
+    var _x$rule;
+    return x === null || x === void 0 || (_x$rule = x.rule) === null || _x$rule === void 0 ? void 0 : _x$rule.children.filter(child => (0, _valueChecker.doesHaveValue)(child.scenario)).forEach(child => {
+      var _child$scenario;
+      if (child !== null && child !== void 0 && (_child$scenario = child.scenario) !== null && _child$scenario !== void 0 && _child$scenario.id && x.rule) {
+        result[child.scenario.id] = x.rule;
+      }
+    });
+  });
+  return result;
+}
+function getGherkinScenarioLocationMap(gherkinDocument) {
+  const locationMap = {};
+  const scenarioMap = getGherkinScenarioMap(gherkinDocument);
+  Object.keys(scenarioMap).forEach(id => {
+    const scenario = scenarioMap[id];
+    locationMap[id] = scenario.location;
+    if ((0, _valueChecker.doesHaveValue)(scenario.examples)) {
+      scenario.examples.forEach(x => x.tableBody.forEach(tableRow => locationMap[tableRow.id] = tableRow.location));
+    }
+  });
+  return locationMap;
+}

package/build/bdd-framework/cucumber/formatter/PickleParser.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPickleStepMap = getPickleStepMap;
+exports.getScenarioDescription = getScenarioDescription;
+exports.getStepKeyword = getStepKeyword;
+function getScenarioDescription({
+  pickle,
+  gherkinScenarioMap
+}) {
+  return pickle.astNodeIds.map(id => gherkinScenarioMap[id]).filter(x => x != null)[0].description;
+}
+function getStepKeyword({
+  pickleStep,
+  gherkinStepMap
+}) {
+  return pickleStep.astNodeIds.map(id => gherkinStepMap[id]).filter(x => x != null)[0].keyword;
+}
+function getPickleStepMap(pickle) {
+  const result = {};
+  pickle.steps.forEach(pickleStep => result[pickleStep.id] = pickleStep);
+  return result;
+}

package/build/bdd-framework/cucumber/formatter/durationHelpers.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.durationToNanoseconds = durationToNanoseconds;
+/**
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/helpers/duration_helpers.ts#L5
+ */
+const NANOS_IN_SECOND = 1_000_000_000;
+function durationToNanoseconds(duration) {
+  return Math.floor(duration.seconds * NANOS_IN_SECOND + duration.nanos);
+}

package/build/bdd-framework/cucumber/formatter/getColorFns.js

@@ -0,0 +1,57 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getColorFns;
+var _chalk = _interopRequireDefault(require("chalk"));
+var _supportsColor = require("supports-color");
+var _valueChecker = require("../valueChecker");
+function getColorFns(stream, env, enabled) {
+  const support = detectSupport(stream, env, enabled);
+  if (support) {
+    const chalkInstance = new _chalk.default.Instance(support);
+    return {
+      forStatus(status) {
+        return {
+          AMBIGUOUS: chalkInstance.red.bind(_chalk.default),
+          FAILED: chalkInstance.red.bind(_chalk.default),
+          PASSED: chalkInstance.green.bind(_chalk.default),
+          PENDING: chalkInstance.yellow.bind(_chalk.default),
+          SKIPPED: chalkInstance.cyan.bind(_chalk.default),
+          UNDEFINED: chalkInstance.yellow.bind(_chalk.default),
+          UNKNOWN: chalkInstance.yellow.bind(_chalk.default)
+        }[status];
+      },
+      location: chalkInstance.gray.bind(_chalk.default),
+      tag: chalkInstance.cyan.bind(_chalk.default),
+      diffAdded: chalkInstance.green.bind(_chalk.default),
+      diffRemoved: chalkInstance.red.bind(_chalk.default),
+      errorMessage: chalkInstance.red.bind(_chalk.default),
+      errorStack: chalkInstance.grey.bind(_chalk.default)
+    };
+  } else {
+    return {
+      forStatus() {
+        return x => x;
+      },
+      location: x => x,
+      tag: x => x,
+      diffAdded: x => x,
+      diffRemoved: x => x,
+      errorMessage: x => x,
+      errorStack: x => x
+    };
+  }
+}
+function detectSupport(stream, env, enabled) {
+  const support = (0, _supportsColor.supportsColor)(stream);
+  // if we find FORCE_COLOR, we can let the supports-color library handle that
+  if ('FORCE_COLOR' in env || (0, _valueChecker.doesNotHaveValue)(enabled)) {
+    return support;
+  }
+  return enabled ? support || {
+    level: 1
+  } : false;
+}

package/build/bdd-framework/cucumber/formatter/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// simplified Formatter class
+class Formatter {
+  options;
+  static documentation;
+  constructor(options) {
+    this.options = options;
+  }
+  async finished() {}
+}
+exports.default = Formatter;

package/build/bdd-framework/cucumber/formatter/locationHelpers.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.formatLocation = formatLocation;
+var _path = _interopRequireDefault(require("path"));
+var _valueChecker = require("../valueChecker");
+function formatLocation(obj, cwd) {
+  let uri = obj.uri;
+  if ((0, _valueChecker.doesHaveValue)(cwd)) {
+    uri = _path.default.relative(cwd, uri);
+  }
+  return `${uri}:${obj.line.toString()}`;
+}

package/build/bdd-framework/cucumber/loadFeatures.js

@@ -3,37 +3,68 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.loadFeatures = loadFeatures;
-var _loadSources = require("./loadSources");
-var _exit = require("../utils/exit");
-async function loadFeatures(runConfiguration, environment) {
-  const {
-    filteredPickles,
-    parseErrors
-  } = await (0, _loadSources.loadSources)(runConfiguration.sources, environment);
-  handleParseErrors(parseErrors);
-  return groupByDocument(filteredPickles);
+exports.FeaturesLoader = void 0;
+var _gherkinStreams = require("@cucumber/gherkin-streams");
+var _gherkinUtils = require("@cucumber/gherkin-utils");
+/**
+ * Load features.
+ *
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/api/load_sources.ts
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/api/gherkin.ts
+ */
+
+class FeaturesLoader {
+  gherkinQuery = new _gherkinUtils.Query();
+  parseErrors = [];
+  /**
+     * Loads and parses feature files.
+     * - featurePaths should be absolute.
+     *   See: https://github.com/cucumber/gherkin-streams/blob/main/src/GherkinStreams.ts#L36
+     * - if options.relativeTo is provided, uri in gherkin documents will be relative to it.
+     *   See: https://github.com/cucumber/gherkin-streams/blob/main/src/SourceMessageStream.ts#L31
+     * - options.defaultDialect is 'en' by default.
+     *   See: https://github.com/cucumber/gherkin-streams/blob/main/src/makeGherkinOptions.ts#L5
+     */
+  async load(featurePaths, options) {
+    this.gherkinQuery = new _gherkinUtils.Query();
+    this.parseErrors = [];
+    await gherkinFromPaths(featurePaths, options, envelope => {
+      this.gherkinQuery.update(envelope);
+      if (envelope.parseError) {
+        this.parseErrors.push(envelope.parseError);
+      }
+    });
+  }
+  getDocumentsCount() {
+    return this.gherkinQuery.getGherkinDocuments().length;
+  }
+  getDocumentsWithPickles() {
+    return this.gherkinQuery.getGherkinDocuments().map(gherkinDocument => {
+      const pickles = this.getDocumentPickles(gherkinDocument);
+      return {
+        ...gherkinDocument,
+        pickles
+      };
+    });
+  }
+  getDocumentPickles(gherkinDocument) {
+    return this.gherkinQuery.getPickles().filter(pickle => gherkinDocument.uri === pickle.uri).map(pickle => this.getPickleWithLocation(pickle));
+  }
+  getPickleWithLocation(pickle) {
+    const lastAstNodeId = pickle.astNodeIds[pickle.astNodeIds.length - 1];
+    const location = this.gherkinQuery.getLocation(lastAstNodeId);
+    return {
+      ...pickle,
+      location
+    };
+  }
 }
-function groupByDocument(filteredPickles) {
-  const features = new Map();
-  filteredPickles.forEach(({
-    pickle,
-    gherkinDocument
-  }) => {
-    let pickles = features.get(gherkinDocument);
-    if (!pickles) {
-      pickles = [];
-      features.set(gherkinDocument, pickles);
-    }
-    pickles.push(pickle);
+exports.FeaturesLoader = FeaturesLoader;
+async function gherkinFromPaths(paths, options, onEnvelope) {
+  return new Promise((resolve, reject) => {
+    const gherkinMessageStream = _gherkinStreams.GherkinStreams.fromPaths(paths, options);
+    gherkinMessageStream.on('data', onEnvelope);
+    gherkinMessageStream.on('end', resolve);
+    gherkinMessageStream.on('error', reject);
   });
-  return features;
-}
-function handleParseErrors(parseErrors) {
-  if (parseErrors.length) {
-    const message = parseErrors.map(parseError => {
-      return `Parse error in "${parseError.source.uri}" ${parseError.message}`;
-    }).join('\n');
-    (0, _exit.exit)(message);
-  }
 }

package/build/bdd-framework/cucumber/loadSteps.js

@@ -21,6 +21,13 @@ async function loadSteps(runConfiguration, environment = {}) {
   }
   return lib;
 }
+/**
+ * Finds step definition by step text.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/runtime/assemble_test_cases.ts#L103
+ *
+ * Handling case when several step definitions found:
+ * https://github.com/cucumber/cucumber-js/blob/main/src/runtime/test_case_runner.ts#L313
+ */
 function findStepDefinition(supportCodeLibrary, stepText, file) {
   const matchedSteps = supportCodeLibrary.stepDefinitions.filter(step => {
     return step.matchesStepName(stepText);

package/build/bdd-framework/cucumber/resolveFeaturePaths.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resovleFeaturePaths = resovleFeaturePaths;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _environment = require("@cucumber/cucumber/lib/api/environment");
+var _console_logger = require("@cucumber/cucumber/lib/api/console_logger");
+var _utils = require("../utils");
+/**
+ * Representation of https://github.com/cucumber/cucumber-js/blob/main/src/paths/paths.ts
+ * Since Cucumber 10.1 resolvePaths was moved from lib/api/paths to lib/paths/paths.
+ * This module makes resolvePaths working with any version of Cucumber.
+ * See: https://github.com/cucumber/cucumber-js/pull/2361/files
+ *
+ * todo: replace with own paths resolution.
+ */
+
+/**
+ * Returns list of absolute feature paths.
+ */
+// eslint-disable-next-line max-statements
+async function resovleFeaturePaths(runConfiguration, environment = {}) {
+  const {
+    cwd,
+    stderr,
+    debug
+  } = (0, _environment.mergeEnvironment)(environment);
+  const logger = new _console_logger.ConsoleLogger(stderr, debug);
+  const cucumberRoot = (0, _utils.resolvePackageRoot)('@cucumber/cucumber');
+  const pathsModuleBefore10_1 = _path.default.join(cucumberRoot, 'lib/api/paths.js');
+  const pathsModuleAfter10_1 = _path.default.join(cucumberRoot, 'lib/paths/paths.js');
+  const isNewResolvePaths = _fs.default.existsSync(pathsModuleAfter10_1);
+  if (isNewResolvePaths) {
+    const {
+      resolvePaths
+    } = require(pathsModuleAfter10_1);
+    const {
+      sourcePaths,
+      unexpandedSourcePaths
+    } = await resolvePaths(logger, cwd, runConfiguration.sources);
+    return {
+      featurePaths: sourcePaths,
+      unexpandedFeaturePaths: unexpandedSourcePaths
+    };
+  } else {
+    const {
+      resolvePaths
+    } = require(pathsModuleBefore10_1);
+    const {
+      featurePaths,
+      unexpandedFeaturePaths
+    } = await resolvePaths(logger, cwd, runConfiguration.sources);
+    return {
+      featurePaths,
+      unexpandedFeaturePaths
+    };
+  }
+}