cucumberjs-qase-reporter 2.3.0 → 2.4.1

package/changelog.md

@@ -1,3 +1,24 @@
+# cucumberjs-qase-reporter@2.4.1
+
+## Fixed
+
+- Gherkin step `execution.start_time` and `execution.end_time` are now populated from the Cucumber `testStepStarted` / `testStepFinished` envelope timestamps (Unix seconds with fractional ms). Previously both fields were hardcoded to `null`, breaking timeline rendering on the Qase side.
+- Step `execution.duration` now includes the `nanos` part of the Cucumber duration. Previously only `seconds * 1000` was emitted, so any sub-second step was reported as 0 ms.
+
+# cucumberjs-qase-reporter@2.4.0
+
+## Changed
+
+- Decomposed `storage.ts` (595 LOC) into a thin facade plus 6 focused modules under `src/modules/`: `TagParser`, `EventStorage`, `StatusTracker`, `StepConverter`, `ProfilerTracker`, `ResultBuilder`, plus `STATUS_MAP` / `STEP_STATUS_MAP` constants. Public contract preserved: `Storage` named export, constructor signature, all 7 instance methods, static `statusMap` and `stepStatusMap`, all 9 user-facing tag patterns.
+
+## Bug fixes
+
+- Cross-reporter consistency: `testops_id` is now `null` when project mapping (`@qaseid.PROJ(ids)` tag) is set, matching the behavior of mocha / cypress / jest reporters. Previously cucumberjs emitted both `testops_id: ids` and `testops_project_mapping: mapping`, which could lead to ambiguous results in multi-project runs.
+
+## Internal
+
+- Added 38 per-module unit tests on top of the existing 44 facade integration tests (82 total).
+
 # cucumberjs-qase-reporter@2.3.0
 
 ## What's new

package/dist/modules/eventStorage.d.ts

@@ -0,0 +1,30 @@
+import { Attachment as Attach, GherkinDocument, Pickle, TestCaseStarted, TestStepFinished, TestStepStarted } from '@cucumber/messages';
+import { TestCase } from '@cucumber/messages/dist/esm/src/messages';
+import { Attachment } from 'qase-javascript-commons';
+import { ScenarioData } from '../models';
+export declare class EventStorage {
+    private pickles;
+    private testCaseStarts;
+    private testStepStarted;
+    private testStepFinished;
+    private testCases;
+    private scenarios;
+    private attachments;
+    addPickle(pickle: Pickle): void;
+    addScenario(document: GherkinDocument): void;
+    addAttachment(attachment: Attach): void;
+    addTestCase(testCase: TestCase): void;
+    addTestCaseStarted(testCaseStarted: TestCaseStarted): void;
+    addTestStepStarted(step: TestStepStarted): void;
+    addTestStepFinished(step: TestStepFinished): void;
+    getPickle(id: string): Pickle | undefined;
+    getTestCase(id: string): TestCase | undefined;
+    getTestCaseStarted(id: string): TestCaseStarted | undefined;
+    getScenario(id: string): ScenarioData | undefined;
+    getAttachments(key: string): Attachment[];
+    getTestStepFinished(id: string): TestStepFinished | undefined;
+    getAllTestStepFinished(): Map<string, TestStepFinished>;
+    getAllTestStepStarted(): Map<string, TestStepStarted>;
+    private appendAttachment;
+    static getFileNameFromMediaType(mediaType: string): string;
+}

