@zohodesk/testinglibrary 0.1.8-exp-bdd-v3 → 0.1.8-exp-bdd

package/build/bdd-framework/run/bddWorld.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BddWorld = void 0;
+exports.getWorldConstructor = getWorldConstructor;
+var _cucumber = require("@cucumber/cucumber");
+var _loadSteps = require("../cucumber/loadSteps");
+var _getLocationInFile = require("../playwright/getLocationInFile");
+var _testTypeImpl = require("../playwright/testTypeImpl");
+var _defineStep = require("../stepDefinitions/defineStep");
+class BddWorld extends _cucumber.World {
+  options;
+  builtinFixtures;
+  customFixtures;
+  constructor(options) {
+    super(options);
+    this.options = options;
+    this.invokeStep = this.invokeStep.bind(this);
+  }
+  async invokeStep(text, argument, customFixtures) {
+    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.options.supportCodeLibrary, text, this.testInfo.file);
+    if (!stepDefinition) {
+      throw new Error(`Undefined step: "${text}"`);
+    }
+    // attach custom fixtures to world - the only way to pass them to cucumber step fn
+    this.customFixtures = customFixtures;
+    const code = (0, _defineStep.getStepCode)(stepDefinition);
+    // Get location of step call in generated test file.
+    // This call must be exactly here to have correct call stack.
+    const location = (0, _getLocationInFile.getLocationInFile)(this.test.info().file);
+    const {
+      parameters
+    } = await stepDefinition.getInvocationParameters({
+      hookParameter: {},
+      step: {
+        text,
+        argument
+      },
+      world: this
+    });
+    const res = await (0, _testTypeImpl.runStepWithCustomLocation)(this.test, text, location, () => code.apply(this, parameters));
+    delete this.customFixtures;
+    return res;
+  }
+  get page() {
+    return this.builtinFixtures.page;
+  }
+  get context() {
+    return this.builtinFixtures.context;
+  }
+  get browser() {
+    return this.builtinFixtures.browser;
+  }
+  get browserName() {
+    return this.builtinFixtures.browserName;
+  }
+  get request() {
+    return this.builtinFixtures.request;
+  }
+  get testInfo() {
+    return this.options.testInfo;
+  }
+  get tags() {
+    return this.options.$tags;
+  }
+  get test() {
+    return this.options.$test;
+  }
+  async init() {
+    // async setup before each test
+  }
+  async destroy() {
+    // async teardown after each test
+  }
+}
+exports.BddWorld = BddWorld;
+function getWorldConstructor(supportCodeLibrary) {
+  // setWorldConstructor was not called
+  if (supportCodeLibrary.World === _cucumber.World) {
+    return BddWorld;
+  }
+  if (!Object.prototype.isPrototypeOf.call(BddWorld, supportCodeLibrary.World)) {
+    throw new Error(`CustomWorld should inherit from playwright-bdd World`);
+  }
+  return supportCodeLibrary.World;
+}

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

