@zohodesk/testinglibrary 0.1.8 → 0.1.9

package/build/bdd-framework/reporter/cucumber/json.js

@@ -0,0 +1,312 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var messages = _interopRequireWildcard(require("@cucumber/messages"));
+var _base = _interopRequireDefault(require("./base"));
+var GherkinDocumentParser = _interopRequireWildcard(require("../../cucumber/formatter/GherkinDocumentParser"));
+var PickleParser = _interopRequireWildcard(require("../../cucumber/formatter/PickleParser"));
+var _valueChecker = require("../../cucumber/valueChecker");
+var _stepArguments = require("../../cucumber/stepArguments");
+var _durationHelpers = require("../../cucumber/formatter/durationHelpers");
+var _locationHelpers = require("../../cucumber/formatter/locationHelpers");
+var _GherkinDocument = require("./messagesBuilder/GherkinDocument");
+var _Projects = require("./messagesBuilder/Projects");
+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; }
+/**
+ * Cucumber json reporter.
+ * Based on: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/json_formatter.ts
+ *
+ * Although json reporter is marked as deprecated in CucumberJS docs
+ * (see https://github.com/cucumber/cucumber-js/blob/main/docs/formatters.md#json),
+ * this decision was rolled back:
+ * (see https://github.com/cucumber/json-formatter/issues/34).
+ *
+ * See also: separate tool to convert cucumber messages to cucumber json:
+ * https://github.com/vrymar/cucumber-json-report-formatter/tree/master
+ */
+/* eslint-disable max-lines, max-statements, max-nested-callbacks, complexity */
+
+const {
+  getGherkinExampleRuleMap,
+  getGherkinScenarioLocationMap,
+  getGherkinStepMap,
+  getGherkinScenarioMap
+} = GherkinDocumentParser;
+const {
+  getScenarioDescription,
+  getPickleStepMap,
+  getStepKeyword
+} = PickleParser;
+class JsonReporter extends _base.default {
+  userOptions;
+  // for now omit step definitions
+  supportCodeLibrary = {
+    stepDefinitions: []
+  };
+  constructor(internalOptions, userOptions = {}) {
+    super(internalOptions);
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+    this.eventBroadcaster.on('envelope', envelope => {
+      if ((0, _valueChecker.doesHaveValue)(envelope.testRunFinished)) {
+        this.onTestRunFinished();
+      }
+    });
+  }
+  convertNameToId(obj) {
+    return obj.name.replace(/ /g, '-').toLowerCase();
+  }
+  formatDataTable(dataTable) {
+    return {
+      rows: dataTable.rows.map(row => ({
+        cells: row.cells.map(x => x.value)
+      }))
+    };
+  }
+  formatDocString(docString, gherkinStep) {
+    var _gherkinStep$docStrin;
+    return {
+      content: docString.content,
+      line: (_gherkinStep$docStrin = gherkinStep.docString) === null || _gherkinStep$docStrin === void 0 ? void 0 : _gherkinStep$docStrin.location.line
+    };
+  }
+  formatStepArgument(stepArgument, gherkinStep) {
+    if ((0, _valueChecker.doesNotHaveValue)(stepArgument)) {
+      return [];
+    }
+    return [(0, _stepArguments.parseStepArgument)(stepArgument, {
+      dataTable: dataTable => this.formatDataTable(dataTable),
+      docString: docString => this.formatDocString(docString, gherkinStep)
+    })];
+  }
+  onTestRunFinished() {
+    const groupedTestCaseAttempts = {};
+    this.eventDataCollector.getTestCaseAttempts().forEach(testCaseAttempt => {
+      if (!testCaseAttempt.willBeRetried) {
+        const uri = testCaseAttempt.pickle.uri;
+        if ((0, _valueChecker.doesNotHaveValue)(groupedTestCaseAttempts[uri])) {
+          groupedTestCaseAttempts[uri] = [];
+        }
+        groupedTestCaseAttempts[uri].push(testCaseAttempt);
+      }
+    });
+    const features = Object.keys(groupedTestCaseAttempts).map(uri => {
+      const group = groupedTestCaseAttempts[uri];
+      const {
+        gherkinDocument
+      } = group[0];
+      const gherkinStepMap = getGherkinStepMap(gherkinDocument);
+      const gherkinScenarioMap = getGherkinScenarioMap(gherkinDocument);
+      const gherkinExampleRuleMap = getGherkinExampleRuleMap(gherkinDocument);
+      const gherkinScenarioLocationMap = getGherkinScenarioLocationMap(gherkinDocument);
+      const elements = group.map(testCaseAttempt => {
+        const {
+          pickle
+        } = testCaseAttempt;
+        const pickleStepMap = getPickleStepMap(pickle);
+        let isBeforeHook = true;
+        const steps = testCaseAttempt.testCase.testSteps.map(testStep => {
+          isBeforeHook = isBeforeHook && !(0, _valueChecker.doesHaveValue)(testStep.pickleStepId);
+          return this.getStepData({
+            isBeforeHook,
+            gherkinStepMap,
+            pickleStepMap,
+            testStep,
+            testStepAttachments: testCaseAttempt.stepAttachments[testStep.id],
+            testStepResult: testCaseAttempt.stepResults[testStep.id]
+          });
+        });
+        return this.getScenarioData({
+          feature: gherkinDocument.feature,
+          gherkinScenarioLocationMap,
+          gherkinExampleRuleMap,
+          gherkinScenarioMap,
+          pickle,
+          steps
+        });
+      });
+      return this.getFeatureData({
+        gherkinDocument,
+        elements
+      });
+    });
+    this.outputStream.write(JSON.stringify(features, null, 2));
+  }
+  getFeatureData({
+    gherkinDocument,
+    elements
+  }) {
+    const meta = _GherkinDocument.GherkinDocumentMessage.extractMeta(gherkinDocument);
+    const feature = gherkinDocument.feature;
+    const featureNameWithProject = (0, _Projects.getFeatureNameWithProject)(meta.projectName, feature.name);
+    return {
+      description: feature.description,
+      elements,
+      id: this.convertNameToId({
+        name: featureNameWithProject
+      }),
+      line: feature.location.line,
+      keyword: feature.keyword,
+      name: this.userOptions.addProjectToFeatureName ? featureNameWithProject : feature.name,
+      tags: this.getFeatureTags(feature),
+      uri: meta.originalUri,
+      metadata: this.getFeatureMetadata(gherkinDocument)
+    };
+  }
+  getFeatureMetadata(gherkinDocument) {
+    if (!this.userOptions.addMetadata) {
+      return;
+    }
+    const meta = _GherkinDocument.GherkinDocumentMessage.extractMeta(gherkinDocument);
+    const metadata = {
+      Project: meta.projectName || '',
+      Browser: meta.browserName || ''
+    };
+    return this.userOptions.addMetadata === 'object' ? metadata : Object.keys(metadata).map(name => ({
+      name,
+      value: metadata[name]
+    }));
+  }
+  getScenarioData({
+    feature,
+    gherkinScenarioLocationMap,
+    gherkinExampleRuleMap,
+    gherkinScenarioMap,
+    pickle,
+    steps
+  }) {
+    const description = getScenarioDescription({
+      pickle,
+      gherkinScenarioMap
+    });
+    return {
+      description,
+      id: this.formatScenarioId({
+        feature,
+        pickle,
+        gherkinExampleRuleMap
+      }),
+      keyword: gherkinScenarioMap[pickle.astNodeIds[0]].keyword,
+      line: gherkinScenarioLocationMap[pickle.astNodeIds[pickle.astNodeIds.length - 1]].line,
+      name: pickle.name,
+      steps,
+      tags: this.getScenarioTags({
+        feature,
+        pickle,
+        gherkinScenarioMap
+      }),
+      type: 'scenario'
+    };
+  }
+  formatScenarioId({
+    feature,
+    pickle,
+    gherkinExampleRuleMap
+  }) {
+    let parts;
+    const rule = gherkinExampleRuleMap[pickle.astNodeIds[0]];
+    if ((0, _valueChecker.doesHaveValue)(rule)) {
+      parts = [feature, rule, pickle];
+    } else {
+      parts = [feature, pickle];
+    }
+    return parts.map(part => this.convertNameToId(part)).join(';');
+  }
+  getStepData({
+    isBeforeHook,
+    gherkinStepMap,
+    pickleStepMap,
+    testStep,
+    testStepAttachments,
+    testStepResult
+  }) {
+    const data = {};
+    if ((0, _valueChecker.doesHaveValue)(testStep.pickleStepId)) {
+      const pickleStep = pickleStepMap[testStep.pickleStepId];
+      data.arguments = this.formatStepArgument(pickleStep.argument, gherkinStepMap[pickleStep.astNodeIds[0]]);
+      data.keyword = getStepKeyword({
+        pickleStep,
+        gherkinStepMap
+      });
+      data.line = gherkinStepMap[pickleStep.astNodeIds[0]].location.line;
+      data.name = pickleStep.text;
+    } else {
+      data.keyword = isBeforeHook ? 'Before' : 'After';
+      data.hidden = true;
+    }
+    if ((0, _valueChecker.doesHaveValue)(testStep.stepDefinitionIds) && testStep.stepDefinitionIds.length === 1) {
+      const stepDefinition = this.supportCodeLibrary.stepDefinitions.find(s => {
+        var _testStep$stepDefinit;
+        return s.id === ((_testStep$stepDefinit = testStep.stepDefinitionIds) === null || _testStep$stepDefinit === void 0 ? void 0 : _testStep$stepDefinit[0]);
+      });
+      if ((0, _valueChecker.doesHaveValue)(stepDefinition)) {
+        data.match = {
+          location: (0, _locationHelpers.formatLocation)(stepDefinition)
+        };
+      }
+    }
+    const {
+      message,
+      status
+    } = testStepResult;
+    data.result = {
+      status: messages.TestStepResultStatus[status].toLowerCase()
+    };
+    if ((0, _valueChecker.doesHaveValue)(testStepResult.duration)) {
+      data.result.duration = (0, _durationHelpers.durationToNanoseconds)(testStepResult.duration);
+    }
+    if (status === messages.TestStepResultStatus.FAILED && (0, _valueChecker.doesHaveValue)(message)) {
+      data.result.error_message = message;
+    }
+    const allowedAttachments = this.getAllowedAttachments(testStepAttachments);
+    if (allowedAttachments && allowedAttachments.length > 0) {
+      data.embeddings = allowedAttachments.map(attachment => ({
+        data: attachment.contentEncoding === messages.AttachmentContentEncoding.IDENTITY ? Buffer.from(attachment.body).toString('base64') : attachment.body,
+        mime_type: attachment.mediaType
+      }));
+    }
+    return data;
+  }
+  getFeatureTags(feature) {
+    return feature.tags.map(tagData => ({
+      name: tagData.name,
+      line: tagData.location.line
+    }));
+  }
+  getScenarioTags({
+    feature,
+    pickle,
+    gherkinScenarioMap
+  }) {
+    const scenario = gherkinScenarioMap[pickle.astNodeIds[0]];
+    return pickle.tags.map(tagData => this.getScenarioTag(tagData, feature, scenario));
+  }
+  getScenarioTag(tagData, feature, scenario) {
+    var _tag$location;
+    const byAstNodeId = tag => tag.id === tagData.astNodeId;
+    const flatten = (acc, val) => acc.concat(val);
+    const tag = feature.tags.find(byAstNodeId) || scenario.tags.find(byAstNodeId) || scenario.examples.map(e => e.tags).reduce((acc, val) => flatten(acc, val), []).find(byAstNodeId);
+    return {
+      name: tagData.name,
+      line: tag === null || tag === void 0 || (_tag$location = tag.location) === null || _tag$location === void 0 ? void 0 : _tag$location.line
+    };
+  }
+  getAllowedAttachments(testStepAttachments) {
+    const {
+      skipAttachments
+    } = this.userOptions;
+    if (Array.isArray(skipAttachments)) {
+      return testStepAttachments === null || testStepAttachments === void 0 ? void 0 : testStepAttachments.filter(attachment => {
+        return !skipAttachments.includes(attachment.mediaType);
+      });
+    } else {
+      return skipAttachments ? [] : testStepAttachments;
+    }
+  }
+}
+exports.default = JsonReporter;

