jest-qase-reporter 2.0.2 → 2.0.4

package/README.md

@@ -59,7 +59,6 @@ module.exports = {
 Now, run the Jest tests as usual.
 Test results will be reported to a new test run in Qase.
 
-
 ```console
 $ npx jest
 Determining test suites to run...
@@ -79,32 +78,49 @@ and suites from your test data.
 But if necessary, you can independently register the ID of already
 existing test cases from TMS before the executing tests. For example:
 
-```typescript
-const { qase } = require("jest-qase-reporter/jest");
+### Metadata
 
-describe('My First Test', () => {
-    test(qase([1,2], 'Several ids'), () => {
-        expect(true).toBe(true);
-    })
+- `qase.title` - set the title of the test case
+- `qase.fields` - set the fields of the test case
+- `qase.suite` - set the suite of the test case
+- `qase.comment` - set the comment of the test case
+- `qase.parameters` - set the parameters of the test case
+- `qase.groupParameters` - set the group parameters of the test case
+- `qase.ignore` - ignore the test case in Qase. The test will be executed, but the results will not be sent to Qase.
+- `qase.step` - create a step in the test case
+- `qase.attach` - attach a file to the test case
 
-    test(qase(3, 'Correct test'), () => {
-        expect(true).toBe(true);
-    })
-
-    test.skip(qase("4", 'Skipped test'), () => {
-        expect(true).toBe(true);
-    })
+```typescript
+const { qase } = require('jest-qase-reporter/jest');
 
-    test(qase(["5", "6"], 'Failed test'), () => {
-        expect(true).toBe(false);
-    })
+describe('My First Test', () => {
+  test(qase([1, 2], 'Several ids'), () => {
+    expect(true).toBe(true);
+  });
+
+  test(qase(3, 'Correct test'), () => {
+    qase.title('Title');
+    expect(true).toBe(true);
+  });
+
+  test.skip(qase('4', 'Skipped test'), () => {
+    expect(true).toBe(true);
+  });
+
+  test(qase(['5', '6'], 'Failed test'), () => {
+    expect(true).toBe(false);
+  });
 });
 ```
+
 To run tests and create a test run, execute the command (for example from folder examples):
+
 ```bash
 QASE_MODE=testops npx jest
 ```
+
 or
+
 ```bash
 npm test
 ```
@@ -125,10 +141,9 @@ Reporter options (* - required):
 
 - `mode` - `testops`/`off` Enables reporter, default - `off`
 - `debug` - Enables debug logging, default - `false`
-- `environment` - To execute with the sending of the envinroment information 
-- *`testops.api.token` - Token for API access, you can find more information
-  [here](https://developers.qase.io/#authentication)
-- *`testops.project` - Qase project code, for example, in https://app.qase.io/project/DEMO the code is `DEMO`
+- `environment` - To execute with the sending of the envinroment information
+- *`testops.api.token` - Token for API access, you can generate it [here](https://developers.qase.io/#authentication).
+- *`testops.project` - [Your project's code](https://help.qase.io/en/articles/9787250-how-do-i-find-my-project-code)
 - `testops.run.id` - Qase test run ID, used when the test run was created earlier using CLI or API call.
 - `testops.run.title` - Set custom Run name, when new run is created
 - `testops.run.description` - Set custom Run description, when new run is created
@@ -167,7 +182,7 @@ Supported ENV variables:
 
 - `QASE_MODE` - Same as `mode`
 - `QASE_DEBUG` - Same as `debug`
-- `QASE_ENVIRONMENT` - Same as `environment` 
+- `QASE_ENVIRONMENT` - Same as `environment`
 - `QASE_TESTOPS_API_TOKEN` - Same as `testops.api.token`
 - `QASE_TESTOPS_PROJECT` - Same as `testops.project`
 - `QASE_TESTOPS_RUN_ID` - Pass Run ID from ENV and override reporter option `testops.run.id`
@@ -176,7 +191,8 @@ Supported ENV variables:
 
 ## Requirements
 
-We maintain the reporter on LTS versions of Node. You can find the current versions by following the [link](https://nodejs.org/en/about/releases/)
+We maintain the reporter on LTS versions of Node. You can find the current versions by following
+the [link](https://nodejs.org/en/about/releases/)
 
 `jest >= 28.0.0`
 

package/changelog.md

@@ -1,9 +1,52 @@
+# jest-qase-reporter@2.0.4
+
+## What's new
+
+Improved test name processing: Qase IDs are now automatically removed when uploading results
+
+# jest-qase-reporter@2.0.3
+
+## What's new
+
+Added the ability to specify a test metadata in tests:
+
+- `qase.title` - set the test title
+- `qase.fields` - set the test fields
+- `qase.suite` - set the test suite
+- `qase.comment` - set the test comment
+- `qase.parameters` - set the test parameters
+- `qase.groupParameters` - set the test group parameters
+- `qase.ignore` - ignore the test in Qase
+- `qase.attach` - attach a file to the test
+- `qase.steps` - add the test steps
+
+```ts
+const { qase } = require('jest-qase-reporter/jest');
+
+test('test', () => {
+  qase.title('Title');
+  qase.fields({ custom_field: 'value' });
+  qase.suite('Suite');
+  qase.comment('Comment');
+  qase.parameters({ param01: 'value' });
+  qase.groupParameters({ param02: 'value' });
+  qase.ignore();
+  qase.attach({ name: 'attachment.txt', content: 'Hello, world!', type: 'text/plain' });
+
+  qase.step('Step 1', () => {
+    expect(true).toBe(true);
+  });
+
+  expect(true).toBe(true);
+});
+```
+
 # jest-qase-reporter@2.0.1
 
 ## What's new
 
 Fixed a bug when a test was marked as skipped.
-This reporter has uploaded this test as blocked. 
+This reporter has uploaded this test as blocked.
 Right now the reporter will upload this test as skipped.
 
 # jest-qase-reporter@2.0.0

package/dist/global.d.ts

@@ -0,0 +1,23 @@
+import { JestQaseReporter } from './reporter';
+import { Attachment, TestStepType } from 'qase-javascript-commons';
+declare global {
+    namespace NodeJS {
+        interface Global {
+            Qase: Qase;
+        }
+    }
+}
+export declare class Qase {
+    private reporter;
+    constructor(reporter: JestQaseReporter);
+    title(title: string): void;
+    ignore(): void;
+    comment(value: string): void;
+    suite(value: string): void;
+    fields(values: Record<string, string>): void;
+    parameters(values: Record<string, string>): void;
+    groupParams(values: Record<string, string>): void;
+    step(step: TestStepType): void;
+    attachment(attachment: Attachment): void;
+}
+export {};

package/dist/global.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Qase = void 0;
+class Qase {
+    reporter;
+    constructor(reporter) {
+        this.reporter = reporter;
+    }
+    title(title) {
+        this.reporter.addTitle(title);
+    }
+    ignore() {
+        this.reporter.addIgnore();
+    }
+    comment(value) {
+        this.reporter.addComment(value);
+    }
+    suite(value) {
+        this.reporter.addSuite(value);
+    }
+    fields(values) {
+        const stringRecord = {};
+        for (const [key, value] of Object.entries(values)) {
+            stringRecord[String(key)] = String(value);
+        }
+        this.reporter.addFields(stringRecord);
+    }
+    parameters(values) {
+        const stringRecord = {};
+        for (const [key, value] of Object.entries(values)) {
+            stringRecord[String(key)] = String(value);
+        }
+        this.reporter.addParameters(stringRecord);
+    }
+    groupParams(values) {
+        const stringRecord = {};
+        for (const [key, value] of Object.entries(values)) {
+            stringRecord[String(key)] = String(value);
+        }
+        this.reporter.addGroupParams(stringRecord);
+    }
+    step(step) {
+        this.reporter.addStep(step);
+    }
+    attachment(attachment) {
+        this.reporter.addAttachment(attachment);
+    }
+}
+exports.Qase = Qase;

package/dist/jest.d.ts

@@ -1 +1,102 @@
-export declare const qase: (caseId: number | string | number[] | string[], name: string) => string;
+import { StepFunction } from './step';
+export declare const qase: {
+    (caseId: number | string | number[] | string[], name: string): string;
+    /**
+     * Set a title for the test case
+     * @param {string} value
+     * @example
+     * test('test', () => {
+     *    qase.title("Title");
+     *     expect(true).toBe(true);
+     * });
+     */
+    title(value: string): void;
+    /**
+     * Ignore the test case
+     * @example
+     * test('test', () => {
+     *    qase.ignore();
+     *     expect(true).toBe(true);
+     * });
+     */
+    ignore(): void;
+    /**
+     * Add a comment to the test case
+     * @param {string} value
+     * @example
+     * test('test', () => {
+     *    qase.comment("Comment");
+     *     expect(true).toBe(true);
+     * });
+     */
+    comment(value: string): void;
+    /**
+     * Set a suite for the test case
+     * @param {string} value
+     * @example
+     * test('test', () => {
+     *    qase.suite("Suite");
+     *     expect(true).toBe(true);
+     * });
+     */
+    suite(value: string): void;
+    /**
+     * Set fields for the test case
+     * @param {Record<string, string>} values
+     * @example
+     * test('test', () => {
+     *    qase.fields({field: "value"});
+     *     expect(true).toBe(true);
+     * });
+     */
+    fields(values: Record<string, string>): void;
+    /**
+     * Set parameters for the test case
+     * @param {Record<string, string>} values
+     * @example
+     * test('test', () => {
+     *    qase.parameters({param: "value"});
+     *     expect(true).toBe(true);
+     * });
+     */
+    parameters(values: Record<string, string>): void;
+    /**
+     * Set group params for the test case
+     * @param {Record<string, string>} values
+     * @example
+     * test('test', () => {
+     *    qase.groupParameters({param: "value"});
+     *     expect(true).toBe(true);
+     * });
+     */
+    groupParameters(values: Record<string, string>): void;
+    /**
+     * Add a step to the test case
+     * @param name
+     * @param body
+     * @example
+     * test('test', () => {
+     *    qase.step("Step", () => {
+     *      expect(true).toBe(true);
+     *    });
+     *     expect(true).toBe(true);
+     * });
+     */
+    step(name: string, body: StepFunction): Promise<void>;
+    /**
+     * Add an attachment to the test case
+     * @param attach
+     * @example
+     * test('test', () => {
+     *   qase.attach({ name: 'attachment.txt', content: 'Hello, world!', type: 'text/plain' });
+     *   qase.attach({ paths: ['/path/to/file', '/path/to/another/file']});
+     *     expect(true).toBe(true);
+     * });
+     */
+    attach(attach: {
+        name?: string;
+        type?: string;
+        content?: string;
+        paths?: string[];
+    }): void;
+};

package/dist/jest.js

@@ -1,8 +1,152 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.qase = void 0;
+const step_1 = require("./step");
+const path_1 = __importDefault(require("path"));
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const uuid_1 = require("uuid");
 const qase = (caseId, name) => {
     const caseIds = Array.isArray(caseId) ? caseId : [caseId];
     return `${name} (Qase ID: ${caseIds.join(',')})`;
 };
 exports.qase = qase;
+/**
+ * Set a title for the test case
+ * @param {string} value
+ * @example
+ * test('test', () => {
+ *    qase.title("Title");
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.title = (value) => {
+    global.Qase.title(value);
+};
+/**
+ * Ignore the test case
+ * @example
+ * test('test', () => {
+ *    qase.ignore();
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.ignore = () => {
+    global.Qase.ignore();
+};
+/**
+ * Add a comment to the test case
+ * @param {string} value
+ * @example
+ * test('test', () => {
+ *    qase.comment("Comment");
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.comment = (value) => {
+    global.Qase.comment(value);
+};
+/**
+ * Set a suite for the test case
+ * @param {string} value
+ * @example
+ * test('test', () => {
+ *    qase.suite("Suite");
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.suite = (value) => {
+    global.Qase.suite(value);
+};
+/**
+ * Set fields for the test case
+ * @param {Record<string, string>} values
+ * @example
+ * test('test', () => {
+ *    qase.fields({field: "value"});
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.fields = (values) => {
+    global.Qase.fields(values);
+};
+/**
+ * Set parameters for the test case
+ * @param {Record<string, string>} values
+ * @example
+ * test('test', () => {
+ *    qase.parameters({param: "value"});
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.parameters = (values) => {
+    global.Qase.parameters(values);
+};
+/**
+ * Set group params for the test case
+ * @param {Record<string, string>} values
+ * @example
+ * test('test', () => {
+ *    qase.groupParameters({param: "value"});
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.groupParameters = (values) => {
+    global.Qase.groupParams(values);
+};
+/**
+ * Add a step to the test case
+ * @param name
+ * @param body
+ * @example
+ * test('test', () => {
+ *    qase.step("Step", () => {
+ *      expect(true).toBe(true);
+ *    });
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.step = async (name, body) => {
+    const runningStep = new step_1.QaseStep(name);
+    // eslint-disable-next-line @typescript-eslint/require-await
+    await runningStep.run(body, async (step) => global.Qase.step(step));
+};
+/**
+ * Add an attachment to the test case
+ * @param attach
+ * @example
+ * test('test', () => {
+ *   qase.attach({ name: 'attachment.txt', content: 'Hello, world!', type: 'text/plain' });
+ *   qase.attach({ paths: ['/path/to/file', '/path/to/another/file']});
+ *     expect(true).toBe(true);
+ * });
+ */
+exports.qase.attach = (attach) => {
+    if (attach.paths) {
+        for (const file of attach.paths) {
+            const attachmentName = path_1.default.basename(file);
+            const contentType = (0, qase_javascript_commons_1.getMimeTypes)(file);
+            global.Qase.attachment({
+                file_path: file,
+                size: 0,
+                id: (0, uuid_1.v4)(),
+                file_name: attachmentName,
+                mime_type: contentType,
+                content: '',
+            });
+        }
+        return;
+    }
+    if (attach.content) {
+        global.Qase.attachment({
+            file_path: null,
+            size: attach.content.length,
+            id: (0, uuid_1.v4)(),
+            file_name: attach.name ?? 'attachment',
+            mime_type: attach.type ?? 'application/octet-stream',
+            content: attach.content,
+        });
+    }
+};

package/dist/models.d.ts

@@ -0,0 +1,12 @@
+import { Attachment, TestStepType } from 'qase-javascript-commons';
+export interface Metadata {
+    title: string | undefined;
+    ignore: boolean;
+    comment: string | undefined;
+    suite: string | undefined;
+    fields: Record<string, string>;
+    parameters: Record<string, string>;
+    groupParams: Record<string, string>;
+    steps: TestStepType[];
+    attachments: Attachment[];
+}

package/dist/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/reporter.d.ts

@@ -1,6 +1,6 @@
 import { Config, Reporter, Test, TestResult } from '@jest/reporters';
-import { Status } from '@jest/test-result';
-import { ConfigLoader, ConfigType, TestStatusEnum } from 'qase-javascript-commons';
+import { Status, TestCaseResult } from '@jest/test-result';
+import { Attachment, ConfigLoader, ConfigType, TestStatusEnum, TestStepType } from 'qase-javascript-commons';
 export type JestQaseOptionsType = ConfigType;
 /**
  * @class JestQaseReporter
@@ -17,7 +17,7 @@ export declare class JestQaseReporter implements Reporter {
     static qaseIdRegExp: RegExp;
     /**
      * @param {string} title
-     * @returns {any}
+     * @returns {number[]}
      * @private
      */
     private static getCaseId;
@@ -26,6 +26,11 @@ export declare class JestQaseReporter implements Reporter {
      * @private
      */
     private reporter;
+    /**
+     * @type {Metadata}
+     * @private
+     */
+    private metadata;
     /**
      * @param {Config.GlobalConfig} _
      * @param {JestQaseOptionsType} options
@@ -37,6 +42,7 @@ export declare class JestQaseReporter implements Reporter {
      * @see {Reporter.onRunStart}
      */
     onRunStart(): void;
+    onTestCaseResult(test: Test, testCaseResult: TestCaseResult): void;
     /**
      * @param {Test} _
      * @param {TestResult} result
@@ -68,4 +74,32 @@ export declare class JestQaseReporter implements Reporter {
      * @private
      */
     private getCurrentTestPath;
+    addTitle(title: string): void;
+    addComment(comment: string): void;
+    addSuite(suite: string): void;
+    addFields(fields: Record<string, string>): void;
+    addParameters(parameters: Record<string, string>): void;
+    addGroupParams(groupParams: Record<string, string>): void;
+    addIgnore(): void;
+    addStep(step: TestStepType): void;
+    addAttachment(attachment: Attachment): void;
+    private cleanMetadata;
+    /**
+     * @param {AssertionResult} value
+     * @param {string} path
+     * @private
+     * @returns {TestResultType}
+     */
+    private convertToResult;
+    /**
+     * @returns {Metadata}
+     * @private
+     */
+    private createEmptyMetadata;
+    /**
+     * @param {string} title
+     * @returns {string}
+     * @private
+     */
+    private removeQaseIdsFromTitle;
 }

package/dist/reporter.js

@@ -8,20 +8,47 @@ const lodash_has_1 = __importDefault(require("lodash.has"));
 const lodash_get_1 = __importDefault(require("lodash.get"));
 const uuid_1 = require("uuid");
 const qase_javascript_commons_1 = require("qase-javascript-commons");
+const global_1 = require("./global");
 /**
  * @class JestQaseReporter
  * @implements Reporter
  */
 class JestQaseReporter {
+    /**
+     * @type {Record<Status, TestStatusEnum>}
+     */
+    static statusMap = {
+        passed: qase_javascript_commons_1.TestStatusEnum.passed,
+        failed: qase_javascript_commons_1.TestStatusEnum.failed,
+        skipped: qase_javascript_commons_1.TestStatusEnum.skipped,
+        disabled: qase_javascript_commons_1.TestStatusEnum.disabled,
+        pending: qase_javascript_commons_1.TestStatusEnum.skipped,
+        todo: qase_javascript_commons_1.TestStatusEnum.disabled,
+        focused: qase_javascript_commons_1.TestStatusEnum.passed,
+    };
+    /**
+     * @type {RegExp}
+     */
+    static qaseIdRegExp = /\(Qase ID: ([\d,]+)\)/;
     /**
      * @param {string} title
-     * @returns {any}
+     * @returns {number[]}
      * @private
      */
     static getCaseId(title) {
         const [, ids] = title.match(JestQaseReporter.qaseIdRegExp) ?? [];
         return ids ? ids.split(',').map((id) => Number(id)) : [];
     }
+    /**
+     * @type {ReporterInterface}
+     * @private
+     */
+    reporter;
+    /**
+     * @type {Metadata}
+     * @private
+     */
+    metadata;
     /**
      * @param {Config.GlobalConfig} _
      * @param {JestQaseOptionsType} options
@@ -36,6 +63,8 @@ class JestQaseReporter {
             frameworkName: 'jest',
             reporterName: 'jest-qase-reporter',
         });
+        global.Qase = new global_1.Qase(this);
+        this.metadata = this.createEmptyMetadata();
     }
     /**
      * @see {Reporter.onRunStart}
@@ -43,49 +72,59 @@ class JestQaseReporter {
     onRunStart() {
         void this.reporter.startTestRun();
     }
+    onTestCaseResult(test, testCaseResult) {
+        if (this.metadata.ignore) {
+            this.cleanMetadata();
+            return;
+        }
+        const result = this.convertToResult(testCaseResult, test.path);
+        if (this.metadata.title) {
+            result.title = this.metadata.title;
+        }
+        if (this.metadata.comment) {
+            result.message = this.metadata.comment;
+        }
+        if (this.metadata.suite) {
+            result.relations = {
+                suite: {
+                    data: [
+                        {
+                            title: this.metadata.suite,
+                            public_id: null,
+                        },
+                    ],
+                },
+            };
+        }
+        if (Object.keys(this.metadata.fields).length > 0) {
+            result.fields = this.metadata.fields;
+        }
+        if (Object.keys(this.metadata.parameters).length > 0) {
+            result.params = this.metadata.parameters;
+        }
+        if (Object.keys(this.metadata.groupParams).length > 0) {
+            result.group_params = this.metadata.groupParams;
+        }
+        if (this.metadata.steps.length > 0) {
+            result.steps = this.metadata.steps;
+        }
+        if (this.metadata.attachments.length > 0) {
+            result.attachments = this.metadata.attachments;
+        }
+        this.cleanMetadata();
+        void this.reporter.addTestResult(result);
+    }
     /**
      * @param {Test} _
      * @param {TestResult} result
      */
     onTestResult(_, result) {
-        console.log(result);
-        result.testResults.forEach(({ title, fullName, ancestorTitles, status, duration, failureMessages, failureDetails, }) => {
-            let error;
-            if (status === 'failed') {
-                error = new Error(failureDetails.map((item) => {
-                    if ((0, lodash_has_1.default)(item, 'matcherResult.message')) {
-                        return String((0, lodash_get_1.default)(item, 'matcherResult.message'));
-                    }
-                    return 'Runtime exception';
-                }).join('\n\n'));
-                error.stack = failureMessages.join('\n\n');
+        result.testResults.forEach((value) => {
+            if (value.status !== 'pending') {
+                return;
             }
-            const ids = JestQaseReporter.getCaseId(title);
-            const filePath = this.getCurrentTestPath(result.testFilePath);
-            void this.reporter.addTestResult({
-                attachments: [],
-                author: null,
-                execution: {
-                    status: JestQaseReporter.statusMap[status],
-                    start_time: null,
-                    end_time: null,
-                    duration: duration ?? 0,
-                    stacktrace: error?.stack ?? null,
-                    thread: null,
-                },
-                fields: {},
-                message: error?.message ?? null,
-                muted: false,
-                params: {},
-                group_params: {},
-                relations: this.getRelations(filePath, ancestorTitles),
-                run_id: null,
-                signature: this.getSignature(filePath, fullName, ids),
-                steps: [],
-                testops_id: ids.length > 0 ? ids : null,
-                id: (0, uuid_1.v4)(),
-                title: title,
-            });
+            const model = this.convertToResult(value, result.testFilePath);
+            void this.reporter.addTestResult(model);
         });
     }
     /**
@@ -146,21 +185,108 @@ class JestQaseReporter {
         const executionPath = process.cwd() + '/';
         return fullPath.replace(executionPath, '');
     }
+    addTitle(title) {
+        this.metadata.title = title;
+    }
+    addComment(comment) {
+        this.metadata.comment = comment;
+    }
+    addSuite(suite) {
+        this.metadata.suite = suite;
+    }
+    addFields(fields) {
+        this.metadata.fields = fields;
+    }
+    addParameters(parameters) {
+        this.metadata.parameters = parameters;
+    }
+    addGroupParams(groupParams) {
+        this.metadata.groupParams = groupParams;
+    }
+    addIgnore() {
+        this.metadata.ignore = true;
+    }
+    addStep(step) {
+        this.metadata.steps.push(step);
+    }
+    addAttachment(attachment) {
+        this.metadata.attachments.push(attachment);
+    }
+    cleanMetadata() {
+        this.metadata = this.createEmptyMetadata();
+    }
+    /**
+     * @param {AssertionResult} value
+     * @param {string} path
+     * @private
+     * @returns {TestResultType}
+     */
+    convertToResult(value, path) {
+        let error;
+        if (value.status === 'failed') {
+            error = new Error(value.failureDetails.map((item) => {
+                if ((0, lodash_has_1.default)(item, 'matcherResult.message')) {
+                    return String((0, lodash_get_1.default)(item, 'matcherResult.message'));
+                }
+                return 'Runtime exception';
+            }).join('\n\n'));
+            error.stack = value.failureMessages.join('\n\n');
+        }
+        const ids = JestQaseReporter.getCaseId(value.title);
+        const filePath = this.getCurrentTestPath(path);
+        return {
+            attachments: [],
+            author: null,
+            execution: {
+                status: JestQaseReporter.statusMap[value.status],
+                start_time: null,
+                end_time: null,
+                duration: value.duration ?? 0,
+                stacktrace: error?.stack ?? null,
+                thread: null,
+            },
+            fields: {},
+            message: error?.message ?? null,
+            muted: false,
+            params: {},
+            group_params: {},
+            relations: this.getRelations(filePath, value.ancestorTitles),
+            run_id: null,
+            signature: this.getSignature(filePath, value.fullName, ids),
+            steps: [],
+            testops_id: ids.length > 0 ? ids : null,
+            id: (0, uuid_1.v4)(),
+            title: this.removeQaseIdsFromTitle(value.title),
+        };
+    }
+    /**
+     * @returns {Metadata}
+     * @private
+     */
+    createEmptyMetadata() {
+        return {
+            title: undefined,
+            ignore: false,
+            comment: undefined,
+            suite: undefined,
+            fields: {},
+            parameters: {},
+            groupParams: {},
+            steps: [],
+            attachments: [],
+        };
+    }
+    /**
+     * @param {string} title
+     * @returns {string}
+     * @private
+     */
+    removeQaseIdsFromTitle(title) {
+        const matches = title.match(/\(Qase ID: ([0-9,]+)\)$/i);
+        if (matches) {
+            return title.replace(matches[0], '').trimEnd();
+        }
+        return title;
+    }
 }
 exports.JestQaseReporter = JestQaseReporter;
-/**
- * @type {Record<Status, TestStatusEnum>}
- */
-JestQaseReporter.statusMap = {
-    passed: qase_javascript_commons_1.TestStatusEnum.passed,
-    failed: qase_javascript_commons_1.TestStatusEnum.failed,
-    skipped: qase_javascript_commons_1.TestStatusEnum.skipped,
-    disabled: qase_javascript_commons_1.TestStatusEnum.disabled,
-    pending: qase_javascript_commons_1.TestStatusEnum.skipped,
-    todo: qase_javascript_commons_1.TestStatusEnum.disabled,
-    focused: qase_javascript_commons_1.TestStatusEnum.passed,
-};
-/**
- * @type {RegExp}
- */
-JestQaseReporter.qaseIdRegExp = /\(Qase ID: ([\d,]+)\)/;

package/dist/step.d.ts

@@ -0,0 +1,16 @@
+import { Attachment, TestStepType } from 'qase-javascript-commons';
+export type StepFunction<T = any> = (this: QaseStep, step: QaseStep) => T | Promise<T>;
+export declare class QaseStep {
+    name: string;
+    attachments: Attachment[];
+    steps: TestStepType[];
+    constructor(name: string);
+    attach(attach: {
+        name?: string;
+        type?: string;
+        content?: string;
+        paths?: string[] | string;
+    }): void;
+    step(name: string, body: StepFunction): Promise<void>;
+    run(body: StepFunction, messageEmitter: (step: TestStepType) => Promise<void>): Promise<void>;
+}

package/dist/step.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QaseStep = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const uuid_1 = require("uuid");
+const path_1 = __importDefault(require("path"));
+// TODO: Move to common, because it's duplicated in qase-wdio/src/step.ts
+class QaseStep {
+    name = '';
+    attachments = [];
+    steps = [];
+    constructor(name) {
+        this.name = name;
+    }
+    attach(attach) {
+        if (attach.paths) {
+            const files = Array.isArray(attach.paths) ? attach.paths : [attach.paths];
+            for (const file of files) {
+                const attachmentName = path_1.default.basename(file);
+                const contentType = 'application/octet-stream';
+                this.attachments.push({
+                    id: (0, uuid_1.v4)(),
+                    file_name: attachmentName,
+                    mime_type: contentType,
+                    content: '',
+                    file_path: file,
+                    size: 0,
+                });
+            }
+            return;
+        }
+        if (attach.content) {
+            const attachmentName = attach.name ?? 'attachment';
+            const contentType = attach.type ?? 'application/octet-stream';
+            this.attachments.push({
+                id: (0, uuid_1.v4)(),
+                file_name: attachmentName,
+                mime_type: contentType,
+                content: attach.content,
+                file_path: null,
+                size: attach.content.length,
+            });
+        }
+    }
+    async step(name, body) {
+        const childStep = new QaseStep(name);
+        // eslint-disable-next-line @typescript-eslint/require-await
+        await childStep.run(body, async (step) => {
+            this.steps.push(step);
+        });
+    }
+    async run(body, messageEmitter) {
+        const startDate = new Date().getTime();
+        const step = new qase_javascript_commons_1.TestStepType();
+        step.data = {
+            action: this.name,
+            expected_result: null,
+        };
+        try {
+            await body.call(this, this);
+            step.execution = {
+                start_time: startDate,
+                end_time: new Date().getTime(),
+                status: qase_javascript_commons_1.StepStatusEnum.passed,
+                duration: null,
+            };
+            step.attachments = this.attachments;
+            step.steps = this.steps;
+            await messageEmitter(step);
+        }
+        catch (e) {
+            step.execution = {
+                start_time: startDate,
+                end_time: new Date().getTime(),
+                status: qase_javascript_commons_1.StepStatusEnum.failed,
+                duration: null,
+            };
+            step.attachments = this.attachments;
+            step.steps = this.steps;
+            await messageEmitter(step);
+            throw e;
+        }
+    }
+}
+exports.QaseStep = QaseStep;

package/docs/usage.md

@@ -0,0 +1,209 @@
+# Qase Syntax
+
+> [**Click here**](../../examples/jest/test) to view Example tests for the following syntax.
+
+Here is the complete list of syntax options available for the reporter:
+- [Qase Id](#qase-id)
+- [Qase Title](#qase-title)
+- [Steps](#steps)
+- [Fields](#fields)
+- [Suite](#suite)
+- [Parameters](#parameters)
+- [Comment](#comment)
+- [Attach](#attach)
+- [Ignore](#ignore)
+
+If you do not use any Qase syntax, the reporter uses the title from the `describe` and `test` functions as the Suite and Test case title respectively, when publishing results.
+
+<br>
+
+### Import Statement
+---
+Add the following statement at the beginning of your spec file, before any tests.
+
+```javascript
+const { qase } = require("jest-qase-reporter/jest");
+```
+<br>
+
+### Qase ID
+---
+
+You can link one or more Qase Ids to a test.
+
+```javascript
+test(qase(1, "A test with Qase Id"), () => {
+    ..
+    
+test(qase(['2', '3'], "A test with multiple Qase Ids"), () => {
+    ..
+```
+
+<br>
+
+### Qase Title
+--- 
+
+The `qase.title()` method is used to set the title of a test case, both when creating a new test case from the result, and when updating the title of an existing test case - *if used with `qase.id()`.*
+
+```javascript
+test("This won't appear in Qase", () => {
+  qase.title("This text will be the title of the test, in Qase");
+    // Test logic here
+});
+```
+
+If you don’t explicitly set a title using this method, the title specified in the `test(..)` function will be used for creating new test cases. However, if this method is defined, it always takes precedence and overrides the title from the `test(..)` function.
+
+<br>
+
+### Steps
+--- 
+
+The reporter uses the title from the `test.step` function as the step title. By providing clear and descriptive step names, you make it easier to understand the test’s flow when reviewing the test case.
+
+Additionally, these steps get their own result in the Qase Test run, offering a well-organized summary of the test flow. This helps quickly identify the cause of any failures.
+
+```javascript
+test('A Test case with steps, updated from code', async () => {
+  await test.step('Initialize the environment', async () => {
+    // Set up test environment
+  });
+  await test.step('Test Core Functionality of the app', async () => {
+    // Exercise core functionality
+  });
+
+  await test.step('Verify Expected Behavior of the app', async () => {
+    // Assert expected behavior
+  });
+});
+```
+<br>
+
+### Fields
+---
+
+You can define the `description`, `pre-conditions`, `post-conditions`, and fields such as `severity`, `priority`, and `layer` using this method, which enables you to specify and maintain the context of the case directly within your code.
+
+```javascript
+test('Maintain your test meta-data from code', async () => {
+  await qase.fields({
+    severity: 'high',
+    priority: 'medium',
+    layer: 'api',
+    precondition: 'add your precondition',
+    postcondition: 'add your postcondition',
+    description: `Code it quick, fix it slow,
+                  Tech debt grows where shortcuts go,
+                  Refactor later? Ha! We know.`
+  });
+    //  test logic here
+});
+```
+
+<br>
+
+
+### Suite 
+---
+
+You can use this method to nest the resulting test cases in a particular suite. There's something to note here – suites, unlike test cases, are not identified uniquely by the Reporter. Therefore, when defining an existing suite - the title of the suite is used for matching.
+
+```js
+test("Test with a defined suite", () => {
+  qase.suite("Suite defined with qase.suite()");
+    /*
+     *  Or, nest multiple levels of suites. 
+     *  `\t` is used for dividing each suite name.
+     */
+     
+test("Test with a nested suite", () => {
+  qase.suite("Application\tAuthentication\tLogin\tEdge_case");
+  //  test logic here
+});
+```
+<br>
+
+### Parameters
+---
+Parameters are a great way to make your tests more dynamic, reusable, and data-driven. By defining parameters in this method, you can ensure only one test case with all the parameters is created in your Qase project, avoiding duplication.
+
+
+```javascript
+const testCases = [
+  { browser: "Chromium", username: "@alice", password: "123" },
+  { browser: "Firefox", username: "@bob", password: "456" },
+  { browser: "Webkit", username: "@charlie", password: "789" },
+];
+
+testCases.forEach(({ browser, username, password,  }) => {
+  test(`Test login with ${browser}`, async () => {
+    qase.title("Verify if page loads on all browsers");
+
+    qase.parameters({ Browser: browser });  // Single parameter
+  // test logic
+
+testCases.forEach(({ username, password }) => {
+  test(`Test login with ${username} using qase.groupParameters`, () => {
+    qase.title("Verify if user is able to login with their username.");
+
+    qase.groupParameters({  // Group parameters
+      Username: username,
+      Password: password,
+    });
+  // test logic
+```
+<br>
+
+### Comment
+---
+In addition to `test.step()`, this method can be used to provide any additional context to your test, it helps maintiain the code by clarifying the expected result of the test.
+
+```js
+test("A test case with qase.comment()", () => {
+    /*
+     * Please note, this comment is added to a Result, not to the Test case.
+     */
+  qase.comment("This comment is added to the result");
+  // test logic here
+});
+```
+<br>
+
+### Attach
+---
+This method can help attach one, or more files to the test's result. You can also add the file's contents directly from code. For example: 
+
+```js
+test('Test result with attachment', async () => {
+
+  test("Test result with attachment", async () => {
+    
+      // To attach a single file
+    await qase.attach({
+      paths: "./attachments/test-file.txt",
+    });
+
+      // Add multiple attachments. 
+    await qase.attach({ paths: ['/path/to/file', '/path/to/another/file'] });
+
+      // Upload file's contents directly from code.
+    await qase.attach({
+      name: "attachment.txt",
+      content: "Hello, world!",
+      contentType: "text/plain",
+    });
+      // test logic here
+});
+```
+<br>
+
+### Ignore
+---
+If this method is added, the reporter will exclude the test’s result from the report sent to Qase. While the test will still executed by jest, its result will not be considered by the reporter.
+
+```js
+test("This test is executed by jest; however, it is NOT reported to Qase", () => {
+  qase.ignore();
+//  test logic here
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-qase-reporter",
-  "version": "2.0.2",
+  "version": "2.0.4",
   "description": "Qase TMS Jest Reporter",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -45,7 +45,7 @@
   "dependencies": {
     "lodash.get": "^4.4.2",
     "lodash.has": "^4.5.2",
-    "qase-javascript-commons": "~2.2.0",
+    "qase-javascript-commons": "~2.2.1",
     "uuid": "^9.0.0"
   },
   "devDependencies": {