@zohodesk/testinglibrary 0.1.6 → 0.1.7

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

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.TestPoms = void 0;
 exports.buildFixtureTag = buildFixtureTag;
-var _poms = require("../stepDefinitions/decorators/poms");
+var _class = require("../stepDefinitions/decorators/class");
 var _exit = require("../utils/exit");
 /**
  * Track PomNodes used in the particular test.
@@ -44,7 +44,7 @@ class TestPoms {
     });
   }
   addByFixtureName(fixtureName) {
-    const pomNode = (0, _poms.getPomNodeByFixtureName)(fixtureName);
+    const pomNode = (0, _class.getPomNodeByFixtureName)(fixtureName);
     this.addUsedPom(pomNode, {
       byTag: false
     });
@@ -52,7 +52,7 @@ class TestPoms {
   addByTag(tag) {
     const fixtureName = extractFixtureName(tag);
     if (fixtureName) {
-      const pomNode = (0, _poms.getPomNodeByFixtureName)(fixtureName);
+      const pomNode = (0, _class.getPomNodeByFixtureName)(fixtureName);
       this.addUsedPom(pomNode, {
         byTag: true
       });
@@ -73,10 +73,14 @@ class TestPoms {
      */
   getResolvedFixtures(pomNode) {
     const usedPom = this.usedPoms.get(pomNode);
-    if (usedPom !== null && usedPom !== void 0 && usedPom.fixtures) return usedPom.fixtures;
+    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 (!usedPom) {
+      return childFixtures;
+    }
     if (childFixtures.length) {
       this.verifyChildFixtures(pomNode, usedPom, childFixtures);
       usedPom.fixtures = childFixtures;
@@ -91,10 +95,14 @@ class TestPoms {
   addUsedPom(pomNode, {
     byTag
   }) {
-    if (!pomNode) return;
+    if (!pomNode) {
+      return;
+    }
     const usedPom = this.usedPoms.get(pomNode);
     if (usedPom) {
-      if (byTag && !usedPom.byTag) usedPom.byTag = true;
+      if (byTag && !usedPom.byTag) {
+        usedPom.byTag = true;
+      }
     } else {
       this.usedPoms.set(pomNode, {
         byTag
@@ -107,7 +115,9 @@ class TestPoms {
      * @fixture:xxx tag provides maximum fixture that can be used in the scenario.
      */
   verifyChildFixtures(pomNode, usedPom, childFixtures) {
-    if (!usedPom.byTag) return;
+    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}"`);

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/playwright/fixtureParameterNames.js

@@ -11,16 +11,24 @@ exports.fixtureParameterNames = fixtureParameterNames;
 /* 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);
+  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 [];
+  if (!match) {
+    return [];
+  }
   const trimmedParams = match[1].trim();
-  if (!trimmedParams) return [];
+  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());
@@ -40,9 +48,13 @@ function filterOutComments(s) {
   let commentState = 'none';
   for (let i = 0; i < s.length; ++i) {
     if (commentState === 'singleline') {
-      if (s[i] === '\n') commentState = 'none';
+      if (s[i] === '\n') {
+        commentState = 'none';
+      }
     } else if (commentState === 'multiline') {
-      if (s[i - 1] === '*' && s[i] === '/') commentState = 'none';
+      if (s[i - 1] === '*' && s[i] === '/') {
+        commentState = 'none';
+      }
     } else if (commentState === 'none') {
       if (s[i] === '/' && s[i + 1] === '/') {
         commentState = 'singleline';
@@ -67,11 +79,15 @@ function splitByComma(s) {
       stack.pop();
     } else if (!stack.length && s[i] === ',') {
       const token = s.substring(start, i).trim();
-      if (token) result.push(token);
+      if (token) {
+        result.push(token);
+      }
       start = i + 1;
     }
   }
   const lastToken = s.substring(start).trim();
-  if (lastToken) result.push(lastToken);
+  if (lastToken) {
+    result.push(lastToken);
+  }
   return result;
 }

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

@@ -13,21 +13,27 @@ var _utils = require("./utils");
  * 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 => frame.getFileName() === filePath);
-    if (!frameInFile) return {
-      file: '',
-      line: 0,
-      column: 0
-    };
+    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 && fileName.startsWith('file://') ? _url.default.fileURLToPath(fileName) : fileName;
+    const file = fileName !== null && fileName !== void 0 && fileName.startsWith('file://') ? _url.default.fileURLToPath(fileName) : fileName;
     return {
       file,
       line: frame.getLineNumber(),

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isParentChildTest = isParentChildTest;
+exports.isTestContainsSubtest = isTestContainsSubtest;
 exports.runStepWithCustomLocation = runStepWithCustomLocation;
 var _test = require("@playwright/test");
 var _utils = require("../utils");
@@ -39,13 +39,17 @@ async function runStepWithCustomLocation(test, stepText, location, body) {
   });
 }
 /**
- * Returns true if all fixtures of parent test found in child test.
+ * Returns true if test contains all fixtures of subtest.
+ * - test was extended from subtest
+ * - test is a result of mergeTests(subtest, ...)
  */
-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 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({

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

@@ -30,13 +30,17 @@ function installTransform() {
   function resolveFilename(specifier, parent, ...rest) {
     if (!reverted && parent) {
       const resolved = resolveHook(parent.filename, specifier);
-      if (resolved !== undefined) specifier = resolved;
+      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;
+    if (!shouldTransform(filename)) {
+      return code;
+    }
     return transformHook(code, filename);
   }, {
     exts: ['.ts', '.tsx', '.js', '.jsx', '.mjs']

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;

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

@@ -13,12 +13,15 @@ var _config = require("../config");
 var _env = require("../config/env");
 var _steps = require("../stepDefinitions/decorators/steps");
 var _dir = require("../config/dir");
+var _scenario = require("../hooks/scenario");
+var _worker = require("../hooks/worker");
+var _StepInvoker = require("./StepInvoker");
 const test = exports.test = _test.test.extend({
-  $bddWorldBase: async ({
-    $tags,
-    $test
-  }, use, testInfo) => {
-    const config = (0, _env.getConfigFromEnv)(testInfo.project.testDir);
+  // load cucumber once per worker (auto-fixture)
+  // todo: maybe remove caching in cucumber/loadConfig.ts and cucumber/loadSteps.ts
+  // as we call it once per worker. Check generation phase.
+  $cucumber: [async ({}, use, workerInfo) => {
+    const config = (0, _env.getConfigFromEnv)(workerInfo.project.testDir);
     const environment = {
       cwd: (0, _dir.getPlaywrightConfigDir)()
     };
@@ -30,11 +33,37 @@ const test = exports.test = _test.test.extend({
     const supportCodeLibrary = await (0, _loadSteps.loadSteps)(runConfiguration, environment);
     (0, _steps.appendDecoratorSteps)(supportCodeLibrary);
     const World = (0, _bddWorld.getWorldConstructor)(supportCodeLibrary);
+    await use({
+      runConfiguration,
+      supportCodeLibrary,
+      World
+    });
+  }, {
+    auto: true,
+    scope: 'worker'
+  }],
+  $lang: ({}, use) => use(''),
+  // init $bddWorldFixtures with empty object, will be owerwritten in test file for cucumber-style
+  $bddWorldFixtures: ({}, use) => use({}),
+  $bddWorld: async ({
+    $tags,
+    $test,
+    $bddWorldFixtures,
+    $cucumber,
+    $lang
+  }, use, testInfo) => {
+    const {
+      runConfiguration,
+      supportCodeLibrary,
+      World
+    } = $cucumber;
     const world = new World({
       testInfo,
       supportCodeLibrary,
       $tags,
       $test,
+      $bddWorldFixtures,
+      lang: $lang,
       parameters: runConfiguration.runtime.worldParameters || {},
       log: () => {},
       attach: async () => {}
@@ -43,63 +72,97 @@ const test = exports.test = _test.test.extend({
     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_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Given').invoke),
+  When: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  Then_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'When').invoke),
+  Then: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  And_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Then').invoke),
+  And: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  But_: ({
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'And').invoke),
+  But: ({
     $bddWorld
-  }, use) => use($bddWorld.invokeStep),
-  // Init $tags fixture with empty array. Can be owerwritten in test file
-  // eslint-disable-next-line
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'But').invoke),
+  // init $tags with empty array, can be owerwritten in test file
   $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)
+  // init $test with base test, but it will be always overwritten in test file
+  $test: ({}, use) => use(_test.test),
+  // can be owerwritten in test file if there are scenario hooks
+  $scenarioHookFixtures: ({}, use) => use({}),
+  $before: [
+  // Unused dependencies are important:
+  // 1. $beforeAll / $afterAll: in pw < 1.39 worker-scoped auto-fixtures were called after test-scoped
+  // 2. $after: to call after hooks in case of errors in before hooks
+  async ({
+    $scenarioHookFixtures,
+    $bddWorld,
+    $tags,
+    $beforeAll,
+    $afterAll,
+    $after
+  }, use, $testInfo) => {
+    await (0, _scenario.runScenarioHooks)('before', {
+      $bddWorld,
+      $tags,
+      $testInfo,
+      ...$scenarioHookFixtures
+    });
+    await use();
+  }, {
+    auto: true
+  }],
+  $after: [async ({
+    $scenarioHookFixtures,
+    $bddWorld,
+    $tags
+  }, use, $testInfo) => {
+    await use();
+    await (0, _scenario.runScenarioHooks)('after', {
+      $bddWorld,
+      $tags,
+      $testInfo,
+      ...$scenarioHookFixtures
+    });
+  }, {
+    auto: true
+  }],
+  // can be owerwritten in test file if there are worker hooks
+  $workerHookFixtures: [({}, use) => use({}), {
+    scope: 'worker'
+  }],
+  $beforeAll: [
+  // Important unused dependencies:
+  // 1. $afterAll: in pw < 1.39 worker-scoped auto-fixtures are called in incorrect order
+  // 2. $cucumber: to load hooks before this fixtures
+  async ({
+    $workerHookFixtures,
+    $cucumber
+  }, use, $workerInfo) => {
+    await (0, _worker.runWorkerHooks)('beforeAll', {
+      $workerInfo,
+      ...$workerHookFixtures
+    });
+    await use();
+  }, {
+    auto: true,
+    scope: 'worker'
+  }],
+  $afterAll: [async ({
+    $workerHookFixtures
+  }, use, $workerInfo) => {
+    await use();
+    await (0, _worker.runWorkerHooks)('afterAll', {
+      $workerInfo,
+      ...$workerHookFixtures
+    });
+  }, {
+    auto: true,
+    scope: 'worker'
+  }]
 });
 const BDD_AUTO_INJECT_FIXTURES = ['$testInfo', '$test', '$tags'];
 function isBddAutoInjectFixture(name) {