@zohodesk/testinglibrary 0.0.4 → 0.0.5-exp.10

package/build/bdd-framework/playwright/transform.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installTransform = installTransform;
+exports.requireTransform = requireTransform;
+var _module = _interopRequireDefault(require("module"));
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("./utils");
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+/* eslint-disable max-params */
+/**
+ * Installs require hook to transform ts.
+ * Extracted from playwright.
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/transform/transform.ts
+ */
+function installTransform() {
+  const {
+    pirates
+  } = (0, _utils.requirePlaywrightModule)('lib/utilsBundle.js');
+  const {
+    resolveHook,
+    shouldTransform,
+    transformHook
+  } = requireTransform();
+  let reverted = false;
+  const originalResolveFilename = _module.default._resolveFilename;
+  function resolveFilename(specifier, parent, ...rest) {
+    if (!reverted && parent) {
+      const resolved = resolveHook(parent.filename, specifier);
+      if (resolved !== undefined) {
+        specifier = resolved;
+      }
+    }
+    return originalResolveFilename.call(this, specifier, parent, ...rest);
+  }
+  _module.default._resolveFilename = resolveFilename;
+  const revertPirates = pirates.addHook((code, filename) => {
+    if (!shouldTransform(filename)) {
+      return code;
+    }
+    return transformHook(code, filename);
+  }, {
+    exts: ['.ts', '.tsx', '.js', '.jsx', '.mjs']
+  });
+  return () => {
+    reverted = true;
+    _module.default._resolveFilename = originalResolveFilename;
+    revertPirates();
+  };
+}
+function requireTransform() {
+  const transformPathSince1_35 = (0, _utils.getPlaywrightModulePath)('lib/transform/transform.js');
+  if (_fs.default.existsSync(transformPathSince1_35)) {
+    const {
+      resolveHook,
+      shouldTransform,
+      transformHook,
+      requireOrImport
+    } = (0, _utils.requirePlaywrightModule)(transformPathSince1_35);
+    return {
+      resolveHook,
+      shouldTransform,
+      transformHook,
+      requireOrImport
+    };
+  } else {
+    const {
+      resolveHook,
+      transformHook,
+      requireOrImport
+    } = (0, _utils.requirePlaywrightModule)('lib/common/transform.js');
+    // see: https://github.com/microsoft/playwright/blob/b4ffb848de1b00e9a0abad6dacdccce60cce9bed/packages/playwright-test/src/reporters/base.ts#L524
+    const shouldTransform = file => !file.includes(`${_path.default.sep}node_modules${_path.default.sep}`);
+    return {
+      resolveHook,
+      shouldTransform,
+      transformHook,
+      requireOrImport
+    };
+  }
+}

package/build/bdd-framework/playwright/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightModulePath = getPlaywrightModulePath;
+exports.requirePlaywrightModule = requirePlaywrightModule;
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("../utils");
+const playwrightRoot = (0, _utils.resolvePackageRoot)('@playwright/test');
+
+/**
+ * Requires Playwright's internal module that is not exported via package.exports.
+ */
+function requirePlaywrightModule(modulePath) {
+  const absPath = _path.default.isAbsolute(modulePath) ? modulePath : getPlaywrightModulePath(modulePath);
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require(absPath);
+}
+function getPlaywrightModulePath(relativePath) {
+  const parts = relativePath.split('/');
+  return _path.default.join(playwrightRoot, ...parts);
+}

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

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isBddAutoInjectFixture = isBddAutoInjectFixture;
+exports.test = void 0;
+var _test = require("@playwright/test");
+var _loadConfig = require("../cucumber/loadConfig");
+var _loadSteps = require("../cucumber/loadSteps");
+var _bddWorld = require("./bddWorld");
+var _config = require("../config");
+var _env = require("../config/env");
+var _createDecorators = require("../stepDefinitions/createDecorators");
+var _dir = require("../config/dir");
+const test = _test.test.extend({
+  $bddWorldBase: async ({
+    $tags,
+    $test
+  }, use, testInfo) => {
+    const config = (0, _env.getConfigFromEnv)(testInfo.project.testDir);
+    const environment = {
+      cwd: (0, _dir.getPlaywrightConfigDir)()
+    };
+    const {
+      runConfiguration
+    } = await (0, _loadConfig.loadConfig)({
+      provided: (0, _config.extractCucumberConfig)(config)
+    }, environment);
+    const supportCodeLibrary = await (0, _loadSteps.loadSteps)(runConfiguration, environment);
+    (0, _createDecorators.appendDecoratorSteps)(supportCodeLibrary);
+    const World = (0, _bddWorld.getWorldConstructor)(supportCodeLibrary);
+    const world = new World({
+      testInfo,
+      supportCodeLibrary,
+      $tags,
+      $test,
+      parameters: runConfiguration.runtime.worldParameters || {},
+      log: () => {},
+      attach: async () => {} // eslint-disable-line @typescript-eslint/no-empty-function
+    });
+
+    await world.init();
+    await use(world);
+    await world.destroy();
+  },
+  $bddWorld: async ({
+    $bddWorldBase,
+    page,
+    context,
+    browser,
+    browserName,
+    request
+  }, use) => {
+    $bddWorldBase.builtinFixtures = {
+      page,
+      context,
+      browser,
+      browserName,
+      request
+    };
+    await use($bddWorldBase);
+  },
+  // below fixtures are used in playwright-style
+  // and does not automatically init Playwright builtin fixtures
+  Given: ({
+    $bddWorldBase
+  }, use) => use($bddWorldBase.invokeStep),
+  When: ({
+    $bddWorldBase
+  }, use) => use($bddWorldBase.invokeStep),
+  Then: ({
+    $bddWorldBase
+  }, use) => use($bddWorldBase.invokeStep),
+  And: ({
+    $bddWorldBase
+  }, use) => use($bddWorldBase.invokeStep),
+  But: ({
+    $bddWorldBase
+  }, use) => use($bddWorldBase.invokeStep),
+  // below fixtures are used in cucumber-style
+  // and automatically init Playwright builtin fixtures
+  Given_: ({
+    $bddWorld
+  }, use) => use($bddWorld.invokeStep),
+  When_: ({
+    $bddWorld
+  }, use) => use($bddWorld.invokeStep),
+  Then_: ({
+    $bddWorld
+  }, use) => use($bddWorld.invokeStep),
+  And_: ({
+    $bddWorld
+  }, use) => use($bddWorld.invokeStep),
+  But_: ({
+    $bddWorld
+  }, use) => use($bddWorld.invokeStep),
+  // Init $tags fixture with empty array. Can be owerwritten in test file
+  // eslint-disable-next-line
+  $tags: ({}, use) => use([]),
+  // Init $test fixture with base test, but it will be always overwritten in test file
+  // eslint-disable-next-line
+  $test: ({}, use) => use(_test.test)
+});
+exports.test = test;
+const BDD_AUTO_INJECT_FIXTURES = ['$testInfo', '$test', '$tags'];
+function isBddAutoInjectFixture(name) {
+  return BDD_AUTO_INJECT_FIXTURES.includes(name);
+}

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