package/build/bdd-framework/reporter/cucumber/junit.js

@@ -0,0 +1,205 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _xmlbuilder = _interopRequireDefault(require("xmlbuilder"));
+var _messages = require("@cucumber/messages");
+var _base = _interopRequireDefault(require("./base"));
+var _valueChecker = require("../../cucumber/valueChecker");
+var _GherkinDocumentParser = require("../../cucumber/formatter/GherkinDocumentParser");
+var _PickleParser = require("../../cucumber/formatter/PickleParser");
+var _GherkinDocument = require("./messagesBuilder/GherkinDocument");
+var _Projects = require("./messagesBuilder/Projects");
+/**
+ * Cucumber junit reporter.
+ * Based on: https://github.com/cucumber/cucumber-js/blob/main/src/formatter/junit_formatter.ts
+ * Junit spec(ish): https://github.com/testmoapp/junitxml
+ * See also: https://github.com/cucumber/cucumber-junit-xml-formatter
+ * See also: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/reporters/junit.ts
+ */
+/* eslint-disable complexity, max-lines, max-statements */
+
+class JunitReporter extends _base.default {
+  userOptions;
+  names = {};
+  constructor(internalOptions, userOptions = {}) {
+    super(internalOptions);
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+    this.eventBroadcaster.on('envelope', envelope => {
+      if ((0, _valueChecker.doesHaveValue)(envelope.testRunFinished)) {
+        this.onTestRunFinished();
+      }
+    });
+  }
+  get suiteName() {
+    return (0, _valueChecker.valueOrDefault)(this.userOptions.suiteName, 'cucumber-js');
+  }
+  getTestCases() {
+    return this.eventDataCollector.getTestCaseAttempts().filter(attempt => !attempt.willBeRetried);
+  }
+  getTestSteps(testCaseAttempt, gherkinStepMap, pickleStepMap) {
+    return testCaseAttempt.testCase.testSteps.map(testStep => {
+      const isBeforeHook = !(0, _valueChecker.doesHaveValue)(testStep.pickleStepId);
+      return this.getTestStep({
+        isBeforeHook,
+        gherkinStepMap,
+        pickleStepMap,
+        testStep,
+        testStepAttachments: testCaseAttempt.stepAttachments[testStep.id],
+        testStepResult: testCaseAttempt.stepResults[testStep.id]
+      });
+    });
+  }
+  getTestStep({
+    isBeforeHook,
+    gherkinStepMap,
+    pickleStepMap,
+    testStep,
+    testStepAttachments,
+    testStepResult
+  }) {
+    const data = {};
+    if (testStep.pickleStepId) {
+      const pickleStep = pickleStepMap[testStep.pickleStepId];
+      data.keyword = (0, _PickleParser.getStepKeyword)({
+        pickleStep,
+        gherkinStepMap
+      });
+      data.line = gherkinStepMap[pickleStep.astNodeIds[0]].location.line;
+      data.name = pickleStep.text;
+    } else {
+      data.keyword = isBeforeHook ? 'Before' : 'After';
+      data.hidden = true;
+    }
+    data.result = testStepResult;
+    data.time = testStepResult.duration ? this.durationToSeconds(testStepResult.duration) : 0;
+    data.attachments = testStepAttachments;
+    return data;
+  }
+  getTestCaseResult(steps) {
+    const {
+      status,
+      message,
+      exception
+    } = (0, _messages.getWorstTestStepResult)(steps.map(step => step.result));
+    return {
+      status,
+      failure: message || exception ? {
+        type: (exception === null || exception === void 0 ? void 0 : exception.type) || '',
+        message: exception === null || exception === void 0 ? void 0 : exception.message,
+        detail: message || ''
+      } : undefined
+    };
+  }
+  durationToSeconds(duration) {
+    const NANOS_IN_SECOND = 1_000_000_000;
+    return (duration.seconds * NANOS_IN_SECOND + duration.nanos) / NANOS_IN_SECOND;
+  }
+  nameOrDefault(name, fallbackSuffix) {
+    if (!name) {
+      return `(unnamed ${fallbackSuffix})`;
+    }
+    return name;
+  }
+  getTestCaseName(featureName, rule, pickle) {
+    const pickleName = this.nameOrDefault(pickle.name, 'scenario');
+    const testCaseName = [featureName, rule ? this.nameOrDefault(rule.name, 'rule') : '', pickleName].filter(Boolean).join(_Projects.TITLE_SEPARATOR);
+    if (!this.names[featureName]) {
+      this.names[featureName] = [];
+    }
+    let index = 0;
+    while (this.names[featureName].includes(index > 0 ? `${testCaseName} [${index}]` : testCaseName)) {
+      index++;
+    }
+    const name = index > 0 ? `${testCaseName} [${index}]` : testCaseName;
+    this.names[featureName].push(name);
+    return name;
+  }
+  formatTestSteps(steps) {
+    return steps.filter(step => !step.hidden).map(step => {
+      const statusText = step.result.status.toLowerCase();
+      const maxLength = 80 - statusText.length - 3;
+      const stepText = `${step.keyword}${step.name}`.padEnd(maxLength, '.').substring(0, maxLength);
+      return `${stepText}...${statusText}`;
+    }).join('\n');
+  }
+  onTestRunFinished() {
+    const testCases = this.getTestCases();
+    const tests = testCases.map(testCaseAttempt => {
+      const {
+        gherkinDocument,
+        pickle
+      } = testCaseAttempt;
+      const {
+        feature
+      } = gherkinDocument;
+      if (!feature) {
+        throw new Error(`Gherkin document without feature: ${gherkinDocument.uri}`);
+      }
+      const meta = _GherkinDocument.GherkinDocumentMessage.extractMeta(gherkinDocument);
+      const gherkinExampleRuleMap = (0, _GherkinDocumentParser.getGherkinExampleRuleMap)(gherkinDocument);
+      const rule = gherkinExampleRuleMap[pickle.astNodeIds[0]];
+      const gherkinStepMap = (0, _GherkinDocumentParser.getGherkinStepMap)(gherkinDocument);
+      const pickleStepMap = (0, _PickleParser.getPickleStepMap)(pickle);
+      const steps = this.getTestSteps(testCaseAttempt, gherkinStepMap, pickleStepMap);
+      const stepDuration = steps.reduce((total, step) => total + (step.time || 0), 0);
+      const featureName = this.nameOrDefault(feature.name, 'feature');
+      const featureNameWithProject = (0, _Projects.getFeatureNameWithProject)(meta.projectName, featureName);
+      return {
+        classname: featureName,
+        // always add project to testcase name
+        // see: https://github.com/microsoft/playwright/issues/23432
+        name: this.getTestCaseName(featureNameWithProject, rule, pickle),
+        time: stepDuration,
+        result: this.getTestCaseResult(steps),
+        systemOutput: this.formatTestSteps(steps),
+        steps
+      };
+    });
+    const passed = tests.filter(item => item.result.status === _messages.TestStepResultStatus.PASSED).length;
+    const skipped = tests.filter(item => item.result.status === _messages.TestStepResultStatus.SKIPPED).length;
+    const failures = tests.length - passed - skipped;
+    const testSuite = {
+      name: this.suiteName,
+      tests,
+      failures,
+      skipped,
+      time: tests.reduce((total, test) => total + test.time, 0)
+    };
+    this.outputStream.write(this.buildXmlReport(testSuite));
+  }
+  buildXmlReport(testSuite) {
+    const xmlReport = _xmlbuilder.default.create('testsuite', {
+      encoding: 'UTF-8',
+      invalidCharReplacement: ''
+    }).att('failures', testSuite.failures).att('skipped', testSuite.skipped).att('name', testSuite.name).att('time', testSuite.time).att('tests', testSuite.tests.length);
+    testSuite.tests.forEach(test => {
+      const xmlTestCase = xmlReport.ele('testcase', {
+        classname: test.classname,
+        name: test.name,
+        time: test.time
+      });
+      if (test.result.status === _messages.TestStepResultStatus.SKIPPED) {
+        xmlTestCase.ele('skipped');
+      } else if (test.result.status !== _messages.TestStepResultStatus.PASSED) {
+        var _test$result$failure, _test$result$failure2, _test$result;
+        const xmlFailure = xmlTestCase.ele('failure', {
+          type: (_test$result$failure = test.result.failure) === null || _test$result$failure === void 0 ? void 0 : _test$result$failure.type,
+          message: (_test$result$failure2 = test.result.failure) === null || _test$result$failure2 === void 0 ? void 0 : _test$result$failure2.message
+        });
+        if ((_test$result = test.result) !== null && _test$result !== void 0 && _test$result.failure) {
+          xmlFailure.cdata(test.result.failure.detail);
+        }
+      }
+      xmlTestCase.ele('system-out', {}).cdata(test.systemOutput);
+    });
+    return xmlReport.end({
+      pretty: true
+    });
+  }
+}
+exports.default = JunitReporter;

