cucumberjs-qase-reporter 2.0.0-beta.1 → 2.0.0-beta.3

package/changelog.md

@@ -0,0 +1,31 @@
+# qase-cucumberjs@2.0.0-beta.3
+
+## What's new
+
+Added support new Qase tags.
+
+```diff
+-  @Q-1
++  @QaseID=2
++  @QaseTitle=Scenario_with_Qase_title_tag
++  @QaseFields={"description":"Description","severity":"high"}
+  Scenario: simple test
+```
+
+QaseID - is a unique identifier of the test case in the Qase TMS.
+QaseTitle - is a title of the test case in the Qase TMS.
+QaseFields - is a JSON object with additional fields for the test case in the Qase TMS.
+
+# qase-cucumberjs@2.0.0-beta.2
+
+## What's new
+
+Added support gherkin steps.
+Before this version, the reporter was not able to parse the steps from the feature files.
+Now, the reporter can parse the steps and send them to the Qase TMS.
+
+# qase-cucumberjs@2.0.0-beta.1
+
+## What's new
+
+First major beta release for the version 2 series of the Qase Cypress reporter.

package/dist/models.d.ts

@@ -0,0 +1,5 @@
+interface TestMetadata {
+    ids: number[];
+    fields: Record<string, string>;
+    title: string | null;
+}

package/dist/models.js

@@ -0,0 +1 @@
+"use strict";

package/dist/reporter.d.ts

@@ -1,6 +1,5 @@
-import { Formatter, IFormatterOptions, Status } from '@cucumber/cucumber';
-import { ConfigType, ConfigLoader, TestStatusEnum } from 'qase-javascript-commons';
-type TestStepResultStatus = (typeof Status)[keyof typeof Status];
+import { Formatter, IFormatterOptions } from '@cucumber/cucumber';
+import { ConfigLoader, ConfigType } from 'qase-javascript-commons';
 export type CucumberQaseOptionsType = IFormatterOptions & {
     qase?: ConfigType;
 };
