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

package/build/bdd-framework/gen/formatter.js

@@ -0,0 +1,88 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Formatter = void 0;
+var _jsStringWrap = require("../utils/jsStringWrap");
+/**
+ * Helper to format Playwright test file.
+ */
+
+const TAGS_FIXTURE_TEST_KEY_SEPARATOR = '|';
+class Formatter {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  fileHeader(uri, importTestFrom) {
+    const file = (importTestFrom === null || importTestFrom === void 0 ? void 0 : importTestFrom.file) || '@zohodesk/testinglibrary';
+    let varName = (importTestFrom === null || importTestFrom === void 0 ? void 0 : importTestFrom.varName) || 'test';
+    if (varName !== 'test') varName = `${varName} as test`;
+    return [`/** Generated from: ${uri} */`,
+    // this.quoted() is not possible for 'import from' as backticks not parsed
+    `import { ${varName} } from ${JSON.stringify(file)};`, ''];
+  }
+  suite(node, children) {
+    // prettier-ignore
+    return [`test.describe${this.getSubFn(node)}(${this.quoted(node.title)}, () => {`, '', ...children.map(indent), `});`, ''];
+  }
+  beforeEach(fixtures, children) {
+    const fixturesStr = [...fixtures].join(', ');
+    // prettier-ignore
+    return [`test.beforeEach(async ({ ${fixturesStr} }) => {`, ...children.map(indent), `});`, ''];
+  }
+  test(node, fixtures, children) {
+    const fixturesStr = [...fixtures].join(', ');
+    // prettier-ignore
+    return [`test${this.getSubFn(node)}(${this.quoted(node.title)}, async ({ ${fixturesStr} }) => {`, ...children.map(indent), `});`, ''];
+  }
+  // eslint-disable-next-line max-params
+  step(keyword, text, argument, fixtureNames = []) {
+    const fixtures = fixtureNames.length ? `{ ${fixtureNames.join(', ')} }` : '';
+    const argumentArg = argument ? JSON.stringify(argument) : fixtures ? 'null' : '';
+    const textArg = this.quoted(text);
+    const args = [textArg, argumentArg, fixtures].filter(arg => arg !== '').join(', ');
+    return `await ${keyword}(${args});`;
+  }
+  missingStep(keyword, text) {
+    return `// missing step: ${keyword}(${this.quoted(text)});`;
+  }
+  useFixtures(fixtures) {
+    return fixtures.length > 0 ? ['// == technical section ==', '', 'test.use({', ...fixtures.map(indent), '});'] : [];
+  }
+  testFixture() {
+    return ['$test: ({}, use) => use(test),'];
+  }
+  tagsFixture(testNodes) {
+    const lines = testNodes.filter(node => node.tags.length).map(node => {
+      // remove first parent as it is the same for all tests: root suite
+      const key = node.titlePath.slice(1).join(TAGS_FIXTURE_TEST_KEY_SEPARATOR);
+      return `${JSON.stringify(key)}: ${JSON.stringify(node.tags)},`;
+    });
+    return lines.length > 0 ? ['$tags: ({}, use, testInfo) => use({', ...lines.map(indent),
+    // .slice(2) -> b/c we remove filename and root suite title
+    `}[testInfo.titlePath.slice(2).join(${JSON.stringify(TAGS_FIXTURE_TEST_KEY_SEPARATOR)})] || []),`] : [];
+  }
+  getSubFn(node) {
+    if (node.flags.only) return '.only';
+    if (node.flags.skip) return '.skip';
+    if (node.flags.fixme) return '.fixme';
+    return '';
+  }
+  /**
+     * Apply this function only to string literals (mostly titles here).
+     * Objects and arrays are handled with JSON.strinigfy,
+     * b/c object keys can't be in backtiks.
+     * See: https://stackoverflow.com/questions/33194138/template-string-as-object-property-name
+     */
+  quoted(str) {
+    return (0, _jsStringWrap.jsStringWrap)(str, {
+      quotes: this.config.quotes
+    });
+  }
+}
+exports.Formatter = Formatter;
+function indent(value) {
+  return value ? `${'  '}${value}` : value;
+}

