@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.10

package/.babelrc

@@ -0,0 +1,16 @@
+{
+  "presets": [
+    [
+      "@babel/preset-env",
+      {
+        "targets": {
+          "node": "14"
+        },
+        "exclude": ["@babel/plugin-transform-destructuring"]
+      }
+    ]
+  ],
+  "plugins": [
+      ["@babel/plugin-transform-runtime"]
+  ]
+}

package/bin/cli.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-require('../src/lib/cli');
+require('../build/lib/cli');

package/bin/postinstall.js

@@ -1,16 +1 @@
-const path = require('path');
-const { spawn } = require('child_process');
-const { Logger } = require('../src/utils/logger');
-const getFilePathWithExtension = require('../src/utils/getFilePath');
-
-const playwrightPath = path.resolve('node_modules', '.bin', getFilePathWithExtension('playwright'));
-const command = playwrightPath;
-const args = ['install'];
-
-Logger.log(Logger.INFO_TYPE, 'Downloading browsers for running tests');
-
-const childProcess = spawn(command, args, { stdio: 'inherit' });
-
-childProcess.on('error', (error) => {
-  Logger.log(Logger.FAILURE_TYPE, error);
-});
+require('../build/lib/post-install');

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

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.envCommand = void 0;
+exports.getOwnVersion = getOwnVersion;
+var _fs = _interopRequireDefault(require("fs"));
+var _commander = require("commander");
+var _options = require("../options");
+var _path = _interopRequireDefault(require("path"));
+var _logger = require("../../utils/logger");
+var _utils = require("../../utils");
+var _loadConfig = require("../../playwright/loadConfig");
+const envCommand = new _commander.Command('env').description('Prints environment info').addOption(_options.configOption).action(opts => {
+  _logger.logger.log(`Playwright-bdd environment info:\n`);
+  _logger.logger.log(`platform: ${process.platform}`);
+  _logger.logger.log(`node: ${process.version}`);
+  showPackageVersion('playwright-bdd');
+  showPackageVersion('@playwright/test');
+  showPackageVersion('@cucumber/cucumber');
+  showPlaywrightConfigPath(opts.config);
+});
+exports.envCommand = envCommand;
+function showPackageVersion(packageName) {
+  const version = packageName === 'playwright-bdd' ? getOwnVersion() : (0, _utils.getPackageVersion)(packageName);
+  _logger.logger.log(`${packageName}: v${version}`);
+}
+
+/**
+ * Getting own version by relative path instead of using getPackageVersion(),
+ * to aneble using directly from /dist in tests.
+ */
+function getOwnVersion() {
+  // const packageJsonPath = path.resolve(__dirname, '..', '..', '..', `package.json`);
+  // const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  return '5.2.0';
+}
+function showPlaywrightConfigPath(cliConfigPath) {
+  const resolvedConfigFile = (0, _loadConfig.resolveConfigFile)(cliConfigPath);
+  const relPath = _path.default.relative(process.cwd(), resolvedConfigFile);
+  _logger.logger.log(`Playwright config file: ${relPath}`);
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exportCommand = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _commander = require("commander");
+var _options = require("../options");
+var _loadConfig = require("../../playwright/loadConfig");
+var _logger = require("../../utils/logger");
+var _env = require("../../config/env");
+var _test = require("./test");
+var _gen = require("../../gen");
+// filter by project?
+
+const exportCommand = new _commander.Command('export').description('Prints all step definitions').addOption(_options.configOption).action(async opts => {
+  const {
+    resolvedConfigFile
+  } = await (0, _loadConfig.loadConfig)(opts.config);
+  _logger.logger.log(`List of all steps found by config: ${_path.default.relative(process.cwd(), resolvedConfigFile)}\n`);
+  const configs = Object.values((0, _env.getEnvConfigs)());
+  (0, _test.assertConfigsCount)(configs);
+  await showStepsForConfigs(configs);
+});
+exports.exportCommand = exportCommand;
+async function showStepsForConfigs(configs) {
+  // here we don't need workers (as in test command) because if some step files
+  // are already in node cache, we collected them.
+  const steps = new Set();
+  const tasks = configs.map(async config => {
+    const stepDefinitions = await new _gen.TestFilesGenerator(config).extractSteps();
+    stepDefinitions.forEach(s => steps.add(`* ${getStepText(s)}`));
+  });
+  await Promise.all(tasks);
+  steps.forEach(stepText => _logger.logger.log(stepText));
+}
+function getStepText({
+  pattern,
+  keyword
+}) {
+  // for Unknown return When as it looks the most suitable
+  const keywordText = keyword === 'Unknown' ? 'When' : keyword;
+  const patternText = typeof pattern === 'string' ? pattern : pattern.source;
+  return `${keywordText} ${patternText}`;
+}

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

@@ -0,0 +1,60 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assertConfigsCount = assertConfigsCount;
+exports.testCommand = void 0;
+var _worker_threads = require("worker_threads");
+var _events = require("events");
+var _path = _interopRequireDefault(require("path"));
+var _commander = require("commander");
+var _gen = require("../../gen");
+var _utils = require("../../utils");
+var _loadConfig = require("../../playwright/loadConfig");
+var _env = require("../../config/env");
+var _config = require("../../config");
+var _options = require("../options");
+const GEN_WORKER_PATH = _path.default.resolve(__dirname, '..', 'worker.js');
+const testCommand = new _commander.Command('test').description('Generate Playwright test files from Gherkin documents').addOption(_options.configOption).option('--tags <expression>', `Tags expression to filter scenarios for generation`).option('--verbose', `Verbose mode (default: ${Boolean(_config.defaults.verbose)})`).action(async opts => {
+  await (0, _loadConfig.loadConfig)(opts.config);
+  const configs = Object.values((0, _env.getEnvConfigs)());
+  assertConfigsCount(configs);
+  const cliOptions = buildCliOptions(opts);
+  await generateFilesForConfigs(configs, cliOptions);
+});
+exports.testCommand = testCommand;
+function buildCliOptions(opts) {
+  const config = {};
+  if ('tags' in opts) config.tags = opts.tags;
+  if ('verbose' in opts) config.verbose = Boolean(opts.verbose);
+  return config;
+}
+function assertConfigsCount(configs) {
+  if (configs.length === 0) {
+    (0, _utils.exitWithMessage)(`No BDD configs found. Did you use defineBddConfig() in playwright.config.ts?`);
+  }
+}
+async function runInWorker(config) {
+  const worker = new _worker_threads.Worker(GEN_WORKER_PATH, {
+    workerData: {
+      config
+    }
+  });
+
+  // todo: check if worker exited with error?
+  await (0, _events.once)(worker, 'exit');
+}
+async function generateFilesForConfigs(configs, cliConfig) {
+  // run first config in main thread and other in workers (to have fresh require cache)
+  // See: https://github.com/vitalets/playwright-bdd/issues/32
+  const tasks = configs.map((config, index) => {
+    const finalConfig = {
+      ...config,
+      ...cliConfig
+    };
+    return index === 0 ? new _gen.TestFilesGenerator(finalConfig).generate() : runInWorker(finalConfig);
+  });
+  return Promise.all(tasks);
+}

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+"use strict";
+
+var _commander = require("commander");
+var _test = require("./commands/test");
+var _env = require("./commands/env");
+var _export = require("./commands/export");
+const program = new _commander.Command();
+program.name('bddgen').description(`Playwright-bdd CLI v${(0, _env.getOwnVersion)()}`).addCommand(_test.testCommand, {
+  isDefault: true
+}).addCommand(_export.exportCommand).addCommand(_env.envCommand).addHelpCommand(false).parse();

package/build/bdd-framework/cli/options.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.configOption = void 0;
+exports.getCliConfigPath = getCliConfigPath;
+var _commander = require("commander");
+/**
+ * Config option moved to separate file as it used in test run.
+ */
+
+const configOption = new _commander.Option(`-c, --config <file>`, `Path to Playwright configuration file (default: playwright.config.(js|ts))`);
+
+/**
+ * Helper used in test run to detect config location.
+ */
+exports.configOption = configOption;
+function getCliConfigPath() {
+  return new _commander.Command().allowUnknownOption().addOption(configOption).parse().getOptionValue('config');
+}

package/build/bdd-framework/cli/worker.js

@@ -0,0 +1,13 @@
+"use strict";
+
+var _worker_threads = require("worker_threads");
+var _gen = require("../gen");
+/**
+ * Worker to generate test files with fresh require/import cache
+ * See: https://github.com/nodejs/modules/issues/307#issuecomment-858729422
+ */
+
+async function main() {
+  await new _gen.TestFilesGenerator(_worker_threads.workerData.config).generate();
+}
+main();

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

@@ -0,0 +1,27 @@
+"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.
+ */
+
+/**
+ * Resolve playwright config dir considering cli flags.
+ */
+function getPlaywrightConfigDir() {
+  if (!process.env.PLAYWRIGHT_BDD_CONFIG_DIR) {
+    const cliConfigPath = (0, _options.getCliConfigPath)();
+    const playwrightConfigFile = (0, _loadConfig.resolveConfigFile)(cliConfigPath);
+    process.env.PLAYWRIGHT_BDD_CONFIG_DIR = playwrightConfigFile ? _path.default.dirname(playwrightConfigFile) : process.cwd();
+  }
+  return process.env.PLAYWRIGHT_BDD_CONFIG_DIR;
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getConfigFromEnv = getConfigFromEnv;
+exports.getEnvConfigs = getEnvConfigs;
+exports.saveConfigToEnv = saveConfigToEnv;
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("../utils");
+/**
+ * Storing configs in env var PLAYWRIGHT_BDD_CONFIGS as JSON-stringified values.
+ * For passing configs to playwright workers and bddgen.
+ */
+
+function saveConfigToEnv(config) {
+  const envConfigs = getEnvConfigs();
+  const existingConfig = envConfigs[config.outputDir];
+  if (existingConfig) {
+    // Playwright config can be evaluated several times.
+    // Throw error only if different calls of defineBddConfig() use the same outputDir.
+    // See: https://github.com/vitalets/playwright-bdd/issues/39#issuecomment-1653805368
+    if (!isSameConfigs(config, existingConfig)) {
+      (0, _utils.exitWithMessage)(`When using several calls of defineBddConfig()`, `please manually provide different "outputDir" option.`);
+    }
+    return;
+  }
+  envConfigs[config.outputDir] = config;
+  saveEnvConfigs(envConfigs);
+}
+function getConfigFromEnv(outputDir) {
+  const envConfigs = getEnvConfigs();
+  outputDir = _path.default.resolve(outputDir);
+  const config = envConfigs[outputDir];
+  if (!config) {
+    (0, _utils.exitWithMessage)(`Config not found for outputDir: "${outputDir}".`, `Available dirs: ${Object.keys(envConfigs).join('\n')}`);
+  }
+  return config;
+}
+function getEnvConfigs() {
+  return JSON.parse(process.env.PLAYWRIGHT_BDD_CONFIGS || '{}');
+}
+function saveEnvConfigs(envConfigs) {
+  process.env.PLAYWRIGHT_BDD_CONFIGS = JSON.stringify(envConfigs);
+}
+function isSameConfigs(config1, config2) {
+  return JSON.stringify(config1) === JSON.stringify(config2);
+}

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

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaults = void 0;
+exports.defineBddConfig = defineBddConfig;
+exports.extractCucumberConfig = extractCucumberConfig;
+var _path = _interopRequireDefault(require("path"));
+var _env = require("./env");
+var _dir = require("./dir");
+var _utils = require("../utils");
+/**
+ * BDD Config.
+ */
+
+const defaults = {
+  outputDir: '.features-gen',
+  verbose: false,
+  examplesTitleFormat: 'Example #<_index_>',
+  publishQuiet: true,
+  quotes: 'double'
+};
+exports.defaults = defaults;
+function defineBddConfig(inputConfig) {
+  const config = getConfig(inputConfig);
+
+  // In main process store config in env to be accessible by workers
+  if (!process.env.TEST_WORKER_INDEX) {
+    (0, _env.saveConfigToEnv)(config);
+  }
+  return config.outputDir;
+}
+function getConfig(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,
+    // important to resolve outputDir as it is used as unique key for input configs
+    outputDir: _path.default.resolve(configDir, config.outputDir),
+    importTestFrom: resolveImportTestFrom(configDir, config.importTestFrom),
+    featuresRoot
+  };
+}
+function extractCucumberConfig(config) {
+  // todo: find more strict way to omit own config fields
+  // see: https://bobbyhadz.com/blog/typescript-object-remove-property
+  const omitProps = {
+    outputDir: true,
+    importTestFrom: true,
+    verbose: true,
+    skip: true,
+    examplesTitleFormat: true,
+    quotes: true,
+    tags: true,
+    featuresRoot: true
+  };
+  const keys = Object.keys(omitProps);
+  const cucumberConfig = {
+    ...config
+  };
+  keys.forEach(key => delete cucumberConfig[key]);
+  stripPublishQuiet(cucumberConfig);
+  return cucumberConfig;
+}
+function resolveImportTestFrom(configDir, importTestFrom) {
+  if (importTestFrom) {
+    const {
+      file,
+      varName
+    } = typeof importTestFrom === 'string' ? {
+      file: importTestFrom
+    } : importTestFrom;
+    return {
+      file: _path.default.resolve(configDir, file),
+      varName
+    };
+  }
+}
+function stripPublishQuiet(cucumberConfig) {
+  const cucumberVersion = (0, _utils.getPackageVersion)('@cucumber/cucumber');
+  // Playwright-bdd supports Cucumber from v9+
+  // publishQuiet was deprecated in Cucumber 9.4.0.
+  // See: https://github.com/cucumber/cucumber-js/pull/2311
+  // Remove publishQuite from Cucumber config to hide deprecation warning.
+  // See: https://github.com/vitalets/playwright-bdd/pull/47
+  if (!/^9\.[0123]\./.test(cucumberVersion)) {
+    delete cucumberConfig.publishQuiet;
+  }
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildStepDefinition = buildStepDefinition;
+var _messages = require("@cucumber/messages");
+var _cucumberExpressions = require("@cucumber/cucumber-expressions");
+var _step_definition = _interopRequireDefault(require("@cucumber/cucumber/lib/models/step_definition"));
+/**
+ * Extracted from cucumber SupportCodeLibraryBuilder.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/support_code_library_builder/index.ts
+ */
+
+const newId = _messages.IdGenerator.uuid();
+function buildStepDefinition({
+  keyword,
+  pattern,
+  code,
+  line,
+  options,
+  uri
+}, supportCodeLibrary) {
+  // todo: handle error.undefinedParameterTypeName as it's done in cucumber?
+  const expression = typeof pattern === 'string' ? new _cucumberExpressions.CucumberExpression(pattern, supportCodeLibrary.parameterTypeRegistry) : new _cucumberExpressions.RegularExpression(pattern, supportCodeLibrary.parameterTypeRegistry);
+
+  // skip wrapping code as it is not needed for decorator steps
+  // const wrappedCode = this.wrapCode({
+  //   code,
+  //   wrapperOptions: options.wrapperOptions,
+  // })
+
+  return new _step_definition.default({
+    code,
+    expression,
+    id: newId(),
+    line,
+    options,
+    keyword,
+    pattern,
+    unwrappedCode: code,
+    uri
+  });
+}

package/build/bdd-framework/cucumber/gherkin.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Copied from @cucumber/cucumber/lib/api/gherkin.d.ts
+ * Fixes error:
+ * Return type of exported function has or is using name 'PickleWithDocument'
+ * from external module "../node_modules/@cucumber/cucumber/lib/api/gherkin"
+ * but cannot be named
+ */
+import {
+  Envelope,
+  GherkinDocument,
+  IdGenerator,
+  Location,
+  ParseError,
+  Pickle,
+} from '@cucumber/messages';
+import { ISourcesCoordinates } from '@cucumber/cucumber/lib/api/types';
+import { ILogger } from '@cucumber/cucumber/lib/logger';
+
+declare module '@cucumber/cucumber/lib/api/gherkin' {
+  export interface PickleWithDocument {
+    gherkinDocument: GherkinDocument;
+    location: Location;
+    pickle: Pickle;
+  }
+  export function getFilteredPicklesAndErrors({
+    newId,
+    cwd,
+    logger,
+    unexpandedFeaturePaths,
+    featurePaths,
+    coordinates,
+    onEnvelope,
+  }: {
+    newId: IdGenerator.NewId;
+    cwd: string;
+    logger: ILogger;
+    unexpandedFeaturePaths: string[];
+    featurePaths: string[];
+    coordinates: ISourcesCoordinates;
+    onEnvelope?: (envelope: Envelope) => void;
+  }): Promise<{
+    filteredPickles: PickleWithDocument[];
+    parseErrors: ParseError[];
+  }>;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadConfig = loadConfig;
+var _api = require("@cucumber/cucumber/api");
+const cache = new Map();
+async function loadConfig(options, environment) {
+  const cacheKey = JSON.stringify(options);
+  let config = cache.get(cacheKey);
+  if (!config) {
+    config = (0, _api.loadConfiguration)(options, environment);
+    cache.set(cacheKey, config);
+  }
+  return config;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadFeatures = loadFeatures;
+var _loadSources = require("./loadSources");
+var _utils = require("../utils");
+async function loadFeatures(runConfiguration, environment) {
+  const {
+    filteredPickles,
+    parseErrors
+  } = await (0, _loadSources.loadSources)(runConfiguration.sources, environment);
+  handleParseErrors(parseErrors);
+  return groupByDocument(filteredPickles);
+}
+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);
+  });
+  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, _utils.exitWithMessage)(message);
+  }
+}

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

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadSnippetBuilder = loadSnippetBuilder;
+var _cucumber = require("@cucumber/cucumber");
+/**
+ * Loads snippet builder
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/builder.ts
+ */
+
+async function loadSnippetBuilder(supportCodeLibrary, snippetInterface, snippetSyntax) {
+  return _cucumber.FormatterBuilder.getStepDefinitionSnippetBuilder({
+    cwd: process.cwd(),
+    snippetInterface,
+    snippetSyntax,
+    supportCodeLibrary
+  });
+}

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

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadSources = loadSources;
+var _paths = require("@cucumber/cucumber/lib/api/paths");
+var _messages = require("@cucumber/messages");
+var _environment = require("@cucumber/cucumber/lib/api/environment");
+var _gherkin = require("@cucumber/cucumber/lib/api/gherkin");
+var _console_logger = require("@cucumber/cucumber/lib/api/console_logger");
+/**
+ * Copied from original load_sources, but returns full Pickles.
+ * See: https://github.com/cucumber/cucumber-js/blob/main/src/api/load_sources.ts
+ */
+/// <reference path="./gherkin.d.ts" />
+
+/**
+ * Load and parse features, produce a filtered and ordered test plan and/or parse errors.
+ *
+ * @public
+ * @param coordinates - Coordinates required to find features
+ * @param environment - Project environment.
+ */
+async function loadSources(coordinates, environment = {}) {
+  const {
+    cwd,
+    stderr,
+    debug
+  } = (0, _environment.mergeEnvironment)(environment);
+  const logger = new _console_logger.ConsoleLogger(stderr, debug);
+  const newId = _messages.IdGenerator.uuid();
+  const {
+    unexpandedFeaturePaths,
+    featurePaths
+  } = await (0, _paths.resolvePaths)(logger, cwd, coordinates);
+  if (featurePaths.length === 0) {
+    return {
+      filteredPickles: [],
+      parseErrors: []
+    };
+  }
+  const {
+    filteredPickles,
+    parseErrors
+  } = await (0, _gherkin.getFilteredPicklesAndErrors)({
+    newId,
+    cwd,
+    logger,
+    unexpandedFeaturePaths,
+    featurePaths,
+    coordinates
+  });
+  return {
+    filteredPickles,
+    parseErrors
+  };
+}