wdio-qase-reporter 1.0.0-beta.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,145 @@
+# Qase TMS WebDriverIO reporter
+
+Publish results simple and easy.
+
+To install the latest beta version, run:
+
+```sh
+npm install -D wdio-qase-reporter@beta
+```
+
+## Getting started
+
+The WebDriverIO reporter can auto-generate test cases
+and suites from your test data.
+Test results of subsequent test runs will match the same test cases
+as long as their names and file paths don't change.
+
+You can also annotate the tests with the IDs of existing test cases
+from Qase.io before executing tests. It's a more reliable way to bind
+autotests to test cases, that persists when you rename, move, or
+parameterize your tests.
+
+For example:
+
+### Mocha/Jasmine
+
+```typescript
+import {qase} from "wdio-qase-reporter";
+
+describe('My First Test', () => {
+  it('Several ids', () => {
+    qase.id(1);
+    expect(true).to.equal(true);
+  });
+
+  // a test can check multiple test cases
+  it('Correct test', () => {
+    qase.id([2, 3]);
+    expect(true).to.equal(true);
+  });
+
+  it('With steps',async  () => {
+    await qase.step('Step 1', async (s1) => {
+      await s1.step('Step 1.1', async () => {
+        // do something
+        s1.attach({name: 'screenshot.png', type: 'image/png', content: await browser.takeScreenshot()})
+      })
+
+      qase.attach({name: 'log.txt', content: 'test', type: 'text/plain'})
+
+      await s1.step('Step 1.2', async () => {
+        // do something
+      })
+    })
+    expect(true).to.equal(true);
+  });
+});
+```
+
+### Cucumber
+
+```gherkin
+Feature: Test user role
+
+  @QaseId=3
+  Scenario: Login
+    Given I test login
+```
+
+To execute WebDriverIO tests and report them to Qase.io, run the command:
+
+```bash
+QASE_MODE=testops wdio run ./wdio.conf.ts
+```
+
+<p align="center">
+  <img width="65%" src="./screenshots/screenshot.png">
+</p>
+
+A test run will be performed and available at:
+
+```
+https://app.qase.io/run/QASE_PROJECT_CODE
+```
+
+## Configuration
+
+Qase WebDriverIO reporter can be configured in multiple ways:
+
+- using a separate config file `qase.config.json`,
+- using environment variables (they override the values from the configuration files).
+
+For a full list of configuration options, see
+the [Configuration reference](../qase-javascript-commons/README.md#configuration).
+
+Example `qase.config.json` config:
+
+```json
+{
+  "mode": "testops",
+  "debug": true,
+  "testops": {
+    "api": {
+      "token": "api_key"
+    },
+    "project": "project_code",
+    "run": {
+      "complete": true
+    }
+  }
+}
+```
+
+Also, you need to configure the reporter using the `wdio.conf.ts` file:
+
+```ts
+// wdio.conf.ts
+import WDIOQaseReporter from 'wdio-qase-reporter';
+import type { Options } from '@wdio/types';
+
+export const config: Options.Testrunner = {
+  reporters: [[WDIOQaseReporter, {
+    disableWebdriverStepsReporting: true,
+    disableWebdriverScreenshotsReporting: true,
+    useCucumber: false,
+  }]],
+  // ... other options
+};
+```
+
+Additional options of the reporter in the `wdio.conf.ts` file:
+
+- `disableWebdriverStepsReporting` - optional parameter(`false` by default), in order to log only custom steps to the reporter.
+- `disableWebdriverScreenshotsReporting` - optional parameter(`false` by default), in order to not attach screenshots to the reporter.
+- `useCucumber` - optional parameter (`false` by default), if you use Cucumber, set it to true
+
+## Requirements
+
+We maintain the reporter on [LTS versions of Node](https://nodejs.org/en/about/releases/).
+
+`wdio >= 8.40.0`
+
+<!-- references -->
+
+[auth]: https://developers.qase.io/#authentication

package/changelog.md

@@ -0,0 +1,5 @@
+# qase-wdio@1.0.0-beta.1
+
+## What's new
+
+First major beta release for the version 1 series of the Qase WebDriverIO reporter.

package/dist/events.d.ts

@@ -0,0 +1,12 @@
+export declare const events: {
+    readonly addQaseID: "qase:id";
+    readonly addTitle: "qase:title";
+    readonly addFields: "qase:fields";
+    readonly addSuite: "qase:suite";
+    readonly addIgnore: "qase:ignore";
+    readonly addParameters: "qase:parameters";
+    readonly addAttachment: "qase:attachment";
+    readonly startStep: "qase:startStep";
+    readonly endStep: "qase:endStep";
+    readonly addStep: "qase:addStep";
+};

package/dist/events.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.events = void 0;
+exports.events = {
+    addQaseID: 'qase:id',
+    addTitle: 'qase:title',
+    addFields: 'qase:fields',
+    addSuite: 'qase:suite',
+    addIgnore: 'qase:ignore',
+    addParameters: 'qase:parameters',
+    addAttachment: 'qase:attachment',
+    startStep: 'qase:startStep',
+    endStep: 'qase:endStep',
+    addStep: 'qase:addStep',
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import WDIOQaseReporter from './reporter.js';
+export * from './wdio';
+export default WDIOQaseReporter;

package/dist/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const reporter_js_1 = __importDefault(require("./reporter.js"));
+__exportStar(require("./wdio"), exports);
+exports.default = reporter_js_1.default;

package/dist/models.d.ts

@@ -0,0 +1,18 @@
+export interface AddQaseIdEventArgs {
+    ids: number[];
+}
+export interface AddRecordsEventArgs {
+    records: Record<string, string>;
+}
+export interface AddTitleEventArgs {
+    title: string;
+}
+export interface AddSuiteEventArgs {
+    suite: string;
+}
+export interface AddAttachmentEventArgs {
+    name?: string;
+    type?: string;
+    content?: string;
+    paths?: string[];
+}

package/dist/models.js

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

package/dist/options.d.ts

@@ -0,0 +1,6 @@
+export declare class QaseReporterOptions {
+    useCucumber?: boolean;
+    disableWebdriverStepsReporting?: boolean;
+    disableWebdriverScreenshotsReporting?: boolean;
+    constructor();
+}

package/dist/options.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QaseReporterOptions = void 0;
+class QaseReporterOptions {
+    constructor() {
+        this.useCucumber = false;
+        this.disableWebdriverStepsReporting = false;
+        this.disableWebdriverScreenshotsReporting = false;
+    }
+}
+exports.QaseReporterOptions = QaseReporterOptions;

package/dist/reporter.d.ts

@@ -0,0 +1,57 @@
+import WDIOReporter, { AfterCommandArgs, BeforeCommandArgs, RunnerStats, SuiteStats, TestStats } from '@wdio/reporter';
+import { TestStatusEnum, TestStepType } from 'qase-javascript-commons';
+import { AddAttachmentEventArgs, AddQaseIdEventArgs, AddRecordsEventArgs, AddSuiteEventArgs, AddTitleEventArgs } from './models';
+export default class WDIOQaseReporter extends WDIOReporter {
+    /**
+     * @type {Record<string, TestStatusEnum>}
+     */
+    static statusMap: Record<string, TestStatusEnum>;
+    /**
+     * @type {ReporterInterface}
+     * @private
+     */
+    private reporter;
+    private storage;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private isSync;
+    private _options;
+    private _isMultiremote?;
+    constructor(options: any);
+    get isSynchronised(): boolean;
+    set isSynchronised(value: boolean);
+    onRunnerStart(runner: RunnerStats): void;
+    onSuiteStart(suite: SuiteStats): void;
+    onSuiteEnd(suite: SuiteStats): Promise<void>;
+    onRunnerEnd(_: RunnerStats): Promise<void>;
+    onTestStart(test: TestStats): void;
+    /**
+     * @param {Error[]} testErrors
+     * @returns {CompoundError}
+     * @private
+     */
+    private static transformError;
+    onTestEnd(test: TestStats): Promise<void>;
+    private _endTest;
+    onHookStart(): void;
+    onHookEnd(): void;
+    onBeforeCommand(command: BeforeCommandArgs): void;
+    onAfterCommand(command: AfterCommandArgs): void;
+    registerListeners(): void;
+    addQaseId({ ids }: AddQaseIdEventArgs): void;
+    addTitle({ title }: AddTitleEventArgs): void;
+    addSuite({ suite }: AddSuiteEventArgs): void;
+    addParameters({ records }: AddRecordsEventArgs): void;
+    addFields({ records }: AddRecordsEventArgs): void;
+    addAttachment({ name, type, content, paths }: AddAttachmentEventArgs): void;
+    ignore(): void;
+    addStep(step: TestStepType): void;
+    private _startTest;
+    private _startStep;
+    private attachJSON;
+    private attachFile;
+    private _endStep;
+    private parseTag;
+}

package/dist/reporter.js

@@ -0,0 +1,413 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const reporter_1 = __importDefault(require("@wdio/reporter"));
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const uuid_1 = require("uuid");
+const storage_1 = require("./storage");
+const options_1 = require("./options");
+const utils_1 = require("./utils");
+const path_1 = __importDefault(require("path"));
+const events_1 = require("./events");
+class WDIOQaseReporter extends reporter_1.default {
+    constructor(options) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        super(options);
+        const configLoader = new qase_javascript_commons_1.ConfigLoader();
+        const config = configLoader.load();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        this.reporter = qase_javascript_commons_1.QaseReporter.getInstance({
+            ...(0, qase_javascript_commons_1.composeOptions)(options, config),
+            frameworkPackage: 'wdio',
+            frameworkName: 'wdio',
+            reporterName: 'wdio-qase-reporter',
+        });
+        this.isSync = true;
+        this.storage = new storage_1.Storage();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        this._options = Object.assign(new options_1.QaseReporterOptions(), options);
+        this.registerListeners();
+    }
+    get isSynchronised() {
+        return this.isSync;
+    }
+    set isSynchronised(value) {
+        this.isSync = value;
+    }
+    onRunnerStart(runner) {
+        this._isMultiremote = runner.isMultiremote;
+        this.reporter.startTestRun();
+        this.isSync = false;
+    }
+    onSuiteStart(suite) {
+        this.storage.currentFile = suite.file;
+        if (this._options.useCucumber && suite.type === 'scenario') {
+            this._startTest(suite.title, suite.cid ?? '');
+            if (suite.tags === undefined) {
+                return;
+            }
+            const tags = suite.tags.map((tag) => {
+                return tag.name;
+            });
+            for (const tag of tags) {
+                if (!tag.includes('=')) {
+                    continue;
+                }
+                const tagData = this.parseTag(tag);
+                if (tagData === null) {
+                    continue;
+                }
+                switch (tagData.key.toLowerCase()) {
+                    case '@qaseid':
+                        this.addQaseId({ ids: tagData.value.split(',').map((id) => parseInt(id)) });
+                        break;
+                    case '@title':
+                        this.addTitle({ title: tagData.value });
+                        break;
+                    case '@suite':
+                        this.addSuite({ suite: tagData.value });
+                        break;
+                    // case 'parameters':
+                    //   const params = tagData.value.split(',').map((param) => {
+                    //     const [key, value] = param.split(':');
+                    //     return { key, value };
+                    //   });
+                    //   process.emit(events.addParameters, { records: params });
+                    //   break;
+                    // case 'fields':
+                    //   const fields = tagData.value.split(',').map((field) => {
+                    //     const [key, value] = field.split(':');
+                    //     return { key, value };
+                    //   });
+                    //   process.emit(events.addFields, { records: fields });
+                    //   break;
+                }
+            }
+            return;
+        }
+        this.storage.suites.push(suite.title);
+    }
+    async onSuiteEnd(suite) {
+        this.storage.currentFile = undefined;
+        if (this._options.useCucumber && suite.type === 'scenario') {
+            suite.hooks = suite.hooks.map((hook) => {
+                hook.state = hook.state ?? 'passed';
+                return hook;
+            });
+            const suiteChildren = [...suite.tests, ...suite.hooks];
+            const isSkipped = suite.tests.every(item => ['skipped'].includes(item.state))
+                && suite.hooks.every(item => ['passed', 'skipped'].includes(item.state ?? 'passed'));
+            if (isSkipped) {
+                await this._endTest(qase_javascript_commons_1.TestStatusEnum.skipped, null);
+                return;
+            }
+            const isFailed = suiteChildren.find(item => item.state === 'failed');
+            if (isFailed) {
+                const err = WDIOQaseReporter.transformError(isFailed.errors ?? []);
+                await this._endTest(qase_javascript_commons_1.TestStatusEnum.failed, err);
+                return;
+            }
+            const isPassed = suiteChildren.every(item => item.state === 'passed');
+            const isPartiallySkipped = suiteChildren.every(item => ['passed', 'skipped'].includes(item.state ?? 'passed'));
+            if (isPassed || isPartiallySkipped) {
+                await this._endTest(qase_javascript_commons_1.TestStatusEnum.passed, null);
+                return;
+            }
+            return;
+        }
+        this.storage.clear();
+    }
+    async onRunnerEnd(_) {
+        await this.reporter.publish();
+        this.isSync = true;
+    }
+    onTestStart(test) {
+        if (this._options.useCucumber) {
+            this._startStep(test.title);
+            return;
+        }
+        this._startTest(test.title, test.cid, test.start.valueOf() / 1000);
+    }
+    /**
+     * @param {Error[]} testErrors
+     * @returns {CompoundError}
+     * @private
+     */
+    static transformError(testErrors) {
+        const err = new qase_javascript_commons_1.CompoundError();
+        for (const error of testErrors) {
+            if (error.message == undefined) {
+                continue;
+            }
+            err.addMessage(error.message);
+        }
+        for (const error of testErrors) {
+            if (error.stack == undefined) {
+                continue;
+            }
+            err.addStacktrace(error.stack);
+        }
+        return err;
+    }
+    async onTestEnd(test) {
+        const error = test.errors ? WDIOQaseReporter.transformError(test.errors) : null;
+        await this._endTest(WDIOQaseReporter.statusMap[test.state] ?? qase_javascript_commons_1.TestStatusEnum.skipped, error, test.end ? test.end.valueOf() / 1000 : Date.now().valueOf() / 1000);
+    }
+    async _endTest(status, err, end_time = Date.now().valueOf() / 1000) {
+        const testResult = this.storage.getCurrentTest();
+        if (testResult === undefined || this.storage.ignore) {
+            return;
+        }
+        const relations = {};
+        if (this.storage.suites.length > 0) {
+            relations.suite = {
+                data: this.storage.suites.map((suite) => {
+                    return {
+                        title: suite,
+                        public_id: null,
+                    };
+                }),
+            };
+        }
+        testResult.relations = relations;
+        testResult.execution.duration = testResult.execution.start_time ? Math.round(end_time - testResult.execution.start_time) : 0;
+        testResult.execution.status = status;
+        testResult.execution.stacktrace = err === null ?
+            null : err.stacktrace === undefined ?
+            null : err.stacktrace;
+        testResult.message = err === null ?
+            null : err.message === undefined ?
+            null : err.message;
+        console.log(testResult);
+        await this.reporter.addTestResult(testResult);
+    }
+    onHookStart() {
+        console.log('Hook started');
+    }
+    onHookEnd() {
+        console.log('Hook ended');
+    }
+    onBeforeCommand(command) {
+        if (!this.storage.getLastItem()) {
+            return;
+        }
+        const { disableWebdriverStepsReporting } = this._options;
+        if (disableWebdriverStepsReporting || this._isMultiremote) {
+            return;
+        }
+        const { method, endpoint } = command;
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        const stepName = command.command ? command.command : `${method} ${endpoint}`;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const payload = command.body || command.params;
+        this._startStep(stepName);
+        if (!(0, utils_1.isEmpty)(payload)) {
+            this.attachJSON('Request', payload);
+        }
+    }
+    onAfterCommand(command) {
+        const { disableWebdriverStepsReporting, disableWebdriverScreenshotsReporting } = this._options;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const commandResult = command.result || undefined;
+        const isScreenshot = (0, utils_1.isScreenshotCommand)(command);
+        if (!disableWebdriverScreenshotsReporting && isScreenshot && commandResult) {
+            this.attachFile('Screenshot', Buffer.from(commandResult, 'base64'), 'image/png');
+        }
+        if (disableWebdriverStepsReporting || this._isMultiremote || !this.storage.getCurrentStep()) {
+            return;
+        }
+        this.attachJSON('Response', commandResult);
+        this._endStep();
+    }
+    registerListeners() {
+        process.on(events_1.events.addQaseID, this.addQaseId.bind(this));
+        process.on(events_1.events.addTitle, this.addTitle.bind(this));
+        process.on(events_1.events.addFields, this.addFields.bind(this));
+        process.on(events_1.events.addSuite, this.addSuite.bind(this));
+        process.on(events_1.events.addParameters, this.addParameters.bind(this));
+        process.on(events_1.events.addAttachment, this.addAttachment.bind(this));
+        process.on(events_1.events.addIgnore, this.ignore.bind(this));
+        process.on(events_1.events.addStep, this.addStep.bind(this));
+    }
+    addQaseId({ ids }) {
+        const curTest = this.storage.getCurrentTest();
+        if (!curTest) {
+            return;
+        }
+        curTest.testops_id = ids;
+    }
+    addTitle({ title }) {
+        const curTest = this.storage.getCurrentTest();
+        if (!curTest) {
+            return;
+        }
+        curTest.title = title;
+    }
+    addSuite({ suite }) {
+        const curTest = this.storage.getCurrentTest();
+        if (!curTest) {
+            return;
+        }
+        curTest.relations = {
+            suite: {
+                data: [
+                    {
+                        title: suite,
+                        public_id: null,
+                    },
+                ],
+            },
+        };
+    }
+    addParameters({ records }) {
+        const curTest = this.storage.getCurrentTest();
+        if (!curTest) {
+            return;
+        }
+        const stringRecord = {};
+        for (const [key, value] of Object.entries(records)) {
+            stringRecord[String(key)] = String(value);
+        }
+        curTest.params = stringRecord;
+    }
+    addFields({ records }) {
+        const curTest = this.storage.getCurrentTest();
+        if (!curTest) {
+            return;
+        }
+        const stringRecord = {};
+        for (const [key, value] of Object.entries(records)) {
+            stringRecord[String(key)] = String(value);
+        }
+        curTest.fields = records;
+    }
+    addAttachment({ name, type, content, paths }) {
+        console.log('addAttachment');
+        console.log(name, type, content, paths);
+        const curTest = this.storage.getCurrentTest();
+        if (!curTest) {
+            return;
+        }
+        if (paths) {
+            for (const file of paths) {
+                const attachmentName = path_1.default.basename(file);
+                const contentType = (0, qase_javascript_commons_1.getMimeTypes)(file);
+                const attach = {
+                    file_path: file,
+                    size: 0,
+                    id: (0, uuid_1.v4)(),
+                    file_name: attachmentName,
+                    mime_type: contentType,
+                    content: '',
+                };
+                curTest.attachments.push(attach);
+            }
+            return;
+        }
+        if (content) {
+            const attachmentName = name ?? 'attachment';
+            const contentType = type ?? 'application/octet-stream';
+            const attach = {
+                file_path: null,
+                size: content.length,
+                id: (0, uuid_1.v4)(),
+                file_name: attachmentName,
+                mime_type: contentType,
+                content: content,
+            };
+            curTest.attachments.push(attach);
+        }
+    }
+    ignore() {
+        const curTest = this.storage.getCurrentTest();
+        if (!curTest) {
+            return;
+        }
+        this.storage.ignore = true;
+    }
+    addStep(step) {
+        const curItem = this.storage.getLastItem();
+        if (!curItem) {
+            return;
+        }
+        curItem.steps.push(step);
+    }
+    _startTest(title, cid, start_time = Date.now().valueOf() / 1000) {
+        const result = new qase_javascript_commons_1.TestResultType(title);
+        result.execution.thread = cid;
+        result.execution.start_time = start_time;
+        result.id = (0, uuid_1.v4)();
+        this.storage.push(result);
+    }
+    _startStep(title) {
+        const step = {
+            id: (0, uuid_1.v4)(),
+            step_type: qase_javascript_commons_1.StepType.TEXT,
+            data: {
+                action: title,
+                expected_result: null,
+            },
+            parent_id: this.storage.getLastItem()?.id ?? null,
+            execution: {
+                start_time: Date.now().valueOf() / 1000,
+                end_time: null,
+                status: qase_javascript_commons_1.StepStatusEnum.passed,
+                duration: null,
+            },
+            steps: [],
+            attachments: [],
+        };
+        this.storage.getLastItem()?.steps.push(step);
+        this.storage.push(step);
+    }
+    attachJSON(name, json) {
+        const isStr = typeof json === 'string';
+        const content = isStr ? json : JSON.stringify(json, null, 2);
+        this.attachFile(name, String(content), isStr ? 'application/json' : 'text/plain');
+    }
+    attachFile(name, content, contentType) {
+        if (!this.storage.getLastItem()) {
+            throw new Error('There isn\'t any active test!');
+        }
+        const attach = {
+            file_path: null,
+            size: content.length,
+            id: (0, uuid_1.v4)(),
+            file_name: name,
+            mime_type: contentType,
+            content: content,
+        };
+        console.log('attachFile:', attach);
+        this.storage.getLastItem()?.attachments.push(attach);
+    }
+    _endStep(status = qase_javascript_commons_1.TestStatusEnum.passed) {
+        if (!this.storage.getLastItem()) {
+            return;
+        }
+        const step = this.storage.pop();
+        if (!step) {
+            return;
+        }
+        step.execution.end_time = Date.now().valueOf() / 1000;
+        step.execution.status = status;
+    }
+    parseTag(tag) {
+        const [key, value] = tag.split('=');
+        if (!key || !value) {
+            return null;
+        }
+        return { key, value };
+    }
+}
+/**
+ * @type {Record<string, TestStatusEnum>}
+ */
+WDIOQaseReporter.statusMap = {
+    'passed': qase_javascript_commons_1.TestStatusEnum.passed,
+    'failed': qase_javascript_commons_1.TestStatusEnum.failed,
+    'skipped': qase_javascript_commons_1.TestStatusEnum.skipped,
+    'pending': qase_javascript_commons_1.TestStatusEnum.skipped,
+};
+exports.default = WDIOQaseReporter;

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,87 @@
+"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"));
+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/dist/storage.d.ts

