@zohodesk/testinglibrary 0.1.8-stb-bdd-v26 → 0.1.9-exp-actors

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

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestCase = void 0;
+var _utils = require("../../../utils");
+class TestCase {
+  id;
+  gherkinDocuments;
+  #pickle;
+  #projectInfo;
+  beforeHooks = new Map();
+  afterHooks = new Map();
+  mainSteps = [];
+  constructor(id, gherkinDocuments) {
+    this.id = id;
+    this.gherkinDocuments = gherkinDocuments;
+  }
+  get projectInfo() {
+    if (!this.#projectInfo) {
+      throw new Error(`Empty projectInfo for testCase: ${this.id}`);
+    }
+    return this.#projectInfo;
+  }
+  get pickle() {
+    if (!this.#pickle) {
+      throw new Error(`Empty pickle for testCase: ${this.id}`);
+    }
+    return this.#pickle;
+  }
+  addRun(testCaseRun) {
+    if (!this.#projectInfo) {
+      this.#projectInfo = testCaseRun.projectInfo;
+    }
+    this.addHooks(testCaseRun, 'before');
+    this.addHooks(testCaseRun, 'after');
+    if (!this.#pickle) {
+      this.#pickle = this.findPickle(testCaseRun.bddData);
+      this.addStepsFromPickle(this.#pickle);
+    }
+    this.addStepsArgumentsLists(testCaseRun);
+  }
+  getHooks(hookType) {
+    return hookType == 'before' ? this.beforeHooks : this.afterHooks;
+  }
+  getMainSteps() {
+    return this.mainSteps;
+  }
+  buildMessage() {
+    const testSteps = [...Array.from(this.beforeHooks.values()).map(hook => hook.testStep), ...(this.mainSteps || []), ...Array.from(this.afterHooks.values()).map(hook => hook.testStep)];
+    const testCase = {
+      id: this.id,
+      pickleId: this.pickle.id,
+      testSteps
+    };
+    return {
+      testCase
+    };
+  }
+  /**
+     * We collect hooks from all runs of this test case, avoiding duplicates.
+     */
+  addHooks(testCaseRun, hookType) {
+    const testCaseHooks = hookType === 'before' ? this.beforeHooks : this.afterHooks;
+    const testRunHooks = testCaseRun.getExecutedHooks(hookType);
+    testRunHooks.forEach(({
+      hook
+    }) => {
+      if (testCaseHooks.has(hook.internalId)) {
+        return;
+      }
+      const testStep = {
+        id: `${this.id}-${hookType}-${testCaseHooks.size}`,
+        hookId: hook.id
+      };
+      testCaseHooks.set(hook.internalId, {
+        hook,
+        testStep
+      });
+    });
+  }
+  /**
+     * Initially create steps from pickle steps, with empty stepMatchArgumentsLists.
+     */
+  addStepsFromPickle(pickle) {
+    this.mainSteps = pickle.steps.map((pickleStep, stepIndex) => {
+      return {
+        id: `${this.id}-step-${stepIndex}`,
+        pickleStepId: pickleStep.id,
+        stepDefinitionIds: [],
+        stepMatchArgumentsLists: []
+      };
+    });
+  }
+  /**
+     * Fill stepMatchArgumentsLists from all test runs.
+     * It allows to fill as many steps as possible.
+     * Possibly, we write the same stepMatchArgumentsLists several times,
+     * looks like it's not a problem as they should be equal for all runs.
+     */
+  addStepsArgumentsLists(testCaseRun) {
+    testCaseRun.bddData.steps.forEach((bddDataStep, stepIndex) => {
+      var _this$mainSteps;
+      const testCaseStep = (_this$mainSteps = this.mainSteps) === null || _this$mainSteps === void 0 ? void 0 : _this$mainSteps[stepIndex];
+      if (testCaseStep && bddDataStep.stepMatchArgumentsLists) {
+        testCaseStep.stepMatchArgumentsLists = bddDataStep.stepMatchArgumentsLists;
+      }
+    });
+  }
+  findPickle({
+    uri,
+    pickleLocation
+  }) {
+    const doc = this.gherkinDocuments.find(doc => doc.uri === uri);
+    if (!doc) {
+      throw new Error('GherkinDocument not found');
+    }
+    const pickle = doc.pickles.find(pickle => {
+      return (0, _utils.stringifyLocation)(pickle.location) === pickleLocation;
+    });
+    if (!pickle) {
+      throw new Error('Pickle not found');
+    }
+    return pickle;
+  }
+}
+exports.TestCase = TestCase;

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

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestCaseRun = void 0;
+var _utils = require("../../../utils");
+var _TestStepRun = require("./TestStepRun");
+var _timing = require("./timing");
+var _pwUtils = require("./pwUtils");
+var _bddDataAttachment = require("../../../run/bddDataAttachment");
+var _AttachmentMapper = require("./AttachmentMapper");
+var _TestCaseRunHooks = require("./TestCaseRunHooks");
+var _Projects = require("./Projects");
+class TestCaseRun {
+  test;
+  result;
+  hooks;
+  id;
+  bddData;
+  testCase;
+  attachmentMapper;
+  projectInfo;
+  executedBeforeHooks;
+  executedAfterHooks;
+  executedSteps;
+  // eslint-disable-next-line max-params
+  constructor(test, result, hooks) {
+    this.test = test;
+    this.result = result;
+    this.hooks = hooks;
+    this.id = this.generateTestRunId();
+    this.bddData = this.getBddData();
+    this.projectInfo = (0, _Projects.getProjectInfo)(this.test);
+    this.attachmentMapper = new _AttachmentMapper.AttachmentMapper(this.result);
+    this.executedSteps = this.fillExecutedSteps();
+    this.executedBeforeHooks = this.fillExecutedHooks('before');
+    this.executedAfterHooks = this.fillExecutedHooks('after');
+  }
+  getTestCase() {
+    if (!this.testCase) {
+      throw new Error(`TestCase is not set.`);
+    }
+    return this.testCase;
+  }
+  generateTestRunId() {
+    return `${this.test.id}-run-${this.result.retry}`;
+  }
+  getBddData() {
+    const bddData = (0, _bddDataAttachment.getBddDataFromTestResult)(this.result);
+    if (!bddData) {
+      throw new Error([`BDD data attachment is not found for test: ${this.test.title}`, `Did you set enrichReporterData: true in the Playwright config?`, ''].join('\n'));
+    }
+    return bddData;
+  }
+  fillExecutedSteps() {
+    const possiblePwSteps = this.getPossiblePlaywrightSteps();
+    return this.bddData.steps.map(bddDataStep => {
+      const pwStep = this.findPlaywrightStep(possiblePwSteps, bddDataStep);
+      return {
+        bddDataStep,
+        pwStep
+      };
+    });
+  }
+  fillExecutedHooks(hookType) {
+    return new _TestCaseRunHooks.TestCaseRunHooks(this, hookType).fill(this.executedSteps);
+  }
+  buildMessages() {
+    return [this.buildTestCaseStarted(), ...this.executedBeforeHooks.buildMessages(), ...this.buildStepRuns(), ...this.executedAfterHooks.buildMessages(), this.buildTestCaseFinished()];
+  }
+  getExecutedHooks(hookType) {
+    return hookType === 'before' ? this.executedBeforeHooks.executedHooks : this.executedAfterHooks.executedHooks;
+  }
+  buildTestCaseStarted() {
+    const testCaseStarted = {
+      id: this.id,
+      attempt: this.result.retry,
+      testCaseId: this.getTestCase().id,
+      // workerId: 'worker-1'
+      timestamp: (0, _timing.toCucumberTimestamp)(this.result.startTime.getTime())
+    };
+    return {
+      testCaseStarted
+    };
+  }
+  buildStepRuns() {
+    return this.getTestCase().getMainSteps().reduce((messages, testStep, stepIndex) => {
+      const {
+        pwStep
+      } = this.executedSteps[stepIndex] || {};
+      const testStepRun = new _TestStepRun.TestStepRun(this, testStep, pwStep);
+      return messages.concat(testStepRun.buildMessages());
+    }, []);
+  }
+  buildTestCaseFinished() {
+    const {
+      startTime,
+      duration
+    } = this.result;
+    const testCaseFinished = {
+      testCaseStartedId: this.id,
+      willBeRetried: Boolean(this.result.error && this.result.retry < this.test.retries),
+      timestamp: (0, _timing.toCucumberTimestamp)(startTime.getTime() + duration)
+    };
+    return {
+      testCaseFinished
+    };
+  }
+  findPlaywrightStep(possiblePwSteps, bddDataStep) {
+    const pwStep = possiblePwSteps.find(pwStep => {
+      return pwStep.location && (0, _utils.stringifyLocation)(pwStep.location) === bddDataStep.pwStepLocation;
+    });
+    if (!pwStep) {
+      throw new Error('Playwright step not found for bdd step');
+    }
+    return pwStep;
+  }
+  getPossiblePlaywrightSteps() {
+    const beforeHooksRoot = (0, _pwUtils.getHooksRootStep)(this.result, 'before');
+    const bgSteps = (0, _pwUtils.collectStepsWithCategory)(beforeHooksRoot, 'test.step');
+    const topLevelSteps = this.result.steps.filter(step => step.category === 'test.step');
+    return [...bgSteps, ...topLevelSteps];
+  }
+}
+exports.TestCaseRun = TestCaseRun;

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

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TestCaseRunHooks = void 0;
+var _Hook = require("./Hook");
+var _pwUtils = require("./pwUtils");
+var _TestStepRun = require("./TestStepRun");
+class TestCaseRunHooks {
+  testCaseRun;
+  hookType;
+  rootStep;
+  candidateSteps = [];
+  hookSteps = new Set();
+  executedHooks = new Map();
+  constructor(testCaseRun, hookType) {
+    this.testCaseRun = testCaseRun;
+    this.hookType = hookType;
+  }
+  fill(mainSteps) {
+    this.setRootStep();
+    this.setCandidateSteps();
+    this.addStepsWithName();
+    this.addStepsWithAttachment();
+    this.addStepWithError();
+    this.excludeBackgroundSteps(mainSteps);
+    this.setExecutedHooks();
+    return this;
+  }
+  buildMessages() {
+    const messages = [];
+    this.testCaseRun.getTestCase().getHooks(this.hookType).forEach(hookInfo => {
+      const executedHook = this.executedHooks.get(hookInfo.hook.internalId);
+      // todo: if pwStep is not found in this.executedBeforeHooks,
+      // it means that this hook comes from another run of this test case.
+      // We can stil try to find it in test result, as otherwise it will be marked as skipped,
+      // but actually it was executed.
+      const testStepRun = new _TestStepRun.TestStepRun(this.testCaseRun, hookInfo.testStep, executedHook === null || executedHook === void 0 ? void 0 : executedHook.pwStep);
+      messages.push(...testStepRun.buildMessages());
+    });
+    return messages;
+  }
+  setRootStep() {
+    this.rootStep = (0, _pwUtils.getHooksRootStep)(this.testCaseRun.result, this.hookType);
+  }
+  setCandidateSteps() {
+    if (this.rootStep) {
+      this.candidateSteps.push(this.rootStep);
+    }
+    this.candidateSteps.push(...(0, _pwUtils.collectStepsDfs)(this.rootStep));
+  }
+  addStepsWithName() {
+    this.candidateSteps.forEach(pwStep => {
+      if (pwStep.category === 'test.step' && pwStep.title) {
+        this.hookSteps.add(pwStep);
+      }
+    });
+  }
+  addStepsWithAttachment() {
+    const {
+      attachmentMapper
+    } = this.testCaseRun;
+    this.candidateSteps.forEach(pwStep => {
+      if (attachmentMapper.getStepAttachments(pwStep).length > 0) {
+        this.hookSteps.add(pwStep);
+      }
+    });
+  }
+  addStepWithError() {
+    const stepWithError = (0, _pwUtils.findDeepestErrorStep)(this.rootStep);
+    if (stepWithError) {
+      this.hookSteps.add(stepWithError);
+      // in Playwright error is inherited by all parent steps,
+      // but we want to show it once (in the deepest step)
+      this.hookSteps.forEach(step => {
+        if (step !== stepWithError) {
+          delete step.error;
+        }
+      });
+    }
+  }
+  excludeBackgroundSteps(mainSteps) {
+    // exclude background steps, b/c they are in pickle, not in hooks.
+    // Important to run this fn after this.fillExecutedSteps()
+    // as we assume steps are already populated
+    if (this.hookType === 'before') {
+      mainSteps.forEach(stepInfo => this.hookSteps.delete(stepInfo.pwStep));
+    }
+  }
+  setExecutedHooks() {
+    this.hookSteps.forEach(pwStep => {
+      const internalId = _Hook.Hook.getInternalId(pwStep);
+      const hook = this.testCaseRun.hooks.getOrCreate(internalId, () => new _Hook.Hook(internalId, pwStep));
+      this.executedHooks.set(internalId, {
+        hook,
+        pwStep
+      });
+    });
+  }
+}
+exports.TestCaseRunHooks = TestCaseRunHooks;

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

@@ -0,0 +1,50 @@
+"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"));
+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) {
+    return pwAttachment.path ? _fs.default.readFileSync(pwAttachment.path, 'base64') : pwAttachment.body.toString('base64');
+  }
+}
+exports.TestStepAttachments = TestStepAttachments;

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

