qase-javascript-commons 2.0.12 → 2.1.0-beta.1

package/changelog.md

@@ -1,3 +1,17 @@
+# qase-javascript-commons@2.1.0-beta.1
+
+## What's new
+
+- update a `InternalReporterInterface`. Added a new methods `sendResults` and `complete` to send the results and complete the test run.
+- add `StateManager` class to manage and share the state of the reporter between the different instances of the reporter.
+
+# qase-javascript-commons@2.0.13
+
+## What's new
+
+- If a plan ID is specified then when creating a test run it also specifies the plan ID.
+- If a test run ID is specified then the reporter won't check for the existence of a test run.
+
 # qase-javascript-commons@2.0.12
 
 ## What's new

package/dist/qase.d.ts

@@ -5,6 +5,9 @@ export interface ReporterInterface {
     publish(): Promise<void>;
     startTestRun(): void;
     isCaptureLogs(): boolean;
+    getResults(): TestResultType[];
+    sendResults(): Promise<void>;
+    complete(): Promise<void>;
 }
 /**
  * @class QaseReporter
@@ -47,14 +50,20 @@ export declare class QaseReporter implements ReporterInterface {
     private useFallback;
     private readonly logger;
     private startTestRunOperation?;
+    private options;
     /**
      * @param {OptionsType} options
      */
     private constructor();
+    getResults(): TestResultType[];
+    setTestResults(results: TestResultType[]): void;
+    sendResults(): Promise<void>;
+    complete(): Promise<void>;
     /**
      * @returns {void}
      */
     startTestRun(): void;
+    startTestRunAsync(): Promise<void>;
     /**
      * @param {OptionsType} options
      * @returns {QaseReporter}

package/dist/qase.js

@@ -17,6 +17,7 @@ const get_package_version_1 = require("./utils/get-package-version");
 const custom_boundary_1 = require("./utils/custom-boundary");
 const disabled_exception_1 = require("./utils/disabled-exception");
 const logger_1 = require("./utils/logger");
+const state_1 = require("./state/state");
 /**
  * @type {Record<TestStatusEnum, (test: TestResultType) => string>}
  */
@@ -79,8 +80,18 @@ class QaseReporter {
          * @private
          */
         this.useFallback = false;
+        if (state_1.StateManager.isStateExists()) {
+            const state = state_1.StateManager.getState();
+            if (state.IsModeChanged && state.Mode) {
+                process.env[env_1.EnvEnum.mode] = state.Mode.toString();
+            }
+            if (state.RunId) {
+                process.env[env_1.EnvRunEnum.id] = state.RunId.toString();
+            }
+        }
         const env = (0, env_1.envToConfig)((0, env_schema_1.default)({ schema: env_1.envValidationSchema }));
         const composedOptions = (0, options_1.composeOptions)(options, env);
+        this.options = composedOptions;
         this.logger = new logger_1.Logger({ debug: composedOptions.debug });
         this.logger.logDebug(`Config: ${JSON.stringify(composedOptions)}`);
         this.captureLogs = composedOptions.captureLogs;
@@ -120,6 +131,89 @@ class QaseReporter {
                 }
             }
         }
