@zohodesk/testinglibrary 0.1.8-stb-bdd-v26 → 0.1.9-exp-actors

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

@@ -0,0 +1,465 @@
+"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 _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");
+var _fixtures = require("./fixtures");
+var _scenario = require("../hooks/scenario");
+var _worker = require("../hooks/worker");
+var _lang = require("../config/lang");
+var _testMeta = require("./testMeta");
+/**
+ * Generate Playwright test file for feature.
+ */
+
+class TestFile {
+  options;
+  lines = [];
+  i18nKeywordsMap;
+  formatter;
+  testMetaBuilder;
+  hasCucumberStyle = false;
+  hasCustomTest = false;
+  undefinedSteps = [];
+  featureUri;
+  constructor(options) {
+    this.options = options;
+    this.formatter = new _formatter.Formatter(options.config);
+    this.testMetaBuilder = new _testMeta.TestMetaBuilder();
+    this.featureUri = this.getFeatureUri();
+  }
+  get gherkinDocument() {
+    return this.options.gherkinDocument;
+  }
+  get pickles() {
+    return this.gherkinDocument.pickles;
+  }
+  get content() {
+    return this.lines.join('\n');
+  }
+  get language() {
+    var _this$gherkinDocument;
+    return ((_this$gherkinDocument = this.gherkinDocument.feature) === null || _this$gherkinDocument === void 0 ? void 0 : _this$gherkinDocument.language) || _lang.LANG_EN;
+  }
+  get isEnglish() {
+    return (0, _lang.isEnglish)(this.language);
+  }
+  get config() {
+    return this.options.config;
+  }
+  get outputPath() {
+    return this.options.outputPath;
+  }
+  get testCount() {
+    return this.testMetaBuilder.testCount;
+  }
+  build() {
+    this.loadI18nKeywords();
+    this.lines = [...this.getFileHeader(),
+    // prettier-ignore
+    ...this.getRootSuite(), ...this.getTechnicalSection()];
+    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.featureUri, importTestFrom);
+  }
+  loadI18nKeywords() {
+    if (!this.isEnglish) {
+      this.i18nKeywordsMap = (0, _i18n.getKeywordsMap)(this.language);
+    }
+  }
+  getFeatureUri() {
+    const {
+      uri
+    } = this.gherkinDocument;
+    if (!uri) {
+      var _this$gherkinDocument2;
+      throw new Error(`Document without uri: ${(_this$gherkinDocument2 = this.gherkinDocument.feature) === null || _this$gherkinDocument2 === void 0 ? void 0 : _this$gherkinDocument2.name}`);
+    }
+    return uri;
+  }
+  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
+    };
+  }
+  getTechnicalSection() {
+    return this.formatter.technicalSection(this.testMetaBuilder, this.featureUri, [...(!this.isEnglish ? this.formatter.langFixture(this.language) : []), ...((0, _scenario.hasScenarioHooks)() || this.hasCucumberStyle ? this.formatter.bddWorldFixtures() : []), ...this.formatter.scenarioHookFixtures((0, _scenario.getScenarioHooksFixtures)()), ...this.formatter.workerHookFixtures((0, _worker.getWorkerHooksFixtures)())]);
+  }
+  getRootSuite() {
+    const {
+      feature
+    } = this.gherkinDocument;
+    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);
+    if (node.isSkipped()) {
+      return this.formatter.suite(node, []);
+    }
+    const lines = [];
+    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);
+    if (node.isSkipped()) {
+      return this.formatter.suite(node, []);
+    }
+    const lines = [];
+    let exampleIndex = 0;
+    scenario.examples.forEach(examples => {
+      const titleFormat = this.getExamplesTitleFormat(scenario, 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 [];
+    }
+    const pickle = this.findPickle(scenario, exampleRow);
+    this.testMetaBuilder.registerTest(node, pickle);
+    if (node.isSkipped()) {
+      return this.formatter.test(node, new Set(), []);
+    }
+    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 [];
+    }
+    const pickle = this.findPickle(scenario);
+    this.testMetaBuilder.registerTest(node, pickle);
+    if (node.isSkipped()) {
+      return this.formatter.test(node, new Set(), []);
+    }
+    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.findPickleStep(step, outlineExampleRowId);
+    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.options.supportCodeLibrary, pickleStep.text, this.featureUri);
+    const keywordType = (0, _index.getStepKeywordType)({
+      keyword: step.keyword,
+      language: this.language,
+      previousKeywordType
+    });
+    const enKeyword = this.getStepEnglishKeyword(step);
+    if (!stepDefinition) {
+      this.undefinedSteps.push({
+        keywordType,
+        step,
+        pickleStep
+      });
+      return this.getMissingStep(enKeyword, 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;
+    }
+    if (!(0, _stepConfig.isPlaywrightStyle)(stepConfig)) {
+      this.hasCucumberStyle = true;
+    }
+    const fixtureNames = this.getStepFixtureNames(stepDefinition);
+    const line = (0, _stepConfig.isDecorator)(stepConfig) ? '' : this.formatter.step(enKeyword, pickleStep.text, pickleStep.argument, fixtureNames);
+    return {
+      keyword: enKeyword,
+      keywordType,
+      fixtureNames,
+      line,
+      pickleStep,
+      stepConfig
+    };
+  }
+  getMissingStep(keyword, keywordType, pickleStep) {
+    return {
+      keyword,
+      keywordType,
+      fixtureNames: [],
+      line: this.formatter.missingStep(keyword, pickleStep.text),
+      pickleStep,
+      stepConfig: undefined
+    };
+  }
+  /**
+     * Returns pickle for scenario.
+     * Pickle is executable entity including background and steps with example values.
+     */
+  findPickle(scenario, exampleRow) {
+    const pickle = this.pickles.find(pickle => {
+      const hasScenarioId = pickle.astNodeIds.includes(scenario.id);
+      const hasExampleRowId = !exampleRow || pickle.astNodeIds.includes(exampleRow.id);
+      return hasScenarioId && hasExampleRowId;
+    });
+    if (!pickle) {
+      throw new Error(`Pickle not found for scenario: ${scenario.name}`);
+    }
+    return pickle;
+  }
+  /**
+     * Returns pickleStep for ast step.
+     * PickleStep contains step text with inserted example values.
+     *
+     * Note:
+     * When searching for pickleStep iterate all pickles in a file
+     * b/c for background steps there is no own pickle.
+     * This can be optimized: pass optional 'pickle' parameter
+     * and search only inside it if it exists.
+     * But this increases code complexity, and performance impact seems to be minimal
+     * b/c number of pickles inside feature file is not very big.
+     */
+  findPickleStep(step, exampleRowId) {
+    for (const pickle of this.pickles) {
+      const pickleStep = pickle.steps.find(({
+        astNodeIds
+      }) => {
+        const hasStepId = astNodeIds.includes(step.id);
+        const hasRowId = !exampleRowId || astNodeIds.includes(exampleRowId);
+        return hasStepId && hasRowId;
+      });
+      if (pickleStep) {
+        return pickleStep;
+      }
+    }
+    throw new Error(`Pickle step not found for step: ${step.text}`);
+  }
+  getStepEnglishKeyword(step) {
+    const nativeKeyword = step.keyword.trim();
+    const enKeyword = nativeKeyword === '*' ? 'And' : this.getEnglishKeyword(nativeKeyword);
+    if (!enKeyword) {
+      throw new Error(`Keyword not found: ${nativeKeyword}`);
+    }
+    return enKeyword;
+  }
+  getStepFixtureNames(stepDefinition) {
+    const stepConfig = (0, _stepConfig.getStepConfig)(stepDefinition);
+    if ((0, _stepConfig.isPlaywrightStyle)(stepConfig)) {
+      // for decorator steps fixtureNames are defined later in second pass
+      return (0, _stepConfig.isDecorator)(stepConfig) ? [] : (0, _fixtures.extractFixtureNames)(stepConfig.fn);
+    } else {
+      return (0, _fixtures.extractFixtureNamesFromFnBodyMemo)(stepDefinition.code);
+    }
+  }
+  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.featureUri}.`, `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(scenario, examples) {
+    return this.getExamplesTitleFormatFromComment(examples) || this.getExamplesTitleFormatFromScenarioName(scenario, examples) || this.config.examplesTitleFormat;
+  }
+  getExamplesTitleFormatFromComment(examples) {
+    var _comment$text;
+    const {
+      line
+    } = examples.location;
+    const titleFormatCommentLine = line - 1;
+    const comment = this.gherkinDocument.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() : '';
+  }
+  getExamplesTitleFormatFromScenarioName(scenario, examples) {
+    var _examples$tableHeader2;
+    const columnsInScenarioName = (0, _utils.extractTemplateParams)(scenario.name);
+    const hasColumnsFromExamples = columnsInScenarioName.length && ((_examples$tableHeader2 = examples.tableHeader) === null || _examples$tableHeader2 === void 0 || (_examples$tableHeader2 = _examples$tableHeader2.cells) === null || _examples$tableHeader2 === void 0 ? void 0 : _examples$tableHeader2.some(cell => {
+      return cell.value && columnsInScenarioName.includes(cell.value);
+    }));
+    return hasColumnsFromExamples ? scenario.name : '';
+  }
+  skipByTagsExpression(node) {
+    // see: https://github.com/cucumber/tag-expressions/tree/main/javascript
+    const {
+      tagsExpression
+    } = this.options;
+    return tagsExpression && !tagsExpression.evaluate(node.tags);
+  }
+  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;

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

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestMetaBuilder = void 0;
+exports.getTestMeta = getTestMeta;
+var _utils = require("../utils");
+/**
+ * Class to build and print testMeta object containing meta info about each test.
+ * Tests are identified by special key constructed from title path.
+ *
+ * Example:
+ * const testMeta = {
+ *  "Simple scenario": { pickleLocation: "3:10", tags: ["@foo"] },
+ *  "Scenario with examples|Example #1": { pickleLocation: "8:26", tags: [] },
+ *  "Rule 1|Scenario with examples|Example #1": { pickleLocation: "9:42", tags: [] },
+ * };
+ */
+
+const TEST_KEY_SEPARATOR = '|';
+class TestMetaBuilder {
+  tests = [];
+  get testCount() {
+    return this.tests.length;
+  }
+  registerTest(node, pickle) {
+    const testMeta = {
+      pickleLocation: (0, _utils.stringifyLocation)(pickle.location),
+      tags: node.tags.length ? node.tags : undefined
+    };
+    this.tests.push({
+      node,
+      testMeta
+    });
+  }
+  getObjectLines() {
+    // build object line by line to have each test on a separate line,
+    // but value should be in one line.
+    return this.tests.map(test => {
+      const testKey = this.getTestKey(test.node);
+      return `${JSON.stringify(testKey)}: ${JSON.stringify(test.testMeta)},`;
+    });
+  }
+  getTestKey(node) {
+    // .slice(1) -> b/c we remove top describe title (it's same for all tests)
+    return node.titlePath.slice(1).join(TEST_KEY_SEPARATOR);
+  }
+}
+exports.TestMetaBuilder = TestMetaBuilder;
+function getTestMeta(testMetaMap, testInfo) {
+  // .slice(2) -> b/c we remove filename and top describe title
+  const key = testInfo.titlePath.slice(2).join(TEST_KEY_SEPARATOR);
+  const testMeta = testMetaMap[key];
+  if (!testMeta) {
+    // throw new Error(`Can't find testMeta for key "${key}"`);
+    return {};
+  }
+  return testMeta;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestNode = void 0;
+var _utils = require("../utils");
+/**
+ * Universal TestNode class representing test or suite in a test file.
+ * Holds parent-child links.
+ * Allows to inherit tags and titles path.
+ */
+
+const SPECIAL_TAGS = ['@only', '@skip', '@fixme'];
+class TestNode {
+  title;
+  titlePath;
+  ownTags;
+  tags;
+  flags = {};
+  constructor(gherkinNode, parent) {
+    this.title = gherkinNode.name;
+    this.titlePath = ((parent === null || parent === void 0 ? void 0 : parent.titlePath) || []).concat([this.title]);
+    this.ownTags = (0, _utils.removeDuplicates)(getTagNames(gherkinNode.tags));
+    this.tags = (0, _utils.removeDuplicates)(((parent === null || parent === void 0 ? void 0 : parent.tags) || []).concat(this.ownTags));
+    this.initFlags();
+  }
+  isSkipped() {
+    return this.flags.skip || this.flags.fixme;
+  }
+  initFlags() {
+    this.ownTags.forEach(tag => {
+      if (isSpecialTag(tag)) {
+        this.setFlag(tag);
+      }
+    });
+  }
+  // eslint-disable-next-line complexity
+  setFlag(tag) {
+    // in case of several special tags, @only takes precendence
+    if (tag === '@only') {
+      this.flags = {
+        only: true
+      };
+    }
+    if (tag === '@skip' && !this.flags.only) {
+      this.flags.skip = true;
+    }
+    if (tag === '@fixme' && !this.flags.only) {
+      this.flags.fixme = true;
+    }
+  }
+}
+exports.TestNode = TestNode;
+function getTagNames(tags) {
+  return tags.map(tag => tag.name);
+}
+function isSpecialTag(tag) {
+  return SPECIAL_TAGS.includes(tag);
+}