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

package/build/bdd-framework/hooks/scenario.js

@@ -0,0 +1,107 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getScenarioHooksFixtures = getScenarioHooksFixtures;
+exports.hasScenarioHooks = hasScenarioHooks;
+exports.runScenarioHooks = runScenarioHooks;
+exports.scenarioHookFactory = scenarioHookFactory;
+var _tagExpressions = _interopRequireDefault(require("@cucumber/tag-expressions"));
+var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
+var _utils = require("../utils");
+/**
+ * Scenario level hooks: Before / After.
+ *
+ * before(async ({ page }) => {})
+ */
+
+const scenarioHooks = [];
+let scenarioHooksFixtures;
+/**
+ * Returns Before() / After() functions.
+ */
+function scenarioHookFactory(type) {
+  return (...args) => {
+    addHook({
+      type,
+      options: getOptionsFromArgs(args),
+      fn: getFnFromArgs(args)
+    });
+  };
+}
+function hasScenarioHooks() {
+  return scenarioHooks.length > 0;
+}
+// eslint-disable-next-line complexity
+async function runScenarioHooks(type, fixtures) {
+  let error;
+  for (const hook of scenarioHooks) {
+    if (hook.type !== type) {
+      continue;
+    }
+    if (hook.tagsExpression && !hook.tagsExpression.evaluate(fixtures.$tags)) {
+      continue;
+    }
+    const {
+      timeout
+    } = hook.options;
+    try {
+      await (0, _utils.callWithTimeout)(() => hook.fn.call(fixtures.$bddWorld, fixtures), timeout, `${type} hook timeout (${timeout} ms)`);
+    } catch (e) {
+      if (type === 'before') {
+        throw e;
+      }
+      if (!error) {
+        error = e;
+      }
+    }
+  }
+  if (error) {
+    throw error;
+  }
+}
+function getScenarioHooksFixtures() {
+  if (!scenarioHooksFixtures) {
+    const fixturesFakeObj = {
+      $bddWorld: null,
+      $tags: null,
+      $testInfo: null
+    };
+    const set = new Set();
+    scenarioHooks.forEach(hook => {
+      (0, _fixtureParameterNames.fixtureParameterNames)(hook.fn).filter(fixtureName => !Object.prototype.hasOwnProperty.call(fixturesFakeObj, fixtureName)).forEach(fixtureName => set.add(fixtureName));
+    });
+    scenarioHooksFixtures = [...set];
+  }
+  return scenarioHooksFixtures;
+}
+function getOptionsFromArgs(args) {
+  if (typeof args[0] === 'string') {
+    return {
+      tags: args[0]
+    };
+  }
+  if (typeof args[0] === 'object') {
+    return args[0];
+  }
+  return {};
+}
+function getFnFromArgs(args) {
+  return args.length === 1 ? args[0] : args[1];
+}
+function setTagsExpression(hook) {
+  if (hook.options.tags) {
+    hook.tagsExpression = (0, _tagExpressions.default)(hook.options.tags);
+  }
+}
+function addHook(hook) {
+  setTagsExpression(hook);
+  if (hook.type === 'before') {
+    scenarioHooks.push(hook);
+  } else {
+    // 'after' hooks run in reverse order
+    scenarioHooks.unshift(hook);
+  }
+}

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

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getWorkerHooksFixtures = getWorkerHooksFixtures;
+exports.runWorkerHooks = runWorkerHooks;
+exports.workerHookFactory = workerHookFactory;
+var _fixtureParameterNames = require("../playwright/fixtureParameterNames");
+var _utils = require("../utils");
+/**
+ * Worker-level hooks: BeforeAll / AfterAll.
+ */
+
+const workerHooks = [];
+let workerHooksFixtures;
+/**
+ * Returns BeforeAll() / AfterAll() functions.
+ */
+function workerHookFactory(type) {
+  return (...args) => {
+    addHook({
+      type,
+      options: getOptionsFromArgs(args),
+      fn: getFnFromArgs(args)
+    });
+  };
+}
+// eslint-disable-next-line complexity
+async function runWorkerHooks(type, fixtures) {
+  let error;
+  for (const hook of workerHooks) {
+    if (hook.type !== type) {
+      continue;
+    }
+    const {
+      timeout
+    } = hook.options;
+    try {
+      await (0, _utils.callWithTimeout)(() => hook.fn(fixtures), timeout, `${type} hook timeout (${timeout} ms)`);
+    } catch (e) {
+      if (type === 'beforeAll') {
+        throw e;
+      }
+      if (!error) {
+        error = e;
+      }
+    }
+  }
+  if (error) {
+    throw error;
+  }
+}
+function getWorkerHooksFixtures() {
+  if (!workerHooksFixtures) {
+    const fixturesFakeObj = {
+      $workerInfo: null
+    };
+    const set = new Set();
+    workerHooks.forEach(hook => {
+      (0, _fixtureParameterNames.fixtureParameterNames)(hook.fn).filter(fixtureName => !Object.prototype.hasOwnProperty.call(fixturesFakeObj, fixtureName)).forEach(fixtureName => set.add(fixtureName));
+    });
+    workerHooksFixtures = [...set];
+  }
+  return workerHooksFixtures;
+}
+function getOptionsFromArgs(args) {
+  if (typeof args[0] === 'object') {
+    return args[0];
+  }
+  return {};
+}
+function getFnFromArgs(args) {
+  return args.length === 1 ? args[0] : args[1];
+}
+function addHook(hook) {
+  if (hook.type === 'beforeAll') {
+    workerHooks.push(hook);
+  } else {
+    // 'afterAll' hooks run in reverse order
+    workerHooks.unshift(hook);
+  }
+}