package/dist/modules/eventStorage.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStorage = void 0;
+const uuid_1 = require("uuid");
+class EventStorage {
+    pickles = {};
+    testCaseStarts = {};
+    testStepStarted = {};
+    testStepFinished = {};
+    testCases = {};
+    scenarios = {};
+    attachments = {};
+    addPickle(pickle) {
+        this.pickles[pickle.id] = pickle;
+    }
+    addScenario(document) {
+        if (!document.feature)
+            return;
+        const { children, name } = document.feature;
+        for (const { scenario } of children) {
+            if (!scenario)
+                continue;
+            const parameters = {};
+            scenario.examples?.forEach((example) => {
+                if (example.tableHeader) {
+                    const columnNames = example.tableHeader.cells.map((cell) => cell.value);
+                    example.tableBody.forEach((row) => {
+                        const rowParams = {};
+                        row.cells.forEach((cell, index) => {
+                            const columnName = columnNames[index];
+                            if (columnName) {
+                                rowParams[columnName] = cell.value;
+                            }
+                        });
+                        parameters[row.id] = rowParams;
+                    });
+                }
+            });
+            this.scenarios[scenario.id] = {
+                name,
+                parameters,
+            };
+        }
+    }
+    addAttachment(attachment) {
+        if (attachment.testStepId) {
+            this.appendAttachment(attachment.testStepId, attachment);
+        }
+        if (attachment.testCaseStartedId) {
+            this.appendAttachment(attachment.testCaseStartedId, attachment);
+        }
+    }
+    addTestCase(testCase) {
+        this.testCases[testCase.id] = testCase;
+    }
+    addTestCaseStarted(testCaseStarted) {
+        this.testCaseStarts[testCaseStarted.id] = testCaseStarted;
+    }
+    addTestStepStarted(step) {
+        this.testStepStarted[step.testStepId] = step;
+    }
+    addTestStepFinished(step) {
+        this.testStepFinished[step.testStepId] = step;
+    }
+    getPickle(id) {
+        return this.pickles[id];
+    }
+    getTestCase(id) {
+        return this.testCases[id];
+    }
+    getTestCaseStarted(id) {
+        return this.testCaseStarts[id];
+    }
+    getScenario(id) {
+        return this.scenarios[id];
+    }
+    getAttachments(key) {
+        return this.attachments[key] ?? [];
+    }
+    getTestStepFinished(id) {
+        return this.testStepFinished[id];
+    }
+    getAllTestStepFinished() {
+        return new Map(Object.entries(this.testStepFinished));
+    }
+    getAllTestStepStarted() {
+        return new Map(Object.entries(this.testStepStarted));
+    }
+    appendAttachment(key, attachment) {
+        const list = this.attachments[key] ?? [];
+        this.attachments[key] = list;
+        list.push({
+            file_name: EventStorage.getFileNameFromMediaType(attachment.mediaType),
+            mime_type: attachment.mediaType,
+            file_path: null,
+            content: attachment.body,
+            size: 0,
+            id: (0, uuid_1.v4)(),
+        });
+    }
+    static getFileNameFromMediaType(mediaType) {
+        const extensions = {
+            'text/plain': 'txt',
+            'application/json': 'json',
+            'image/png': 'png',
+            'image/jpeg': 'jpg',
+            'image/gif': 'gif',
+            'text/html': 'html',
+            'application/pdf': 'pdf',
+            'application/xml': 'xml',
+            'application/zip': 'zip',
+            'application/msword': 'doc',
+            'application/vnd.ms-excel': 'xls',
+            'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'docx',
+            'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'xlsx',
+        };
+        const extension = extensions[mediaType];
+        return extension ? `file.${extension}` : 'file';
+    }
+}
+exports.EventStorage = EventStorage;

package/dist/modules/profilerTracker.d.ts

@@ -0,0 +1,11 @@
+import { TestStepType } from 'qase-javascript-commons';
+import { NetworkProfiler } from 'qase-javascript-commons/profilers';
+export declare class ProfilerTracker {
+    private readonly profiler;
+    private snapshots;
+    constructor(profiler: NetworkProfiler | null);
+    onTestStart(testCaseStartedId: string): void;
+    getEvents(testCaseStartedId: string): TestStepType[];
+    reset(testCaseStartedId: string): void;
+    restore(): void;
+}