+        if (!state_1.StateManager.isStateExists()) {
+            const state = {
+                RunId: undefined,
+                Mode: this.useFallback ? composedOptions.fallback : composedOptions.mode,
+                IsModeChanged: undefined,
+            };
+            if (this.disabled) {
+                state.Mode = options_1.ModeEnum.off;
+            }
+            state_1.StateManager.setState(state);
+        }
+    }
+    getResults() {
+        if (this.disabled) {
+            return [];
+        }
+        if (this.useFallback) {
+            return this.fallbackReporter?.getTestResults() ?? [];
+        }
+        return this.upstreamReporter?.getTestResults() ?? [];
+    }
+    setTestResults(results) {
+        if (this.disabled) {
+            return;
+        }
+        if (this.useFallback) {
+            this.fallbackReporter?.setTestResults(results);
+        }
+        else {
+            this.upstreamReporter?.setTestResults(results);
+        }
+    }
+    async sendResults() {
+        if (this.disabled) {
+            return;
+        }
+        try {
+            await this.upstreamReporter?.sendResults();
+        }
+        catch (error) {
+            this.logger.logError('Unable to send the results to the upstream reporter:', error);
+            if (this.fallbackReporter == undefined) {
+                state_1.StateManager.setMode(options_1.ModeEnum.off);
+                return;
+            }
+            if (!this.useFallback) {
+                this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
+                this.useFallback = true;
+            }
+            try {
+                await this.fallbackReporter?.sendResults();
+                state_1.StateManager.setMode(this.options.fallback);
+            }
+            catch (error) {
+                this.logger.logError('Unable to send the results to the fallback reporter:', error);
+                state_1.StateManager.setMode(options_1.ModeEnum.off);
+            }
+        }
+    }
+    async complete() {
+        state_1.StateManager.clearState();
+        if (this.disabled) {
+            return;
+        }
+        try {
+            await this.upstreamReporter?.complete();
+        }
+        catch (error) {
+            this.logger.logError('Unable to complete the run in the upstream reporter:', error);
+            if (this.fallbackReporter == undefined) {
+                return;
+            }
+            if (!this.useFallback) {
+                this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
+                this.useFallback = true;
+            }
+            try {
+                await this.fallbackReporter?.complete();
+            }
+            catch (error) {
+                this.logger.logError('Unable to complete the run in the fallback reporter:', error);
+            }
+        }
     }
     /**
      * @returns {void}
@@ -134,18 +228,25 @@ class QaseReporter {
                 this.logger.logError('Unable to start test run in the upstream reporter: ', error);
                 if (this.fallbackReporter == undefined) {
                     this.disabled = true;
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
                     return;
                 }
                 try {
                     this.startTestRunOperation = this.fallbackReporter?.startTestRun();
+                    state_1.StateManager.setMode(this.options.fallback);
                 }
                 catch (error) {
                     this.logger.logError('Unable to start test run in the fallback reporter: ', error);
                     this.disabled = true;
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
                 }
             }
         }
     }
+    async startTestRunAsync() {
+        this.startTestRun();
+        await this.startTestRunOperation;
+    }
     /**
      * @param {OptionsType} options
      * @returns {QaseReporter}
@@ -174,6 +275,7 @@ class QaseReporter {
                 this.logger.logError('Unable to add the result to the upstream reporter:', error);
                 if (this.fallbackReporter == undefined) {
                     this.disabled = true;
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
                     return;
                 }
                 if (!this.useFallback) {
@@ -191,10 +293,12 @@ class QaseReporter {
     async addTestResultToFallback(result) {
         try {
             await this.fallbackReporter?.addTestResult(result);
+            state_1.StateManager.setMode(this.options.fallback);
         }
         catch (error) {
             this.logger.logError('Unable to add the result to the fallback reporter:', error);
             this.disabled = true;
+            state_1.StateManager.setMode(options_1.ModeEnum.off);
         }
     }
     /**
@@ -220,6 +324,7 @@ class QaseReporter {
                 this.logger.logError('Unable to publish the run results to the upstream reporter:', error);
                 if (this.fallbackReporter == undefined) {
                     this.disabled = true;
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
                     return;
                 }
                 if (!this.useFallback) {
@@ -236,8 +341,10 @@ class QaseReporter {
     async publishFallback() {
         try {
             await this.fallbackReporter?.publish();
+            state_1.StateManager.setMode(this.options.fallback);
         }
         catch (error) {
+            state_1.StateManager.setMode(options_1.ModeEnum.off);
             this.logger.logError('Unable to publish the run results to the fallback reporter:', error);
             this.disabled = true;
         }

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

@@ -6,6 +6,8 @@ export interface InternalReporterInterface {
     startTestRun(): Promise<void>;
     getTestResults(): TestResultType[];
     setTestResults(results: TestResultType[]): void;
+    sendResults(): Promise<void>;
+    complete(): Promise<void>;
 }
 /**
  * @abstract
@@ -31,6 +33,14 @@ export declare abstract class AbstractReporter implements InternalReporterInterf
      * @returns {Promise<void>}
      */
     abstract startTestRun(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract complete(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract sendResults(): Promise<void>;
     /**
      * @protected
      * @param {LoggerInterface} logger

package/dist/reporters/abstract-reporter.js

@@ -24,7 +24,9 @@ class AbstractReporter {
      * @returns {TestResultType[]}
      */
     getTestResults() {
-        return this.results;
+        const results = this.results;
+        this.results = [];
+        return results;
     }
     /**
      * @param {TestResultType} result

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

@@ -28,6 +28,8 @@ export declare class ReportReporter extends AbstractReporter {
      *
      */
     publish(): Promise<void>;
+    sendResults(): Promise<void>;
+    complete(): Promise<void>;
     /**
      * @param {TestStepType[]} steps
      * @returns {TestStepType[]}

package/dist/reporters/report-reporter.js

@@ -61,6 +61,40 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
      *
      */
     async publish() {
+        await this.sendResults();
+        await this.complete();
+    }
+    async sendResults() {
+        this.writer.clearPreviousResults();
+        for (const result of this.results) {
+            if (result.attachments.length > 0) {
+                result.attachments = this.writer.writeAttachment(result.attachments);
+            }
+            result.steps = this.copyStepAttachments(result.steps);
+            result.run_id = this.runId ?? null;
+            if (result.relations != null && this.rootSuite != null) {
+                const data = {
+                    title: this.rootSuite,
+                    public_id: null,
+                };
+                result.relations.suite?.data.unshift(data);
+            }
+            else if (this.rootSuite != null) {
+                result.relations = {
+                    suite: {
+                        data: [
+                            {
+                                title: this.rootSuite,
+                                public_id: null,
+                            },
+                        ],
+                    },
+                };
+            }
+            await this.writer.writeTestResult(result);
+        }
+    }
+    async complete() {
         this.writer.clearPreviousResults();
         const report = {
             title: 'Test report',
@@ -103,9 +137,6 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                     report.stats.muted++;
                     break;
             }
-            if (result.execution.thread && !report.threads.includes(result.execution.thread)) {
-                report.threads.push(result.execution.thread);
-            }
             report.execution.cumulative_duration += result.execution.duration ?? 0;
             report.results.push({
                 duration: result.execution.duration ?? 0,
@@ -114,31 +145,6 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
                 thread: result.execution.thread,
                 title: result.title,
             });
-            if (result.attachments.length > 0) {
-                result.attachments = this.writer.writeAttachment(result.attachments);
-            }
-            result.steps = this.copyStepAttachments(result.steps);
-            result.run_id = this.runId ?? null;
-            if (result.relations != null && this.rootSuite != null) {
-                const data = {
-                    title: this.rootSuite,
-                    public_id: null,
-                };
-                result.relations.suite?.data.unshift(data);
-            }
-            else if (this.rootSuite != null) {
-                result.relations = {
-                    suite: {
-                        data: [
-                            {
-                                title: this.rootSuite,
-                                public_id: null,
-                            },
-                        ],
-                    },
-                };
-            }
-            await this.writer.writeTestResult(result);
         }
         const path = await this.writer.writeReport(report);
         this.logger.log(`Report saved to ${path}`);

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

@@ -62,10 +62,15 @@ export declare class TestOpsReporter extends AbstractReporter {
      */
     private run;
     /**
-     * @type { number | undefined}
+     * @type { string | undefined}
      * @private
      */
     private readonly environment;
+    /**
+     * @type { number | undefined}
+     * @private
+     */
+    private readonly planId;
     /**
      * @type {TestResultType[]}
      * @private
@@ -128,6 +133,14 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @returns {Promise<void>}
      */
     publish(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    sendResults(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    complete(): Promise<void>;
     /**
      * @param {TestResultType} result
      * @returns Promise<ResultCreateV2>
@@ -167,12 +180,6 @@ export declare class TestOpsReporter extends AbstractReporter {
      */
     private transformStepsV1;
     private logEmptyStep;
-    /**
-     * @param {number} runId
-     * @returns {Promise<void>}
-     * @private
-     */
-    private checkRun;
     /**
      * @param {string} title
      * @param {string} description

package/dist/reporters/testops-reporter.js

@@ -11,6 +11,7 @@ const abstract_reporter_1 = require("./abstract-reporter");
 const models_1 = require("../models");
 const qase_error_1 = require("../utils/qase-error");
 const axios_1 = __importDefault(require("axios"));
+const state_1 = require("../state/state");
 const defaultChunkSize = 200;
 /**
  * @class TestOpsReporter
@@ -26,7 +27,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      * @param {string | undefined} baseUrl
      */
     constructor(logger, options, api, environment, rootSuite, baseUrl) {
-        const { project, uploadAttachments, run, } = options;
+        const { project, uploadAttachments, run, plan, } = options;
         super(logger);
         this.api = api;
         /**
@@ -44,6 +45,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         this.isUploadAttachments = uploadAttachments;
         this.run = { complete: true, ...run };
         this.environment = environment;
+        this.planId = plan.id;
         this.batchSize = options.batch?.size ?? defaultChunkSize;
         this.useV2 = options.useV2 ?? false;
         this.defect = options.defect ?? false;
@@ -86,8 +88,6 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      */
     async checkOrCreateTestRun() {
         if (this.run.id !== undefined) {
-            this.logger.logDebug('Check test run');
-            await this.checkRun(this.run.id);
             this.isTestRunReady = true;
             return;
         }
@@ -112,6 +112,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         this.logger.logDebug(`Test run created: ${result.id}`);
         this.run.id = result.id;
         process.env['QASE_TESTOPS_RUN_ID'] = String(result.id);
+        state_1.StateManager.setRunId(result.id);
         this.isTestRunReady = true;
     }
     /**
@@ -156,6 +157,13 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      * @returns {Promise<void>}
      */
     async publish() {
+        await this.sendResults();
+        await this.complete();
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async sendResults() {
         if (this.results.length === 0) {
             this.logger.log((0, chalk_1.default) `{yellow No results to send to Qase}`);
             return;
@@ -165,6 +173,11 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         }
         // Clear results because we don't need to send them again then we use Cypress reporter
         this.results.length = 0;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async complete() {
         if (!this.run.complete) {
             return;
         }
@@ -369,20 +382,6 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     logEmptyStep(testTitle) {
         this.logger.log((0, chalk_1.default) `{magenta Test '${testTitle}' has empty action in step. The reporter will mark this step as unnamed step.}`);
     }
-    /**
-     * @param {number} runId
-     * @returns {Promise<void>}
-     * @private
-     */
-    async checkRun(runId) {
-        try {
-            const resp = await this.api.runs.getRun(this.projectCode, runId);
-            this.logger.log(`Get run result on checking run "${String(resp.data.result?.id)}"`);
-        }
-        catch (error) {
-            throw this.processError(error, 'Error on checking run');
-        }
-    }
     /**
      * @param {string} title
      * @param {string} description
@@ -402,6 +401,9 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             if (environment !== undefined) {
                 runObject.environment_id = environment;
             }
+            if (this.planId) {
+                runObject.plan_id = this.planId;
+            }
             const { data } = await this.api.runs.createRun(this.projectCode, runObject);
             return data;
         }

package/dist/state/state.d.ts

@@ -0,0 +1,15 @@
+import { ModeEnum } from '../options';
+export interface StateModel {
+    RunId: number | undefined;
+    Mode: ModeEnum | undefined;
+    IsModeChanged: boolean | undefined;
+}
+export declare class StateManager {
+    static getState(): StateModel;
+    static setRunId(runId: number): void;
+    static setMode(mode: ModeEnum): void;
+    static setIsModeChanged(isModeChanged: boolean): void;
+    static setState(state: StateModel): void;
+    static clearState(): void;
+    static isStateExists(): boolean;
+}

package/dist/state/state.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StateManager = void 0;
+const fs_1 = require("fs");
+const statePath = 'reporterState.json';
+class StateManager {
+    static getState() {
+        let state = {
+            RunId: undefined,
+            Mode: undefined,
+            IsModeChanged: undefined,
+        };
+        try {
+            const data = (0, fs_1.readFileSync)(statePath, 'utf8');
+            state = JSON.parse(data);
+        }
+        catch (err) {
+            console.error('Error reading state file:', err);
+        }
+        return state;
+    }
+    static setRunId(runId) {
+        const state = this.getState();
+        state.RunId = runId;
+        this.setState(state);
+    }
+    static setMode(mode) {
+        const state = this.getState();
+        state.Mode = mode;
+        this.setState(state);
+    }
+    static setIsModeChanged(isModeChanged) {
+        const state = this.getState();
+        state.IsModeChanged = isModeChanged;
+        this.setState(state);
+    }
+    static setState(state) {
+        try {
+            const data = JSON.stringify(state);
+            (0, fs_1.writeFileSync)(statePath, data);
+        }
+        catch (err) {
+            console.error('Error writing state file:', err);
+        }
+    }
+    static clearState() {
+        try {
+            (0, fs_1.unlinkSync)(statePath);
+        }
+        catch (err) {
+            console.error('Error clearing state file:', err);
+        }
+    }
+    static isStateExists() {
+        return (0, fs_1.existsSync)(statePath);
+    }
+}
+exports.StateManager = StateManager;

package/package.json

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