@@ -0,0 +1,14 @@
+import { TestResultType, TestStepType } from 'qase-javascript-commons';
+export declare class Storage {
+    currentFile?: string | undefined;
+    suites: string[];
+    ignore: boolean;
+    items: (TestResultType | TestStepType)[];
+    clear(): void;
+    push(item: TestResultType | TestStepType): void;
+    pop(): TestResultType | TestStepType | undefined;
+    getCurrentTest(): TestResultType | undefined;
+    getCurrentStep(): TestStepType | undefined;
+    getLastItem(): TestResultType | TestStepType | undefined;
+}
+export declare const findLast: <T>(arr: T[], predicate: (el: T) => boolean) => T | undefined;

package/dist/storage.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLast = exports.Storage = void 0;
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+class Storage {
+    constructor() {
+        this.suites = [];
+        this.ignore = false;
+        this.items = [];
+    }
+    clear() {
+        this.currentFile = undefined;
+        this.suites = [];
+        this.items = [];
+        this.ignore = false;
+    }
+    push(item) {
+        this.items.push(item);
+    }
+    pop() {
+        return this.items.pop();
+    }
+    getCurrentTest() {
+        return (0, exports.findLast)(this.items, (item) => item instanceof qase_javascript_commons_1.TestResultType);
+    }
+    getCurrentStep() {
+        return (0, exports.findLast)(this.items, (item) => item instanceof qase_javascript_commons_1.TestStepType);
+    }
+    getLastItem() {
+        return this.items[this.items.length - 1];
+    }
+}
+exports.Storage = Storage;
+const findLast = (arr, predicate) => {
+    let result;
+    for (let i = arr.length - 1; i >= 0; i--) {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        if (predicate(arr[i])) {
+            result = arr[i];
+            break;
+        }
+    }
+    return result;
+};
+exports.findLast = findLast;

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+import { CommandArgs } from '@wdio/reporter';
+/**
+ * Check is object is empty
+ * @param object {Object}
+ * @private
+ */
+export declare const isEmpty: (object: any) => boolean;
+export declare const isScreenshotCommand: (command: CommandArgs) => boolean;