package/dist/modules/profilerTracker.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProfilerTracker = void 0;
+class ProfilerTracker {
+    profiler;
+    snapshots = {};
+    constructor(profiler) {
+        this.profiler = profiler;
+    }
+    onTestStart(testCaseStartedId) {
+        if (this.profiler) {
+            this.snapshots[testCaseStartedId] = this.profiler.getAllSteps().length;
+        }
+    }
+    getEvents(testCaseStartedId) {
+        if (!this.profiler)
+            return [];
+        const snapshot = this.snapshots[testCaseStartedId] ?? 0;
+        return this.profiler.getAllSteps().slice(snapshot);
+    }
+    reset(testCaseStartedId) {
+        delete this.snapshots[testCaseStartedId];
+    }
+    restore() {
+        this.profiler?.restore();
+    }
+}
+exports.ProfilerTracker = ProfilerTracker;

package/dist/modules/resultBuilder.d.ts

@@ -0,0 +1,22 @@
+import { Pickle, TestCaseFinished, TestCaseStarted } from '@cucumber/messages';
+import { TestCase } from '@cucumber/messages/dist/esm/src/messages';
+import { Attachment, CompoundError, TestResultType, TestStatusEnum, TestStepType } from 'qase-javascript-commons';
+import { TestMetadata } from '../models';
+export interface BuildArgs {
+    testCaseFinished: TestCaseFinished;
+    testCaseStarted: TestCaseStarted;
+    testCase: TestCase;
+    pickle: Pickle;
+    metadata: TestMetadata;
+    status: TestStatusEnum;
+    error: CompoundError | undefined;
+    steps: TestStepType[];
+    profilerSteps: TestStepType[];
+    attachments: Attachment[];
+    scenarioName: string | undefined;
+    scenarioParameters: Record<string, string>;
+}
+export declare class ResultBuilder {
+    static build(args: BuildArgs): TestResultType;
+    static getSignature(pickle: Pickle, ids: number[], parameters?: Record<string, string>): string;
+}

package/dist/modules/resultBuilder.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultBuilder = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+class ResultBuilder {
+    static build(args) {
+        const { testCaseFinished, testCaseStarted, pickle, metadata, status, error, steps, profilerSteps, attachments, scenarioName, scenarioParameters, } = args;
+        let relations = null;
+        if (metadata.suite) {
+            const suiteParts = metadata.suite.split('\t').filter((part) => part.trim().length > 0);
+            relations = {
+                suite: {
+                    data: suiteParts.map((suite) => ({
+                        title: suite.trim(),
+                        public_id: null,
+                    })),
+                },
+            };
+        }
+        else if (scenarioName !== undefined) {
+            relations = {
+                suite: {
+                    data: [
+                        { title: scenarioName, public_id: null },
+                    ],
+                },
+            };
+        }
+        // Merge scenario params with metadata parameters (metadata wins)
+        const params = { ...scenarioParameters, ...metadata.parameters };
+        const hasProjectMapping = Object.keys(metadata.projectMapping).length > 0;
+        return {
+            attachments,
+            author: null,
+            execution: {
+                status,
+                start_time: testCaseStarted.timestamp.seconds,
+                end_time: testCaseFinished.timestamp.seconds,
+                duration: Math.abs(testCaseFinished.timestamp.seconds - testCaseStarted.timestamp.seconds) * 1000,
+                stacktrace: error?.stacktrace ?? null,
+                thread: null,
+            },
+            fields: metadata.fields,
+            message: error?.message ?? null,
+            muted: false,
+            params,
+            group_params: metadata.group_params,
+            relations,
+            run_id: null,
+            signature: ResultBuilder.getSignature(pickle, metadata.ids, params),
+            steps: [...steps, ...profilerSteps],
+            testops_id: hasProjectMapping ? null : (metadata.ids.length > 0 ? metadata.ids : null),
+            testops_project_mapping: hasProjectMapping ? metadata.projectMapping : null,
+            id: testCaseStarted.id,
+            title: metadata.title ?? pickle.name,
+            tags: metadata.tags,
+        };
+    }
+    static getSignature(pickle, ids, parameters = {}) {
+        return (0, qase_javascript_commons_1.generateSignature)(ids, [...pickle.uri.split('/'), pickle.name], parameters);
+    }
+}
+exports.ResultBuilder = ResultBuilder;

