@zohodesk/testinglibrary 0.4.6-experimental → 2.9.1

package/build/bdd-framework/reporter/cucumber/messagesBuilder/TestStepAttachments.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestStepAttachments = void 0;
+var _fs = _interopRequireDefault(require("fs"));
+var messages = _interopRequireWildcard(require("@cucumber/messages"));
+var _path = _interopRequireDefault(require("path"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+/**
+ * Class for getting attachment messages for a particular step.
+ */
+
+class TestStepAttachments {
+  testCaseRun;
+  testStep;
+  pwStep;
+  constructor(testCaseRun, testStep, pwStep) {
+    this.testCaseRun = testCaseRun;
+    this.testStep = testStep;
+    this.pwStep = pwStep;
+  }
+  buildMessages() {
+    if (!this.pwStep) {
+      return [];
+    }
+    return this.testCaseRun.attachmentMapper.getStepAttachments(this.pwStep).map(pwAttachment => this.buildAttachmentMessage(pwAttachment));
+  }
+  buildAttachmentMessage(pwAttachment) {
+    const attachment = {
+      testCaseStartedId: this.testCaseRun.id,
+      testStepId: this.testStep.id,
+      // for now always attach as base64
+      // todo: for text/plain and application/json use raw to save some bytes
+      body: this.getAttachmentBodyBase64(pwAttachment),
+      contentEncoding: messages.AttachmentContentEncoding.BASE64,
+      mediaType: pwAttachment.contentType,
+      fileName: pwAttachment.name
+    };
+    return {
+      attachment
+    };
+  }
+  getAttachmentBodyBase64(pwAttachment) {
+    if (pwAttachment.path) {
+      if (_fs.default.existsSync(pwAttachment.path)) {
+        return _fs.default.readFileSync(pwAttachment.path, 'base64');
+      }
+      throw createMissingAttachmentError(pwAttachment.path);
+    }
+    if (pwAttachment.body) {
+      return pwAttachment.body.toString('base64');
+    }
+    throw new Error(`Playwright attachment without path and body`);
+  }
+}
+exports.TestStepAttachments = TestStepAttachments;
+function createMissingAttachmentError(attachmentPath) {
+  const attachmentDir = _path.default.join(_path.default.dirname(attachmentPath));
+  const attachmentDirExists = _fs.default.existsSync(attachmentDir);
+  const files = attachmentDirExists ? _fs.default.readdirSync(attachmentDir) : [];
+  const errorMsg = [`Attachment file is not found:`, attachmentPath, `Attachment dir ${attachmentDirExists ? 'exists' : 'does not exist'}.`, ...(attachmentDirExists ? [`Available files (${files.length}):`, ...files] : []), ''].join('\n');
+  return new Error(errorMsg);
+}

package/build/bdd-framework/reporter/cucumber/messagesBuilder/TestStepRun.js

@@ -0,0 +1,114 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestStepRun = void 0;
+var messages = _interopRequireWildcard(require("@cucumber/messages"));
+var _stripAnsiEscapes = require("../../../utils/stripAnsiEscapes");
+var _timing = require("./timing");
+var _TestStepAttachments = require("./TestStepAttachments");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+class TestStepRun {
+  testCaseRun;
+  testStep;
+  pwStep;
+  constructor(testCaseRun, testStep, pwStep) {
+    this.testCaseRun = testCaseRun;
+    this.testStep = testStep;
+    this.pwStep = pwStep;
+  }
+  buildMessages() {
+    const stepAttachments = new _TestStepAttachments.TestStepAttachments(this.testCaseRun, this.testStep, this.pwStep);
+    return [this.buildTestStepStarted(),
+    // prettier-ignore
+    ...stepAttachments.buildMessages(), this.buildTestStepFinished()];
+  }
+  isHook() {
+    return Boolean(this.testStep.hookId);
+  }
+  wasExecuted() {
+    return Boolean(this.pwStep);
+  }
+  get startTime() {
+    return this.wasExecuted() ? this.pwStep.startTime : this.testCaseRun.result.startTime;
+  }
+  get duration() {
+    return this.wasExecuted() ? this.pwStep.duration : 0;
+  }
+  buildTestStepStarted() {
+    const testStepStarted = {
+      testCaseStartedId: this.testCaseRun.id,
+      testStepId: this.testStep.id,
+      timestamp: (0, _timing.toCucumberTimestamp)(this.startTime.getTime())
+    };
+    return {
+      testStepStarted
+    };
+  }
+  buildTestStepFinished() {
+    const error = this.getStepError();
+    const testStepFinished = {
+      testCaseStartedId: this.testCaseRun.id,
+      testStepId: this.testStep.id,
+      testStepResult: {
+        duration: messages.TimeConversion.millisecondsToDuration(this.duration),
+        status: this.getStatus(error),
+        // 'message' is deprecated since cucumber 10.4 in favor of 'exception' field
+        // See: https://github.com/cucumber/react-components/pull/345
+        message: error ? buildErrorMessage(error) : undefined,
+        exception: error ? buildException(error) : undefined
+      },
+      timestamp: (0, _timing.toCucumberTimestamp)(this.startTime.getTime() + this.duration)
+    };
+    return {
+      testStepFinished
+    };
+  }
+  getStatus(error) {
+    switch (true) {
+      case Boolean(error):
+        return messages.TestStepResultStatus.FAILED;
+      // For hooks that were not executted we return PASSED, not SKIPPED.
+      // Because these hooks can be from another run attempt of this testCase.
+      // If marked as skipped, the whole run is marked as skipped in reporter.
+      case !this.isHook() && !this.wasExecuted():
+        return messages.TestStepResultStatus.SKIPPED;
+      default:
+        return messages.TestStepResultStatus.PASSED;
+    }
+  }
+  // eslint-disable-next-line complexity
+  getStepError() {
+    if (!this.pwStep) {
+      return;
+    }
+    if (this.testCaseRun.errorSteps.has(this.pwStep)) {
+      return this.pwStep.error;
+    }
+    if (this.testCaseRun.isTimeouted() && this.pwStep === this.testCaseRun.timeoutedStep) {
+      var _this$testCaseRun$res;
+      return {
+        message: (_this$testCaseRun$res = this.testCaseRun.result.errors) === null || _this$testCaseRun$res === void 0 ? void 0 : _this$testCaseRun$res.map(e => e.message).join('\n\n')
+      };
+    }
+  }
+}
+exports.TestStepRun = TestStepRun;
+function buildErrorMessage(error) {
+  return (0, _stripAnsiEscapes.stripAnsiEscapes)([error.message, error.snippet].filter(Boolean).join('\n'));
+}
+function buildException(error) {
+  return {
+    type: 'Error',
+    message: buildErrorMessage(error),
+    // todo: extract only trace?
+    stackTrace: error.stack ? extractStackTrace((0, _stripAnsiEscapes.stripAnsiEscapes)(error.stack)) : undefined
+    // Use type casting b/c older versions of @cucumber/messages don't have 'stackTrace' field
+    // todo: add direct dependency on @cucumber/messages
+  };
+}
+function extractStackTrace(errorStack) {
+  return errorStack.split('\n').filter(line => line.match(/^\s+at .*/)).join('\n');
+}

package/build/bdd-framework/reporter/cucumber/messagesBuilder/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getMessagesBuilderRef = getMessagesBuilderRef;
+var _Builder = require("./Builder");
+/**
+ * Returns reference to a messagesBuilder singleton.
+ * We pass onTestEnd and onEnd calls only for the first reference (reporter),
+ * otherwise all events will be duplicated.
+ */
+
+let instance;
+let referenceCount = 0;
+function getMessagesBuilderRef() {
+  if (!instance) {
+    instance = new _Builder.MessagesBuilder();
+  }
+  const isFirstRef = ++referenceCount === 1;
+  return {
+    builder: instance,
+    onTestEnd(test, result) {
+      isFirstRef && this.builder.onTestEnd(test, result);
+    },
+    onEnd(fullResult) {
+      isFirstRef && this.builder.onEnd(fullResult);
+    }
+  };
+}

package/build/bdd-framework/reporter/cucumber/messagesBuilder/pwStepUtils.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectStepsDfs = collectStepsDfs;
+exports.collectStepsWithCategory = collectStepsWithCategory;
+exports.findDeepestStepWithError = findDeepestStepWithError;
+exports.findDeepestStepWithUnknownDuration = findDeepestStepWithUnknownDuration;
+exports.getHooksRootPwStep = getHooksRootPwStep;
+exports.isUnknownDuration = isUnknownDuration;
+/**
+ * Utility functions for filtering Playwright steps.
+ */
+// Playwright step categoires, that can be mapped to testStep / hook in Cucumber messages
+const MEANINGFUL_STEP_CATEGORIES = ['hook', 'fixture', 'test.step'];
+function collectStepsWithCategory(parent, category) {
+  const categories = Array.isArray(category) ? category : [category];
+  const steps = collectStepsDfs(parent);
+  return steps.filter(step => categories.includes(step.category));
+}
+function getHooksRootPwStep(result, type) {
+  const rootStepTitle = type === 'before' ? 'Before Hooks' : 'After Hooks';
+  return result.steps.find(step => step.category === 'hook' && step.title === rootStepTitle);
+}
+function findDeepestStepWithError(root) {
+  if (!root) {
+    return;
+  }
+  return findDeepestStepWith(root, pwStep => {
+    return Boolean(pwStep.error) && MEANINGFUL_STEP_CATEGORIES.includes(pwStep.category);
+  });
+}
+function findDeepestStepWithUnknownDuration(root) {
+  if (!root) {
+    return;
+  }
+  return findDeepestStepWith(root, pwStep => {
+    return isUnknownDuration(pwStep) && MEANINGFUL_STEP_CATEGORIES.includes(pwStep.category);
+  });
+}
+/**
+ * Finds the deepest step that satisfies predicate function.
+ */
+function findDeepestStepWith(root, predicate) {
+  let currentStep = predicate(root) ? root : undefined;
+  while (currentStep) {
+    const nextStep = currentStep.steps.find(pwStep => predicate(pwStep));
+    if (!nextStep) {
+      break;
+    }
+    currentStep = nextStep;
+  }
+  return currentStep;
+}
+/**
+ * Returns all steps in DFS order.
+ * See: https://en.wikipedia.org/wiki/Depth-first_search
+ */
+function collectStepsDfs(parent) {
+  var _parent$steps;
+  return (parent === null || parent === void 0 || (_parent$steps = parent.steps) === null || _parent$steps === void 0 ? void 0 : _parent$steps.reduce((res, step) => {
+    res.push(step);
+    res.push(...collectStepsDfs(step));
+    return res;
+  }, [])) || [];
+}
+function isUnknownDuration(pwStep) {
+  return pwStep.duration === -1;
+}

package/build/bdd-framework/reporter/cucumber/messagesBuilder/timing.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.calcMinMaxByArray = calcMinMaxByArray;
+exports.toCucumberTimestamp = toCucumberTimestamp;
+var _messages = require("@cucumber/messages");
+/**
+ * Timing utils.
+ */
+
+function toCucumberTimestamp(time) {
+  return _messages.TimeConversion.millisecondsSinceEpochToTimestamp(time);
+}
+function calcMinMaxByArray(items) {
+  let startTime = items.length > 0 ? items[0].startTime : new Date();
+  let endTime = items.length > 0 ? getEndTime(items[0]) : new Date();
+  items.forEach(item => {
+    const resultEndTime = getEndTime(item);
+    if (item.startTime < startTime) {
+      startTime = item.startTime;
+    }
+    if (resultEndTime > endTime) {
+      endTime = resultEndTime;
+    }
+  });
+  return {
+    startTime,
+    duration: endTime.getTime() - startTime.getTime()
+  };
+}
+function getEndTime(entity) {
+  return new Date(entity.startTime.getTime() + entity.duration);
+}

package/build/bdd-framework/reporter/cucumber/messagesBuilder/types.js

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

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

@@ -0,0 +1,69 @@
+"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("../steps/defineStep");
+var _lang = require("../config/lang");
+/**
+ * Class to invoke step in playwright runner.
+ */
+
+class StepInvoker {
+  world;
+  keyword;
+  constructor(world, keyword) {
+    this.world = world;
+    this.keyword = keyword;
+    this.invoke = this.invoke.bind(this);
+  }
+  /**
+     * Invokes particular step.
+     * See: https://github.com/cucumber/cucumber-js/blob/main/src/runtime/test_case_runner.ts#L299
+     */
+  async invoke(stepText, argument, stepFixtures) {
+    var _this$world$$internal;
+    this.world.$internal.currentStepFixtures = stepFixtures || {};
+    const stepDefinition = this.getStepDefinition(stepText);
+    // 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)(this.world.testInfo.file);
+    const stepTitle = this.getStepTitle(stepText);
+    const code = (0, _defineStep.getStepCode)(stepDefinition);
+    const parameters = await this.getStepParameters(stepDefinition, stepText, argument || undefined);
+    (_this$world$$internal = this.world.$internal.bddDataManager) === null || _this$world$$internal === void 0 || _this$world$$internal.registerStep(stepDefinition, stepText, location);
+    await (0, _testTypeImpl.runStepWithCustomLocation)(this.world.test, stepTitle, location, () => code.apply(this.world, parameters));
+  }
+  getStepDefinition(text) {
+    const stepDefinition = (0, _loadSteps.findStepDefinition)(this.world.options.supportCodeLibrary, text, this.world.testInfo.file);
+    if (!stepDefinition) {
+      throw new Error(`Undefined step: "${text}"`);
+    }
+    return stepDefinition;
+  }
+  async getStepParameters(stepDefinition, text, argument) {
+    // see: https://github.com/cucumber/cucumber-js/blob/main/src/models/step_definition.ts#L25
+    const {
+      parameters
+    } = await stepDefinition.getInvocationParameters({
+      hookParameter: {},
+      // only text and argument are needed
+      step: {
+        text,
+        argument
+      },
+      world: this.world
+    });
+    return parameters;
+  }
+  getStepTitle(text) {
+    // 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} ${text}` : text;
+  }
+}
+exports.StepInvoker = StepInvoker;

package/build/bdd-framework/run/bddData/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BddDataManager = void 0;
+exports.getBddDataFromTest = getBddDataFromTest;
+var _createTestStep = require("../../cucumber/createTestStep");
+var _utils = require("../../utils");
+var _utils2 = require("../../playwright/utils");
+const BDD_DATA_ANNOTATION_NAME = '__bddData';
+class BddDataManager {
+  testInfo;
+  data;
+  constructor(testInfo, testMeta, uri) {
+    this.testInfo = testInfo;
+    this.data = {
+      uri,
+      pickleLocation: testMeta.pickleLocation,
+      steps: []
+    };
+    this.save({
+      create: true
+    });
+  }
+  registerStep(stepDefinition, stepText, pwStepLocation) {
+    const step = (0, _createTestStep.createTestStep)(stepDefinition, stepText);
+    this.data.steps.push({
+      pwStepLocation: (0, _utils.stringifyLocation)(pwStepLocation),
+      stepMatchArgumentsLists: step.stepMatchArgumentsLists || []
+    });
+    this.save();
+  }
+  save({
+    create = false
+  } = {}) {
+    (0, _utils2.updateAnnotation)(this.testInfo, {
+      type: BDD_DATA_ANNOTATION_NAME,
+      description: JSON.stringify(this.data)
+    }, {
+      create
+    });
+  }
+}
+exports.BddDataManager = BddDataManager;
+function getBddDataFromTest({
+  annotations
+}) {
+  const annotationIndex = annotations.findIndex(isBddDataAnnotation);
+  const annotation = annotations[annotationIndex];
+  const bddData = annotation !== null && annotation !== void 0 && annotation.description ? JSON.parse(annotation.description) : undefined;
+  return {
+    bddData,
+    annotationIndex
+  };
+}
+function isBddDataAnnotation(annotation) {
+  return annotation.type === BDD_DATA_ANNOTATION_NAME;
+}

package/build/bdd-framework/run/bddData/types.js

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

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

@@ -0,0 +1,192 @@
+"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("../steps/decorators/steps");
+var _configDir = require("../config/configDir");
+var _scenario = require("../hooks/scenario");
+var _worker = require("../hooks/worker");
+var _StepInvoker = require("./StepInvoker");
+var _testMeta = require("../gen/testMeta");
+var _logger = require("../utils/logger");
+var _enrichReporterData = require("../config/enrichReporterData");
+var _bddData = require("./bddData");
+const test = exports.test = _test.test.extend({
+  // 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, _configDir.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);
+    await use({
+      runConfiguration,
+      supportCodeLibrary,
+      World,
+      config
+    });
+  }, {
+    auto: true,
+    scope: 'worker'
+  }],
+  // $lang fixture can be overwritten in test file
+  $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,
+    $testMeta,
+    $uri
+  }, use, testInfo) => {
+    const {
+      runConfiguration,
+      supportCodeLibrary,
+      World,
+      config
+    } = $cucumber;
+    const world = new World({
+      testInfo,
+      supportCodeLibrary,
+      $tags,
+      $test,
+      $bddWorldFixtures,
+      lang: $lang,
+      parameters: runConfiguration.runtime.worldParameters || {},
+      log: () => _logger.logger.warn(`world.log() is noop, please use world.testInfo.attach()`),
+      attach: async () => _logger.logger.warn(`world.attach() is noop, please use world.testInfo.attach()`)
+    });
+    if ((0, _enrichReporterData.getEnrichReporterData)(config)) {
+      world.$internal.bddDataManager = new _bddData.BddDataManager(testInfo, $testMeta, $uri);
+    }
+    await world.init();
+    await use(world);
+    await world.destroy();
+  },
+  Given: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Given').invoke),
+  When: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'When').invoke),
+  Then: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'Then').invoke),
+  And: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'And').invoke),
+  But: ({
+    $bddWorld
+  }, use) => use(new _StepInvoker.StepInvoker($bddWorld, 'But').invoke),
+  // init $testMetaMap with empty object, will be overwritten in each test file
+  $testMetaMap: ({}, use) => use({}),
+  // concrete test meta
+  $testMeta: ({
+    $testMetaMap
+  }, use, testInfo) => use((0, _testMeta.getTestMeta)($testMetaMap, testInfo)),
+  // concrete test tags
+  $tags: ({
+    $testMeta
+  }, use) => use($testMeta.tags || []),
+  // init $test with base test, but it will be overwritten in test file
+  $test: ({}, use) => use(_test.test),
+  // feature file uri, relative to configDir, will be overwritten in test file
+  $uri: ({}, use) => use(''),
+  // 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) {
+  return BDD_AUTO_INJECT_FIXTURES.includes(name);
+}