@@ -0,0 +1,134 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Snippets = void 0;
+var _loadSnippetBuilder = require("../cucumber/loadSnippetBuilder");
+var _logger = require("../utils/logger");
+var _stepConfig = require("../stepDefinitions/stepConfig");
+/**
+ * Generate and show snippets for undefined steps
+ */
+
+class Snippets {
+  files;
+  runConfiguration;
+  supportCodeLibrary;
+  snippetBuilder;
+  bddBuiltInSyntax = false;
+  constructor(files, runConfiguration, supportCodeLibrary) {
+    this.files = files;
+    this.runConfiguration = runConfiguration;
+    this.supportCodeLibrary = supportCodeLibrary;
+  }
+  async print() {
+    this.snippetBuilder = await this.createSnippetBuilder();
+    const snippets = this.getSnippets();
+    this.printHeader();
+    this.printSnippets(snippets);
+    this.printFooter(snippets);
+    // exit();
+  }
+  async createSnippetBuilder() {
+    const {
+      snippetInterface
+    } = this.runConfiguration.formats.options;
+    const snippetSyntax = this.getSnippetSyntax();
+    return (0, _loadSnippetBuilder.loadSnippetBuilder)(this.supportCodeLibrary, snippetInterface, snippetSyntax);
+  }
+  getSnippetSyntax() {
+    const {
+      snippetSyntax
+    } = this.runConfiguration.formats.options;
+    if (!snippetSyntax && this.isPlaywrightStyle()) {
+      this.bddBuiltInSyntax = true;
+      return this.isDecorators() ? require.resolve('./snippetSyntaxDecorators.js') : this.isTypeScript() ? require.resolve('./snippetSyntaxTs.js') : require.resolve('./snippetSyntax.js');
+    } else {
+      return snippetSyntax;
+    }
+  }
+  getSnippets() {
+    const snippetsSet = new Set();
+    const snippets = [];
+    this.files.forEach(file => {
+      file.undefinedSteps.forEach(undefinedStep => {
+        const {
+          snippet,
+          snippetWithLocation
+        } = this.getSnippet(file, snippets.length + 1, undefinedStep);
+        if (!snippetsSet.has(snippet)) {
+          snippetsSet.add(snippet);
+          snippets.push(snippetWithLocation);
+        }
+      });
+    });
+    return snippets;
+  }
+  getSnippet(file, index, undefinedStep) {
+    const snippet = this.snippetBuilder.build({
+      keywordType: undefinedStep.keywordType,
+      pickleStep: undefinedStep.pickleStep
+    });
+    const {
+      line,
+      column
+    } = undefinedStep.step.location;
+    const snippetWithLocation = [`// ${index}. Missing step definition for "${file.sourceFile}:${line}:${column}"`, snippet].join('\n');
+    return {
+      snippet,
+      snippetWithLocation
+    };
+  }
+  isTypeScript() {
+    const {
+      requirePaths,
+      importPaths
+    } = this.supportCodeLibrary.originalCoordinates;
+    return requirePaths.some(p => p.endsWith('.ts')) || importPaths.some(p => p.endsWith('.ts'));
+  }
+  isPlaywrightStyle() {
+    const {
+      stepDefinitions
+    } = this.supportCodeLibrary;
+    return stepDefinitions.length > 0 ? stepDefinitions.some(step => (0, _stepConfig.isPlaywrightStyle)((0, _stepConfig.getStepConfig)(step))) : true;
+  }
+  isDecorators() {
+    const {
+      stepDefinitions
+    } = this.supportCodeLibrary;
+    const decoratorSteps = stepDefinitions.filter(step => (0, _stepConfig.isDecorator)((0, _stepConfig.getStepConfig)(step)));
+    return decoratorSteps.length > stepDefinitions.length / 2;
+  }
+  printHeader() {
+    const lines = [`Missing steps found. Use snippets below:`];
+    if (this.bddBuiltInSyntax) {
+      if (this.isDecorators()) {
+        lines.push(`import { Fixture, Given, When, Then } from 'playwright-bdd/decorators';\n`);
+      } else {
+        lines.push(`import { createBdd } from '@zohodesk/testinglibrary';`, `const { Given, When, Then } = createBdd();\n`);
+      }
+    } else {
+      lines.push(`import { Given, When, Then } from '@cucumber/cucumber';\n`);
+    }
+    _logger.logger.error(lines.join('\n\n'));
+  }
+  printSnippets(snippets) {
+    _logger.logger.error(snippets.concat(['']).join('\n\n'));
+  }
+  printFooter(snippets) {
+    _logger.logger.error(`Missing step definitions (${snippets.length}).`, `Use snippets above to create them.`);
+    this.printWarningOnZeroScannedFiles();
+  }
+  printWarningOnZeroScannedFiles() {
+    const {
+      requirePaths,
+      importPaths
+    } = this.supportCodeLibrary.originalCoordinates;
+    const scannedFilesCount = requirePaths.length + importPaths.length;
+    if (scannedFilesCount === 0 && !this.isDecorators()) {
+      _logger.logger.error(`Note that 0 step definition files found, check the config.`);
+    }
+  }
+}
+exports.Snippets = Snippets;