package/dist/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScreenshotCommand = exports.isEmpty = void 0;
+/**
+ * Check is object is empty
+ * @param object {Object}
+ * @private
+ */
+const isEmpty = (object) => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+!object || Object.keys(object).length === 0;
+exports.isEmpty = isEmpty;
+const isScreenshotCommand = (command) => {
+    const isScreenshotEndpoint = /\/session\/[^/]*(\/element\/[^/]*)?\/screenshot/;
+    return (
+    // WebDriver protocol
+    (command.endpoint && isScreenshotEndpoint.test(command.endpoint)) ||
+        // DevTools protocol
+        command.command === 'takeScreenshot');
+};
+exports.isScreenshotCommand = isScreenshotCommand;

package/dist/wdio.d.ts

@@ -0,0 +1,55 @@
+import { StepFunction } from './step';
+export declare class qase {
+    /**
+     * Assign QaseID to test
+     * @name id
+     * @param {number | number[]} value
+     */
+    static id(value: number | number[]): typeof qase;
+    /**
+     * Assign title to test
+     * @name title
+     * @param {string} value
+     */
+    static title(value: string): typeof qase;
+    /**
+     * Assign parameters to test
+     * @name parameters
+     * @param {Record<string, string>} values
+     */
+    static parameters(values: Record<string, string>): typeof qase;
+    /**
+     * Assign fields to test
+     * @name fields
+     * @param {Record<string, string>} values
+     */
+    static fields(values: Record<string, string>): typeof qase;
+    /**
+     * Assign suite to test
+     * @name suite
+     * @param {string} value
+     */
+    static suite(value: string): typeof qase;
+    /**
+     * Assign ignore mark to test
+     * @name ignore
+     */
+    static ignore(): typeof qase;
+    /**
+     * Assign attachment to test
+     * @name attach
+     * @param attach
+     */
+    static attach(attach: {
+        name?: string;
+        type?: string;
+        content?: string;
+        paths?: string[];
+    }): typeof qase;
+    /**
+     * Starts step
+     * @param {string} name - the step name
+     * @param {StepFunction} body - the step content function
+     */
+    static step(name: string, body: StepFunction): Promise<void>;
+}

