qase-javascript-commons 2.2.19 → 2.3.1

package/README.md

@@ -31,31 +31,31 @@ Qase JS Reporters can be configured in multiple ways:
 
 All configuration options are listed in the table below:
 
-| Description                                                                                                                | Config file                | Environment variable            | Default value                           | Required | Possible values            |
-|----------------------------------------------------------------------------------------------------------------------------|----------------------------|---------------------------------|-----------------------------------------|----------|----------------------------|
-| **Common**                                                                                                                 |                            |                                 |                                         |          |                            |
-| Mode of reporter                                                                                                           | `mode`                     | `QASE_MODE`                     | `off`                                  | No       | `testops`, `report`, `off` |
-| Fallback mode of reporter                                                                                                  | `fallback`                 | `QASE_FALLBACK`                 | `off`                                   | No       | `testops`, `report`, `off` |
-| Environment                                                                                                                | `environment`              | `QASE_ENVIRONMENT`              | undefined                              | No       | Any string                 |
-| Root suite                                                                                                                 | `rootSuite`                | `QASE_ROOT_SUITE`               | undefined                               | No       | Any string                 |
-| Enable debug logs                                                                                                          | `debug`                    | `QASE_DEBUG`                    | `False`                                 | No       | `True`, `False`            |
-| Enable capture logs from `stdout` and `stderr`                                                                             | `testops.defect`           | `QASE_CAPTURE_LOGS`             | `False`                                 | No       | `True`, `False`            |
-| **Qase Report configuration**                                                                                              |                            |                                 |                                         |          |                            |
-| Driver used for report mode                                                                                                | `report.driver`            | `QASE_REPORT_DRIVER`            | `local`                                 | No       | `local`                    |
-| Path to save the report                                                                                                    | `report.connection.path`   | `QASE_REPORT_CONNECTION_PATH`   | `./build/qase-report`                   |          |                            |
-| Local report format                                                                                                        | `report.connection.format` | `QASE_REPORT_CONNECTION_FORMAT` | `json`                                  |          | `json`, `jsonp`            |
-| **Qase TestOps configuration**                                                                                             |                            |                                 |                                         |          |                            |
-| Token for [API access](https://developers.qase.io/#authentication)                                                         | `testops.api.token`        | `QASE_TESTOPS_API_TOKEN`        |  undefined                              | Yes      | Any string                 |
-| Qase API host. For enterprise users, specify full address: `api-example.qase.io`                                           | `testops.api.host`         | `QASE_TESTOPS_API_HOST`         | `qase.io`                               | No       | Any string                 |
-| Qase enterprise environment                                                                                                | `testops.api.enterprise`   | `QASE_TESTOPS_API_ENTERPRISE`   | `False`                                 | No       | `True`, `False`            |
+| Description                                                                                                           | Config file                | Environment variable            | Default value                           | Required | Possible values            |
+|-----------------------------------------------------------------------------------------------------------------------|----------------------------|---------------------------------|-----------------------------------------|----------|----------------------------|
+| **Common**                                                                                                            |                            |                                 |                                         |          |                            |
+| Mode of reporter                                                                                                      | `mode`                     | `QASE_MODE`                     | `off`                                  | No       | `testops`, `report`, `off` |
+| Fallback mode of reporter                                                                                             | `fallback`                 | `QASE_FALLBACK`                 | `off`                                   | No       | `testops`, `report`, `off` |
+| Environment                                                                                                           | `environment`              | `QASE_ENVIRONMENT`              | undefined                              | No       | Any string                 |
+| Root suite                                                                                                            | `rootSuite`                | `QASE_ROOT_SUITE`               | undefined                               | No       | Any string                 |
+| Enable debug logs                                                                                                     | `debug`                    | `QASE_DEBUG`                    | `False`                                 | No       | `True`, `False`            |
+| Enable capture logs from `stdout` and `stderr`                                                                        | `testops.defect`           | `QASE_CAPTURE_LOGS`             | `False`                                 | No       | `True`, `False`            |
+| **Qase Report configuration**                                                                                         |                            |                                 |                                         |          |                            |
+| Driver used for report mode                                                                                           | `report.driver`            | `QASE_REPORT_DRIVER`            | `local`                                 | No       | `local`                    |
+| Path to save the report                                                                                               | `report.connection.path`   | `QASE_REPORT_CONNECTION_PATH`   | `./build/qase-report`                   |          |                            |
+| Local report format                                                                                                   | `report.connection.format` | `QASE_REPORT_CONNECTION_FORMAT` | `json`                                  |          | `json`, `jsonp`            |
+| **Qase TestOps configuration**                                                                                        |                            |                                 |                                         |          |                            |
+| Token for [API access](https://developers.qase.io/#authentication)                                                    | `testops.api.token`        | `QASE_TESTOPS_API_TOKEN`        |  undefined                              | Yes      | Any string                 |
+| Qase API host. For enterprise users, specify address: `example.qase.io`                                           | `testops.api.host`         | `QASE_TESTOPS_API_HOST`         | `qase.io`                               | No       | Any string                 |
+| Qase enterprise environment                                                                                           | `testops.api.enterprise`   | `QASE_TESTOPS_API_ENTERPRISE`   | `False`                                 | No       | `True`, `False`            |
 | Code of your project, which you can take from the URL: `https://app.qase.io/project/DEMOTR` - `DEMOTR` is the project code | `testops.project`          | `QASE_TESTOPS_PROJECT`          |  undefined                              | Yes      | Any string                 |
-| Qase test run ID                                                                                                           | `testops.run.id`           | `QASE_TESTOPS_RUN_ID`           |  undefined                              | No       | Any integer                |
-| Qase test run title                                                                                                        | `testops.run.title`        | `QASE_TESTOPS_RUN_TITLE`        | `Automated run <Current date and time>` | No       | Any string                 |
-| Qase test run description                                                                                                  | `testops.run.description`  | `QASE_TESTOPS_RUN_DESCRIPTION`  | `<Framework name> automated run`        | No       | Any string                 |
-| Qase test run complete                                                                                                     | `testops.run.complete`     | `QASE_TESTOPS_RUN_COMPLETE`     | `True`                                  |          | `True`, `False`            |
-| Qase test plan ID                                                                                                          | `testops.plan.id`          | `QASE_TESTOPS_PLAN_ID`          |  undefined                              | No       | Any integer                |
-| Size of batch for sending test results                                                                                     | `testops.batch.size`       | `QASE_TESTOPS_BATCH_SIZE`       | `200`                                   | No       | Any integer                |
-| Enable defects for failed test cases                                                                                       | `testops.defect`           | `QASE_TESTOPS_DEFECT`           | `False`                                 | No       | `True`, `False`            |
+| Qase test run ID                                                                                                      | `testops.run.id`           | `QASE_TESTOPS_RUN_ID`           |  undefined                              | No       | Any integer                |
+| Qase test run title                                                                                                   | `testops.run.title`        | `QASE_TESTOPS_RUN_TITLE`        | `Automated run <Current date and time>` | No       | Any string                 |
+| Qase test run description                                                                                             | `testops.run.description`  | `QASE_TESTOPS_RUN_DESCRIPTION`  | `<Framework name> automated run`        | No       | Any string                 |
+| Qase test run complete                                                                                                | `testops.run.complete`     | `QASE_TESTOPS_RUN_COMPLETE`     | `True`                                  |          | `True`, `False`            |
+| Qase test plan ID                                                                                                     | `testops.plan.id`          | `QASE_TESTOPS_PLAN_ID`          |  undefined                              | No       | Any integer                |
+| Size of batch for sending test results                                                                                | `testops.batch.size`       | `QASE_TESTOPS_BATCH_SIZE`       | `200`                                   | No       | Any integer                |
+| Enable defects for failed test cases                                                                                  | `testops.defect`           | `QASE_TESTOPS_DEFECT`           | `False`                                 | No       | `True`, `False`            |
 
 ### Example `qase.config.json` config:
 

package/changelog.md

@@ -1,3 +1,9 @@
+# qase-javascript-commons@2.3.0
+
+## What's new
+
+Migrated to the new API clients for v1 (`qase-api-client`) and v2 (`qase-api-v2-client`) from the `qaseio`.
+
 # qase-javascript-commons@2.2.18
 
 ## What's new
@@ -289,10 +295,10 @@ log a warning message.
 
 ## What's new
 
-* The `useV2` option in the reporter's configuration will now enable using the experimental v2 API.
+- The `useV2` option in the reporter's configuration will now enable using the experimental v2 API.
   Before this fix, v1 API was used despite the configuration.
 
-* Attachments from test steps will now be uploaded to Qase.
+- Attachments from test steps will now be uploaded to Qase.
   Before this fix, the reporter uploaded only the attachments made outside of any step scope.
 
 # qase-javascript-commons@2.0.0-beta.10
@@ -380,10 +386,10 @@ where `10` is the size of the chunk in test result's count.
 Qase TestOps API has two endpoints for reporting test results:
 
 - Version 1, stable and used my most test reporters.
-  https://developers.qase.io/reference/create-result-bulk
+  <https://developers.qase.io/reference/create-result-bulk>
 - Version 2, currently in beta access, and currently supported only
   in the `playwright-qase-reporter`.
-  https://developers.qase.io/v2.0/reference/create-results-v2
+  <https://developers.qase.io/v2.0/reference/create-results-v2>
 
 This commit introduces a way to select the API version to use.
 It enables using all new features of v2 JS reporters with the stable v1 API,
@@ -398,7 +404,7 @@ To enable using API v2, set an environment variable before running the tests:
 QASE_TESTOPS_API_V2=true
 ```
 
-### Support adding test suite description to a test report.
+### Support adding test suite description to a test report
 
 Test reporters can now test suite description to test results.
 Such description can be collected from test's location and attributes
@@ -414,22 +420,22 @@ Add new data models:
 
 ## What's new
 
-* Update the config of reporters. Added `captureLogs` field. If it is set to `true`, the reporter will capture logs from
+- Update the config of reporters. Added `captureLogs` field. If it is set to `true`, the reporter will capture logs from
   the test framework.
-* Added `getMimeType` function to the commons package. It returns the MIME type of the file by its extension.
+- Added `getMimeType` function to the commons package. It returns the MIME type of the file by its extension.
 
 # qase-javascript-commons@2.0.0-beta.4
 
 ## What's new
 
-* Added support for uploading attachments from strings and buffers in the testops reporter.
-* Changed data type of `content` in the attachment data from `any` to `string | Buffer`.
+- Added support for uploading attachments from strings and buffers in the testops reporter.
+- Changed data type of `content` in the attachment data from `any` to `string | Buffer`.
 
 # qase-javascript-commons@2.0.0-beta.3
 
 ## What's new
 
-* Changed data type of `fields` and `parameters` in the test result data
+- Changed data type of `fields` and `parameters` in the test result data
   from `Map<string, string>` to `Record<string, string>`.
 
 # qase-javascript-commons@2.0.0-beta.2
@@ -448,10 +454,10 @@ npm install playwright-qase-reporter@beta
 
 ## What's new
 
-* Set a fallback reporter when the primary reporter can't be used,
+- Set a fallback reporter when the primary reporter can't be used,
   such as when the `testops` reporter can't authenticate with the Qase API.
-* Rename some environment variables to keep naming consistent between reporters in all languages.
-* Add several environment variables for new config options.
-* Write outputs in JSONP format, which can be used with
+- Rename some environment variables to keep naming consistent between reporters in all languages.
+- Add several environment variables for new config options.
+- Write outputs in JSONP format, which can be used with
   [Qase Report](https://github.com/qase-tms/qase-report).
-* Logic for handling test with multiple case IDs moved to the commons package.
+- Logic for handling test with multiple case IDs moved to the commons package.

package/dist/client/clientV1.d.ts

@@ -0,0 +1,31 @@
+import { Attachment, TestResultType } from '../models';
+import { TestOpsOptionsType } from '../models/config/TestOpsOptionsType';
+import { QaseError } from '../utils/qase-error';
+import { IClient } from './interface';
+import { LoggerInterface } from '../utils/logger';
+export declare class ClientV1 implements IClient {
+    protected readonly logger: LoggerInterface;
+    protected readonly config: TestOpsOptionsType;
+    private readonly environment;
+    private readonly appUrl;
+    private readonly runClient;
+    private readonly environmentClient;
+    private readonly attachmentClient;
+    constructor(logger: LoggerInterface, config: TestOpsOptionsType, environment: string | undefined);
+    private createApiConfig;
+    uploadResults(_runId: number, _results: TestResultType[]): Promise<void>;
+    createRun(): Promise<number>;
+    completeRun(runId: number): Promise<void>;
+    protected uploadAttachments(attachments: Attachment[]): Promise<string[]>;
+    private prepareAttachmentData;
+    private getEnvironmentId;
+    private prepareRunObject;
+    /**
+     * Process error and throw QaseError
+     * @param {Error | AxiosError} error
+     * @param {string} message
+     * @param {object} model
+     * @private
+     */
+    protected processError(error: unknown, message: string, model?: object): QaseError;
+}

package/dist/client/clientV1.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientV1 = void 0;
+const qase_api_client_1 = require("qase-api-client");
+const is_axios_error_1 = require("../utils/is-axios-error");
+const qase_error_1 = require("../utils/qase-error");
+const chalk_1 = __importDefault(require("chalk"));
+const fs_1 = require("fs");
+const dateUtils_1 = require("./dateUtils");
+const form_data_1 = __importDefault(require("form-data"));
+const DEFAULT_API_HOST = 'qase.io';
+const API_BASE_URL = 'https://api-';
+const APP_BASE_URL = 'https://app-';
+const API_VERSION = '/v1';
+var ApiErrorCode;
+(function (ApiErrorCode) {
+    ApiErrorCode[ApiErrorCode["UNAUTHORIZED"] = 401] = "UNAUTHORIZED";
+    ApiErrorCode[ApiErrorCode["FORBIDDEN"] = 403] = "FORBIDDEN";
+    ApiErrorCode[ApiErrorCode["NOT_FOUND"] = 404] = "NOT_FOUND";
+    ApiErrorCode[ApiErrorCode["BAD_REQUEST"] = 400] = "BAD_REQUEST";
+    ApiErrorCode[ApiErrorCode["UNPROCESSABLE_ENTITY"] = 422] = "UNPROCESSABLE_ENTITY";
+})(ApiErrorCode || (ApiErrorCode = {}));
+class ClientV1 {
+    logger;
+    config;
+    environment;
+    appUrl;
+    runClient;
+    environmentClient;
+    attachmentClient;
+    constructor(logger, config, environment) {
+        this.logger = logger;
+        this.config = config;
+        this.environment = environment;
+        const { apiConfig, appUrl } = this.createApiConfig();
+        this.appUrl = appUrl;
+        this.runClient = new qase_api_client_1.RunsApi(apiConfig);
+        this.environmentClient = new qase_api_client_1.EnvironmentsApi(apiConfig);
+        this.attachmentClient = new qase_api_client_1.AttachmentsApi(apiConfig);
+    }
+    createApiConfig() {
+        const apiConfig = new qase_api_client_1.Configuration({ apiKey: this.config.api.token, formDataCtor: form_data_1.default });
+        if (this.config.api.host && this.config.api.host != DEFAULT_API_HOST) {
+            apiConfig.basePath = `${API_BASE_URL}${this.config.api.host}${API_VERSION}`;
+            return { apiConfig, appUrl: `${APP_BASE_URL}${this.config.api.host}` };
+        }
+        apiConfig.basePath = `https://api.${DEFAULT_API_HOST}${API_VERSION}`;
+        return { apiConfig, appUrl: `https://app.${DEFAULT_API_HOST}` };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    uploadResults(_runId, _results) {
+        throw new Error('Use ClientV2 to upload results');
+    }
+    async createRun() {
+        if (this.config.run.id) {
+            return this.config.run.id;
+        }
+        try {
+            const environmentId = await this.getEnvironmentId();
+            const runObject = this.prepareRunObject(environmentId);
+            this.logger.logDebug(`Creating test run: ${JSON.stringify(runObject)}`);
+            const { data } = await this.runClient.createRun(this.config.project, runObject);
+            if (!data.result?.id) {
+                throw new qase_error_1.QaseError('Failed to create test run');
+            }
+            this.logger.logDebug(`Test run created: ${JSON.stringify(data)}`);
+            return data.result.id;
+        }
+        catch (error) {
+            throw this.processError(error, 'Error creating test run');
+        }
+    }
+    async completeRun(runId) {
+        if (!this.config.run.complete) {
+            return;
+        }
+        try {
+            await this.runClient.completeRun(this.config.project, runId);
+        }
+        catch (error) {
+            throw this.processError(error, 'Error on completing run');
+        }
+        if (this.appUrl) {
+            const runUrl = `${this.appUrl}/run/${this.config.project}/dashboard/${runId}`;
+            this.logger.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
+        }
+    }
+    async uploadAttachments(attachments) {
+        if (!this.config.uploadAttachments) {
+            return [];
+        }
+        const uploadedHashes = [];
+        for (const attachment of attachments) {
+            try {
+                this.logger.logDebug(`Uploading attachment: ${attachment.file_path ?? attachment.file_name}`);
+                const data = this.prepareAttachmentData(attachment);
+                const response = await this.attachmentClient.uploadAttachment(this.config.project, [data]);
+                const hash = response.data.result?.[0]?.hash;
+                if (hash) {
+                    uploadedHashes.push(hash);
+                }
+            }
+            catch (error) {
+                this.logger.logError('Cannot upload attachment:', error);
+            }
+        }
+        return uploadedHashes;
+    }
+    prepareAttachmentData(attachment) {
+        if (attachment.file_path) {
+            return {
+                name: attachment.file_name,
+                value: (0, fs_1.createReadStream)(attachment.file_path),
+            };
+        }
+        return {
+            name: attachment.file_name,
+            value: typeof attachment.content === 'string'
+                ? Buffer.from(attachment.content)
+                : attachment.content,
+        };
+    }
+    async getEnvironmentId() {
+        if (!this.environment)
+            return undefined;
+        const { data } = await this.environmentClient.getEnvironments(this.config.project, undefined, this.environment, 100);
+        return data.result?.entities?.find((env) => env.slug === this.environment)?.id;
+    }
+    prepareRunObject(environmentId) {
+        const runObject = {
+            title: this.config.run.title ?? `Automated run ${new Date().toISOString()}`,
+            description: this.config.run.description ?? '',
+            is_autotest: true,
+            cases: [],
+            start_time: (0, dateUtils_1.getStartTime)(),
+        };
+        if (environmentId !== undefined) {
+            runObject.environment_id = environmentId;
+        }
+        if (this.config.plan.id) {
+            runObject.plan_id = this.config.plan.id;
+        }
+        return runObject;
+    }
+    /**
+     * Process error and throw QaseError
+     * @param {Error | AxiosError} error
+     * @param {string} message
+     * @param {object} model
+     * @private
+     */
+    processError(error, message, model) {
+        if (!(0, is_axios_error_1.isAxiosError)(error)) {
+            return new qase_error_1.QaseError(message, { cause: error });
+        }
+        const err = error;
+        const errorData = err.response?.data;
+        const status = err.response?.status;
+        switch (status) {
+            case ApiErrorCode.UNAUTHORIZED:
+                return new qase_error_1.QaseError(`${message}: Unauthorized. Please check your API token.`);
+            case ApiErrorCode.FORBIDDEN:
+                return new qase_error_1.QaseError(`${message}: ${errorData?.errorMessage ?? 'Forbidden'}`);
+            case ApiErrorCode.NOT_FOUND:
+                return new qase_error_1.QaseError(`${message}: Not found.`);
+            case ApiErrorCode.BAD_REQUEST:
+            case ApiErrorCode.UNPROCESSABLE_ENTITY:
+                return new qase_error_1.QaseError(`${message}: Bad request\n${JSON.stringify(errorData)}\nBody: ${JSON.stringify(model)}`);
+            default:
+                return new qase_error_1.QaseError(message, { cause: err });
+        }
+    }
+}
+exports.ClientV1 = ClientV1;

package/dist/client/clientV2.d.ts

@@ -0,0 +1,26 @@
+import { ResultStepStatus } from "qase-api-v2-client";
+import { StepStatusEnum, TestResultType, TestStatusEnum } from "../models";
+import { LoggerInterface } from "../utils/logger";
+import { ClientV1 } from "./clientV1";
+import { TestOpsOptionsType } from "../models/config/TestOpsOptionsType";
+export declare class ClientV2 extends ClientV1 {
+    private readonly rootSuite;
+    static statusMap: Record<TestStatusEnum, string>;
+    static stepStatusMap: Record<StepStatusEnum, ResultStepStatus>;
+    private readonly resultsClient;
+    constructor(logger: LoggerInterface, config: TestOpsOptionsType, environment: string | undefined, rootSuite: string | undefined);
+    private createApiConfigV2;
+    uploadResults(runId: number, results: TestResultType[]): Promise<void>;
+    private transformTestResult;
+    private transformParams;
+    private transformGroupParams;
+    private transformSteps;
+    private transformStep;
+    private createBaseResultStep;
+    private processTextStep;
+    private processGherkinStep;
+    private getExecution;
+    private getRelation;
+    private getDefaultSuiteRelation;
+    private buildSuiteData;
+}

package/dist/client/clientV2.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientV2 = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const qase_api_v2_client_1 = require("qase-api-v2-client");
+const models_1 = require("../models");
+const clientV1_1 = require("./clientV1");
+const form_data_1 = __importDefault(require("form-data"));
+const API_CONFIG = {
+    DEFAULT_HOST: 'qase.io',
+    BASE_URL: 'https://api-',
+    VERSION: '/v2'
+};
+class ClientV2 extends clientV1_1.ClientV1 {
+    rootSuite;
+    static statusMap = {
+        [models_1.TestStatusEnum.passed]: 'passed',
+        [models_1.TestStatusEnum.failed]: 'failed',
+        [models_1.TestStatusEnum.skipped]: 'skipped',
+        [models_1.TestStatusEnum.disabled]: 'disabled',
+        [models_1.TestStatusEnum.blocked]: 'blocked',
+        [models_1.TestStatusEnum.invalid]: 'invalid',
+    };
+    static stepStatusMap = {
+        [models_1.StepStatusEnum.passed]: qase_api_v2_client_1.ResultStepStatus.PASSED,
+        [models_1.StepStatusEnum.failed]: qase_api_v2_client_1.ResultStepStatus.FAILED,
+        [models_1.StepStatusEnum.blocked]: qase_api_v2_client_1.ResultStepStatus.BLOCKED,
+        [models_1.StepStatusEnum.skipped]: qase_api_v2_client_1.ResultStepStatus.SKIPPED,
+    };
+    resultsClient;
+    constructor(logger, config, environment, rootSuite) {
+        super(logger, config, environment);
+        this.rootSuite = rootSuite;
+        const apiConfig = this.createApiConfigV2();
+        this.resultsClient = new qase_api_v2_client_1.ResultsApi(apiConfig);
+    }
+    createApiConfigV2() {
+        const apiConfig = new qase_api_v2_client_1.Configuration({ apiKey: this.config.api.token, formDataCtor: form_data_1.default });
+        apiConfig.basePath = this.config.api.host && this.config.api.host != API_CONFIG.DEFAULT_HOST
+            ? `${API_CONFIG.BASE_URL}${this.config.api.host}${API_CONFIG.VERSION}`
+            : `https://api.${API_CONFIG.DEFAULT_HOST}${API_CONFIG.VERSION}`;
+        return apiConfig;
+    }
+    async uploadResults(runId, results) {
+        try {
+            const models = await Promise.all(results.map(result => this.transformTestResult(result)));
+            await this.resultsClient.createResultsV2(this.config.project, runId, {
+                results: models,
+            });
+        }
+        catch (error) {
+            throw this.processError(error, 'Error on uploading results', results);
+        }
+    }
+    async transformTestResult(result) {
+        const attachments = await this.uploadAttachments(result.attachments);
+        const steps = await this.transformSteps(result.steps, result.title);
+        const params = this.transformParams(result.params);
+        const groupParams = this.transformGroupParams(result.group_params, params);
+        const relations = this.getRelation(result.relations);
+        const model = {
+            title: result.title,
+            execution: this.getExecution(result.execution),
+            testops_ids: Array.isArray(result.testops_id)
+                ? result.testops_id
+                : result.testops_id !== null ? [result.testops_id] : null,
+            attachments: attachments,
+            steps: steps,
+            params: params,
+            param_groups: groupParams,
+            relations: relations,
+            message: result.message,
+            fields: result.fields,
+            defect: this.config.defect ?? false,
+        };
+        this.logger.logDebug(`Transformed result: ${JSON.stringify(model)}`);
+        return model;
+    }
+    transformParams(params) {
+        const transformedParams = {};
+        for (const [key, value] of Object.entries(params)) {
+            if (value) {
+                transformedParams[key] = value;
+            }
+        }
+        return transformedParams;
+    }
+    transformGroupParams(groupParams, params) {
+        const keys = Object.keys(groupParams);
+        if (keys.length === 0) {
+            return [];
+        }
+        for (const [key, value] of Object.entries(groupParams)) {
+            if (value) {
+                params[key] = value;
+            }
+        }
+        return [keys];
+    }
+    async transformSteps(steps, testTitle) {
+        return Promise.all(steps.map(step => this.transformStep(step, testTitle)));
+    }
+    async transformStep(step, testTitle) {
+        const attachmentHashes = await this.uploadAttachments(step.attachments);
+        const resultStep = this.createBaseResultStep(attachmentHashes, step.execution.status);
+        if (step.step_type === models_1.StepType.TEXT) {
+            this.processTextStep(step, resultStep, testTitle);
+        }
+        else {
+            this.processGherkinStep(step, resultStep);
+        }
+        if (step.steps.length > 0) {
+            resultStep.steps = await this.transformSteps(step.steps, testTitle);
+        }
+        return resultStep;
+    }
+    createBaseResultStep(attachmentHashes, status) {
+        return {
+            data: {
+                action: '',
+            },
+            execution: {
+                status: ClientV2.stepStatusMap[status],
+                attachments: attachmentHashes,
+            },
+        };
+    }
+    processTextStep(step, resultStep, testTitle) {
+        if (!('action' in step.data) || !resultStep.data) {
+            return;
+        }
+        const stepData = step.data;
+        resultStep.data.action = stepData.action || 'Unnamed step';
+        if (stepData.action === '') {
+            this.logger.log((0, chalk_1.default) `{magenta Test '${testTitle}' has empty action in step. The reporter will mark this step as unnamed step.}`);
+        }
+        if (stepData.expected_result != null) {
+            resultStep.data.expected_result = stepData.expected_result;
+        }
+        if (stepData.data != null) {
+            resultStep.data.input_data = stepData.data;
+        }
+    }
+    processGherkinStep(step, resultStep) {
+        if (!('keyword' in step.data) || !resultStep.data) {
+            return;
+        }
+        const stepData = step.data;
+        resultStep.data.action = stepData.keyword;
+    }
+    getExecution(exec) {
+        return {
+            status: ClientV2.statusMap[exec.status],
+            start_time: exec.start_time,
+            end_time: exec.end_time,
+            duration: exec.duration,
+            stacktrace: exec.stacktrace,
+            thread: exec.thread,
+        };
+    }
+    getRelation(relation) {
+        if (!relation?.suite) {
+            return this.getDefaultSuiteRelation();
+        }
+        const suiteData = this.buildSuiteData(relation.suite.data);
+        return { suite: { data: suiteData } };
+    }
+    getDefaultSuiteRelation() {
+        if (!this.rootSuite)
+            return {};
+        return {
+            suite: {
+                data: [{
+                        public_id: null,
+                        title: this.rootSuite,
+                    }],
+            },
+        };
+    }
+    buildSuiteData(suiteData) {
+        const result = [];
+        if (this.rootSuite) {
+            result.push({
+                public_id: null,
+                title: this.rootSuite,
+            });
+        }
+        return result.concat(suiteData.map(data => ({
+            public_id: null,
+            title: data.title,
+        })));
+    }
+}
+exports.ClientV2 = ClientV2;

package/dist/client/dateUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function formatUTCDate(date: Date): string;
+export declare function getStartTime(): string;

package/dist/client/dateUtils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStartTime = exports.formatUTCDate = void 0;
+// Utils
+const pad = (num) => num.toString().padStart(2, '0');
+function formatUTCDate(date) {
+    const year = date.getUTCFullYear();
+    const month = pad(date.getUTCMonth() + 1);
+    const day = pad(date.getUTCDate());
+    const hours = pad(date.getUTCHours());
+    const minutes = pad(date.getUTCMinutes());
+    const seconds = pad(date.getUTCSeconds());
+    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+exports.formatUTCDate = formatUTCDate;
+function getStartTime() {
+    const date = new Date();
+    return formatUTCDate(new Date(date.getTime() - 10000));
+}
+exports.getStartTime = getStartTime;

package/dist/client/interface.d.ts

@@ -0,0 +1,6 @@
+import { TestResultType } from "../models";
+export interface IClient {
+    createRun(): Promise<number>;
+    completeRun(runId: number): Promise<void>;
+    uploadResults(runId: number, results: TestResultType[]): Promise<void>;
+}

package/dist/client/interface.js

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

package/dist/config/config-validation-schema.js

@@ -51,24 +51,6 @@ exports.configValidationSchema = {
                             type: 'string',
                             nullable: true,
                         },
-                        headers: {
-                            type: 'object',
-                            nullable: true,
-                            additionalProperties: false,
-                            patternProperties: {
-                                '^.*$': {
-                                    type: 'string',
-                                },
-                            },
-                        },
-                        retries: {
-                            type: 'number',
-                            nullable: true,
-                        },
-                        retryDelay: {
-                            type: 'number',
-                            nullable: true,
-                        },
                     },
                 },
                 project: {
@@ -125,10 +107,6 @@ exports.configValidationSchema = {
                     type: 'boolean',
                     nullable: true,
                 },
-                useV2: {
-                    type: 'boolean',
-                    nullable: true,
-                },
             },
         },
         report: {