@@ -0,0 +1,91 @@
+"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");
+// See: https://playwright.dev/docs/test-fixtures#built-in-fixtures
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+class BddWorld extends _cucumber.World {
+  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 = stepDefinition.code;
+
+    // get location of step call in generated test file
+    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.getTestImpl)(this.test)._step(location, text, () => 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,132 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Snippets = void 0;
+var _loadSnippetBuilder = require("../cucumber/loadSnippetBuilder");
+var _utils = require("../utils");
+var _defineStep = require("../stepDefinitions/defineStep");
+var _logger = require("../utils/logger");
+/**
+ * Generate and show snippets for undefined steps
+ */
+
+class Snippets {
+  snippetBuilder;
+  bddBuiltInSyntax = false;
+  constructor(files, runConfiguration, supportCodeLibrary) {
+    this.files = files;
+    this.runConfiguration = runConfiguration;
+    this.supportCodeLibrary = supportCodeLibrary;
+  }
+  async printSnippetsAndExit() {
+    this.snippetBuilder = await this.createSnippetBuilder();
+    const snippets = this.getSnippets();
+    this.printHeader();
+    this.printSnippets(snippets);
+    this.printFooter(snippets);
+  }
+  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, _defineStep.isPlaywrightStyle)(step)) : true;
+  }
+  isDecorators() {
+    const {
+      stepDefinitions
+    } = this.supportCodeLibrary;
+    const decoratorSteps = stepDefinitions.filter(step => {
+      var _getStepConfig;
+      return (_getStepConfig = (0, _defineStep.getStepConfig)(step)) === null || _getStepConfig === void 0 ? void 0 : _getStepConfig.isDecorator;
+    });
+    return decoratorSteps.length > stepDefinitions.length / 2;
+  }
+  printHeader() {
+    const lines = [`Missing steps found. Use snippets below:`];
+    if (this.bddBuiltInSyntax) {
+      if (this.isDecorators()) {
+        // TODO: For Decorators support
+        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) {
+    (0, _utils.exitWithMessage)(`Missing step definitions (${snippets.length}).`, 'Use snippets above to create them.', this.getWarnOnZeroScannedFiles());
+  }
+  getWarnOnZeroScannedFiles() {
+    const {
+      requirePaths,
+      importPaths
+    } = this.supportCodeLibrary.originalCoordinates;
+    const scannedFilesCount = requirePaths.length + importPaths.length;
+    return scannedFilesCount === 0 && !this.isDecorators() ? `\nNote that 0 step definition files found, check the config.` : '';
+  }
+}
+exports.Snippets = Snippets;

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

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Playwright-style snippet syntax.
+ *
+ * See: https://github.com/cucumber/cucumber-js/blob/main/docs/custom_snippet_syntaxes.md
+ */
+
+// 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,
+    // prettier-ignore
+    `  // ...`, '});'].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,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Playwright-style snippet syntax for decorators.
+ *
+ * See: https://github.com/cucumber/cucumber-js/blob/main/docs/custom_snippet_syntaxes.md
+ */
+
+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,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBdd = createBdd;
+exports.extractFixtureNames = extractFixtureNames;
+var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
+var _utils = require("../utils");
+var _bddFixtures = require("../run/bddFixtures");
+var _testTypeImpl = require("../playwright/testTypeImpl");
+var _defineStep = require("./defineStep");
+/**
+ * Stuff related to writing steps in Playwright-style.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/ban-types */
+
+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,
+      isDecorator: false
+    });
+  };
+}
+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, _utils.exitWithMessage)(`createBdd() should use test extended from "playwright-bdd"`);
+  }
+  return isCustomTest;
+}