@@ -0,0 +1,88 @@
+"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()];
+  }
+  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() {
+    var _this$pwStep;
+    const error = (_this$pwStep = this.pwStep) === null || _this$pwStep === void 0 ? void 0 : _this$pwStep.error;
+    const testStepFinished = {
+      testCaseStartedId: this.testCaseRun.id,
+      testStepId: this.testStep.id,
+      testStepResult: {
+        duration: messages.TimeConversion.millisecondsToDuration(this.duration),
+        status: this.getStatus(error),
+        message: error ? formatError(error) : undefined,
+        exception: error ? this.buildException(error) : undefined
+      },
+      timestamp: (0, _timing.toCucumberTimestamp)(this.startTime.getTime() + this.duration)
+    };
+    return {
+      testStepFinished
+    };
+  }
+  buildException(error) {
+    return {
+      type: 'Error',
+      message: error.message ? (0, _stripAnsiEscapes.stripAnsiEscapes)(error.message) : undefined,
+      stackTrace: error.stack ? (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
+    };
+  }
+  getStatus(error) {
+    switch (true) {
+      case !this.wasExecuted():
+        return messages.TestStepResultStatus.SKIPPED;
+      case Boolean(error):
+        return messages.TestStepResultStatus.FAILED;
+      default:
+        return messages.TestStepResultStatus.PASSED;
+    }
+  }
+}
+exports.TestStepRun = TestStepRun;
+function formatError(error) {
+  return (0, _stripAnsiEscapes.stripAnsiEscapes)([error.message, error.snippet].filter(Boolean).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/pwUtils.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collectStepsDfs = collectStepsDfs;
+exports.collectStepsWithCategory = collectStepsWithCategory;
+exports.findDeepestErrorStep = findDeepestErrorStep;
+exports.getHooksRootStep = getHooksRootStep;
+/**
+ * Utility functions for filtering Playwright steps.
+ */
+// Playwright step categoires, that can be mapped to testStep / hook in Cucumber report
+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 getHooksRootStep(result, type) {
+  const rootStepTitle = type === 'before' ? 'Before Hooks' : 'After Hooks';
+  return result.steps.find(step => step.category === 'hook' && step.title === rootStepTitle);
+}
+/**
+ * Drills down to the deepest error step.
+ */
+function findDeepestErrorStep(root) {
+  let errorStep = root !== null && root !== void 0 && root.error ? root : null;
+  while (errorStep) {
+    const nextErrorStep = errorStep.steps.find(step => {
+      return step.error && MEANINGFUL_STEP_CATEGORIES.includes(step.category);
+    });
+    if (!nextErrorStep) {
+      break;
+    }
+    errorStep = nextErrorStep;
+  }
+  return errorStep;
+}
+/**
+ * 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;
+  }, [])) || [];
+}

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,68 @@
+"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 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(text, argument, stepFixtures) {
+    this.world.$internal.currentStepFixtures = stepFixtures || {};
+    const stepDefinition = this.getStepDefinition(text);
+    // 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(text);
+    const code = (0, _defineStep.getStepCode)(stepDefinition);
+    const parameters = await this.getStepParameters(stepDefinition, text, argument || undefined);
+    this.world.$internal.bddData.registerStep(stepDefinition, text, location);
+    return (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;