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

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

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Formatter = void 0;
+var _jsStringWrap = require("../utils/jsStringWrap");
+var _utils = require("../utils");
+/**
+ * Helper to format Playwright test file.
+ */
+
+class Formatter {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  fileHeader(featureUri, importTestFrom) {
+    // always use "/" for imports, see #91
+    const importTestFromFile = (0, _utils.toPosixPath)((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: ${featureUri} */`,
+    // prettier-ignore
+    // this.quoted() is not possible for 'import from' as backticks not parsed
+    `import { ${varName} } from ${JSON.stringify(importTestFromFile)};`, ''];
+  }
+  suite(node, children) {
+    const firstLine = `test.describe${this.getSubFn(node)}(${this.quoted(node.title)}, () => {`;
+    if (!children.length) {
+      return [`${firstLine}});`, ''];
+    }
+    return [firstLine, '', ...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(', ');
+    const title = this.quoted(node.title);
+    const firstLine = `test${this.getSubFn(node)}(${title}, async ({ ${fixturesStr} }) => {`;
+    if (!children.length) {
+      return [`${firstLine}});`, ''];
+    }
+    return [firstLine, ...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)});`;
+  }
+  technicalSection(testMetaBuilder, featureUri, fixtures) {
+    return ['// == technical section ==',
+    // prettier-ignore
+    '', 'test.use({', ...['$test: ({}, use) => use(test),', '$testMetaMap: ({}, use) => use(testMetaMap),', `$uri: ({}, use) => use(${this.quoted(featureUri)}),`, ...fixtures].map(indent), '});', '', 'const testMetaMap = {', ...testMetaBuilder.getObjectLines().map(indent), '};'];
+  }
+  bddWorldFixtures() {
+    const fixturesObj = {
+      page: null,
+      context: null,
+      browser: null,
+      browserName: null,
+      request: null
+    };
+    const fixtures = Object.keys(fixturesObj).join(', ');
+    return [`$bddWorldFixtures: ({ ${fixtures} }, use) => use({ ${fixtures} }),`];
+  }
+  scenarioHookFixtures(fixtureNames) {
+    if (!fixtureNames.length) {
+      return [];
+    }
+    const fixtures = fixtureNames.join(', ');
+    return [`$scenarioHookFixtures: ({ ${fixtures} }, use) => use({ ${fixtures} }),`];
+  }
+  workerHookFixtures(fixtureNames) {
+    if (!fixtureNames.length) {
+      return [];
+    }
+    const fixtures = fixtureNames.join(', ');
+    const scope = this.quoted('worker');
+    return [`$workerHookFixtures: [({ ${fixtures} }, use) => use({ ${fixtures} }), { scope: ${scope} }],`];
+  }
+  langFixture(lang) {
+    return [`$lang: ({}, use) => use(${this.quoted(lang)}),`];
+  }
+  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 backticks.
+     * 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,39 @@
+"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,185 @@
+"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 _configDir = require("../config/configDir");
+var _logger = require("../utils/logger");
+var _tagExpressions = _interopRequireDefault(require("@cucumber/tag-expressions"));
+var _exit = require("../utils/exit");
+var _createBdd = require("../stepDefinitions/createBdd");
+var _resolveFeaturePaths = require("../cucumber/resolveFeaturePaths");
+/**
+ * Generate playwright test files from Gherkin documents.
+ */
+
+class TestFilesGenerator {
+  config;
+  // all these props are exist
+  runConfiguration;
+  featuresLoader = new _loadFeatures.FeaturesLoader();
+  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.checkImportTestFrom();
+      await this.clearOutputDir();
+      await this.saveFiles();
+    });
+  }
+  async extractSteps() {
+    await this.loadCucumberConfig();
+    await this.loadSteps();
+    return this.supportCodeLibrary.stepDefinitions;
+  }
+  async loadCucumberConfig() {
+    const environment = {
+      cwd: (0, _configDir.getPlaywrightConfigDir)()
+    };
+    const {
+      runConfiguration
+    } = await (0, _loadConfig.loadConfig)({
+      provided: (0, _config.extractCucumberConfig)(this.config)
+    }, environment);
+    this.runConfiguration = runConfiguration;
+    this.warnForTsNodeRegister();
+  }
+  async loadFeatures() {
+    const cwd = (0, _configDir.getPlaywrightConfigDir)();
+    const {
+      paths,
+      defaultDialect
+    } = this.runConfiguration.sources;
+    this.logger.log(`Loading features from: ${paths.join(', ')}`);
+    const {
+      featurePaths
+    } = await (0, _resolveFeaturePaths.resovleFeaturePaths)(this.runConfiguration, {
+      cwd
+    });
+    await this.featuresLoader.load(featurePaths, {
+      relativeTo: cwd,
+      defaultDialect
+    });
+    this.handleParseErrors();
+    this.logger.log(`Loaded features: ${this.featuresLoader.getDocumentsCount()}`);
+  }
+  async loadSteps() {
+    const {
+      requirePaths,
+      importPaths
+    } = this.runConfiguration.support;
+    this.logger.log(`Loading steps from: ${requirePaths.concat(importPaths).join(', ')}`);
+    const environment = {
+      cwd: (0, _configDir.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.featuresLoader.getDocumentsWithPickles().map(gherkinDocument => {
+      return new _testFile.TestFile({
+        gherkinDocument,
+        supportCodeLibrary: this.supportCodeLibrary,
+        // 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
+        outputPath: this.getSpecPathByFeaturePath(gherkinDocument.uri),
+        config: this.config,
+        tagsExpression: this.tagsExpression
+      }).build();
+    }).filter(file => file.testCount > 0);
+  }
+  getSpecPathByFeaturePath(relFeaturePath) {
+    const configDir = (0, _configDir.getPlaywrightConfigDir)();
+    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)();
+    }
+  }
+  checkImportTestFrom() {
+    if (_createBdd.hasCustomTest && !this.config.importTestFrom) {
+      (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.`);
+    }
+  }
+  handleParseErrors() {
+    const {
+      parseErrors
+    } = this.featuresLoader;
+    if (parseErrors.length) {
+      const message = parseErrors.map(parseError => {
+        return `Parse error in "${parseError.source.uri}" ${parseError.message}`;
+      }).join('\n');
+      (0, _exit.exit)(message);
+    }
+  }
+}
+exports.TestFilesGenerator = TestFilesGenerator;