package/build/bdd-framework/reporter/cucumber/message.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _base = _interopRequireDefault(require("./base"));
+class MessageReporter extends _base.default {
+  userOptions;
+  constructor(internalOptions, userOptions = {}) {
+    super(internalOptions);
+    this.userOptions = userOptions;
+    this.setOutputStream(this.userOptions.outputFile);
+    this.eventBroadcaster.on('envelope', envelope => {
+      this.outputStream.write(JSON.stringify(envelope) + '\n');
+    });
+  }
+}
+exports.default = MessageReporter;

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

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AttachmentMapper = void 0;
+var _AutofillMap = require("../../../utils/AutofillMap");
+var _pwUtils = require("./pwUtils");
+var _bddDataAttachment = require("../../../run/bddDataAttachment");
+class AttachmentMapper {
+  result;
+  stepAttachments = new _AutofillMap.AutofillMap();
+  unusedAttachments = [];
+  constructor(result) {
+    this.result = result;
+    this.mapAttachments();
+  }
+  getStepAttachments(pwStep) {
+    return this.stepAttachments.get(pwStep) || [];
+  }
+  mapAttachments() {
+    const allAttachments = this.result.attachments.slice();
+    const attachmentSteps = (0, _pwUtils.collectStepsWithCategory)(this.result, 'attach');
+    attachmentSteps.forEach(attachmentStep => {
+      this.mapAttachment(attachmentStep, allAttachments);
+    });
+    this.unusedAttachments.push(...allAttachments);
+    this.mapUnusedAttachments();
+  }
+  mapAttachment(attachmentStep, allAttachments) {
+    const index = allAttachments.findIndex(a => getAttachmentStepTitle(a.name) === attachmentStep.title);
+    if (index === -1) {
+      throw new Error(`Attachment not found for step: ${attachmentStep.title}`);
+    }
+    const [foundAttachment] = allAttachments.splice(index, 1);
+    if ((0, _bddDataAttachment.isBddDataAttachment)(foundAttachment)) {
+      return;
+    }
+    const parentStep = attachmentStep.parent;
+    // step.parent is empty:
+    // - in PW = 1.34 for screenshot attachment
+    // - in PW <= 1.40 when testInfo.attach() promise
+    // is awaited in the next async tick: 'attach' steps are on the top level
+    const stepAttachments = parentStep ? this.stepAttachments.getOrCreate(parentStep, () => []) : this.unusedAttachments;
+    stepAttachments.push(foundAttachment);
+  }
+  mapUnusedAttachments() {
+    if (!this.unusedAttachments.length) {
+      return;
+    }
+    // map unused attachments to the 'After Hooks' step
+    const afterHooksRoot = (0, _pwUtils.getHooksRootStep)(this.result, 'after');
+    if (!afterHooksRoot) {
+      throw new Error(`Can not find after hooks root to attach unused attachments.`);
+    }
+    const stepAttachments = this.stepAttachments.getOrCreate(afterHooksRoot, () => []);
+    stepAttachments.push(...this.unusedAttachments);
+  }
+}
+// See: https://github.com/microsoft/playwright/blob/main/packages/playwright/src/worker/testInfo.ts#L413
+exports.AttachmentMapper = AttachmentMapper;
+function getAttachmentStepTitle(attachmentName) {
+  return `attach "${attachmentName}"`;
+}