package/build/bdd-framework/gen/i18n.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getKeywordsMap = getKeywordsMap;
+var _gherkin = require("@cucumber/gherkin");
+/**
+ * Get i18n keywords.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/cli/i18n.ts
+ */
+
+function getKeywordsMap(language) {
+  const origMap = _gherkin.dialects[language];
+  if (!origMap) {
+    throw new Error(`Language not found: ${language}`);
+  }
+  const targetMap = new Map();
+  const enKeywords = Object.keys(origMap);
+  enKeywords.forEach(enKeyword => handleKeyword(enKeyword, origMap, targetMap));
+  return targetMap;
+}
+function handleKeyword(enKeyword, origMap, targetMap) {
+  const nativeKeywords = origMap[enKeyword];
+  // Array.isArray converts to any[]
+  if (typeof nativeKeywords === 'string') return;
+  nativeKeywords.forEach(nativeKeyword => {
+    nativeKeyword = nativeKeyword.trim();
+    if (!nativeKeyword || nativeKeyword === '*') return;
+    targetMap.set(nativeKeyword, capitalizeFirstLetter(enKeyword));
+  });
+}
+function capitalizeFirstLetter(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}

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

@@ -0,0 +1,163 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestFilesGenerator = void 0;
+var _promises = _interopRequireDefault(require("fs/promises"));
+var _path = _interopRequireDefault(require("path"));
+var _fastGlob = _interopRequireDefault(require("fast-glob"));
+var _testFile = require("./testFile");
+var _loadConfig = require("../cucumber/loadConfig");
+var _loadFeatures = require("../cucumber/loadFeatures");
+var _loadSteps = require("../cucumber/loadSteps");
+var _config = require("../config");
+var _snippets = require("../snippets");
+var _steps = require("../stepDefinitions/decorators/steps");
+var _transform = require("../playwright/transform");
+var _dir = require("../config/dir");
+var _logger = require("../utils/logger");
+var _tagExpressions = _interopRequireDefault(require("@cucumber/tag-expressions"));
+var _exit = require("../utils/exit");
+/**
+ * Generate playwright test files from Gherkin documents.
+ */
+
+class TestFilesGenerator {
+  config;
+  // all these props are exist
+  runConfiguration;
+  features;
+  supportCodeLibrary;
+  files = [];
+  tagsExpression;
+  logger;
+  constructor(config) {
+    this.config = config;
+    this.logger = new _logger.Logger({
+      verbose: config.verbose
+    });
+    if (config.tags) this.tagsExpression = (0, _tagExpressions.default)(config.tags);
+  }
+  async generate() {
+    await (0, _exit.withExitHandler)(async () => {
+      await this.loadCucumberConfig();
+      await Promise.all([this.loadFeatures(), this.loadSteps()]);
+      this.buildFiles();
+      await this.checkUndefinedSteps();
+      this.checkImportCustomTest();
+      await this.clearOutputDir();
+      await this.saveFiles();
+    });
+  }
+  async extractSteps() {
+    await this.loadCucumberConfig();
+    await this.loadSteps();
+    return this.supportCodeLibrary.stepDefinitions;
+  }
+  async loadCucumberConfig() {
+    const environment = {
+      cwd: (0, _dir.getPlaywrightConfigDir)()
+    };
+    const {
+      runConfiguration
+    } = await (0, _loadConfig.loadConfig)({
+      provided: (0, _config.extractCucumberConfig)(this.config)
+    }, environment);
+    this.runConfiguration = runConfiguration;
+    this.warnForTsNodeRegister();
+  }
+  async loadFeatures() {
+    const environment = {
+      cwd: (0, _dir.getPlaywrightConfigDir)()
+    };
+    this.logger.log(`Loading features from: ${this.runConfiguration.sources.paths.join(', ')}`);
+    this.features = await (0, _loadFeatures.loadFeatures)(this.runConfiguration, environment);
+    this.logger.log(`Loaded features: ${this.features.size}`);
+  }
+  async loadSteps() {
+    const {
+      requirePaths,
+      importPaths
+    } = this.runConfiguration.support;
+    this.logger.log(`Loading steps from: ${requirePaths.concat(importPaths).join(', ')}`);
+    const environment = {
+      cwd: (0, _dir.getPlaywrightConfigDir)()
+    };
+    this.supportCodeLibrary = await (0, _loadSteps.loadSteps)(this.runConfiguration, environment);
+    await this.loadDecoratorSteps();
+    this.logger.log(`Loaded steps: ${this.supportCodeLibrary.stepDefinitions.length}`);
+  }
+  async loadDecoratorSteps() {
+    const {
+      importTestFrom
+    } = this.config;
+    if (importTestFrom) {
+      // require importTestFrom for case when it is not required by step definitions
+      // possible re-require but it's not a problem as it is cached by Node.js
+      await (0, _transform.requireTransform)().requireOrImport(importTestFrom.file);
+      (0, _steps.appendDecoratorSteps)(this.supportCodeLibrary);
+    }
+  }
+  buildFiles() {
+    this.files = [...this.features.entries()].map(([doc, pickles]) => {
+      return new _testFile.TestFile({
+        doc,
+        pickles,
+        supportCodeLibrary: this.supportCodeLibrary,
+        outputPath: this.getOutputPath(doc),
+        config: this.config,
+        tagsExpression: this.tagsExpression
+      }).build();
+    }).filter(file => file.testNodes.length > 0);
+  }
+  getOutputPath(doc) {
+    const configDir = (0, _dir.getPlaywrightConfigDir)();
+    // doc.uri is always relative to cwd (coming after cucumber handling)
+    // see: https://github.com/cucumber/cucumber-js/blob/main/src/api/gherkin.ts#L51
+    const relFeaturePath = doc.uri;
+    const absFeaturePath = _path.default.resolve(configDir, relFeaturePath);
+    const relOutputPath = _path.default.relative(this.config.featuresRoot, absFeaturePath);
+    if (relOutputPath.startsWith('..')) {
+      (0, _exit.exit)(`All feature files should be located underneath featuresRoot.`, `Please change featuresRoot or paths in configuration.\n`, `featureFile: ${absFeaturePath}\n`, `featuresRoot: ${this.config.featuresRoot}\n`);
+    }
+    const absOutputPath = _path.default.resolve(this.config.outputDir, relOutputPath);
+    return `${absOutputPath}.spec.js`;
+  }
+  async checkUndefinedSteps() {
+    const undefinedSteps = this.files.reduce((sum, file) => sum + file.undefinedSteps.length, 0);
+    if (undefinedSteps > 0) {
+      const snippets = new _snippets.Snippets(this.files, this.runConfiguration, this.supportCodeLibrary);
+      await snippets.print();
+      (0, _exit.exit)();
+    }
+  }
+  checkImportCustomTest() {
+    if (this.config.importTestFrom) return;
+    const hasCustomTest = this.files.some(file => file.hasCustomTest);
+    if (hasCustomTest) {
+      (0, _exit.exit)(`When using custom "test" function in createBdd() you should`, `set "importTestFrom" config option that points to file exporting custom test.`);
+    }
+  }
+  async saveFiles() {
+    this.files.forEach(file => {
+      file.save();
+      this.logger.log(`Generated: ${_path.default.relative(process.cwd(), file.outputPath)}`);
+    });
+    this.logger.log(`Generated files: ${this.files.length}`);
+  }
+  async clearOutputDir() {
+    const pattern = `${_fastGlob.default.convertPathToPattern(this.config.outputDir)}/**/*.spec.js`;
+    const testFiles = await (0, _fastGlob.default)(pattern);
+    this.logger.log(`Clearing output dir: ${testFiles.length} file(s)`);
+    const tasks = testFiles.map(testFile => _promises.default.rm(testFile));
+    await Promise.all(tasks);
+  }
+  warnForTsNodeRegister() {
+    if ((0, _loadSteps.hasTsNodeRegister)(this.runConfiguration)) {
+      this.logger.warn(`WARNING: usage of requireModule: ['ts-node/register'] is not recommended for playwright-bdd.`, `Remove this option from defineBddConfig() and`, `Playwright's built-in loader will be used to compile TypeScript step definitions.`);
+    }
+  }
+}
+exports.TestFilesGenerator = TestFilesGenerator;