@@ -9,55 +8,11 @@ export type CucumberQaseOptionsType = IFormatterOptions & {
  * @extends Formatter
  */
 export declare class CucumberQaseReporter extends Formatter {
-    /**
-     * @type {Record<TestStepResultStatus, TestStatusEnum | null>}
-     */
-    static statusMap: Record<TestStepResultStatus, TestStatusEnum | null>;
-    /**
-     * @type {RegExp}
-     */
-    static qaseIdRegExp: RegExp;
-    /**
-     * @param {readonly PickleTag[]} tagsList
-     * @returns {number[]}
-     * @private
-     */
-    private static getCaseIds;
-    /**
-     * @type {Record<string, PickleInfoType>}
-     * @private
-     */
-    private pickleInfo;
-    /**
-     * @type {Record<string, TestCaseStarted>}
-     * @private
-     */
-    private testCaseStarts;
-    /**
-     * @type {Record<string, >}
-     * @private
-     */
-    private testCaseStartedResult;
-    /**
-     * @type {Record<string, string[]>}
-     * @private
-     */
-    private testCaseStartedErrors;
-    /**
-     * @type {Record<string, string>}
-     * @private
-     */
-    private testCaseScenarioId;
     /**
      * @type {Record<string, string>}
      * @private
      */
-    private scenarios;
-    /**
-     * @type {Record<string, string>}
-     * @private
-     */
-    private attachments;
+    private storage;
     /**
      * @type {ReporterInterface}
      * @private
@@ -82,5 +37,9 @@ export declare class CucumberQaseReporter extends Formatter {
      * @private
      */
     private publishResults;
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    private startTestRun;
 }
-export {};

package/dist/reporter.js

@@ -3,25 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CucumberQaseReporter = void 0;
 const cucumber_1 = require("@cucumber/cucumber");
 const qase_javascript_commons_1 = require("qase-javascript-commons");
+const storage_1 = require("./storage");
 /**
  * @class CucumberQaseReporter
  * @extends Formatter
  */
 class CucumberQaseReporter extends cucumber_1.Formatter {
-    /**
-     * @param {readonly PickleTag[]} tagsList
-     * @returns {number[]}
-     * @private
-     */
-    static getCaseIds(tagsList) {
-        return tagsList.reduce((acc, tagInfo) => {
-            const ids = Array.from(tagInfo.name.matchAll(CucumberQaseReporter.qaseIdRegExp))
-                .map(([, id]) => Number(id))
-                .filter((id) => id !== undefined);
-            acc.push(...ids);
-            return acc;
-        }, []);
-    }
     /**
      * @param {CucumberQaseOptionsType} options
      * @param {ConfigLoaderInterface} configLoader
@@ -30,48 +17,14 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
         const { qase, ...formatterOptions } = options;
         const config = configLoader.load();
         super(formatterOptions);
-        /**
-         * @type {Record<string, PickleInfoType>}
-         * @private
-         */
-        this.pickleInfo = {};
-        /**
-         * @type {Record<string, TestCaseStarted>}
-         * @private
-         */
-        this.testCaseStarts = {};
-        /**
-         * @type {Record<string, >}
-         * @private
-         */
-        this.testCaseStartedResult = {};
-        /**
-         * @type {Record<string, string[]>}
-         * @private
-         */
-        this.testCaseStartedErrors = {};
-        /**
-         * @type {Record<string, string>}
-         * @private
-         */
-        this.testCaseScenarioId = {};
-        /**
-         * @type {Record<string, string>}
-         * @private
-         */
-        this.scenarios = {};
-        /**
-         * @type {Record<string, string>}
-         * @private
-         */
-        this.attachments = {};
-        this.reporter = new qase_javascript_commons_1.QaseReporter({
+        this.reporter = qase_javascript_commons_1.QaseReporter.getInstance({
             ...(0, qase_javascript_commons_1.composeOptions)(qase, config),
             frameworkPackage: '@cucumber/cucumber',
             frameworkName: 'cucumberjs',
             reporterName: 'cucumberjs-qase-reporter',
         });
         this.eventBroadcaster = formatterOptions.eventBroadcaster;
+        this.storage = new storage_1.Storage();
         this.bindEventListeners();
     }
     /**
@@ -80,95 +33,35 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
     bindEventListeners() {
         this.eventBroadcaster.on('envelope', (envelope) => {
             if (envelope.gherkinDocument) {
-                if (envelope.gherkinDocument.feature) {
-                    const { children, name } = envelope.gherkinDocument.feature;
-                    children.forEach(({ scenario }) => {
-                        if (scenario) {
-                            this.scenarios[scenario.id] = name;
-                        }
-                    });
-                }
+                this.storage.addScenario(envelope.gherkinDocument);
             }
             else if (envelope.pickle) {
-                this.pickleInfo[envelope.pickle.id] = {
-                    caseIds: CucumberQaseReporter.getCaseIds(envelope.pickle.tags),
-                    name: envelope.pickle.name,
-                    lastAstNodeId: envelope.pickle.astNodeIds[envelope.pickle.astNodeIds.length - 1],
-                };
+                this.storage.addPickle(envelope.pickle);
             }
             else if (envelope.attachment) {
-                if (envelope.attachment.testCaseStartedId &&
-                    envelope.attachment.fileName) {
-                    this.attachments[envelope.attachment.testCaseStartedId] =
-                        envelope.attachment.fileName;
-                }
+                this.storage.addAttachment(envelope.attachment);
+            }
+            else if (envelope.testRunStarted) {
+                this.startTestRun();
             }
             else if (envelope.testRunFinished) {
                 void this.publishResults();
             }
             else if (envelope.testCase) {
-                this.testCaseScenarioId[envelope.testCase.id] =
-                    envelope.testCase.pickleId;
+                this.storage.addTestCase(envelope.testCase);
             }
             else if (envelope.testCaseStarted) {
-                this.testCaseStarts[envelope.testCaseStarted.id] =
-                    envelope.testCaseStarted;
-                this.testCaseStartedResult[envelope.testCaseStarted.id] =
-                    qase_javascript_commons_1.TestStatusEnum.passed;
+                this.storage.addTestCaseStarted(envelope.testCaseStarted);
             }
             else if (envelope.testStepFinished) {
-                const stepFin = envelope.testStepFinished;
-                const oldStatus = this.testCaseStartedResult[stepFin.testCaseStartedId];
-                const newStatus = CucumberQaseReporter.statusMap[stepFin.testStepResult.status];
-                if (newStatus === null) {
-                    return;
-                }
-                if (newStatus !== qase_javascript_commons_1.TestStatusEnum.passed) {
-                    if (stepFin.testStepResult.message) {
-                        const errors = this.testCaseStartedErrors[stepFin.testCaseStartedId] ?? [];
-                        if (!this.testCaseStartedErrors[stepFin.testCaseStartedId]) {
-                            this.testCaseStartedErrors[stepFin.testCaseStartedId] = errors;
-                        }
-                        errors.push(stepFin.testStepResult.message);
-                    }
-                    if (oldStatus) {
-                        if (oldStatus !== qase_javascript_commons_1.TestStatusEnum.failed) {
-                            this.testCaseStartedResult[stepFin.testCaseStartedId] = newStatus;
-                        }
-                    }
-                    else {
-                        this.testCaseStartedResult[stepFin.testCaseStartedId] = newStatus;
-                    }
-                }
+                this.storage.addTestCaseStep(envelope.testStepFinished);
             }
             else if (envelope.testCaseFinished) {
-                const tcs = this.testCaseStarts[envelope.testCaseFinished.testCaseStartedId];
-                if (!tcs) {
-                    return;
-                }
-                const pickleId = this.testCaseScenarioId[tcs.testCaseId];
-                if (!pickleId) {
+                const result = this.storage.convertTestCase(envelope.testCaseFinished);
+                if (!result) {
                     return;
                 }
-                const info = this.pickleInfo[pickleId];
-                if (!info) {
-                    return;
-                }
-                let error;
-                if (this.testCaseStartedErrors[tcs.id]?.length) {
-                    error = new Error(this.testCaseStartedErrors[tcs.id]?.join('\n\n'));
-                }
-                this.reporter.addTestResult({
-                    id: tcs.id,
-                    testOpsId: info.caseIds,
-                    title: info.name,
-                    suiteTitle: info.lastAstNodeId && this.scenarios[info.lastAstNodeId],
-                    status: this.testCaseStartedResult[envelope.testCaseFinished.testCaseStartedId] ?? qase_javascript_commons_1.TestStatusEnum.passed,
-                    startTime: tcs.timestamp.seconds,
-                    endTime: envelope.testCaseFinished.timestamp.seconds,
-                    duration: Math.abs(envelope.testCaseFinished.timestamp.seconds - tcs.timestamp.seconds),
-                    error,
-                });
+                void this.reporter.addTestResult(result);
             }
         });
     }
@@ -179,21 +72,12 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
     async publishResults() {
         await this.reporter.publish();
     }
+    /**
+     * @returns {Promise<void>}
+     * @private
+     */
+    startTestRun() {
+        this.reporter.startTestRun();
+    }
 }
 exports.CucumberQaseReporter = CucumberQaseReporter;
-/**
- * @type {Record<TestStepResultStatus, TestStatusEnum | null>}
- */
-CucumberQaseReporter.statusMap = {
-    [cucumber_1.Status.PASSED]: qase_javascript_commons_1.TestStatusEnum.passed,
-    [cucumber_1.Status.FAILED]: qase_javascript_commons_1.TestStatusEnum.failed,
-    [cucumber_1.Status.SKIPPED]: qase_javascript_commons_1.TestStatusEnum.skipped,
-    [cucumber_1.Status.AMBIGUOUS]: null,
-    [cucumber_1.Status.PENDING]: qase_javascript_commons_1.TestStatusEnum.blocked,
-    [cucumber_1.Status.UNDEFINED]: null,
-    [cucumber_1.Status.UNKNOWN]: null,
-};
-/**
- * @type {RegExp}
- */
-CucumberQaseReporter.qaseIdRegExp = /^@[Qq]-?(\d+)$/g;

package/dist/storage.d.ts

@@ -0,0 +1,101 @@
+import { Attachment as Attach, GherkinDocument, Pickle, TestCaseFinished, TestCaseStarted, TestStepFinished } from '@cucumber/messages';
+import { StepStatusEnum, TestResultType, TestStatusEnum } from 'qase-javascript-commons';
+import { TestCase } from '@cucumber/messages/dist/esm/src/messages';
+import { Status } from '@cucumber/cucumber';
+type TestStepResultStatus = (typeof Status)[keyof typeof Status];
+export declare class Storage {
+    /**
+     * @type {Record<string, Pickle>}
+     * @private
+     */
+    private pickles;
+    /**
+     * @type {Record<string, TestCaseStarted>}
+     * @private
+     */
+    private testCaseStarts;
+    /**
+     * @type {Record<string, TestStepFinished>}
+     * @private
+     */
+    private testCaseSteps;
+    /**
+     * @type {Record<string, TestStatusEnum>}
+     * @private
+     */
+    private testCaseStartedResult;
+    /**
+     * @type {Record<string, string[]>}
+     * @private
+     */
+    private testCaseStartedErrors;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private testCases;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private scenarios;
+    /**
+     * @type {Record<string, string>}
+     * @private
+     */
+    private attachments;
+    /**
+     * Add pickle to storage
+     * @param {Pickle} pickle
+     */
+    addPickle(pickle: Pickle): void;
+    /**
+     * Add scenario to storage
+     * @param {GherkinDocument} document
+     */
+    addScenario(document: GherkinDocument): void;
+    /**
+     * Add attachment to storage
+     * @param {Attach} attachment
+     */
+    addAttachment(attachment: Attach): void;
+    /**
+     * Add test case to storage
+     * @param {TestCase} testCase
+     */
+    addTestCase(testCase: TestCase): void;
+    /**
+     * Get all test cases
+     * @param {TestCaseStarted} testCaseStarted
+     */
+    addTestCaseStarted(testCaseStarted: TestCaseStarted): void;
+    /**
+     * Add test case step to storage
+     * @param {TestStepFinished} testCaseStep
+     */
+    addTestCaseStep(testCaseStep: TestStepFinished): void;
+    /**
+     * Convert test case to test result
+     * @param {TestCaseFinished} testCase
+     * @returns {undefined | TestResultType}
+     */
+    convertTestCase(testCase: TestCaseFinished): undefined | TestResultType;
+    /**
+     * Convert test steps to test result steps
+     * @param {readonly PickleStep[]} steps
+     * @param {TestCase} testCase
+     * @returns {TestStepType[]}
+     * @private
+     */
+    private convertSteps;
+    /**
+     * @type {Record<TestStepResultStatus, TestStatusEnum>}
+     */
+    static statusMap: Record<TestStepResultStatus, TestStatusEnum>;
+    /**
+     * @type {Record<TestStepResultStatus, StepStatusEnum>}
+     */
+    static stepStatusMap: Record<TestStepResultStatus, StepStatusEnum>;
+    private parseTags;
+}
+export {};

package/dist/storage.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Storage = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const cucumber_1 = require("@cucumber/cucumber");
+const qaseIdRegExp = /^@[Qq]-?(\d+)$/g;
+const newQaseIdRegExp = /^@[Qq]ase[Ii][Dd]=(\d+)$/g;
+const qaseTitleRegExp = /^@[Qq]ase[Tt]itle=(.+)$/g;
+const qaseFieldsRegExp = /^@[Qq]ase[Ff]ields:(.+?)=(.+)$/g;
+class Storage {
+    constructor() {
+        /**
+         * @type {Record<string, Pickle>}
+         * @private
+         */
+        this.pickles = {};
+        /**
+         * @type {Record<string, TestCaseStarted>}
+         * @private
+         */
+        this.testCaseStarts = {};
+        /**
+         * @type {Record<string, TestStepFinished>}
+         * @private
+         */
+        this.testCaseSteps = {};
+        /**
+         * @type {Record<string, TestStatusEnum>}
+         * @private
+         */
+        this.testCaseStartedResult = {};
+        /**
+         * @type {Record<string, string[]>}
+         * @private
+         */
+        this.testCaseStartedErrors = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.testCases = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.scenarios = {};
+        /**
+         * @type {Record<string, string>}
+         * @private
+         */
+        this.attachments = {};
+    }
+    /**
+     * Add pickle to storage
+     * @param {Pickle} pickle
+     */
+    addPickle(pickle) {
+        this.pickles[pickle.id] = pickle;
+    }
+    /**
+     * Add scenario to storage
+     * @param {GherkinDocument} document
+     */
+    addScenario(document) {
+        if (document.feature) {
+            const { children, name } = document.feature;
+            children.forEach(({ scenario }) => {
+                if (scenario) {
+                    this.scenarios[scenario.id] = name;
+                }
+            });
+        }
+    }
+    /**
+     * Add attachment to storage
+     * @param {Attach} attachment
+     */
+    addAttachment(attachment) {
+        if (attachment.testCaseStartedId && attachment.fileName) {
+            if (!this.attachments[attachment.testCaseStartedId]) {
+                this.attachments[attachment.testCaseStartedId] = [];
+            }
+            this.attachments[attachment.testCaseStartedId]?.push({
+                file_name: attachment.fileName,
+                mime_type: attachment.mediaType,
+                file_path: null,
+                content: attachment.body,
+                size: 0,
+                id: attachment.fileName,
+            });
+        }
+    }
+    /**
+     * Add test case to storage
+     * @param {TestCase} testCase
+     */
+    addTestCase(testCase) {
+        this.testCases[testCase.id] = testCase;
+    }
+    /**
+     * Get all test cases
+     * @param {TestCaseStarted} testCaseStarted
+     */
+    addTestCaseStarted(testCaseStarted) {
+        this.testCaseStarts[testCaseStarted.id] =
+            testCaseStarted;
+        this.testCaseStartedResult[testCaseStarted.id] =
+            qase_javascript_commons_1.TestStatusEnum.passed;
+    }
+    /**
+     * Add test case step to storage
+     * @param {TestStepFinished} testCaseStep
+     */
+    addTestCaseStep(testCaseStep) {
+        const oldStatus = this.testCaseStartedResult[testCaseStep.testCaseStartedId];
+        const newStatus = Storage.statusMap[testCaseStep.testStepResult.status];
+        this.testCaseSteps[testCaseStep.testStepId] = testCaseStep;
+        if (newStatus !== qase_javascript_commons_1.TestStatusEnum.passed) {
+            if (testCaseStep.testStepResult.message) {
+                if (!this.testCaseStartedErrors[testCaseStep.testCaseStartedId]) {
+                    this.testCaseStartedErrors[testCaseStep.testCaseStartedId] = [];
+                }
+                this.testCaseStartedErrors[testCaseStep.testCaseStartedId]?.push(testCaseStep.testStepResult.message);
+            }
+            if (oldStatus) {
+                if (oldStatus !== qase_javascript_commons_1.TestStatusEnum.failed) {
+                    this.testCaseStartedResult[testCaseStep.testCaseStartedId] = newStatus;
+                }
+            }
+            else {
+                this.testCaseStartedResult[testCaseStep.testCaseStartedId] = newStatus;
+            }
+        }
+    }
+    /**
+     * Convert test case to test result
+     * @param {TestCaseFinished} testCase
+     * @returns {undefined | TestResultType}
+     */
+    convertTestCase(testCase) {
+        const tcs = this.testCaseStarts[testCase.testCaseStartedId];
+        if (!tcs) {
+            return undefined;
+        }
+        const tc = this.testCases[tcs.testCaseId];
+        if (!tc) {
+            return undefined;
+        }
+        const pickle = this.pickles[tc.pickleId];
+        if (!pickle) {
+            return undefined;
+        }
+        let error;
+        if (this.testCaseStartedErrors[tcs.id]?.length) {
+            error = new Error(this.testCaseStartedErrors[tcs.id]?.join('\n\n'));
+        }
+        let relations = null;
+        const nodeId = pickle.astNodeIds[pickle.astNodeIds.length - 1];
+        if (nodeId != undefined && this.scenarios[nodeId] != undefined) {
+            relations = {
+                suite: {
+                    data: [
+                        {
+                            title: this.scenarios[nodeId] ?? '',
+                            public_id: null,
+                        },
+                    ],
+                },
+            };
+        }
+        const metadata = this.parseTags(pickle.tags);
+        return {
+            attachments: [],
+            author: null,
+            execution: {
+                status: this.testCaseStartedResult[testCase.testCaseStartedId] ?? qase_javascript_commons_1.TestStatusEnum.passed,
+                start_time: null,
+                end_time: null,
+                duration: Math.abs(testCase.timestamp.seconds - tcs.timestamp.seconds),
+                stacktrace: error?.stack ?? null,
+                thread: null,
+            },
+            fields: metadata.fields,
+            message: null,
+            muted: false,
+            params: {},
+            relations: relations,
+            run_id: null,
+            signature: '',
+            steps: this.convertSteps(pickle.steps, tc),
+            testops_id: metadata.ids.length > 0 ? metadata.ids : null,
+            id: tcs.id,
+            title: metadata.title ?? pickle.name,
+        };
+    }
+    /**
+     * Convert test steps to test result steps
+     * @param {readonly PickleStep[]} steps
+     * @param {TestCase} testCase
+     * @returns {TestStepType[]}
+     * @private
+     */
+    convertSteps(steps, testCase) {
+        const results = [];
+        for (const s of testCase.testSteps) {
+            const finished = this.testCaseSteps[s.id];
+            if (!finished) {
+                continue;
+            }
+            const step = steps.find((step) => step.id === s.pickleStepId);
+            if (!step) {
+                continue;
+            }
+            const result = {
+                id: s.id,
+                step_type: qase_javascript_commons_1.StepType.GHERKIN,
+                data: {
+                    keyword: step.text,
+                    name: step.text,
+                    line: 0,
+                },
+                execution: {
+                    status: Storage.stepStatusMap[finished.testStepResult.status],
+                    start_time: null,
+                    end_time: null,
+                    duration: finished.testStepResult.duration.seconds,
+                },
+                attachments: [],
+                steps: [],
+                parent_id: null,
+            };
+            results.push(result);
+        }
+        return results;
+    }
+    parseTags(tags) {
+        const metadata = {
+            ids: [],
+            fields: {},
+            title: null,
+        };
+        for (const tag of tags) {
+            if (qaseIdRegExp.test(tag.name)) {
+                metadata.ids.push(Number(tag.name.replace(/^@[Qq]-?/, '')));
+                continue;
+            }
+            if (newQaseIdRegExp.test(tag.name)) {
+                metadata.ids.push(Number(tag.name.replace(/^@[Qq]ase[Ii][Dd]=/, '')));
+                continue;
+            }
+            if (qaseTitleRegExp.test(tag.name)) {
+                metadata.title = tag.name.replace(/^@[Qq]ase[Tt]itle=/, '');
+                continue;
+            }
+            if (qaseFieldsRegExp.test(tag.name)) {
+                const value = tag.name.replace(/^@[Qq]ase[Ff]ields:/, '');
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const record = JSON.parse(value);
+                    metadata.fields = { ...metadata.fields, ...record };
+                }
+                catch (e) {
+                    // do nothing
+                }
+            }
+        }
+        return metadata;
+    }
+}
+exports.Storage = Storage;
+/**
+ * @type {Record<TestStepResultStatus, TestStatusEnum>}
+ */
+Storage.statusMap = {
+    [cucumber_1.Status.PASSED]: qase_javascript_commons_1.TestStatusEnum.passed,
+    [cucumber_1.Status.FAILED]: qase_javascript_commons_1.TestStatusEnum.failed,
+    [cucumber_1.Status.SKIPPED]: qase_javascript_commons_1.TestStatusEnum.skipped,
+    [cucumber_1.Status.AMBIGUOUS]: qase_javascript_commons_1.TestStatusEnum.failed,
+    [cucumber_1.Status.PENDING]: qase_javascript_commons_1.TestStatusEnum.skipped,
+    [cucumber_1.Status.UNDEFINED]: qase_javascript_commons_1.TestStatusEnum.skipped,
+    [cucumber_1.Status.UNKNOWN]: qase_javascript_commons_1.TestStatusEnum.skipped,
+};
+/**
+ * @type {Record<TestStepResultStatus, StepStatusEnum>}
+ */
+Storage.stepStatusMap = {
+    [cucumber_1.Status.PASSED]: qase_javascript_commons_1.StepStatusEnum.passed,
+    [cucumber_1.Status.FAILED]: qase_javascript_commons_1.StepStatusEnum.failed,
+    [cucumber_1.Status.SKIPPED]: qase_javascript_commons_1.StepStatusEnum.skipped,
+    [cucumber_1.Status.AMBIGUOUS]: qase_javascript_commons_1.StepStatusEnum.failed,
+    [cucumber_1.Status.PENDING]: qase_javascript_commons_1.StepStatusEnum.skipped,
+    [cucumber_1.Status.UNDEFINED]: qase_javascript_commons_1.StepStatusEnum.skipped,
+    [cucumber_1.Status.UNKNOWN]: qase_javascript_commons_1.StepStatusEnum.skipped,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cucumberjs-qase-reporter",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.3",
   "description": "Qase TMS CucumberJS Reporter",
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "main": "./dist/index.js",
@@ -40,7 +40,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@cucumber/messages": "^22.0.0",
-    "qase-javascript-commons": "^2.0.0-beta.1"
+    "qase-javascript-commons": "^2.0.0-beta.8"
   },
   "peerDependencies": {
     "@cucumber/cucumber": ">=7.0.0"