qase-javascript-commons 2.0.0-beta.6 → 2.0.0-beta.8

package/README.md

@@ -1,102 +1,79 @@
-## Install
+# Qase JavaScript Commons
 
-```
-$ npm install --save qase-core-reporter
-```
-
-## Usage
-
-> Create a new Qase JS reporter in minutes by leveraging this core reporter.
-> Use Qase core reporter with test framework custom reporter hooks
-
-```js
-import {
-  QaseCoreReporter,
-  QaseOptions,
-  QaseCoreReporterOptions,
-  TestResult
-} from "qase-core-reporter";
+This package contains common classes and functions for working with Qase TMS API.
 
-const reporterOptions: QaseOptions = {
-  // expected options, provided by reporter user
-  apiToken: 'lknkldnfknobek'
-  projectCode: 'DH'
-};
+## Installation
 
-const qaseCoreReporterOptions: QaseCoreReporterOptions = {
-  // expected core options, provider by reporter developer
-  frameworkName: 'vitest',
-  reporterName: 'vitest-qase-reporter'
-};
-
-// Initialize Core reporter with expected params
-const reporter = new QaseCoreReporter(reporterOptions, qaseCoreReporterOptions);
-
-// On start hook
-reporter.start();
-
-// On test results
-reporter.addTestResult(test: TestResult, status, attachments);
-
-// On end/complete hook
-reporter.end({ spawn: false }); // spawn true will finish reporting in a child process
+```bash
+npm install qase-javascript-commons@beta
 ```
 
-## Reporter Options
-
-<a name="qase-core-reporter"></a>
-
-## reporter(qaseOptions, qaseCoreReporterOptions) ⇒ <code>QaseCoreReporter</code>
-
-| Param                                       | Type      | Required | Description                                                                       |
-| ------------------------------------------- | --------- | -------- | --------------------------------------------------------------------------------- |
-| qaseOptions                                 | `object`  | yes      |                                                                                   |
-| qaseOptions.`report`                        | `boolean` | no       | Whether or not to enable reporter                                                 |
-| qaseOptions.`apiToken`                      | `string`  | yes      | Qase api key                                                                      |
-| qaseOptions.`projectCode`                   | `string`  | yes      | Qase project ID                                                                   |
-| qaseOptions.`basePath`                      | `string`  | no       | Qase API base url                                                                 |
-| qaseOptions.`rootSuiteTitle`                | `string`  | no       | The root suite that unknown test cases will be added to                           |
-| qaseOptions.`runId`                         | `string`  | no       | Qase run ID, if you want results to be posted to a specific run                   |
-| qaseOptions.`logging`                       | `boolean` | no       | Whether or not to output Qase logs while testing and reporting                    |
-| qaseOptions.`runComplete`                   | `boolean` | no       | Whether or not to complete a test run when results are posted                     |
-| qaseOptions.`environmentId`                 | `string`  | no       | Qase environment ID                                                               |
-| qaseOptions.`runDescription`                | `string`  | no       | Qase run custom description                                                       |
-| qaseOptions.`runName`                       | `string`  | no       | Qase run custom name                                                              |
-| qaseCoreReporterOptions                     | `object`  | yes      |                                                                                   |
-| qaseCoreReporterOptions.`frameworkName`     | `string`  | yes      | Test automation framework/package name                                            |
-| qaseCoreReporterOptions.`reporterName`      | `string`  | yes      | Current qase reporter package name                                                |
-| qaseCoreReporterOptions.`uploadAttachments` | `boolean` | no       | Wether or not to upload attachments                                               |
-| qaseCoreReporterOptions.`screenshotFolder`  | `string`  | no       | Folder to find screenshots with Qase ID in file name                              |
-| qaseCoreReporterOptions.`videoFolder`       | `string`  | no       | Folder to find videos with Qase ID in file name                                   |
-| qaseCoreReporterOptions.`loadConfig`        | `boolean` | no       | Whether or not to also load reporter options from `qase.config.json` or `.qaserc` |
-
-## API (public methods)
-
-<a name="qase-core-reporter-public-methods"></a>
-
-| Method                                   | Description                                                                                                     |
-| ---------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
-| start()                                  | Check if reporting is enabled, check project and create run if needed                                           |
-| addTestResult(test, status, attachments) | Parse and save test results for publishing                                                                      |
-| end({spawn: true/false})                 | Upload attachments if needed and map to existing results, send results as BulkCreate, complete run if specified |
-| uploadAttachments(attachments)           | Upload attachments based on file path and return attachment hashes for test results                             |
-
-## Qase Reporter Environmental Variables
-
-> Qase environmental variables are first class options, which means the user can change all default/static reporter options by using these variables.
-
-<a name="qase-core-reporter-envs"></a>
-| Variable | Type | Description |
-| ------------------------- | --------- | -------------------------------------------------------------- |
-| `QASE_REPORT` | boolean | Whether or not to enable reporter |
-| `QASE_API_TOKEN` | string | Qase api key |
-| `QASE_API_BASE_URL` | string | Qase API base url |
-| `QASE_PROJECT_CODE` | string | Qase project ID |
-| `QASE_RUN_ID` | string | Qase run ID, if you want results to be posted to a specific run |
-| `QASE_RUN_NAME` | string | Qase run custom name |
-| `QASE_RUN_DESCRIPTION` | string | Qase run custom description |
-| `QASE_RUN_COMPLETE` | string | Whether or not to complete a test run when results are posted |
-| `QASE_ENVIRONMENT_ID` | string | Qase environment ID |
-| `QASE_ROOT_SUITE_TITLE` | string | The root suite that unknown test cases will be added to |
-| `QASE_UPLOAD_ATTACHMENTS` | string | Whether or not to upload attachments
-| `QASE_LOGGING` | boolean | Whether or not to output Qase logs while testing and reporting |
+## Configuration
+
+Qase JS Reporters can be configured in multiple ways:
+
+- using a config file `qase.config.json`
+- using environment variables
+
+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`                     | `testops`                               | No       | `testops`, `report`, `off` |
+| Fallback mode of reporter                                                                                                  | `fallback`                 | `QASE_FALLBACK`                 | `off`                                   | No       | `testops`, `report`, `off` |
+| Environment                                                                                                                | `environment`              | `QASE_ENVIRONMENT`              | `local`                                 | 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`        |                                         | Yes      | Any string                 |
+| Qase API host                                                                                                              | `testops.api.host`         | `QASE_TESTOPS_API_HOST`         | `qase.io`                               | No       | Any string                 |
+| 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`          |                                         | Yes      | Any string                 |
+| Qase test run ID                                                                                                           | `testops.run.id`           | `QASE_TESTOPS_RUN_ID`           |                                         | 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`          |                                         | 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:
+
+```json
+{
+  "mode": "testops",
+  "fallback": "report",
+  "debug": false,
+  "environment": "local",
+  "captureLogs": false,
+  "report": {
+    "driver": "local",
+    "connection": {
+      "local": {
+        "path": "./build/qase-report",
+        "format": "json"
+      }
+    }
+  },
+  "testops": {
+    "api": {
+      "token": "<token>",
+      "host": "qase.io"
+    },
+    "run": {
+      "title": "Regress run",
+      "description": "Regress run description",
+      "complete": true
+    },
+    "defect": false,
+    "project": "<project_code>",
+    "batch": {
+      "size": 100
+    }
+  }
+}
+```

package/changelog.md

@@ -1,3 +1,51 @@
+# qase-javascript-commons@2.0.0-beta.8
+
+## What's new
+
+Renamed the `QASE_TESTOPS_CHUNK` environment variable to `QASE_TESTOPS_BATCH_SIZE`.
+Renamed the `chunk` field in the reporter's configuration to `batch.size`.
+
+```diff
+{
+  ...
+  "testops": {
+-   "chunk": 10
++   "batch": {
++      "size": 10
++    }
+    ...
+  },
+  ...
+}
+```
+
+# qase-javascript-commons@2.0.0-beta.7
+
+## What's new
+
+TestOps reporter supports uploading test result in real-time.
+It can be useful for long-running tests, where you want to see the results as soon as they are available.
+You can use chunk size to control the size of the data sent to the Qase.
+
+To enable real-time reporting, set an environment variable before running the tests or use the reporter's configuration:
+
+```bash
+QASE_TESTOPS_CHUNK=10
+```
+
+```diff
+{
+  ...
+  "testops": {
++   "chunk": 10
+    ...
+  },
+  ...
+}
+```
+
+where `10` is the size of the chunk in test result's count.
+
 # qase-javascript-commons@2.0.0-beta.6
 
 ## What's new

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

@@ -107,9 +107,15 @@ exports.configValidationSchema = {
                         },
                     },
                 },
-                chunk: {
-                    type: 'number',
+                batch: {
+                    type: 'object',
                     nullable: true,
+                    properties: {
+                        size: {
+                            type: 'number',
+                            nullable: true,
+                        },
+                    },
                 },
                 defect: {
                     type: 'boolean',

package/dist/env/env-enum.d.ts

@@ -14,7 +14,6 @@ export declare enum EnvEnum {
 export declare enum EnvTestOpsEnum {
     project = "QASE_TESTOPS_PROJECT",
     uploadAttachments = "QASE_TESTOPS_UPLOAD_ATTACHMENTS",
-    chunk = "QASE_TESTOPS_CHUNK",
     defect = "QASE_TESTOPS_DEFECT",
     useV2 = "QASE_TESTOPS_API_V2"
 }
@@ -40,6 +39,12 @@ export declare enum EnvRunEnum {
 export declare enum EnvPlanEnum {
     id = "QASE_TESTOPS_PLAN_ID"
 }
+/**
+ * @enum {string}
+ */
+export declare enum EnvBatchEnum {
+    size = "QASE_TESTOPS_BATCH_SIZE"
+}
 /**
  * @enum {string}
  */

package/dist/env/env-enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EnvLocalEnum = exports.EnvPlanEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
+exports.EnvLocalEnum = exports.EnvBatchEnum = exports.EnvPlanEnum = exports.EnvRunEnum = exports.EnvApiEnum = exports.EnvTestOpsEnum = exports.EnvEnum = void 0;
 /**
  * @enum {string}
  */
@@ -19,7 +19,6 @@ var EnvTestOpsEnum;
 (function (EnvTestOpsEnum) {
     EnvTestOpsEnum["project"] = "QASE_TESTOPS_PROJECT";
     EnvTestOpsEnum["uploadAttachments"] = "QASE_TESTOPS_UPLOAD_ATTACHMENTS";
-    EnvTestOpsEnum["chunk"] = "QASE_TESTOPS_CHUNK";
     EnvTestOpsEnum["defect"] = "QASE_TESTOPS_DEFECT";
     EnvTestOpsEnum["useV2"] = "QASE_TESTOPS_API_V2";
 })(EnvTestOpsEnum || (exports.EnvTestOpsEnum = EnvTestOpsEnum = {}));
@@ -48,6 +47,13 @@ var EnvPlanEnum;
 (function (EnvPlanEnum) {
     EnvPlanEnum["id"] = "QASE_TESTOPS_PLAN_ID";
 })(EnvPlanEnum || (exports.EnvPlanEnum = EnvPlanEnum = {}));
+/**
+ * @enum {string}
+ */
+var EnvBatchEnum;
+(function (EnvBatchEnum) {
+    EnvBatchEnum["size"] = "QASE_TESTOPS_BATCH_SIZE";
+})(EnvBatchEnum || (exports.EnvBatchEnum = EnvBatchEnum = {}));
 /**
  * @enum {string}
  */

package/dist/env/env-to-config.js

@@ -28,7 +28,9 @@ const envToConfig = (env) => ({
         plan: {
             id: env[env_enum_1.EnvPlanEnum.id],
         },
-        chunk: env[env_enum_1.EnvTestOpsEnum.chunk],
+        batch: {
+            size: env[env_enum_1.EnvBatchEnum.size],
+        },
         defect: env[env_enum_1.EnvTestOpsEnum.defect],
         useV2: env[env_enum_1.EnvTestOpsEnum.useV2],
     },

package/dist/env/env-type.d.ts

@@ -1,4 +1,4 @@
-import { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, EnvPlanEnum } from './env-enum';
+import { EnvEnum, EnvTestOpsEnum, EnvApiEnum, EnvRunEnum, EnvLocalEnum, EnvPlanEnum, EnvBatchEnum } from './env-enum';
 import { ModeEnum } from '../options';
 import { FormatEnum } from '../writer';
 export type EnvType = {
@@ -9,7 +9,6 @@ export type EnvType = {
     [EnvEnum.captureLogs]?: boolean;
     [EnvTestOpsEnum.project]?: string;
     [EnvTestOpsEnum.uploadAttachments]?: boolean;
-    [EnvTestOpsEnum.chunk]?: number;
     [EnvTestOpsEnum.defect]?: boolean;
     [EnvTestOpsEnum.useV2]?: boolean;
     [EnvApiEnum.token]?: string;
@@ -19,6 +18,7 @@ export type EnvType = {
     [EnvRunEnum.description]?: string;
     [EnvRunEnum.complete]?: boolean;
     [EnvPlanEnum.id]?: number;
+    [EnvBatchEnum.size]?: number;
     [EnvLocalEnum.path]?: string;
     [EnvLocalEnum.format]?: `${FormatEnum}`;
 };

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

@@ -40,10 +40,6 @@ exports.envValidationSchema = {
             type: 'boolean',
             nullable: true,
         },
-        [env_enum_1.EnvTestOpsEnum.chunk]: {
-            type: 'number',
-            nullable: true,
-        },
         [env_enum_1.EnvTestOpsEnum.defect]: {
             type: 'boolean',
             nullable: true,
@@ -80,6 +76,10 @@ exports.envValidationSchema = {
             type: 'number',
             nullable: true,
         },
+        [env_enum_1.EnvBatchEnum.size]: {
+            type: 'number',
+            nullable: true,
+        },
         [env_enum_1.EnvLocalEnum.path]: {
             type: 'string',
             nullable: true,

package/dist/qase.d.ts

@@ -39,10 +39,14 @@ export declare class QaseReporter extends AbstractReporter {
      * @param {LoggerInterface} logger
      */
     constructor(options: OptionsType, logger?: LoggerInterface);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result: TestResultType): void;
+    addTestResult(result: TestResultType): Promise<void>;
     /**
      * @param {TestResultType} result
      * @private

package/dist/qase.js

@@ -119,18 +119,42 @@ class QaseReporter extends reporters_1.AbstractReporter {
             }
         }
     }
+    /**
+     * @returns {Promise<void>}
+     */
+    async startTestRun() {
+        if (!this.disabled) {
+            try {
+                await this.upstreamReporter?.startTestRun();
+            }
+            catch (error) {
+                this.logError('Unable to start test run in the upstream reporter: ', error);
+                if (this.fallbackReporter == undefined) {
+                    this.disabled = true;
+                    return;
+                }
+                try {
+                    await this.fallbackReporter?.startTestRun();
+                }
+                catch (error) {
+                    this.logError('Unable to start test run in the fallback reporter: ', error);
+                    this.disabled = true;
+                }
+            }
+        }
+    }
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result) {
+    async addTestResult(result) {
         if (!this.disabled) {
             this.logTestItem(result);
             if (this.useFallback) {
-                this.addTestResultToFallback(result);
+                await this.addTestResultToFallback(result);
                 return;
             }
             try {
-                this.upstreamReporter?.addTestResult(result);
+                await this.upstreamReporter?.addTestResult(result);
             }
             catch (error) {
                 this.logError('Unable to add the result to the upstream reporter:', error);
@@ -142,7 +166,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                     this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
                     this.useFallback = true;
                 }
-                this.addTestResultToFallback(result);
+                await this.addTestResultToFallback(result);
             }
         }
     }
@@ -150,9 +174,9 @@ class QaseReporter extends reporters_1.AbstractReporter {
      * @param {TestResultType} result
      * @private
      */
-    addTestResultToFallback(result) {
+    async addTestResultToFallback(result) {
         try {
-            this.fallbackReporter?.addTestResult(result);
+            await this.fallbackReporter?.addTestResult(result);
         }
         catch (error) {
             this.logError('Unable to add the result to the fallback reporter:', error);
@@ -208,7 +232,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
         const { frameworkPackage, frameworkName, reporterName, environment, report = {}, testops = {}, ...commonOptions } = options;
         switch (mode) {
             case options_1.ModeEnum.testops: {
-                const { api: { token, headers, ...api } = {}, project, run: { title, description, ...run } = {}, plan = {}, chunk, uploadAttachments, } = testops;
+                const { api: { token, headers, ...api } = {}, project, run: { title, description, ...run } = {}, plan = {}, batch = {}, uploadAttachments, } = testops;
                 if (!token) {
                     throw new Error(`Either "testops.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "testops" mode`);
                 }