package/build/bdd-framework/gen/poms.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.POMS = void 0;
+exports.buildFixtureTag = buildFixtureTag;
+var _createDecorators = require("../stepDefinitions/createDecorators");
+/**
+ * Handle POMs graph for decorator steps.
+ */
+
+const FIXTURE_TAG_PREFIX = '@fixture:';
+class POMS {
+  usedPoms = new Map();
+  add(pomNode) {
+    if (pomNode) this.usedPoms.set(pomNode, null);
+  }
+  addByFixtureName(fixtureName) {
+    const pomNode = (0, _createDecorators.getPomNodeByFixtureName)(fixtureName);
+    if (pomNode) this.add(pomNode);
+  }
+  addByTag(tag) {
+    const fixtureName = extractFixtureName(tag);
+    if (fixtureName) this.addByFixtureName(fixtureName);
+  }
+  resolveFixtureNames(pomNode) {
+    const resolvedFixtureNames = this.usedPoms.get(pomNode);
+    if (resolvedFixtureNames) return resolvedFixtureNames;
+    const fixtureNames = [...pomNode.children].map(child => this.resolveFixtureNames(child)).flat();
+    if (this.usedPoms.has(pomNode)) {
+      // if nothing returned from children, use own fixtureName,
+      // otherwise use what returned from child
+      if (!fixtureNames.length) fixtureNames.push(pomNode.fixtureName);
+      this.usedPoms.set(pomNode, fixtureNames);
+    }
+    return fixtureNames;
+  }
+}
+exports.POMS = POMS;
+function extractFixtureName(tag) {
+  return tag.startsWith(FIXTURE_TAG_PREFIX) ? tag.replace(FIXTURE_TAG_PREFIX, '') : '';
+}
+function buildFixtureTag(fixtureName) {
+  return `${FIXTURE_TAG_PREFIX}${fixtureName}`;
+}