package/build/bdd-framework/snippets/snippetSyntax.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// todo: custom cucumber parameters
+// See: https://github.com/cucumber/cucumber-expressions#custom-parameter-types
+class _default {
+  isTypescript = false;
+  build({
+    generatedExpressions,
+    functionName,
+    stepParameterNames
+  }) {
+    // Always take only first generatedExpression
+    // Other expressions are for int/float combinations
+    const generatedExpression = generatedExpressions[0];
+    const expressionParameters = generatedExpression.parameterNames.map((name, i) => {
+      const argName = `arg${i === 0 ? '' : i}`;
+      const type = name.startsWith('string') ? 'string' : 'number';
+      return this.isTypescript ? `${argName}: ${type}` : argName;
+    });
+    const stepParameters = stepParameterNames.map(argName => {
+      const type = argName === 'dataTable' ? 'DataTable' : 'string';
+      return this.isTypescript ? `${argName}: ${type}` : argName;
+    });
+    const allParameterNames = ['{}', ...expressionParameters, ...stepParameters];
+    const functionSignature = `${functionName}('${this.escapeSpecialCharacters(generatedExpression)}', async (${allParameterNames.join(', ')}) => {`;
+    return [functionSignature, `  // ...`, '});'].join('\n');
+  }
+  escapeSpecialCharacters(generatedExpression) {
+    let source = generatedExpression.source;
+    // double up any backslashes because we're in a javascript string
+    source = source.replace(/\\/g, '\\\\');
+    // escape any single quotes because that's our quote delimiter
+    source = source.replace(/'/g, "\\'");
+    return source;
+  }
+}
+exports.default = _default;

package/build/bdd-framework/snippets/snippetSyntaxDecorators.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class _default {
+  build({
+    generatedExpressions,
+    functionName
+  }) {
+    // Always take only first generatedExpression
+    // Other expressions are for int/float combinations
+    const generatedExpression = generatedExpressions[0];
+    return `@${functionName}('${this.escapeSpecialCharacters(generatedExpression)}')`;
+  }
+  escapeSpecialCharacters(generatedExpression) {
+    let source = generatedExpression.source;
+    // double up any backslashes because we're in a javascript string
+    source = source.replace(/\\/g, '\\\\');
+    // escape any single quotes because that's our quote delimiter
+    source = source.replace(/'/g, "\\'");
+    return source;
+  }
+}
+exports.default = _default;

package/build/bdd-framework/snippets/snippetSyntaxTs.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _snippetSyntax = _interopRequireDefault(require("./snippetSyntax"));
+/**
+ * Playwright-style snippet syntax for typescript.
+ * Important to use separate file as it's simplest way to distinguish between js/ts
+ * without hooking into cucumber machinery.
+ */
+
+class _default extends _snippetSyntax.default {
+  isTypescript = true;
+}
+exports.default = _default;

package/build/bdd-framework/stepDefinitions/createBdd.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBdd = createBdd;
+exports.extractFixtureNames = extractFixtureNames;
+var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
+var _bddFixtures = require("../run/bddFixtures");
+var _testTypeImpl = require("../playwright/testTypeImpl");
+var _defineStep = require("./defineStep");
+var _exit = require("../utils/exit");
+/**
+ * Stuff related to writing steps in Playwright-style.
+ */
+
+function createBdd(customTest) {
+  const hasCustomTest = isCustomTest(customTest);
+  const Given = defineStepCtor('Given', hasCustomTest);
+  const When = defineStepCtor('When', hasCustomTest);
+  const Then = defineStepCtor('Then', hasCustomTest);
+  const Step = defineStepCtor('Unknown', hasCustomTest);
+  return {
+    Given,
+    When,
+    Then,
+    Step
+  };
+}
+function defineStepCtor(keyword, hasCustomTest) {
+  return (pattern, fn) => {
+    (0, _defineStep.defineStep)({
+      keyword,
+      pattern,
+      fn,
+      hasCustomTest
+    });
+  };
+}
+function extractFixtureNames(fn) {
+  return (0, _fixtureParameterNames.fixtureParameterNames)(fn).filter(name => !(0, _bddFixtures.isBddAutoInjectFixture)(name));
+}
+function isCustomTest(customTest) {
+  const isCustomTest = Boolean(customTest && customTest !== _bddFixtures.test);
+  if (isCustomTest && customTest && !(0, _testTypeImpl.isParentChildTest)(_bddFixtures.test, customTest)) {
+    (0, _exit.exit)(`createBdd() should use test extended from "@zohodesk/testinglibrary"`);
+  }
+  return isCustomTest;
+}

package/build/bdd-framework/stepDefinitions/createDecorators.js

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fixture = Fixture;
+exports.appendDecoratorSteps = appendDecoratorSteps;
+exports.createStepDecorator = createStepDecorator;
+exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
+var _bddFixtures = require("../run/bddFixtures");
+var _defineStep = require("./defineStep");
+var _buildStepDefinition = require("../cucumber/buildStepDefinition");
+/* eslint-disable no-unused-vars */
+/**
+ * Define steps via decorators.
+ */
+
+const pomGraph = new Map();
+const decoratedStepSymbol = Symbol('decoratedStep');
+const decoratedSteps = new Set();
+function Fixture(fixtureName) {
+  // context parameter is required for decorator by TS even though it's not used
+  return (Ctor, _context) => {
+    createPomNode(Ctor, fixtureName);
+  };
+}
+function createStepDecorator(keyword) {
+  return pattern => {
+    // context parameter is required for decorator by TS even though it's not used
+    return (method, _context) => {
+      method[decoratedStepSymbol] = {
+        keyword,
+        pattern,
+        fn: method,
+        hasCustomTest: true,
+        isDecorator: true
+      };
+    };
+  };
+}
+function appendDecoratorSteps(supportCodeLibrary) {
+  decoratedSteps.forEach(stepConfig => {
+    const {
+      keyword,
+      pattern,
+      fn
+    } = stepConfig;
+    stepConfig.fn = (fixturesArg, ...args) => {
+      const fixture = getFirstNonAutoInjectFixture(fixturesArg, stepConfig);
+      return fn.call(fixture, ...args);
+    };
+    const code = (0, _defineStep.buildCucumberStepFn)(stepConfig);
+    const stepDefinition = (0, _buildStepDefinition.buildStepDefinition)({
+      keyword,
+      pattern,
+      code,
+      line: 0,
+      // not used in playwright-bdd
+      options: {},
+      // not used in playwright-bdd
+      uri: '' // not used in playwright-bdd
+    }, supportCodeLibrary);
+    supportCodeLibrary.stepDefinitions.push(stepDefinition);
+  });
+  decoratedSteps.clear();
+  // todo: fill supportCodeLibrary.originalCoordinates as it is used in snippets?
+}
+function getPomNodeByFixtureName(fixtureName) {
+  for (const pomNode of pomGraph.values()) {
+    if (pomNode.fixtureName === fixtureName) return pomNode;
+  }
+}
+function createPomNode(Ctor, fixtureName) {
+  const pomNode = {
+    fixtureName,
+    children: new Set()
+  };
+  pomGraph.set(Ctor, pomNode);
+  getDecoratedSteps(Ctor).forEach(stepConfig => {
+    stepConfig.pomNode = pomNode;
+    decoratedSteps.add(stepConfig);
+  });
+  const parentCtor = Object.getPrototypeOf(Ctor);
+  if (!parentCtor) return;
+  const parentPomNode = pomGraph.get(parentCtor) || createPomNode(parentCtor, '');
+  parentPomNode === null || parentPomNode === void 0 || parentPomNode.children.add(pomNode);
+  return pomNode;
+}
+function getDecoratedSteps(Ctor) {
+  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) return [];
+  const propertyDescriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
+  return Object.keys(propertyDescriptors)
+  // filter out getters / setters
+  .filter(methodName => typeof propertyDescriptors[methodName].value === 'function').map(methodName => {
+    return propertyDescriptors[methodName].value[decoratedStepSymbol];
+  }).filter(Boolean);
+}
+function getFirstNonAutoInjectFixture(fixturesArg, stepConfig) {
+  // there should be exatcly one suitable fixture in fixturesArg
+  const fixtureNames = Object.keys(fixturesArg).filter(fixtureName => !(0, _bddFixtures.isBddAutoInjectFixture)(fixtureName));
+  if (fixtureNames.length === 0) {
+    throw new Error(`No suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  if (fixtureNames.length > 1) {
+    throw new Error(`Several suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  return fixturesArg[fixtureNames[0]];
+}

package/build/bdd-framework/stepDefinitions/decorators/poms.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Fixture = Fixture;
+exports.getPomNodeByFixtureName = getPomNodeByFixtureName;
+var _steps = require("./steps");
+var _exit = require("../../utils/exit");
+/**
+ * POM classes marked with @Fixture
+ */
+
+/**
+ * Graph of POM class inheritance.
+ * Allows to guess correct fixture by step text.
+ */
+const pomGraph = new Map();
+/**
+ * @Fixture decorator.
+ */
+function Fixture(fixtureName) {
+  // context parameter is required for decorator by TS even though it's not used
+  return Ctor => {
+    createPomNode(Ctor, fixtureName);
+  };
+}
+function createPomNode(Ctor, fixtureName) {
+  const pomNode = {
+    fixtureName,
+    className: Ctor.name,
+    children: new Set()
+  };
+  ensureUniqueFixtureName(pomNode);
+  pomGraph.set(Ctor, pomNode);
+  (0, _steps.linkStepsWithPomNode)(Ctor, pomNode);
+  linkParentWithPomNode(Ctor, pomNode);
+  return pomNode;
+}
+function ensureUniqueFixtureName({
+  fixtureName,
+  className
+}) {
+  if (!fixtureName) {
+    return;
+  }
+  const existingPom = getPomNodeByFixtureName(fixtureName);
+  if (existingPom) {
+    (0, _exit.exit)(`Duplicate fixture name "${fixtureName}"`, `defined for classes: ${existingPom.className}, ${className}`);
+  }
+}
+function linkParentWithPomNode(Ctor, pomNode) {
+  const parentCtor = Object.getPrototypeOf(Ctor);
+  if (!parentCtor) return;
+  // if parentCtor is not in pomGraph, add it.
+  // Case: parent class is not marked with @Fixture, but has decorator steps (base class)
+  const parentPomNode = pomGraph.get(parentCtor) || createPomNode(parentCtor, '');
+  parentPomNode.children.add(pomNode);
+}
+function getPomNodeByFixtureName(fixtureName) {
+  for (const pomNode of pomGraph.values()) {
+    if (pomNode.fixtureName === fixtureName) return pomNode;
+  }
+}

package/build/bdd-framework/stepDefinitions/decorators/steps.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.appendDecoratorSteps = appendDecoratorSteps;
+exports.createStepDecorator = createStepDecorator;
+exports.linkStepsWithPomNode = linkStepsWithPomNode;
+var _bddFixtures = require("../../run/bddFixtures");
+var _buildStepDefinition = require("../../cucumber/buildStepDefinition");
+var _defineStep = require("../defineStep");
+/**
+ * Define steps via decorators.
+ */
+
+// initially we sotre step data inside method,
+// and then extract it in @Fixture decorator call
+const decoratedStepSymbol = Symbol('decoratedStep');
+// global list of all decorator steps
+const decoratedSteps = new Set();
+/**
+ * Creates @Given, @When, @Then decorators.
+ */
+function createStepDecorator(keyword) {
+  return pattern => {
+    // context parameter is required for decorator by TS even though it's not used
+    // eslint-disable-next-line no-unused-vars
+    return (method, _context) => {
+      saveStepConfigToMethod(method, {
+        keyword,
+        pattern,
+        fn: method,
+        hasCustomTest: true
+      });
+    };
+  };
+}
+function linkStepsWithPomNode(Ctor, pomNode) {
+  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) return;
+  const propertyDescriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
+  return Object.values(propertyDescriptors).forEach(descriptor => {
+    const stepConfig = getStepConfigFromMethod(descriptor);
+    if (!stepConfig) return;
+    stepConfig.pomNode = pomNode;
+    decoratedSteps.add(stepConfig);
+  });
+}
+/**
+ * Append decorator steps to Cucumber's supportCodeLibrary.
+ */
+function appendDecoratorSteps(supportCodeLibrary) {
+  decoratedSteps.forEach(stepConfig => {
+    const {
+      keyword,
+      pattern,
+      fn
+    } = stepConfig;
+    stepConfig.fn = (fixturesArg, ...args) => {
+      const fixture = getFirstNonAutoInjectFixture(fixturesArg, stepConfig);
+      return fn.call(fixture, ...args);
+    };
+    const code = (0, _defineStep.buildCucumberStepCode)(stepConfig);
+    const stepDefinition = (0, _buildStepDefinition.buildStepDefinition)({
+      keyword,
+      pattern,
+      code,
+      line: 0,
+      options: {},
+      uri: '' // not used in playwright-bdd
+    }, supportCodeLibrary);
+    supportCodeLibrary.stepDefinitions.push(stepDefinition);
+  });
+  decoratedSteps.clear();
+  // todo: fill supportCodeLibrary.originalCoordinates as it is used in snippets?
+}
+function getFirstNonAutoInjectFixture(fixturesArg, stepConfig) {
+  // there should be exatcly one suitable fixture in fixturesArg
+  const fixtureNames = Object.keys(fixturesArg).filter(fixtureName => !(0, _bddFixtures.isBddAutoInjectFixture)(fixtureName));
+  if (fixtureNames.length === 0) {
+    throw new Error(`No suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  if (fixtureNames.length > 1) {
+    throw new Error(`Several suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  return fixturesArg[fixtureNames[0]];
+}
+function saveStepConfigToMethod(method, stepConfig) {
+  method[decoratedStepSymbol] = stepConfig;
+}
+function getStepConfigFromMethod(descriptor) {
+  // filter out getters / setters
+  return typeof descriptor.value === 'function' ? descriptor.value[decoratedStepSymbol] : undefined;
+}

package/build/bdd-framework/stepDefinitions/defineStep.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCucumberStepCode = buildCucumberStepCode;
+exports.defineStep = defineStep;
+exports.getStepCode = getStepCode;
+var _cucumber = require("@cucumber/cucumber");
+var _exit = require("../utils/exit");
+/**
+ * Defines step by config.
+ * Calls cucumber's Given(), When(), Then() under the hood.
+ */
+function defineStep(stepConfig) {
+  const {
+    keyword,
+    pattern
+  } = stepConfig;
+  const cucumberDefineStepFn = getCucumberDefineStepFn(keyword);
+  const code = buildCucumberStepCode(stepConfig);
+  try {
+    cucumberDefineStepFn(pattern, code);
+  } catch (e) {
+    // todo: detect that this is import from test file
+    // and skip/delay registering cucumber steps until cucumber is loaded
+    const isMissingCucumber = /Cucumber that isn't running/i.test(e.message);
+    if (isMissingCucumber) {
+      (0, _exit.exit)(`Option "importTestFrom" should point to a separate file without step definitions`, `(e.g. without calls of Given, When, Then)`);
+    } else {
+      throw e;
+    }
+  }
+}
+function buildCucumberStepCode(stepConfig) {
+  const code = function (...args) {
+    const fixturesArg = Object.assign({}, this.customFixtures, {
+      $testInfo: this.testInfo,
+      $test: this.test,
+      $tags: this.tags
+    });
+    return stepConfig.fn.call(this, fixturesArg, ...args);
+  };
+  code.stepConfig = stepConfig;
+  return code;
+}
+function getStepCode(stepDefinition) {
+  return stepDefinition.code;
+}
+function getCucumberDefineStepFn(keyword) {
+  switch (keyword) {
+    case 'Given':
+      return _cucumber.Given;
+    case 'When':
+      return _cucumber.When;
+    case 'Then':
+      return _cucumber.Then;
+    default:
+      return _cucumber.defineStep;
+  }
+}