@@ -232,7 +256,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                         ...run,
                     },
                     plan,
-                    chunk,
+                    batch,
                     debug: commonOptions.debug,
                     captureLogs: commonOptions.captureLogs,
                 }, apiClient, logger, typeof environment === 'number' ? environment : undefined);

package/dist/reporters/abstract-reporter.d.ts

@@ -9,8 +9,9 @@ export interface ReporterOptionsType {
     captureLogs?: boolean | undefined;
 }
 export interface ReporterInterface {
-    addTestResult(result: TestResultType): void;
+    addTestResult(result: TestResultType): Promise<void>;
     publish(): Promise<void>;
+    startTestRun(): Promise<void>;
     getTestResults(): TestResultType[];
     setTestResults(results: TestResultType[]): void;
     isCaptureLogs(): boolean;
@@ -41,6 +42,10 @@ export declare abstract class AbstractReporter implements ReporterInterface {
      * @returns {Promise<void>}
      */
     abstract publish(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract startTestRun(): Promise<void>;
     /**
      * @param {ReporterOptionsType} options
      * @param {LoggerInterface} logger
@@ -58,7 +63,7 @@ export declare abstract class AbstractReporter implements ReporterInterface {
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result: TestResultType): void;
+    addTestResult(result: TestResultType): Promise<void>;
     /**
      * @param {TestResultType[]} results
      */

package/dist/reporters/abstract-reporter.js

@@ -45,7 +45,8 @@ class AbstractReporter {
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result) {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async addTestResult(result) {
         if (result.testops_id === null || !Array.isArray(result.testops_id)) {
             this.results.push(result);
             return;

package/dist/reporters/report-reporter.d.ts

@@ -8,7 +8,7 @@ export declare class ReportReporter extends AbstractReporter {
     private writer;
     private readonly environment;
     private readonly runId;
-    private readonly startTime;
+    private startTime;
     /**
      * @param {ReporterOptionsType} options
      * @param {WriterInterface} writer
@@ -17,10 +17,13 @@ export declare class ReportReporter extends AbstractReporter {
      * @param {number | undefined} runId
      */
     constructor(options: ReporterOptionsType | undefined, writer: WriterInterface, logger?: LoggerInterface, environment?: string, runId?: number);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
     /**
      * @returns {Promise<void>}
      *
-     * eslint-disable-next-line @typescript-eslint/require-await
      */
     publish(): Promise<void>;
     /**

package/dist/reporters/report-reporter.js

@@ -48,10 +48,16 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
         this.environment = environment;
         this.runId = runId;
     }
+    /**
+     * @returns {Promise<void>}
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async startTestRun() {
+        this.startTime = Date.now();
+    }
     /**
      * @returns {Promise<void>}
      *
-     * eslint-disable-next-line @typescript-eslint/require-await
      */
     async publish() {
         const report = {

package/dist/reporters/testops-reporter.d.ts

@@ -1,6 +1,6 @@
 import { QaseApiInterface, ResultStepStatus, TestStepResultCreateStatusEnum } from 'qaseio';
 import { AbstractReporter, LoggerInterface, ReporterOptionsType } from './abstract-reporter';
-import { StepStatusEnum, TestStatusEnum } from '../models';
+import { StepStatusEnum, TestResultType, TestStatusEnum } from '../models';
 export type TestOpsRunType = {
     id?: number | undefined;
     title: string;
@@ -10,12 +10,15 @@ export type TestOpsRunType = {
 export type TestOpsPlanType = {
     id?: number | undefined;
 };
+export type TestOpsBatchType = {
+    size?: number | undefined;
+};
 export type TestOpsOptionsType = {
     project: string;
     uploadAttachments?: boolean | undefined;
     run: TestOpsRunType;
     plan: TestOpsPlanType;
-    chunk?: number | undefined;
+    batch?: TestOpsBatchType;
     defect?: boolean | undefined;
     useV2?: boolean | undefined;
 };
@@ -66,7 +69,7 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @type {TestResultType[]}
      * @private
      */
-    private readonly chunk;
+    private readonly batchSize;
     /**
      * @type {boolean | undefined}
      * @private
@@ -77,6 +80,16 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @private
      */
     private readonly defect;
+    /**
+     * @type {number}
+     * @private
+     */
+    private firstIndex;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private isTestRunReady;
     /**
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
@@ -84,6 +97,25 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @param {number} environment
      */
     constructor(options: ReporterOptionsType & TestOpsOptionsType, api: QaseApiInterface, logger?: LoggerInterface, environment?: number);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    addTestResult(result: TestResultType): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    private checkOrCreateTestRun;
+    /**
+     * @returns {Promise<void>}
+     * @param testResults
+     * @private
+     */
+    private publishResults;
     /**
      * @returns {Promise<void>}
      */

package/dist/reporters/testops-reporter.js

@@ -26,72 +26,113 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         const { project, uploadAttachments, run, ...restOptions } = options;
         super(restOptions, logger);
         this.api = api;
+        /**
+         * @type {number}
+         * @private
+         */
+        this.firstIndex = 0;
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this.isTestRunReady = false;
         const baseUrl = 'https://app.qase.io';
         this.baseUrl = baseUrl.replace(/\/$/, '');
         this.projectCode = project;
         this.isUploadAttachments = uploadAttachments;
         this.run = { complete: true, ...run };
         this.environment = environment;
-        this.chunk = options.chunk ?? defaultChunkSize;
+        this.batchSize = options.batch?.size ?? defaultChunkSize;
         this.useV2 = options.useV2 ?? false;
         this.defect = options.defect ?? false;
     }
     /**
      * @returns {Promise<void>}
      */
-    async publish() {
-        let runId;
-        if (this.run.id !== undefined) {
-            await this.checkRun(this.run.id);
-            runId = this.run.id;
+    async startTestRun() {
+        await this.checkOrCreateTestRun();
+    }
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    async addTestResult(result) {
+        await super.addTestResult(result);
+        if (!this.isTestRunReady) {
+            return;
         }
-        else {
-            const { result } = await this.createRun(this.run.title, this.run.description, this.environment);
-            if (!result?.id) {
-                throw new Error('Cannot create run.');
-            }
-            runId = result.id;
+        const countOfResults = this.batchSize + this.firstIndex;
+        if (this.results.length >= countOfResults) {
+            await this.publishResults(this.results.slice(this.firstIndex, countOfResults));
+            this.firstIndex = countOfResults;
         }
-        if (!this.results.length) {
-            this.log('No test cases were matched. Ensure that your tests are declared correctly.');
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async checkOrCreateTestRun() {
+        if (this.run.id !== undefined) {
+            await this.checkRun(this.run.id);
+            this.isTestRunReady = true;
             return;
         }
+        const { result } = await this.createRun(this.run.title, this.run.description, this.environment);
+        if (!result?.id) {
+            throw new Error('Cannot create run.');
+        }
+        this.run.id = result.id;
+        this.isTestRunReady = true;
+    }
+    /**
+     * @returns {Promise<void>}
+     * @param testResults
+     * @private
+     */
+    async publishResults(testResults) {
         if (this.useV2) {
             const results = [];
-            for (const result of this.results) {
+            for (const result of testResults) {
                 const resultCreateV2 = await this.transformTestResult(result);
                 results.push(resultCreateV2);
             }
-            for (let i = 0; i < results.length; i += this.chunk) {
-                await this.api.result.createResultsV2(this.projectCode, runId, {
-                    results: results.slice(i, i + this.chunk),
-                });
-            }
+            await this.api.result.createResultsV2(this.projectCode, this.run.id, {
+                results: results,
+            });
         }
         else {
             const results = [];
-            for (const result of this.results) {
+            for (const result of testResults) {
                 const resultCreate = await this.transformTestResultV1(result);
                 results.push(resultCreate);
             }
-            for (let i = 0; i < results.length; i += this.chunk) {
-                await this.api.results.createResultBulk(this.projectCode, runId, {
-                    results: results.slice(i, i + this.chunk),
-                });
-            }
+            await this.api.results.createResultBulk(this.projectCode, this.run.id, {
+                results: results,
+            });
+        }
+        this.log((0, chalk_1.default) `{green ${testResults.length} result(s) sent to Qase}`);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async publish() {
+        if (this.results.length === 0) {
+            this.log((0, chalk_1.default) `{yellow No results to send to Qase}`);
+            return;
+        }
+        if (this.firstIndex < this.results.length) {
+            await this.publishResults(this.results.slice(this.firstIndex));
         }
-        this.log((0, chalk_1.default) `{green ${this.results.length} result(s) sent to Qase}`);
         if (!this.run.complete) {
             return;
         }
         try {
-            await this.api.runs.completeRun(this.projectCode, runId);
-            this.log((0, chalk_1.default) `{green Run ${runId} completed}`);
+            await this.api.runs.completeRun(this.projectCode, this.run.id);
+            this.log((0, chalk_1.default) `{green Run ${this.run.id} completed}`);
         }
         catch (error) {
             throw new qase_error_1.QaseError('Error on completing run', { cause: error });
         }
-        const runUrl = `${this.baseUrl}/run/${this.projectCode}/dashboard/${runId}`;
+        const runUrl = `${this.baseUrl}/run/${this.projectCode}/dashboard/${this.run.id}`;
         this.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
     }
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.0.0-beta.6",
+  "version": "2.0.0-beta.8",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",