qase-javascript-commons 2.2.10 → 2.2.12

package/changelog.md

@@ -1,3 +1,17 @@
+# qase-javascript-commons@2.2.12
+
+## What's new
+
+Added a mutex to ensure correct result submission when running tests in multiple threads, preventing potential
+duplication.
+
+# qase-javascript-commons@2.2.11
+
+## What's new
+
+- Improved state manager behavior to ensure correct handling.
+- Masked token in logs to enhance security.
+
 # qase-javascript-commons@2.2.10
 
 ## What's new

package/dist/qase.d.ts

@@ -51,6 +51,7 @@ export declare class QaseReporter implements ReporterInterface {
     private readonly logger;
     private startTestRunOperation?;
     private options;
+    private withState;
     /**
      * @param {OptionsType} options
      */
@@ -103,4 +104,7 @@ export declare class QaseReporter implements ReporterInterface {
      * @private
      */
     private logTestItem;
+    private setWithState;
+    private maskToken;
+    private sanitizeOptions;
 }

package/dist/qase.js

@@ -95,24 +95,28 @@ class QaseReporter {
     logger;
     startTestRunOperation;
     options;
+    withState;
     /**
      * @param {OptionsType} options
      */
     constructor(options) {
-        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();
+        this.withState = this.setWithState(options);
+        if (this.withState) {
+            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.logger.logDebug(`Config: ${JSON.stringify(this.sanitizeOptions(composedOptions))}`);
         this.captureLogs = composedOptions.captureLogs;
         try {
             this.upstreamReporter = this.createReporter(
@@ -150,16 +154,18 @@ 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;
+        if (this.withState) {
+            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);
             }
-            state_1.StateManager.setState(state);
         }
     }
     getResults() {
@@ -192,7 +198,9 @@ class QaseReporter {
         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);
+                if (this.withState) {
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
+                }
                 return;
             }
             if (!this.useFallback) {
@@ -201,16 +209,22 @@ class QaseReporter {
             }
             try {
                 await this.fallbackReporter?.sendResults();
-                state_1.StateManager.setMode(this.options.fallback);
+                if (this.withState) {
+                    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);
+                if (this.withState) {
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
+                }
             }
         }
     }
     async complete() {
-        state_1.StateManager.clearState();
+        if (this.withState) {
+            state_1.StateManager.clearState();
+        }
         if (this.disabled) {
             return;
         }
@@ -238,6 +252,10 @@ class QaseReporter {
      * @returns {void}
      */
     startTestRun() {
+        if (this.withState) {
+            console.log("Clean state");
+            state_1.StateManager.clearState();
+        }
         if (!this.disabled) {
             this.logger.logDebug('Starting test run');
             try {
@@ -247,17 +265,23 @@ 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);
+                    if (this.withState) {
+                        state_1.StateManager.setMode(options_1.ModeEnum.off);
+                    }
                     return;
                 }
                 try {
                     this.startTestRunOperation = this.fallbackReporter?.startTestRun();
-                    state_1.StateManager.setMode(this.options.fallback);
+                    if (this.withState) {
+                        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);
+                    if (this.withState) {
+                        state_1.StateManager.setMode(options_1.ModeEnum.off);
+                    }
                 }
             }
         }
@@ -294,7 +318,9 @@ 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);
+                    if (this.withState) {
+                        state_1.StateManager.setMode(options_1.ModeEnum.off);
+                    }
                     return;
                 }
                 if (!this.useFallback) {
@@ -312,7 +338,9 @@ class QaseReporter {
     async addTestResultToFallback(result) {
         try {
             await this.fallbackReporter?.addTestResult(result);
-            state_1.StateManager.setMode(this.options.fallback);
+            if (this.withState) {
+                state_1.StateManager.setMode(this.options.fallback);
+            }
         }
         catch (error) {
             this.logger.logError('Unable to add the result to the fallback reporter:', error);
@@ -343,7 +371,9 @@ 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);
+                    if (this.withState) {
+                        state_1.StateManager.setMode(options_1.ModeEnum.off);
+                    }
                     return;
                 }
                 if (!this.useFallback) {
@@ -353,7 +383,9 @@ class QaseReporter {
                 await this.publishFallback();
             }
         }
-        state_1.StateManager.clearState();
+        if (this.withState) {
+            state_1.StateManager.clearState();
+        }
     }
     /**
      * @returns {Promise<void>}
@@ -361,10 +393,14 @@ class QaseReporter {
     async publishFallback() {
         try {
             await this.fallbackReporter?.publish();
-            state_1.StateManager.setMode(this.options.fallback);
+            if (this.withState) {
+                state_1.StateManager.setMode(this.options.fallback);
+            }
         }
         catch (error) {
-            state_1.StateManager.setMode(options_1.ModeEnum.off);
+            if (this.withState) {
+                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;
         }
@@ -407,7 +443,7 @@ class QaseReporter {
                     batch,
                     useV2,
                     defect,
-                }, apiClient, environment, rootSuite, api.host);
+                }, apiClient, this.withState, environment, rootSuite, api.host);
             }
             case options_1.ModeEnum.report: {
                 const localOptions = report.connections?.[writer_1.DriverEnum.local];
@@ -427,5 +463,38 @@ class QaseReporter {
     logTestItem(test) {
         this.logger.log(resultLogMap[test.execution.status](test));
     }
+    setWithState(options) {
+        return options.frameworkName == 'cypress'
+            || options.frameworkName == ''
+            || options.frameworkName == null
+            || options.frameworkName == undefined;
+    }
+    maskToken(token) {
+        if (token.length <= 7) {
+            return '*'.repeat(token.length);
+        }
+        return `${token.slice(0, 3)}****${token.slice(-4)}`;
+    }
+    sanitizeOptions(options) {
+        if (typeof options !== 'object' || options === null) {
+            return options;
+        }
+        const sanitizedObject = {};
+        for (const key in options) {
+            if (Object.prototype.hasOwnProperty.call(options, key)) {
+                const value = options[key];
+                if (key === 'token' && typeof value === 'string') {
+                    sanitizedObject[key] = this.maskToken(value);
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    sanitizedObject[key] = this.sanitizeOptions(value);
+                }
+                else {
+                    sanitizedObject[key] = value;
+                }
+            }
+        }
+        return sanitizedObject;
+    }
 }
 exports.QaseReporter = QaseReporter;

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

@@ -29,6 +29,7 @@ export interface TestOpsOptionsType {
  */
 export declare class TestOpsReporter extends AbstractReporter {
     private api;
+    private withState;
     /**
      * @type {Record<TestStatusEnum, string>}
      */
@@ -101,15 +102,17 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @private
      */
     private isTestRunReady;
+    private mutex;
     /**
      * @param {LoggerInterface} logger
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
+     * @param {boolean} withState
      * @param {string | undefined} environment
      * @param {string | undefined} rootSuite
      * @param {string | undefined} baseUrl
      */
-    constructor(logger: LoggerInterface, options: TestOpsOptionsType, api: QaseApiInterface, environment?: string, rootSuite?: string, baseUrl?: string);
+    constructor(logger: LoggerInterface, options: TestOpsOptionsType, api: QaseApiInterface, withState: boolean, environment?: string, rootSuite?: string, baseUrl?: string);
     /**
      * @returns {Promise<void>}
      */

package/dist/reporters/testops-reporter.js

@@ -12,6 +12,7 @@ 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 async_mutex_1 = require("async-mutex");
 const defaultChunkSize = 200;
 /**
  * @class TestOpsReporter
@@ -19,6 +20,7 @@ const defaultChunkSize = 200;
  */
 class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     api;
+    withState;
     /**
      * @type {Record<TestStatusEnum, string>}
      */
@@ -108,18 +110,21 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      * @private
      */
     isTestRunReady = false;
+    mutex = new async_mutex_1.Mutex();
     /**
      * @param {LoggerInterface} logger
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
+     * @param {boolean} withState
      * @param {string | undefined} environment
      * @param {string | undefined} rootSuite
      * @param {string | undefined} baseUrl
      */
-    constructor(logger, options, api, environment, rootSuite, baseUrl) {
+    constructor(logger, options, api, withState, environment, rootSuite, baseUrl) {
         const { project, uploadAttachments, run, plan, } = options;
         super(logger);
         this.api = api;
+        this.withState = withState;
         this.baseUrl = this.getBaseUrl(baseUrl);
         this.projectCode = project;
         this.isUploadAttachments = uploadAttachments;
@@ -148,15 +153,21 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
                 this.showLink(id, result.title);
             }
         }
-        await super.addTestResult(result);
-        if (!this.isTestRunReady) {
-            return;
+        const release = await this.mutex.acquire();
+        try {
+            await super.addTestResult(result);
+            if (!this.isTestRunReady) {
+                return;
+            }
+            const countOfResults = this.batchSize + this.firstIndex;
+            if (this.results.length >= countOfResults) {
+                const firstIndex = this.firstIndex;
+                this.firstIndex = countOfResults;
+                await this.publishResults(this.results.slice(firstIndex, countOfResults));
+            }
         }
-        const countOfResults = this.batchSize + this.firstIndex;
-        if (this.results.length >= countOfResults) {
-            const firstIndex = this.firstIndex;
-            this.firstIndex = countOfResults;
-            await this.publishResults(this.results.slice(firstIndex, countOfResults));
+        finally {
+            release();
         }
     }
     /**
@@ -188,7 +199,9 @@ 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);
+        if (this.withState) {
+            state_1.StateManager.setRunId(result.id);
+        }
         this.isTestRunReady = true;
     }
     /**
@@ -233,7 +246,13 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      * @returns {Promise<void>}
      */
     async publish() {
-        await this.sendResults();
+        const release = await this.mutex.acquire();
+        try {
+            await this.sendResults();
+        }
+        finally {
+            release();
+        }
         await this.complete();
     }
     /**

package/dist/state/state.js

@@ -7,13 +7,16 @@ exports.StateManager = void 0;
 const fs_1 = require("fs");
 const path_1 = __importDefault(require("path"));
 class StateManager {
-    static statePath = path_1.default.resolve(process.cwd(), 'reporterState.json');
+    static statePath = path_1.default.resolve(__dirname, 'reporterState.json');
     static getState() {
         let state = {
             RunId: undefined,
             Mode: undefined,
             IsModeChanged: undefined,
         };
+        if (!this.isStateExists()) {
+            return state;
+        }
         try {
             const data = (0, fs_1.readFileSync)(this.statePath, 'utf8');
             state = JSON.parse(data);
@@ -49,6 +52,9 @@ class StateManager {
         }
     }
     static clearState() {
+        if (!this.isStateExists()) {
+            return;
+        }
         try {
             (0, fs_1.unlinkSync)(this.statePath);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.2.10",
+  "version": "2.2.12",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -34,7 +34,8 @@
     "mime-types": "^2.1.33",
     "qaseio": "~2.4.0",
     "strip-ansi": "^6.0.1",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.0",
+    "async-mutex": "~0.5.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",