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

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

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestNode = void 0;
+var _utils = require("../utils");
+/**
+ * Universal TestNode class of parent-child relations in test file structure.
+ * Holds tags and titles path.
+ */
+
+const SPECIAL_TAGS = ['@only', '@skip', '@fixme'];
+class TestNode {
+  title;
+  titlePath;
+  ownTags = [];
+  tags = [];
+  flags = {};
+  constructor(gherkinNode, parent) {
+    this.initOwnTags(gherkinNode);
+    this.tags = (0, _utils.removeDuplicates)(((parent === null || parent === void 0 ? void 0 : parent.tags) || []).concat(this.ownTags));
+    this.title = gherkinNode.name;
+    this.titlePath = ((parent === null || parent === void 0 ? void 0 : parent.titlePath) || []).concat([this.title]);
+  }
+  initOwnTags(gherkinNode) {
+    const tagNames = (0, _utils.removeDuplicates)(getTagNames(gherkinNode.tags));
+    tagNames.forEach(tag => {
+      if (isSpecialTag(tag)) {
+        this.setFlag(tag);
+      } else {
+        this.ownTags.push(tag);
+      }
+    });
+  }
+  setFlag(tag) {
+    if (tag === '@only') this.flags.only = true;
+    if (tag === '@skip') this.flags.skip = true;
+    if (tag === '@fixme') this.flags.fixme = true;
+  }
+}
+exports.TestNode = TestNode;
+function getTagNames(tags) {
+  return tags.map(tag => tag.name);
+}
+function isSpecialTag(tag) {
+  return SPECIAL_TAGS.includes(tag);
+}

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

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestPoms = void 0;
+exports.buildFixtureTag = buildFixtureTag;
+var _poms = require("../stepDefinitions/decorators/poms");
+var _exit = require("../utils/exit");
+/**
+ * Track PomNodes used in the particular test.
+ * To select correct fixture for decorator steps.
+ *
+ * Idea: try to use the deepest child fixture for parent steps.
+ *
+ * Example inheritance tree:
+ *      A
+ *     / \
+ *    B   C
+ *   / \   \
+ *  D   E   F
+ *
+ * If test uses steps from classes A and D:
+ * -> resolved fixture will be D, even for steps from A.
+ *
+ * If test uses steps from classes A, D and C:
+ * -> error, b/c A has 2 possible fixtures.
+ *
+ * If test uses steps from classes A and C, but @fixture tag is D:
+ * -> error, b/c A has 2 possible fixtures.
+ */
+
+const FIXTURE_TAG_PREFIX = '@fixture:';
+class TestPoms {
+  title;
+  // map of poms used in test
+  usedPoms = new Map();
+  constructor(title) {
+    this.title = title;
+  }
+  addByStep(pomNode) {
+    this.addUsedPom(pomNode, {
+      byTag: false
+    });
+  }
+  addByFixtureName(fixtureName) {
+    const pomNode = (0, _poms.getPomNodeByFixtureName)(fixtureName);
+    this.addUsedPom(pomNode, {
+      byTag: false
+    });
+  }
+  addByTag(tag) {
+    const fixtureName = extractFixtureName(tag);
+    if (fixtureName) {
+      const pomNode = (0, _poms.getPomNodeByFixtureName)(fixtureName);
+      this.addUsedPom(pomNode, {
+        byTag: true
+      });
+    }
+  }
+  /**
+     * Resolve all used pomNodes to fixtures.
+     * This is needed to handle @fixture: tagged pomNodes
+     * that does not have steps in the test, but should be considered.
+     */
+  resolveFixtures() {
+    this.usedPoms.forEach((_, pomNode) => {
+      this.getResolvedFixtures(pomNode);
+    });
+  }
+  /**
+     * Returns fixtures suitable for particular pomNode (actually for step)
+     */
+  getResolvedFixtures(pomNode) {
+    const usedPom = this.usedPoms.get(pomNode);
+    if (usedPom !== null && usedPom !== void 0 && usedPom.fixtures) return usedPom.fixtures;
+    // Recursively resolve children fixtures, used in test.
+    let childFixtures = [...pomNode.children].map(child => this.getResolvedFixtures(child)).flat();
+    if (!usedPom) return childFixtures;
+    if (childFixtures.length) {
+      this.verifyChildFixtures(pomNode, usedPom, childFixtures);
+      usedPom.fixtures = childFixtures;
+    } else {
+      usedPom.fixtures = [{
+        name: pomNode.fixtureName,
+        byTag: usedPom.byTag
+      }];
+    }
+    return usedPom.fixtures;
+  }
+  addUsedPom(pomNode, {
+    byTag
+  }) {
+    if (!pomNode) return;
+    const usedPom = this.usedPoms.get(pomNode);
+    if (usedPom) {
+      if (byTag && !usedPom.byTag) usedPom.byTag = true;
+    } else {
+      this.usedPoms.set(pomNode, {
+        byTag
+      });
+    }
+  }
+  /**
+     * For scenarios with @fixture:xxx tags verify that there are no steps from fixtures,
+     * deeper than xxx.
+     * @fixture:xxx tag provides maximum fixture that can be used in the scenario.
+     */
+  verifyChildFixtures(pomNode, usedPom, childFixtures) {
+    if (!usedPom.byTag) return;
+    const childFixturesBySteps = childFixtures.filter(f => !f.byTag);
+    if (childFixturesBySteps.length) {
+      (0, _exit.exit)(`Scenario "${this.title}" contains ${childFixturesBySteps.length} step(s)`, `not compatible with required fixture "${pomNode.fixtureName}"`);
+    }
+  }
+}
+exports.TestPoms = TestPoms;
+function extractFixtureName(tag) {
+  return tag.startsWith(FIXTURE_TAG_PREFIX) ? tag.replace(FIXTURE_TAG_PREFIX, '') : '';
+}
+function buildFixtureTag(fixtureName) {
+  return `${FIXTURE_TAG_PREFIX}${fixtureName}`;
+}

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,77 @@
+"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,46 @@
+"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 {
+    sourceMapSupport
+  } = (0, _utils.requirePlaywrightModule)('lib/utilsBundle.js');
+  const oldPrepareStackTrace = Error.prepareStackTrace;
+  Error.prepareStackTrace = (error, stackFrames) => {
+    const frameInFile = stackFrames.find(frame => frame.getFileName() === filePath);
+    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 && 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,57 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isParentChildTest = isParentChildTest;
+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 all fixtures of parent test found in child test.
+ */
+function isParentChildTest(parent, child) {
+  if (parent === child) return false;
+  const childLocationsSet = new Set(getTestFixtures(child).map(f => locationToString(f.location)));
+  return getTestFixtures(parent).every(f => {
+    return childLocationsSet.has(locationToString(f.location));
+  });
+}
+function locationToString({
+  file,
+  line,
+  column
+}) {
+  return `${file}:${line}:${column}`;
+}

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

@@ -0,0 +1,80 @@
+"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,37 @@
+"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');
+
+    // Recently added functionality in playwright
+    const playwrightDir = _path.default.join(playwrightTestRoot, 'node_modules', 'playwright');
+    playwrightRoot = _fs.default.existsSync(libDir) ? playwrightTestRoot : playwrightDir;
+  }
+  return playwrightRoot;
+}

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

@@ -0,0 +1,107 @@
+"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 _steps = require("../stepDefinitions/decorators/steps");
+var _dir = require("../config/dir");
+const test = exports.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, _steps.appendDecoratorSteps)(supportCodeLibrary);
+    const World = (0, _bddWorld.getWorldConstructor)(supportCodeLibrary);
+    const world = new World({
+      testInfo,
+      supportCodeLibrary,
+      $tags,
+      $test,
+      parameters: runConfiguration.runtime.worldParameters || {},
+      log: () => {},
+      attach: async () => {}
+    });
+    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)
+});
+const BDD_AUTO_INJECT_FIXTURES = ['$testInfo', '$test', '$tags'];
+function isBddAutoInjectFixture(name) {
+  return BDD_AUTO_INJECT_FIXTURES.includes(name);
+}