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

package/changelog.md

@@ -1,3 +1,30 @@
+# 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/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);

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;
@@ -77,6 +77,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 +94,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,6 +26,16 @@ 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;
@@ -39,59 +49,90 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     /**
      * @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.chunk + 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,
+            });
+        }
+    }
+    /**
+     * @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.7",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",