package/dist/modules/statusMaps.d.ts

@@ -0,0 +1,5 @@
+import { Status } from '@cucumber/cucumber';
+import { StepStatusEnum, TestStatusEnum } from 'qase-javascript-commons';
+export type TestStepResultStatus = (typeof Status)[keyof typeof Status];
+export declare const STATUS_MAP: Record<TestStepResultStatus, TestStatusEnum>;
+export declare const STEP_STATUS_MAP: Record<TestStepResultStatus, StepStatusEnum>;

package/dist/modules/statusMaps.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STEP_STATUS_MAP = exports.STATUS_MAP = void 0;
+const cucumber_1 = require("@cucumber/cucumber");
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+exports.STATUS_MAP = {
+    [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.invalid,
+    [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,
+};
+exports.STEP_STATUS_MAP = {
+    [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/dist/modules/statusTracker.d.ts

@@ -0,0 +1,10 @@
+import { TestStepFinished } from '@cucumber/messages';
+import { CompoundError, TestStatusEnum } from 'qase-javascript-commons';
+export declare class StatusTracker {
+    private results;
+    private errors;
+    onTestStarted(testCaseStartedId: string): void;
+    applyStep(step: TestStepFinished): void;
+    getStatus(testCaseStartedId: string): TestStatusEnum;
+    getErrors(testCaseStartedId: string): CompoundError | undefined;
+}

package/dist/modules/statusTracker.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusTracker = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const statusMaps_1 = require("./statusMaps");
+class StatusTracker {
+    results = {};
+    errors = {};
+    onTestStarted(testCaseStartedId) {
+        this.results[testCaseStartedId] = qase_javascript_commons_1.TestStatusEnum.passed;
+    }
+    applyStep(step) {
+        const oldStatus = this.results[step.testCaseStartedId];
+        let error = null;
+        if (step.testStepResult.message) {
+            error = new Error(step.testStepResult.message);
+        }
+        const newStatus = (0, qase_javascript_commons_1.determineTestStatus)(error, statusMaps_1.STATUS_MAP[step.testStepResult.status]);
+        if (newStatus !== qase_javascript_commons_1.TestStatusEnum.passed) {
+            if (step.testStepResult.message) {
+                if (!this.errors[step.testCaseStartedId]) {
+                    this.errors[step.testCaseStartedId] = [];
+                }
+                this.errors[step.testCaseStartedId]?.push(step.testStepResult.message);
+            }
+            if (oldStatus) {
+                if (oldStatus !== qase_javascript_commons_1.TestStatusEnum.failed && oldStatus !== qase_javascript_commons_1.TestStatusEnum.invalid) {
+                    this.results[step.testCaseStartedId] = newStatus;
+                }
+            }
+            else {
+                this.results[step.testCaseStartedId] = newStatus;
+            }
+        }
+    }
+    getStatus(testCaseStartedId) {
+        return this.results[testCaseStartedId] ?? qase_javascript_commons_1.TestStatusEnum.passed;
+    }
+    getErrors(testCaseStartedId) {
+        const messages = this.errors[testCaseStartedId];
+        if (!messages)
+            return undefined;
+        const err = new qase_javascript_commons_1.CompoundError();
+        messages.forEach((message) => {
+            err.addMessage(message);
+            err.addStacktrace(message);
+        });
+        return err;
+    }
+}
+exports.StatusTracker = StatusTracker;

package/dist/modules/stepConverter.d.ts

@@ -0,0 +1,11 @@
+import { PickleStep, TestStepFinished, TestStepStarted } from '@cucumber/messages';
+import { TestCase } from '@cucumber/messages/dist/esm/src/messages';
+import { Attachment, TestStepType } from 'qase-javascript-commons';
+export declare class StepConverter {
+    static convert(pickleSteps: readonly PickleStep[], testCase: TestCase, startedSteps: Map<string, TestStepStarted>, finishedSteps: Map<string, TestStepFinished>, getAttachments: (stepId: string) => Attachment[]): TestStepType[];
+    /**
+     * Cucumber `Timestamp` is `{ seconds, nanos }`. Convert to a Unix-seconds
+     * number with fractional milliseconds.
+     */
+    private static toSeconds;
+}

package/dist/modules/stepConverter.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepConverter = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const statusMaps_1 = require("./statusMaps");
+class StepConverter {
+    static convert(pickleSteps, testCase, startedSteps, finishedSteps, getAttachments) {
+        const results = [];
+        for (const s of testCase.testSteps) {
+            const finished = finishedSteps.get(s.id);
+            if (!finished)
+                continue;
+            const step = pickleSteps.find((ps) => ps.id === s.pickleStepId);
+            if (!step)
+                continue;
+            const started = startedSteps.get(s.id);
+            const startTimeSec = started ? StepConverter.toSeconds(started.timestamp) : null;
+            const endTimeSec = StepConverter.toSeconds(finished.timestamp);
+            results.push({
+                id: s.id,
+                step_type: qase_javascript_commons_1.StepType.GHERKIN,
+                data: {
+                    keyword: step.text,
+                    name: step.text,
+                    line: 0,
+                },
+                execution: {
+                    status: statusMaps_1.STEP_STATUS_MAP[finished.testStepResult.status],
+                    start_time: startTimeSec,
+                    end_time: endTimeSec,
+                    duration: finished.testStepResult.duration.seconds * 1000
+                        + Math.round(finished.testStepResult.duration.nanos / 1e6),
+                },
+                attachments: getAttachments(s.id),
+                steps: [],
+                parent_id: null,
+            });
+        }
+        return results;
+    }
+    /**
+     * Cucumber `Timestamp` is `{ seconds, nanos }`. Convert to a Unix-seconds
+     * number with fractional milliseconds.
+     */
+    static toSeconds(ts) {
+        return ts.seconds + ts.nanos / 1e9;
+    }
+}
+exports.StepConverter = StepConverter;

package/dist/modules/tagParser.d.ts

@@ -0,0 +1,6 @@
+import { PickleTag } from '@cucumber/messages';
+import { TestMetadata } from '../models';
+export declare class TagParser {
+    static parse(tags: readonly PickleTag[]): TestMetadata;
+    static normalizeJsonString(jsonString: string): string;
+}

package/dist/modules/tagParser.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TagParser = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const qaseIdRegExp = /^@[Qq]-?(\d+)$/;
+const newQaseIdRegExp = /^@[Qq]ase[Ii][Dd]=(\d+(?:,\s*\d+)*)$/;
+const qaseTitleRegExp = /^@[Qq]ase[Tt]itle=(.+)$/;
+const qaseFieldsRegExp = /^@[Qq]ase[Ff]ields=(.+)$/;
+const qaseParametersRegExp = /^@[Qq]ase[Pp]arameters=(.+)$/;
+const qaseGroupParametersRegExp = /^@[Qq]ase[Gg]roup[Pp]arameters=(.+)$/;
+const qaseSuiteRegExp = /^@[Qq]ase[Ss]uite=(.+)$/;
+const qaseIgnoreRegExp = /^@[Qq]ase[Ii][Gg][Nn][Oo][Rr][Ee]$/;
+const qaseTagsRegExp = /^@[Qq]ase[Tt]ags=(.+)$/;
+class TagParser {
+    static parse(tags) {
+        const tagNames = tags.map((t) => t.name);
+        const { legacyIds, projectMapping } = (0, qase_javascript_commons_1.parseProjectMappingFromTags)(tagNames);
+        const metadata = {
+            ids: [...legacyIds],
+            projectMapping: { ...projectMapping },
+            fields: {},
+            title: null,
+            isIgnore: false,
+            parameters: {},
+            group_params: {},
+            suite: null,
+            tags: [],
+        };
+        for (const tag of tags) {
+            if (qaseIdRegExp.test(tag.name)) {
+                metadata.ids.push(Number(tag.name.replace(/^@[Qq]-?/, '')));
+                continue;
+            }
+            if (newQaseIdRegExp.test(tag.name)) {
+                const idsStr = tag.name.replace(/^@[Qq]ase[Ii][Dd]=/, '');
+                metadata.ids.push(...idsStr.split(',').map((s) => Number(s.trim())));
+                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(TagParser.normalizeJsonString(value));
+                    metadata.fields = { ...metadata.fields, ...record };
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            if (qaseParametersRegExp.test(tag.name)) {
+                const value = tag.name.replace(/^@[Qq]ase[Pp]arameters=/, '');
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const record = JSON.parse(TagParser.normalizeJsonString(value));
+                    metadata.parameters = { ...metadata.parameters, ...record };
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            if (qaseGroupParametersRegExp.test(tag.name)) {
+                const value = tag.name.replace(/^@[Qq]ase[Gg]roup[Pp]arameters=/, '');
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    const record = JSON.parse(TagParser.normalizeJsonString(value));
+                    metadata.group_params = { ...metadata.group_params, ...record };
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            if (qaseSuiteRegExp.test(tag.name)) {
+                metadata.suite = tag.name.replace(/^@[Qq]ase[Ss]uite=/, '');
+                continue;
+            }
+            if (qaseTagsRegExp.test(tag.name)) {
+                const value = tag.name.replace(/^@[Qq]ase[Tt]ags=/, '');
+                const parsedTags = value.split(',').map((t) => t.trim()).filter((t) => t.length > 0);
+                metadata.tags.push(...parsedTags);
+                continue;
+            }
+            if (qaseIgnoreRegExp.test(tag.name)) {
+                metadata.isIgnore = true;
+            }
+        }
+        return metadata;
+    }
+    static normalizeJsonString(jsonString) {
+        if (jsonString.includes("'")) {
+            return jsonString.replace(/'/g, '"');
+        }
+        return jsonString;
+    }
+}
+exports.TagParser = TagParser;

package/dist/reporter.d.ts

@@ -18,11 +18,6 @@ export declare class CucumberQaseReporter extends Formatter {
      * @private
      */
     private reporter;
-    /**
-     * @type {NetworkProfiler | null}
-     * @private
-     */
-    private profiler;
     /**
      * @type {EventEmitter}
      * @private

package/dist/reporter.js

@@ -20,11 +20,6 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
      * @private
      */
     reporter;
-    /**
-     * @type {NetworkProfiler | null}
-     * @private
-     */
-    profiler = null;
     /**
      * @type {EventEmitter}
      * @private
@@ -45,15 +40,16 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
             frameworkName: 'cucumberjs',
             reporterName: 'cucumberjs-qase-reporter',
         });
+        let profiler = null;
         if (composedOptions.profilers?.includes('network')) {
-            this.profiler = new profilers_1.NetworkProfiler({
+            profiler = new profilers_1.NetworkProfiler({
                 skipDomains: composedOptions.networkProfiler?.skip_domains,
                 trackOnFail: composedOptions.networkProfiler?.track_on_fail,
             });
-            this.profiler.enable();
+            profiler.enable();
         }
         this.eventBroadcaster = formatterOptions.eventBroadcaster;
-        this.storage = new storage_1.Storage(this.profiler);
+        this.storage = new storage_1.Storage(profiler);
         this.bindEventListeners();
     }
     /**
@@ -82,6 +78,9 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
             else if (envelope.testCaseStarted) {
                 this.storage.addTestCaseStarted(envelope.testCaseStarted);
             }
+            else if (envelope.testStepStarted) {
+                this.storage.addTestCaseStepStarted(envelope.testStepStarted);
+            }
             else if (envelope.testStepFinished) {
                 this.storage.addTestCaseStep(envelope.testStepFinished);
             }
@@ -99,7 +98,7 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
      * @private
      */
     async publishResults() {
-        this.profiler?.restore();
+        this.storage.restore();
         await this.reporter.publish();
     }
     /**