cucumberjs-qase-reporter 2.3.0 → 2.4.0

package/changelog.md

@@ -1,3 +1,17 @@
+# 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,27 @@
+import { Attachment as Attach, GherkinDocument, Pickle, TestCaseStarted, TestStepFinished } 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 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;
+    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>;
+    private appendAttachment;
+    static getFileNameFromMediaType(mediaType: string): string;
+}

package/dist/modules/eventStorage.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventStorage = void 0;
+const uuid_1 = require("uuid");
+class EventStorage {
+    pickles = {};
+    testCaseStarts = {};
+    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;
+    }
+    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));
+    }
+    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,6 @@
+import { PickleStep, TestStepFinished } 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, finishedSteps: Map<string, TestStepFinished>, getAttachments: (stepId: string) => Attachment[]): TestStepType[];
+}

package/dist/modules/stepConverter.js

@@ -0,0 +1,38 @@
+"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, 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;
+            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: null,
+                    end_time: null,
+                    duration: finished.testStepResult.duration.seconds * 1000,
+                },
+                attachments: getAttachments(s.id),
+                steps: [],
+                parent_id: null,
+            });
+        }
+        return results;
+    }
+}
+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();
     }
     /**
@@ -99,7 +95,7 @@ class CucumberQaseReporter extends cucumber_1.Formatter {
      * @private
      */
     async publishResults() {
-        this.profiler?.restore();
+        this.storage.restore();
         await this.reporter.publish();
     }
     /**

package/dist/storage.d.ts

@@ -2,129 +2,20 @@ import { Attachment as Attach, GherkinDocument, Pickle, TestCaseFinished, TestCa
 import { StepStatusEnum, TestResultType, TestStatusEnum } from 'qase-javascript-commons';
 import { NetworkProfiler } from 'qase-javascript-commons/profilers';
 import { TestCase } from '@cucumber/messages/dist/esm/src/messages';
-import { Status } from '@cucumber/cucumber';
-type TestStepResultStatus = (typeof Status)[keyof typeof Status];
+import { TestStepResultStatus } from './modules/statusMaps';
 export declare class Storage {
-    /**
-     * @type {NetworkProfiler | null}
-     * @private
-     */
-    private profiler;
-    /**
-     * @type {Record<string, number>}
-     * @private
-     */
-    private profilerStepSnapshots;
+    static statusMap: Record<TestStepResultStatus, TestStatusEnum>;
+    static stepStatusMap: Record<TestStepResultStatus, StepStatusEnum>;
+    private events;
+    private statusTracker;
+    private profilerTracker;
     constructor(profiler?: NetworkProfiler | null);
-    /**
-     * @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
-     */
+    restore(): void;
     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;
-    /**
-     * @param {Pickle} pickle
-     * @param {number[]} ids
-     * @param {Record<string, string>} parameters
-     * @private
-     */
-    private getSignature;
-    private getError;
-    /**
-     * Normalize JSON string by converting single quotes to double quotes
-     * This allows parsing JSON-like strings with single quotes
-     * @param {string} jsonString
-     * @returns {string}
-     * @private
-     */
-    private normalizeJsonString;
-    private getFileNameFromMediaType;
 }
-export {};

package/dist/storage.js

@@ -1,496 +1,89 @@
 "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 uuid_1 = require("uuid");