package/build/bdd-framework/index.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BDDInputConfig", {
+  enumerable: true,
+  get: function () {
+    return _config.BDDInputConfig;
+  }
+});
+Object.defineProperty(exports, "BddWorld", {
+  enumerable: true,
+  get: function () {
+    return _bddWorld.BddWorld;
+  }
+});
+Object.defineProperty(exports, "BddWorldOptions", {
+  enumerable: true,
+  get: function () {
+    return _bddWorld.BddWorldOptions;
+  }
+});
+Object.defineProperty(exports, "createBdd", {
+  enumerable: true,
+  get: function () {
+    return _createBdd.createBdd;
+  }
+});
+Object.defineProperty(exports, "defineBddConfig", {
+  enumerable: true,
+  get: function () {
+    return _config.defineBddConfig;
+  }
+});
+Object.defineProperty(exports, "test", {
+  enumerable: true,
+  get: function () {
+    return _bddFixtures.test;
+  }
+});
+var _config = require("./config");
+var _createBdd = require("./stepDefinitions/createBdd");
+var _bddFixtures = require("./run/bddFixtures");
+var _bddWorld = require("./run/bddWorld");

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

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fixtureParameterNames = fixtureParameterNames;
+/**
+ * Extracted from playwright.
+ * https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/fixtures.ts#L226
+ */
+/* eslint-disable max-statements, complexity, max-len, max-depth */
+const signatureSymbol = Symbol('signature');
+function fixtureParameterNames(fn) {
+  if (typeof fn !== 'function') {
+    return [];
+  }
+  if (!fn[signatureSymbol]) {
+    fn[signatureSymbol] = innerFixtureParameterNames(fn);
+  }
+  return fn[signatureSymbol];
+}
+function innerFixtureParameterNames(fn) {
+  const text = filterOutComments(fn.toString());
+  const match = text.match(/(?:async)?(?:\s+function)?[^(]*\(([^)]*)/);
+  if (!match) {
+    return [];
+  }
+  const trimmedParams = match[1].trim();
+  if (!trimmedParams) {
+    return [];
+  }
+  const [firstParam] = splitByComma(trimmedParams);
+  if (firstParam[0] !== '{' || firstParam[firstParam.length - 1] !== '}') {
+    throw new Error('First argument must use the object destructuring pattern: ' + firstParam + ' ' + fn.toString());
+  }
+  const props = splitByComma(firstParam.substring(1, firstParam.length - 1)).map(prop => {
+    const colon = prop.indexOf(':');
+    return colon === -1 ? prop.trim() : prop.substring(0, colon).trim();
+  });
+  const restProperty = props.find(prop => prop.startsWith('...'));
+  if (restProperty) {
+    throw new Error(`Rest property "${restProperty}" is not supported. List all used fixtures explicitly, separated by comma. ${fn.toString()}`);
+  }
+  return props;
+}
+function filterOutComments(s) {
+  const result = [];
+  let commentState = 'none';
+  for (let i = 0; i < s.length; ++i) {
+    if (commentState === 'singleline') {
+      if (s[i] === '\n') {
+        commentState = 'none';
+      }
+    } else if (commentState === 'multiline') {
+      if (s[i - 1] === '*' && s[i] === '/') {
+        commentState = 'none';
+      }
+    } else if (commentState === 'none') {
+      if (s[i] === '/' && s[i + 1] === '/') {
+        commentState = 'singleline';
+      } else if (s[i] === '/' && s[i + 1] === '*') {
+        commentState = 'multiline';
+        i += 2;
+      } else {
+        result.push(s[i]);
+      }
+    }
+  }
+  return result.join('');
+}
+function splitByComma(s) {
+  const result = [];
+  const stack = [];
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '{' || s[i] === '[') {
+      stack.push(s[i] === '{' ? '}' : ']');
+    } else if (s[i] === stack[stack.length - 1]) {
+      stack.pop();
+    } else if (!stack.length && s[i] === ',') {
+      const token = s.substring(start, i).trim();
+      if (token) {
+        result.push(token);
+      }
+      start = i + 1;
+    }
+  }
+  const lastToken = s.substring(start).trim();
+  if (lastToken) {
+    result.push(lastToken);
+  }
+  return result;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getLocationInFile = getLocationInFile;
+var _url = _interopRequireDefault(require("url"));
+var _utils = require("./utils");
+/**
+ * Inspects stacktrace and finds call location in provided file.
+ * This function is based on Playwright's getLocationByStacktrace().
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/transform.ts#L229
+ */
+function getLocationInFile(filePath) {
+  const filePathUrl = _url.default.pathToFileURL(filePath).toString();
+  const {
+    sourceMapSupport
+  } = (0, _utils.requirePlaywrightModule)('lib/utilsBundle.js');
+  const oldPrepareStackTrace = Error.prepareStackTrace;
+  Error.prepareStackTrace = (error, stackFrames) => {
+    const frameInFile = stackFrames.find(frame => {
+      const frameFile = frame.getFileName();
+      return frameFile === filePath || frameFile === filePathUrl;
+    });
+    if (!frameInFile) {
+      return {
+        file: '',
+        line: 0,
+        column: 0
+      };
+    }
+    const frame = sourceMapSupport.wrapCallSite(frameInFile);
+    const fileName = frame.getFileName();
+    // Node error stacks for modules use file:// urls instead of paths.
+    const file = fileName !== null && fileName !== void 0 && fileName.startsWith('file://') ? _url.default.fileURLToPath(fileName) : fileName;
+    return {
+      file,
+      line: frame.getLineNumber(),
+      column: frame.getColumnNumber()
+    };
+  };
+  // commented stackTraceLImit modification, todo: check if it has perf impact
+  // const oldStackTraceLimit = Error.stackTraceLimit;
+  // Error.stackTraceLimit = level + 1;
+  const obj = {};
+  Error.captureStackTrace(obj);
+  const location = obj.stack;
+  // Error.stackTraceLimit = oldStackTraceLimit;
+  Error.prepareStackTrace = oldPrepareStackTrace;
+  return location;
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadConfig = loadConfig;
+exports.resolveConfigFile = resolveConfigFile;
+var _path = _interopRequireDefault(require("path"));
+var _fs = _interopRequireDefault(require("fs"));
+var _utils = require("./utils");
+var _transform = require("./transform");
+var _exit = require("../utils/exit");
+/**
+ * Loading Playwright config.
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/configLoader.ts
+ */
+
+async function loadConfig(cliConfigPath) {
+  const resolvedConfigFile = resolveConfigFile(cliConfigPath);
+  assertConfigFileExists(resolvedConfigFile, cliConfigPath);
+  await (0, _transform.requireTransform)().requireOrImport(resolvedConfigFile);
+  return {
+    resolvedConfigFile
+  };
+}
+function resolveConfigFile(cliConfigPath) {
+  const {
+    resolveConfigFile
+  } = (0, _utils.requirePlaywrightModule)('lib/common/configLoader.js');
+  const configFileOrDirectory = getConfigFilePath(cliConfigPath);
+  return resolveConfigFile(configFileOrDirectory) || '';
+}
+function getConfigFilePath(cliConfigPath) {
+  return cliConfigPath ? _path.default.resolve(process.cwd(), cliConfigPath) : process.cwd();
+}
+function assertConfigFileExists(resolvedConfigFile, cliConfigPath) {
+  if (!resolvedConfigFile || !_fs.default.existsSync(resolvedConfigFile)) {
+    const configFilePath = getConfigFilePath(cliConfigPath);
+    (0, _exit.exit)(`Can't find Playwright config file in: ${configFilePath}`);
+  }
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isTestContainsSubtest = isTestContainsSubtest;
+exports.runStepWithCustomLocation = runStepWithCustomLocation;
+var _test = require("@playwright/test");
+var _utils = require("../utils");
+/**
+ * Helpers to deal with Playwright test internal stuff.
+ * See: https://github.com/microsoft/playwright/blob/main/packages/playwright-test/src/common/testType.ts
+ */
+
+const testTypeSymbol = (0, _utils.getSymbolByName)(_test.test, 'testType');
+/**
+ * Returns test fixtures using Symbol.
+ */
+function getTestFixtures(test) {
+  return getTestImpl(test).fixtures;
+}
+function getTestImpl(test) {
+  return test[testTypeSymbol];
+}
+/**
+ * Run step with location pointing to Given, When, Then call.
+ */
+// eslint-disable-next-line max-params
+async function runStepWithCustomLocation(test, stepText, location, body) {
+  const testInfo = test.info();
+  // See: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/common/testType.ts#L221
+  // @ts-expect-error _runAsStep is hidden from public
+  return testInfo._runAsStep({
+    category: 'test.step',
+    title: stepText,
+    location
+  }, async () => {
+    return await body();
+  });
+}
+/**
+ * Returns true if test contains all fixtures of subtest.
+ * - test was extended from subtest
+ * - test is a result of mergeTests(subtest, ...)
+ */
+function isTestContainsSubtest(test, subtest) {
+  if (test === subtest) {
+    return true;
+  }
+  const testFixtures = new Set(getTestFixtures(test).map(f => locationToString(f.location)));
+  return getTestFixtures(subtest).every(f => {
+    return testFixtures.has(locationToString(f.location));
+  });
+}
+function locationToString({
+  file,
+  line,
+  column
+}) {
+  return `${file}:${line}:${column}`;
+}

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

@@ -0,0 +1,84 @@
+"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 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/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPlaywrightModulePath = getPlaywrightModulePath;
+exports.requirePlaywrightModule = requirePlaywrightModule;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("../utils");
+// cache playwright root
+let playwrightRoot = '';
+/**
+ * Requires Playwright's internal module that is not exported via package.exports.
+ */
+function requirePlaywrightModule(modulePath) {
+  const absPath = _path.default.isAbsolute(modulePath) ? modulePath : getPlaywrightModulePath(modulePath);
+  return require(absPath);
+}
+function getPlaywrightModulePath(relativePath) {
+  return _path.default.join(getPlaywrightRoot(), relativePath);
+}
+function getPlaywrightRoot() {
+  if (!playwrightRoot) {
+    // Since 1.38 all modules moved from @playwright/test to playwright.
+    // Here we check existance of 'lib' dir instead of checking version.
+    // See: https://github.com/microsoft/playwright/pull/26946
+    const playwrightTestRoot = (0, _utils.resolvePackageRoot)('@playwright/test');
+    const libDir = _path.default.join(playwrightTestRoot, 'lib');
+    playwrightRoot = _fs.default.existsSync(libDir) ? playwrightTestRoot : (0, _utils.resolvePackageRoot)('playwright');
+  }
+  return playwrightRoot;
+}

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

@@ -0,0 +1,73 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StepInvoker = void 0;
+var _loadSteps = require("../cucumber/loadSteps");
+var _getLocationInFile = require("../playwright/getLocationInFile");
+var _testTypeImpl = require("../playwright/testTypeImpl");
+var _defineStep = require("../stepDefinitions/defineStep");
+var _lang = require("../config/lang");
+/**
+ * Class to invoke steps in generated files.
+ */
+
+class StepInvoker {
+  world;
+  keyword;
+  text = '';
+  argument;
+  constructor(world, keyword) {
+    this.world = world;
+    this.keyword = keyword;
+    this.invoke = this.invoke.bind(this);
+  }
+  async invoke(text, argument, stepFixtures) {
+    this.text = text;
+    this.argument = argument;
+    const {
+      world
+    } = this;
+    world.stepFixtures = stepFixtures || {};
+    const stepDefinition = this.getStepDefinition();
+    // Get location of step call in generated test file.
+    // This call must be exactly here to have correct call stack (before async calls)
+    const location = (0, _getLocationInFile.getLocationInFile)(world.test.info().file);
+    const stepTitle = this.getStepTitle();
+    const code = (0, _defineStep.getStepCode)(stepDefinition);
+    const parameters = await this.getStepParameters(stepDefinition);
+    return (0, _testTypeImpl.runStepWithCustomLocation)(world.test, stepTitle, location, () => code.apply(world, parameters));
+  }
+  getStepDefinition() {
+    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.world.options.supportCodeLibrary, this.text, this.world.testInfo.file);
+    if (!stepDefinition) {
+      throw new Error(`Undefined step: "${this.text}"`);
+    }
+    return stepDefinition;
+  }
+  async getStepParameters(stepDefinition) {
+    const {
+      text,
+      argument,
+      world
+    } = this;
+    const {
+      parameters
+    } = await stepDefinition.getInvocationParameters({
+      hookParameter: {},
+      step: {
+        text,
+        argument
+      },
+      world
+    });
+    return parameters;
+  }
+  getStepTitle() {
+    // Currently prepend keyword only for English.
+    // For other langs it's more complex as we need to pass original keyword from step.
+    return (0, _lang.isEnglish)(this.world.options.lang) ? `${this.keyword} ${this.text}` : this.text;
+  }
+}
+exports.StepInvoker = StepInvoker;