package/dist/wdio.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qase = void 0;
+const events_1 = require("./events");
+const step_1 = require("./step");
+/**
+ * Send event to reporter
+ * @param {string} event  - event name
+ * @param {object} msg - event payload
+ * @private
+ */
+const sendEvent = (event, msg = {}) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    process.emit(event, msg);
+};
+class qase {
+    /**
+     * Assign QaseID to test
+     * @name id
+     * @param {number | number[]} value
+     */
+    static id(value) {
+        sendEvent(events_1.events.addQaseID, { ids: Array.isArray(value) ? value : [value] });
+        return this;
+    }
+    /**
+     * Assign title to test
+     * @name title
+     * @param {string} value
+     */
+    static title(value) {
+        sendEvent(events_1.events.addTitle, { title: value });
+        return this;
+    }
+    /**
+     * Assign parameters to test
+     * @name parameters
+     * @param {Record<string, string>} values
+     */
+    static parameters(values) {
+        sendEvent(events_1.events.addParameters, { records: values });
+        return this;
+    }
+    /**
+     * Assign fields to test
+     * @name fields
+     * @param {Record<string, string>} values
+     */
+    static fields(values) {
+        sendEvent(events_1.events.addFields, { records: values });
+        return this;
+    }
+    /**
+     * Assign suite to test
+     * @name suite
+     * @param {string} value
+     */
+    static suite(value) {
+        sendEvent(events_1.events.addSuite, { suite: value });
+        return this;
+    }
+    /**
+     * Assign ignore mark to test
+     * @name ignore
+     */
+    static ignore() {
+        sendEvent(events_1.events.addIgnore, {});
+        return this;
+    }
+    /**
+     * Assign attachment to test
+     * @name attach
+     * @param attach
+     */
+    static attach(attach) {
+        sendEvent(events_1.events.addAttachment, attach);
+        return this;
+    }
+    /**
+     * Starts step
+     * @param {string} name - the step name
+     * @param {StepFunction} body - the step content function
+     */
+    static async step(name, body) {
+        const runningStep = new step_1.QaseStep(name);
+        // eslint-disable-next-line @typescript-eslint/require-await
+        await runningStep.run(body, async (message) => sendEvent(events_1.events.addStep, message));
+    }
+}
+exports.qase = qase;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "wdio-qase-reporter",
+  "version": "1.0.0-beta.1",
+  "description": "Qase WebDriverIO Reporter",
+  "homepage": "https://github.com/qase-tms/qase-javascript",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "bugs": {
+    "url": "https://github.com/qase-tms/qase-javascript/issues"
+  },
+  "keywords": [
+    "reporter",
+    "webdriverio",
+    "wdio",
+    "wdio-plugin",
+    "wdio-reporter",
+    "qase"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/qase-tms/qase-javascript.git"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "build": "npm run clean && tsc --project tsconfig.build.json",
+    "lint": "eslint .",
+    "test": "jest --passWithNoTests",
+    "clean": "rm -rf dist"
+  },
+  "author": "Qase Team <support@qase.io>",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "qase-javascript-commons": "~2.1.2",
+    "uuid": "^9.0.1",
+    "@types/node": "^20.1.0",
+    "@wdio/reporter": "^8.39.0",
+    "@wdio/types": "^8.39.0",
+    "csv-stringify": "^6.0.4",
+    "strip-ansi": "^7.1.0"
+  }
+}

package/tsconfig.build.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+
+  "compilerOptions": {
+    "noEmit": false
+  },
+
+  "include": ["./src/**/*.ts"]
+}