-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=(.+)$/;
+const statusMaps_1 = require("./modules/statusMaps");
+const tagParser_1 = require("./modules/tagParser");
+const eventStorage_1 = require("./modules/eventStorage");
+const statusTracker_1 = require("./modules/statusTracker");
+const stepConverter_1 = require("./modules/stepConverter");
+const profilerTracker_1 = require("./modules/profilerTracker");
+const resultBuilder_1 = require("./modules/resultBuilder");
 class Storage {
-    /**
-     * @type {NetworkProfiler | null}
-     * @private
-     */
-    profiler;
-    /**
-     * @type {Record<string, number>}
-     * @private
-     */
-    profilerStepSnapshots = {};
+    static statusMap = statusMaps_1.STATUS_MAP;
+    static stepStatusMap = statusMaps_1.STEP_STATUS_MAP;
+    events = new eventStorage_1.EventStorage();
+    statusTracker = new statusTracker_1.StatusTracker();
+    profilerTracker;
     constructor(profiler = null) {
-        this.profiler = profiler;
+        this.profilerTracker = new profilerTracker_1.ProfilerTracker(profiler);
+    }
+    restore() {
+        this.profilerTracker.restore();
     }
-    /**
-     * @type {Record<string, Pickle>}
-     * @private
-     */
-    pickles = {};
-    /**
-     * @type {Record<string, TestCaseStarted>}
-     * @private
-     */
-    testCaseStarts = {};
-    /**
-     * @type {Record<string, TestStepFinished>}
-     * @private
-     */
-    testCaseSteps = {};
-    /**
-     * @type {Record<string, TestStatusEnum>}
-     * @private
-     */
-    testCaseStartedResult = {};
-    /**
-     * @type {Record<string, string[]>}
-     * @private
-     */
-    testCaseStartedErrors = {};
-    /**
-     * @type {Record<string, string>}
-     * @private
-     */
-    testCases = {};
-    /**
-     * @type {Record<string, string>}
-     * @private
-     */
-    scenarios = {};
-    /**
-     * @type {Record<string, string>}
-     * @private
-     */
-    attachments = {};
-    /**
-     * Add pickle to storage
-     * @param {Pickle} pickle
-     */
     addPickle(pickle) {
-        this.pickles[pickle.id] = pickle;
+        this.events.addPickle(pickle);
     }
-    /**
-     * Add scenario to storage
-     * @param {GherkinDocument} document
-     */
     addScenario(document) {
-        if (document.feature) {
-            const { children, name } = document.feature;
-            children.forEach(({ scenario }) => {
-                if (scenario) {
-                    const parameters = {};
-                    scenario.examples?.forEach((example) => {
-                        if (example.tableHeader && example.tableBody) {
-                            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: name,
-                        parameters: parameters,
-                    };
-                }
-            });
-        }
+        this.events.addScenario(document);
     }
-    /**
-     * Add attachment to storage
-     * @param {Attach} attachment
-     */
     addAttachment(attachment) {
-        if (attachment.testStepId) {
-            if (!this.attachments[attachment.testStepId]) {
-                this.attachments[attachment.testStepId] = [];
-            }
-            this.attachments[attachment.testStepId]?.push({
-                file_name: this.getFileNameFromMediaType(attachment.mediaType),
-                mime_type: attachment.mediaType,
-                file_path: null,
-                content: attachment.body,
-                size: 0,
-                id: (0, uuid_1.v4)(),
-            });
-        }
-        if (attachment.testCaseStartedId) {
-            if (!this.attachments[attachment.testCaseStartedId]) {
-                this.attachments[attachment.testCaseStartedId] = [];
-            }
-            this.attachments[attachment.testCaseStartedId]?.push({
-                file_name: this.getFileNameFromMediaType(attachment.mediaType),
-                mime_type: attachment.mediaType,
-                file_path: null,
-                content: attachment.body,
-                size: 0,
-                id: (0, uuid_1.v4)(),
-            });
-        }
+        this.events.addAttachment(attachment);
     }
-    /**
-     * Add test case to storage
-     * @param {TestCase} testCase
-     */
     addTestCase(testCase) {
-        this.testCases[testCase.id] = testCase;
+        this.events.addTestCase(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;
-        if (this.profiler) {
-            this.profilerStepSnapshots[testCaseStarted.id] = this.profiler.getAllSteps().length;
-        }
+        this.events.addTestCaseStarted(testCaseStarted);
+        this.statusTracker.onTestStarted(testCaseStarted.id);
+        this.profilerTracker.onTestStart(testCaseStarted.id);
     }
-    /**
-     * Add test case step to storage
-     * @param {TestStepFinished} testCaseStep
-     */
     addTestCaseStep(testCaseStep) {
-        const oldStatus = this.testCaseStartedResult[testCaseStep.testCaseStartedId];
-        // Create error object for status determination
-        let error = null;
-        if (testCaseStep.testStepResult.message) {
-            error = new Error(testCaseStep.testStepResult.message);
-        }
-        // Determine status based on error type
-        const newStatus = (0, qase_javascript_commons_1.determineTestStatus)(error, 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 && oldStatus !== qase_javascript_commons_1.TestStatusEnum.invalid) {
-                    this.testCaseStartedResult[testCaseStep.testCaseStartedId] = newStatus;
-                }
-            }
-            else {
-                this.testCaseStartedResult[testCaseStep.testCaseStartedId] = newStatus;
-            }
-        }
+        this.events.addTestStepFinished(testCaseStep);
+        this.statusTracker.applyStep(testCaseStep);
     }
-    /**
-     * Convert test case to test result
-     * @param {TestCaseFinished} testCase
-     * @returns {undefined | TestResultType}
-     */
     convertTestCase(testCase) {
-        const tcs = this.testCaseStarts[testCase.testCaseStartedId];
-        if (!tcs) {
+        const tcs = this.events.getTestCaseStarted(testCase.testCaseStartedId);
+        if (!tcs)
             return undefined;
-        }
-        const tc = this.testCases[tcs.testCaseId];
-        if (!tc) {
+        const tc = this.events.getTestCase(tcs.testCaseId);
+        if (!tc)
             return undefined;
-        }
-        const pickle = this.pickles[tc.pickleId];
-        if (!pickle) {
+        const pickle = this.events.getPickle(tc.pickleId);
+        if (!pickle)
             return undefined;
-        }
-        const metadata = this.parseTags(pickle.tags);
-        if (metadata.isIgnore) {
+        const metadata = tagParser_1.TagParser.parse(pickle.tags);
+        if (metadata.isIgnore)
             return undefined;
-        }
-        const error = this.getError(tcs.id);
-        let relations = null;
-        let params = {};
+        const error = this.statusTracker.getErrors(tcs.id);
+        const status = this.statusTracker.getStatus(testCase.testCaseStartedId);
         const nodeId = pickle.astNodeIds[0];
-        // If suite is specified in metadata, use it (split by tab for sub-suites)
-        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 (nodeId != undefined && this.scenarios[nodeId] != undefined) {
-            // Otherwise, use feature name as suite
-            relations = {
-                suite: {
-                    data: [
-                        {
-                            title: this.scenarios[nodeId]?.name ?? '',
-                            public_id: null,
-                        },
-                    ],
-                },
-            };
-        }
-        // Extract parameters from Gherkin examples
-        if (nodeId != undefined && this.scenarios[nodeId] != undefined) {
+        const scenario = nodeId !== undefined ? this.events.getScenario(nodeId) : undefined;
+        let scenarioParameters = {};
+        if (scenario) {
             for (const id of pickle.astNodeIds) {
-                if (this.scenarios[nodeId]?.parameters[id] != undefined) {
-                    params = { ...params, ...this.scenarios[nodeId]?.parameters[id] };
-                }
-            }
-        }
-        // Merge parameters from tags with parameters from Gherkin examples
-        // Parameters from tags take precedence over Gherkin examples
-        params = { ...params, ...metadata.parameters };
-        const steps = this.convertSteps(pickle.steps, tc);
-        // Collect profiler steps since this test case started
-        let profilerSteps = [];
-        if (this.profiler) {
-            const snapshot = this.profilerStepSnapshots[testCase.testCaseStartedId] ?? 0;
-            const allSteps = this.profiler.getAllSteps();
-            profilerSteps = allSteps.slice(snapshot);
-            delete this.profilerStepSnapshots[testCase.testCaseStartedId];
-        }
-        const hasProjectMapping = Object.keys(metadata.projectMapping).length > 0;
-        const result = {
-            attachments: this.attachments[testCase.testCaseStartedId] ?? [],
-            author: null,
-            execution: {
-                status: this.testCaseStartedResult[testCase.testCaseStartedId] ?? qase_javascript_commons_1.TestStatusEnum.passed,
-                start_time: tcs.timestamp.seconds,
-                end_time: testCase.timestamp.seconds,
-                duration: Math.abs(testCase.timestamp.seconds - tcs.timestamp.seconds) * 1000,
-                stacktrace: error?.stacktrace ?? null,
-                thread: null,
-            },
-            fields: metadata.fields,
-            message: error?.message ?? null,
-            muted: false,
-            params: params,
-            group_params: metadata.group_params,
-            relations: relations,
-            run_id: null,
-            signature: this.getSignature(pickle, metadata.ids, params),
-            steps: [...steps, ...profilerSteps],
-            testops_id: metadata.ids.length > 0 ? metadata.ids : null,
-            testops_project_mapping: hasProjectMapping ? metadata.projectMapping : null,
-            id: tcs.id,
-            title: metadata.title ?? pickle.name,
-            tags: metadata.tags,
-        };
-        return result;
-    }
-    /**
-     * 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 * 1000,
-                },
-                attachments: this.attachments[s.id] ?? [],
-                steps: [],
-                parent_id: null,
-            };
-            results.push(result);
-        }
-        return results;
-    }
-    /**
-     * @type {Record<TestStepResultStatus, TestStatusEnum>}
-     */
-    static 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.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,
-    };
-    /**
-     * @type {Record<TestStepResultStatus, StepStatusEnum>}
-     */
-    static 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,
-    };
-    parseTags(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(this.normalizeJsonString(value));
-                    metadata.fields = { ...metadata.fields, ...record };
-                }
-                catch (e) {
-                    // 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(this.normalizeJsonString(value));
-                    metadata.parameters = { ...metadata.parameters, ...record };
-                }
-                catch (e) {
-                    // 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(this.normalizeJsonString(value));
-                    metadata.group_params = { ...metadata.group_params, ...record };
+                const params = scenario.parameters[id];
+                if (params) {
+                    scenarioParameters = { ...scenarioParameters, ...params };
                 }
-                catch (e) {
-                    // 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;
-    }
-    /**
-     * @param {Pickle} pickle
-     * @param {number[]} ids
-     * @param {Record<string, string>} parameters
-     * @private
-     */
-    getSignature(pickle, ids, parameters = {}) {
-        return (0, qase_javascript_commons_1.generateSignature)(ids, [...pickle.uri.split('/'), pickle.name], parameters);
-    }
-    getError(testCaseId) {
-        const testErrors = this.testCaseStartedErrors[testCaseId];
-        if (!testErrors) {
-            return undefined;
-        }
-        const error = new qase_javascript_commons_1.CompoundError();
-        testErrors.forEach((message) => {
-            error.addMessage(message);
-            error.addStacktrace(message);
+        const steps = stepConverter_1.StepConverter.convert(pickle.steps, tc, this.events.getAllTestStepFinished(), (stepId) => this.events.getAttachments(stepId));
+        const profilerSteps = this.profilerTracker.getEvents(testCase.testCaseStartedId);
+        this.profilerTracker.reset(testCase.testCaseStartedId);
+        return resultBuilder_1.ResultBuilder.build({
+            testCaseFinished: testCase,
+            testCaseStarted: tcs,
+            testCase: tc,
+            pickle,
+            metadata,
+            status,
+            error,
+            steps,
+            profilerSteps,
+            attachments: this.events.getAttachments(testCase.testCaseStartedId),
+            scenarioName: scenario?.name,
+            scenarioParameters,
         });
-        return error;
-    }
-    /**
-     * Normalize JSON string by converting single quotes to double quotes
-     * This allows parsing JSON-like strings with single quotes
-     * @param {string} jsonString
-     * @returns {string}
-     * @private
-     */
-    normalizeJsonString(jsonString) {
-        // If the string contains single quotes, convert them to double quotes
-        // This handles cases like {'key':'value'} which should be {"key":"value"}
-        if (jsonString.includes("'")) {
-            return jsonString.replace(/'/g, '"');
-        }
-        // If no single quotes, return as-is (already valid JSON or will fail with proper error)
-        return jsonString;
-    }
-    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];
-        if (extension) {
-            return `file.${extension}`;
-        }
-        else {
-            return 'file';
-        }
     }
 }
 exports.Storage = Storage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cucumberjs-qase-reporter",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "Qase TMS CucumberJS Reporter",
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "main": "./dist/index.js",