package/build/bdd-framework/gen/testFile.js

@@ -0,0 +1,356 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestFile = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _formatter = require("./formatter");
+var _i18n = require("./i18n");
+var _loadSteps = require("../cucumber/loadSteps");
+var _createBdd = require("../stepDefinitions/createBdd");
+var _index = require("@cucumber/cucumber/lib/formatter/helpers/index");
+var _utils = require("../utils");
+var _testPoms = require("./testPoms");
+var _testNode = require("./testNode");
+var _stepConfig = require("../stepDefinitions/stepConfig");
+var _exit = require("../utils/exit");
+/**
+ * Generate test code.
+ */
+
+class TestFile {
+  options;
+  lines = [];
+  i18nKeywordsMap;
+  formatter;
+  testNodes = [];
+  hasCustomTest = false;
+  undefinedSteps = [];
+  constructor(options) {
+    this.options = options;
+    this.formatter = new _formatter.Formatter(options.config);
+  }
+  get sourceFile() {
+    const {
+      uri
+    } = this.options.doc;
+    if (!uri) throw new Error(`Document without uri`);
+    return uri;
+  }
+  get content() {
+    return this.lines.join('\n');
+  }
+  get language() {
+    var _this$options$doc$fea;
+    return ((_this$options$doc$fea = this.options.doc.feature) === null || _this$options$doc$fea === void 0 ? void 0 : _this$options$doc$fea.language) || 'en';
+  }
+  get config() {
+    return this.options.config;
+  }
+  get outputPath() {
+    return this.options.outputPath;
+  }
+  build() {
+    this.loadI18nKeywords();
+    this.lines = [...this.getFileHeader(), ...this.getRootSuite(), ...this.getFileFixtures()];
+    return this;
+  }
+  save() {
+    const dir = _path.default.dirname(this.outputPath);
+    if (!_fs.default.existsSync(dir)) _fs.default.mkdirSync(dir, {
+      recursive: true
+    });
+    _fs.default.writeFileSync(this.outputPath, this.content);
+  }
+  getFileHeader() {
+    const importTestFrom = this.getRelativeImportTestFrom();
+    return this.formatter.fileHeader(this.sourceFile, importTestFrom);
+  }
+  loadI18nKeywords() {
+    if (this.language !== 'en') {
+      this.i18nKeywordsMap = (0, _i18n.getKeywordsMap)(this.language);
+    }
+  }
+  getRelativeImportTestFrom() {
+    const {
+      importTestFrom
+    } = this.config;
+    if (!importTestFrom) return;
+    const {
+      file,
+      varName
+    } = importTestFrom;
+    const dir = _path.default.dirname(this.outputPath);
+    return {
+      file: _path.default.relative(dir, file),
+      varName
+    };
+  }
+  getFileFixtures() {
+    return this.formatter.useFixtures([...this.formatter.testFixture(), ...this.formatter.tagsFixture(this.testNodes)]);
+  }
+  getRootSuite() {
+    const {
+      feature
+    } = this.options.doc;
+    if (!feature) throw new Error(`Document without feature.`);
+    return this.getSuite(feature);
+  }
+  /**
+     * Generate test.describe suite for root Feature or Rule
+     */
+  getSuite(feature, parent) {
+    const node = new _testNode.TestNode(feature, parent);
+    const lines = [];
+    // const { backgrounds, rules, scenarios } =
+    // bgFixtures, bgTags - used as fixture hints for decorator steps
+    feature.children.forEach(child => lines.push(...this.getSuiteChild(child, node)));
+    return this.formatter.suite(node, lines);
+  }
+  getSuiteChild(child, parent) {
+    if ('rule' in child && child.rule) return this.getSuite(child.rule, parent);
+    if (child.background) return this.getBeforeEach(child.background, parent);
+    if (child.scenario) return this.getScenarioLines(child.scenario, parent);
+    throw new Error(`Empty child: ${JSON.stringify(child)}`);
+  }
+  getScenarioLines(scenario, parent) {
+    return this.isOutline(scenario) ? this.getOutlineSuite(scenario, parent) : this.getTest(scenario, parent);
+  }
+  /**
+     * Generate test.beforeEach for Background
+     */
+  getBeforeEach(bg, parent) {
+    const node = new _testNode.TestNode({
+      name: 'background',
+      tags: []
+    }, parent);
+    const {
+      fixtures,
+      lines
+    } = this.getSteps(bg, node.tags);
+    return this.formatter.beforeEach(fixtures, lines);
+  }
+  /**
+     * Generate test.describe suite for Scenario Outline
+     */
+  getOutlineSuite(scenario, parent) {
+    const node = new _testNode.TestNode(scenario, parent);
+    const lines = [];
+    let exampleIndex = 0;
+    scenario.examples.forEach(examples => {
+      const titleFormat = this.getExamplesTitleFormat(examples);
+      examples.tableBody.forEach(exampleRow => {
+        const testTitle = this.getOutlineTestTitle(titleFormat, examples, exampleRow, ++exampleIndex);
+        const testLines = this.getOutlineTest(scenario, examples, exampleRow, testTitle, node);
+        lines.push(...testLines);
+      });
+    });
+    return this.formatter.suite(node, lines);
+  }
+  /**
+     * Generate test from Examples row of Scenario Outline
+     */
+  // eslint-disable-next-line max-params
+  getOutlineTest(scenario, examples, exampleRow, title, parent) {
+    const node = new _testNode.TestNode({
+      name: title,
+      tags: examples.tags
+    }, parent);
+    if (this.skipByTagsExpression(node)) return [];
+    this.testNodes.push(node);
+    const {
+      fixtures,
+      lines
+    } = this.getSteps(scenario, node.tags, exampleRow.id);
+    return this.formatter.test(node, fixtures, lines);
+  }
+  /**
+     * Generate test from Scenario
+     */
+  getTest(scenario, parent) {
+    const node = new _testNode.TestNode(scenario, parent);
+    if (this.skipByTagsExpression(node)) return [];
+    this.testNodes.push(node);
+    const {
+      fixtures,
+      lines
+    } = this.getSteps(scenario, node.tags);
+    return this.formatter.test(node, fixtures, lines);
+  }
+  /**
+     * Generate test steps
+     */
+  getSteps(scenario, tags, outlineExampleRowId) {
+    const testFixtureNames = new Set();
+    const testPoms = new _testPoms.TestPoms(scenario.name || 'Background');
+    const decoratorSteps = [];
+    let previousKeywordType = undefined;
+    const lines = scenario.steps.map((step, index) => {
+      const {
+        keyword,
+        keywordType,
+        fixtureNames: stepFixtureNames,
+        line,
+        pickleStep,
+        stepConfig
+      } = this.getStep(step, previousKeywordType, outlineExampleRowId);
+      previousKeywordType = keywordType;
+      testFixtureNames.add(keyword);
+      stepFixtureNames.forEach(fixtureName => testFixtureNames.add(fixtureName));
+      if ((0, _stepConfig.isDecorator)(stepConfig)) {
+        testPoms.addByStep(stepConfig.pomNode);
+        decoratorSteps.push({
+          index,
+          keyword,
+          pickleStep,
+          pomNode: stepConfig.pomNode
+        });
+      }
+      return line;
+    });
+    // decorator steps handled in second pass to guess fixtures
+    if (decoratorSteps.length) {
+      testFixtureNames.forEach(fixtureName => testPoms.addByFixtureName(fixtureName));
+      tags === null || tags === void 0 || tags.forEach(tag => testPoms.addByTag(tag));
+      testPoms.resolveFixtures();
+      decoratorSteps.forEach(step => {
+        const {
+          line,
+          fixtureName
+        } = this.getDecoratorStep(step, testPoms);
+        lines[step.index] = line;
+        testFixtureNames.add(fixtureName);
+      });
+    }
+    return {
+      fixtures: testFixtureNames,
+      lines
+    };
+  }
+  /**
+     * Generate step for Given, When, Then
+     */
+  // eslint-disable-next-line max-statements, complexity
+  getStep(step, previousKeywordType, outlineExampleRowId) {
+    const pickleStep = this.getPickleStep(step, outlineExampleRowId);
+    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.options.supportCodeLibrary, pickleStep.text, this.sourceFile);
+    const keywordType = (0, _index.getStepKeywordType)({
+      keyword: step.keyword,
+      language: this.language,
+      previousKeywordType
+    });
+    let keyword = this.getStepKeyword(step);
+    if (!stepDefinition) {
+      this.undefinedSteps.push({
+        keywordType,
+        step,
+        pickleStep
+      });
+      return this.getMissingStep(keyword, keywordType, pickleStep);
+    }
+    // for cucumber-style stepConfig is undefined
+    const stepConfig = (0, _stepConfig.getStepConfig)(stepDefinition);
+    if (stepConfig !== null && stepConfig !== void 0 && stepConfig.hasCustomTest) this.hasCustomTest = true;
+    // for cucumber-style transform Given/When/Then -> Given_/When_/Then_
+    // to use own bddWorld (containing PW built-in fixtures)
+    if (!(0, _stepConfig.isPlaywrightStyle)(stepConfig)) keyword = `${keyword}_`;
+    // for decorator steps fixtureNames are defined later in second pass
+    const fixtureNames = (0, _stepConfig.isDecorator)(stepConfig) ? [] : (0, _createBdd.extractFixtureNames)(stepConfig === null || stepConfig === void 0 ? void 0 : stepConfig.fn);
+    const line = (0, _stepConfig.isDecorator)(stepConfig) ? '' : this.formatter.step(keyword, pickleStep.text, pickleStep.argument, fixtureNames);
+    return {
+      keyword,
+      keywordType,
+      fixtureNames,
+      line,
+      pickleStep,
+      stepConfig
+    };
+  }
+  getMissingStep(keyword, keywordType, pickleStep) {
+    return {
+      keyword,
+      keywordType,
+      fixtureNames: [],
+      line: this.formatter.missingStep(keyword, pickleStep.text),
+      pickleStep,
+      stepConfig: undefined
+    };
+  }
+  getPickleStep(step, outlineExampleRowId) {
+    for (const pickle of this.options.pickles) {
+      const pickleStep = pickle.steps.find(({
+        astNodeIds
+      }) => {
+        const hasStepId = astNodeIds.includes(step.id);
+        const hasRowId = !outlineExampleRowId || astNodeIds.includes(outlineExampleRowId);
+        return hasStepId && hasRowId;
+      });
+      if (pickleStep) return pickleStep;
+    }
+    throw new Error(`Pickle step not found for step: ${step.text}`);
+  }
+  getStepKeyword(step) {
+    const origKeyword = step.keyword.trim();
+    const enKeyword = origKeyword === '*' ? 'And' : this.getEnglishKeyword(origKeyword);
+    if (!enKeyword) throw new Error(`Keyword not found: ${origKeyword}`);
+    return enKeyword;
+  }
+  getDecoratorStep(step, testPoms) {
+    const {
+      keyword,
+      pickleStep,
+      pomNode
+    } = step;
+    const resolvedFixtures = testPoms.getResolvedFixtures(pomNode);
+    if (resolvedFixtures.length !== 1) {
+      const suggestedTags = resolvedFixtures.filter(f => !f.byTag).map(f => (0, _testPoms.buildFixtureTag)(f.name)).join(', ');
+      const suggestedTagsStr = suggestedTags.length ? ` or set one of the following tags: ${suggestedTags}` : '.';
+      (0, _exit.exit)(`Can't guess fixture for decorator step "${pickleStep.text}" in file: ${this.sourceFile}.`, `Please refactor your Page Object classes${suggestedTagsStr}`);
+    }
+    const fixtureName = resolvedFixtures[0].name;
+    return {
+      fixtureName,
+      line: this.formatter.step(keyword, pickleStep.text, pickleStep.argument, [fixtureName])
+    };
+  }
+  getOutlineTestTitle(titleFormat, examples, exampleRow, exampleIndex) {
+    const params = {
+      _index_: exampleIndex
+    };
+    exampleRow.cells.forEach((cell, index) => {
+      var _examples$tableHeader;
+      const colName = (_examples$tableHeader = examples.tableHeader) === null || _examples$tableHeader === void 0 || (_examples$tableHeader = _examples$tableHeader.cells[index]) === null || _examples$tableHeader === void 0 ? void 0 : _examples$tableHeader.value;
+      if (colName) params[colName] = cell.value;
+    });
+    return (0, _utils.template)(titleFormat, params);
+  }
+  getExamplesTitleFormat(examples) {
+    var _comment$text;
+    const {
+      line
+    } = examples.location;
+    const titleFormatCommentLine = line - 1;
+    const comment = this.options.doc.comments.find(c => {
+      return c.location.line === titleFormatCommentLine;
+    });
+    const commentText = comment === null || comment === void 0 || (_comment$text = comment.text) === null || _comment$text === void 0 ? void 0 : _comment$text.trim();
+    const prefix = '# title-format:';
+    return commentText !== null && commentText !== void 0 && commentText.startsWith(prefix) ? commentText.replace(prefix, '').trim() : this.config.examplesTitleFormat;
+  }
+  skipByTagsExpression(node) {
+    var _this$options$tagsExp;
+    // see: https://github.com/cucumber/tag-expressions/tree/main/javascript
+    return ((_this$options$tagsExp = this.options.tagsExpression) === null || _this$options$tagsExp === void 0 ? void 0 : _this$options$tagsExp.evaluate(node.tags)) === false;
+  }
+  isOutline(scenario) {
+    const keyword = this.getEnglishKeyword(scenario.keyword);
+    return keyword === 'ScenarioOutline' || keyword === 'Scenario Outline' || keyword === 'Scenario Template';
+  }
+  getEnglishKeyword(keyword) {
+    return this.i18nKeywordsMap ? this.i18nKeywordsMap.get(keyword) : keyword;
+  }
+}
+exports.TestFile = TestFile;