jest-qase-reporter 2.0.2 → 2.0.3

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,7 +141,7 @@ 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 
+- `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`
@@ -167,7 +183,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 +192,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,46 @@
+# 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,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Qase = void 0;
+class Qase {
+    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,26 @@ 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;
 }

package/dist/reporter.js

@@ -8,6 +8,7 @@ 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
@@ -15,7 +16,7 @@ const qase_javascript_commons_1 = require("qase-javascript-commons");
 class JestQaseReporter {
     /**
      * @param {string} title
-     * @returns {any}
+     * @returns {number[]}
      * @private
      */
     static getCaseId(title) {
@@ -36,6 +37,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 +46,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,6 +159,97 @@ 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: value.title,
+        };
+    }
+    /**
+     * @returns {Metadata}
+     * @private
+     */
+    createEmptyMetadata() {
+        return {
+            title: undefined,
+            ignore: false,
+            comment: undefined,
+            suite: undefined,
+            fields: {},
+            parameters: {},
+            groupParams: {},
+            steps: [],
+            attachments: [],
+        };
+    }
 }
 exports.JestQaseReporter = JestQaseReporter;
 /**

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 {
+    constructor(name) {
+        this.name = '';
+        this.attachments = [];
+        this.steps = [];
+        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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jest-qase-reporter",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "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": {