qase-javascript-commons 2.6.2 → 2.6.3

package/dist/qase.js

@@ -4,19 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QaseReporter = void 0;
-const env_schema_1 = __importDefault(require("env-schema"));
 const chalk_1 = __importDefault(require("chalk"));
-const reporters_1 = require("./reporters");
 const options_1 = require("./options");
-const env_1 = require("./env");
 const models_1 = require("./models");
-const writer_1 = require("./writer");
 const disabled_exception_1 = require("./utils/disabled-exception");
 const logger_1 = require("./utils/logger");
-const state_1 = require("./state/state");
 const hostData_1 = require("./utils/hostData");
-const clientV2_1 = require("./client/clientV2");
-const status_mapping_utils_1 = require("./utils/status-mapping-utils");
+const token_masker_1 = require("./utils/token-masker");
+const state_1 = require("./state/state");
+const options_resolver_1 = require("./qase/options-resolver");
+const reporter_factory_1 = require("./qase/reporter-factory");
+const status_processor_1 = require("./qase/status-processor");
+const fallback_coordinator_1 = require("./reporters/shared/fallback-coordinator");
 /**
  * @type {Record<TestStatusEnum, (test: TestResultType) => string>}
  */
@@ -30,476 +29,195 @@ const resultLogMap = {
 };
 /**
  * @class QaseReporter
- * @implements AbstractReporter
+ *
+ * Thin orchestrator: delegates to OptionsResolver, ReporterFactory,
+ * StatusProcessor, and FallbackCoordinator. Public API is preserved.
  */
 class QaseReporter {
     static instance;
-    /**
-     * @type {InternalReporterInterface}
-     * @private
-     */
-    upstreamReporter;
-    /**
-     * @type {InternalReporterInterface}
-     * @private
-     */
-    fallbackReporter;
-    /**
-     * @type {boolean | undefined}
-     * @private
-     */
-    captureLogs;
-    /**
-     * @type {boolean}
-     * @private
-     */
-    disabled = false;
-    /**
-     * @type {boolean}
-     * @private
-     */
-    useFallback = false;
     logger;
-    startTestRunOperation;
     options;
     withState;
-    hostData;
+    captureLogs;
+    statusProcessor;
+    fallback;
+    startTestRunOperation;
     /**
      * @param {OptionsType} options
      */
     constructor(options) {
-        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();
+        const resolved = new options_resolver_1.OptionsResolver().resolve(options);
+        this.options = resolved.composed;
+        this.withState = resolved.withState;
+        this.captureLogs = resolved.composed.captureLogs;
+        this.logger = this.buildLogger(resolved);
+        this.logger.logDebug(`Config: ${JSON.stringify((0, token_masker_1.sanitizeOptionsForLog)(resolved.composed))}`);
+        const hostData = (0, hostData_1.getHostInfo)(options.frameworkPackage, options.reporterName);
+        this.logger.logDebug(`Host data: ${JSON.stringify(hostData)}`);
+        const factory = new reporter_factory_1.ReporterFactory(this.logger, hostData);
+        const { upstream, fallback, disabled, useFallbackFromStart } = this.buildReporters(factory, resolved);
+        this.statusProcessor = new status_processor_1.StatusProcessor(this.logger, resolved.composed.statusMapping, resolved.composed.testops?.statusFilter);
+        this.fallback = new fallback_coordinator_1.FallbackCoordinator(this.logger, upstream, fallback, {
+            onFallbackActivated: () => {
+                if (this.withState) {
+                    state_1.StateManager.setMode(resolved.composed.fallback);
                 }
-                if (state.RunId) {
-                    process.env[env_1.EnvRunEnum.id] = state.RunId.toString();
+            },
+            onDisabled: () => {
+                if (this.withState) {
+                    state_1.StateManager.setMode(options_1.ModeEnum.off);
                 }
-            }
+            },
+        });
+        if (disabled) {
+            this.fallback.setDisabled(true);
         }
-        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;
-        // Process logging options with backward compatibility
-        const loggerOptions = {
-            debug: composedOptions.debug,
-        };
-        if (composedOptions.logging?.console !== undefined) {
-            loggerOptions.consoleLogging = composedOptions.logging.console;
+        if (useFallbackFromStart) {
+            this.fallback.setUseFallback(true);
+        }
+        this.persistInitialState(resolved, disabled, useFallbackFromStart);
+    }
+    buildLogger(resolved) {
+        const opts = { debug: resolved.composed.debug };
+        if (resolved.composed.logging?.console !== undefined) {
+            opts.consoleLogging = resolved.composed.logging.console;
         }
-        if (composedOptions.logging?.file !== undefined) {
-            loggerOptions.fileLogging = composedOptions.logging.file;
+        if (resolved.composed.logging?.file !== undefined) {
+            opts.fileLogging = resolved.composed.logging.file;
         }
-        this.logger = new logger_1.Logger(loggerOptions);
-        this.logger.logDebug(`Config: ${JSON.stringify(this.sanitizeOptions(composedOptions))}`);
-        const effectiveMode = composedOptions.mode || options_1.ModeEnum.off;
-        const effectiveFallback = composedOptions.fallback || options_1.ModeEnum.off;
-        this.hostData = (0, hostData_1.getHostInfo)(options.frameworkPackage, options.reporterName);
-        this.logger.logDebug(`Host data: ${JSON.stringify(this.hostData)}`);
-        this.captureLogs = composedOptions.captureLogs;
+        return new logger_1.Logger(opts);
+    }
+    buildReporters(factory, resolved) {
+        let upstream;
+        let fallbackReporter;
+        let disabled = false;
+        let upstreamFailed = false;
         try {
-            this.upstreamReporter = this.createReporter(effectiveMode, composedOptions);
+            upstream = factory.create(resolved.effectiveMode, resolved.composed, this.withState);
         }
         catch (error) {
             if (error instanceof disabled_exception_1.DisabledException) {
-                this.disabled = true;
+                disabled = true;
             }
             else {
                 this.logger.logError('Unable to create upstream reporter:', error);
-                if (composedOptions.fallback != undefined) {
-                    this.disabled = true;
-                    return;
+                if (resolved.composed.fallback === undefined) {
+                    disabled = true;
+                    return { upstream, fallback: fallbackReporter, disabled, useFallbackFromStart: false };
                 }
-                this.useFallback = true;
+                upstreamFailed = true;
             }
         }
         try {
-            this.fallbackReporter = this.createReporter(effectiveFallback, composedOptions);
+            fallbackReporter = factory.create(resolved.effectiveFallback, resolved.composed, this.withState);
         }
         catch (error) {
             if (error instanceof disabled_exception_1.DisabledException) {
-                if (this.useFallback) {
-                    this.disabled = true;
-                }
+                if (upstreamFailed)
+                    disabled = true;
             }
             else {
                 this.logger.logError('Unable to create fallback reporter:', error);
-                if (this.useFallback && this.upstreamReporter === undefined) {
-                    this.disabled = true;
-                }
-            }
-        }
-        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);
+                if (upstreamFailed && upstream === undefined)
+                    disabled = true;
             }
         }
+        const useFallbackFromStart = upstreamFailed && fallbackReporter !== undefined;
+        return { upstream, fallback: fallbackReporter, disabled, useFallbackFromStart };
     }
-    async uploadAttachment(attachment) {
-        if (this.disabled) {
-            return '';
+    persistInitialState(resolved, disabled, useFallbackFromStart) {
+        if (!this.withState)
+            return;
+        if (state_1.StateManager.isStateExists())
+            return;
+        const state = {
+            RunId: undefined,
+            Mode: useFallbackFromStart
+                ? resolved.composed.fallback
+                : resolved.composed.mode,
+            IsModeChanged: undefined,
+        };
+        if (disabled) {
+            state.Mode = options_1.ModeEnum.off;
         }
-        if (this.useFallback) {
-            return await this.fallbackReporter?.uploadAttachment(attachment) ?? '';
+        state_1.StateManager.setState(state);
+    }
+    static getInstance(options) {
+        if (!QaseReporter.instance) {
+            QaseReporter.instance = new QaseReporter(options);
         }
-        return await this.upstreamReporter?.uploadAttachment(attachment) ?? '';
+        return QaseReporter.instance;
+    }
+    getStatusMapping() {
+        return this.options.statusMapping;
+    }
+    async uploadAttachment(attachment) {
+        const result = await this.fallback.run((r) => r.uploadAttachment(attachment), 'upload attachment');
+        return result ?? '';
     }
     getResults() {
-        if (this.disabled) {
+        if (this.fallback.isDisabled())
             return [];
-        }
-        if (this.useFallback) {
-            return this.fallbackReporter?.getTestResults() ?? [];
-        }
-        return this.upstreamReporter?.getTestResults() ?? [];
+        const active = this.fallback.isUsingFallback()
+            ? this.fallback.getFallback()
+            : this.fallback.getUpstream();
+        return active?.getTestResults() ?? [];
     }
     setTestResults(results) {
-        if (this.disabled) {
+        if (this.fallback.isDisabled())
             return;
-        }
-        if (this.useFallback) {
-            this.fallbackReporter?.setTestResults(results);
-        }
-        else {
-            this.upstreamReporter?.setTestResults(results);
-        }
+        const active = this.fallback.isUsingFallback()
+            ? this.fallback.getFallback()
+            : this.fallback.getUpstream();
+        active?.setTestResults(results);
     }
-    async sendResults() {
-        if (this.disabled) {
+    async addTestResult(result) {
+        if (this.fallback.isDisabled())
             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) {
-                if (this.withState) {
-                    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();
-                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);
-                if (this.withState) {
-                    state_1.StateManager.setMode(options_1.ModeEnum.off);
-                }
-            }
-        }
-    }
-    async complete() {
-        if (this.withState) {
-            state_1.StateManager.clearState();
-        }
-        if (this.disabled) {
+        const processed = this.statusProcessor.process(result);
+        if (!processed)
             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);
-            }
-        }
+        await this.startTestRunOperation;
+        this.logger.log(resultLogMap[processed.execution.status](processed));
+        await this.fallback.run((r) => r.addTestResult(processed), 'add the result');
     }
-    /**
-     * @returns {void}
-     */
     startTestRun() {
-        if (this.withState) {
+        if (this.withState)
             state_1.StateManager.clearState();
-        }
-        this.disabled = false;
-        this.useFallback = false;
-        if (!this.disabled) {
-            this.logger.logDebug('Starting test run');
-            try {
-                this.startTestRunOperation = this.upstreamReporter?.startTestRun();
-            }
-            catch (error) {
-                this.logger.logError('Unable to start test run in the upstream reporter: ', error);
-                if (this.fallbackReporter == undefined) {
-                    this.disabled = true;
-                    if (this.withState) {
-                        state_1.StateManager.setMode(options_1.ModeEnum.off);
-                    }
-                    return;
-                }
-                try {
-                    this.startTestRunOperation = this.fallbackReporter.startTestRun();
-                    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;
-                    if (this.withState) {
-                        state_1.StateManager.setMode(options_1.ModeEnum.off);
-                    }
-                }
-            }
-        }
+        this.fallback.reset();
+        this.logger.logDebug('Starting test run');
+        const runOp = this.fallback.run(async (r) => {
+            await r.startTestRun();
+        }, 'start test run');
+        this.startTestRunOperation = runOp.then(() => undefined);
     }
     async startTestRunAsync() {
         this.startTestRun();
         await this.startTestRunOperation;
     }
-    /**
-     * @param {OptionsType} options
-     * @returns {QaseReporter}
-     */
-    static getInstance(options) {
-        if (!QaseReporter.instance) {
-            QaseReporter.instance = new QaseReporter(options);
-        }
-        return QaseReporter.instance;
-    }
-    /**
-     * Get status mapping configuration
-     * @returns Status mapping configuration or undefined
-     */
-    getStatusMapping() {
-        return this.options.statusMapping;
-    }
-    /**
-     * @param {TestResultType} result
-     */
-    async addTestResult(result) {
-        if (!this.disabled) {
-            // Apply status mapping if configured
-            const statusMapping = this.getStatusMapping();
-            if (statusMapping) {
-                const originalStatus = result.execution.status;
-                const mappedStatus = (0, status_mapping_utils_1.applyStatusMapping)(originalStatus, statusMapping);
-                if (mappedStatus !== originalStatus) {
-                    this.logger.logDebug(`Status mapping applied: ${originalStatus} -> ${mappedStatus}`);
-                    result.execution.status = mappedStatus;
-                }
-            }
-            // Check if result should be filtered out based on status
-            if (this.shouldFilterResult(result)) {
-                this.logger.logDebug(`Filtering out test result with status: ${result.execution.status}`);
-                return;
-            }
-            await this.startTestRunOperation;
-            this.logTestItem(result);
-            if (this.useFallback) {
-                await this.addTestResultToFallback(result);
-                return;
-            }
-            try {
-                await this.upstreamReporter?.addTestResult(result);
-            }
-            catch (error) {
-                this.logger.logError('Unable to add the result to the upstream reporter:', error);
-                if (this.fallbackReporter == undefined) {
-                    this.disabled = true;
-                    if (this.withState) {
-                        state_1.StateManager.setMode(options_1.ModeEnum.off);
-                    }
-                    return;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                if (!this.useFallback) {
-                    this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
-                    this.useFallback = true;
-                }
-                await this.addTestResultToFallback(result);
-            }
-        }
-    }
-    /**
-     * @param {TestResultType} result
-     * @private
-     */
-    shouldFilterResult(result) {
-        const statusFilter = this.options.testops?.statusFilter;
-        if (!statusFilter || statusFilter.length === 0) {
-            return false;
-        }
-        // Convert TestStatusEnum to string for comparison
-        const statusString = result.execution.status.toString();
-        this.logger.logDebug(`Checking filter: status="${statusString}", filter=${JSON.stringify(statusFilter)}`);
-        // Check if the status is in the filter list
-        const shouldFilter = statusFilter.includes(statusString);
-        this.logger.logDebug(`Filter result: ${shouldFilter ? 'FILTERED' : 'NOT FILTERED'}`);
-        return shouldFilter;
-    }
-    /**
-     * @param {TestResultType} result
-     * @private
-     */
-    async addTestResultToFallback(result) {
-        try {
-            await this.fallbackReporter?.addTestResult(result);
-            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);
-            this.disabled = true;
-            state_1.StateManager.setMode(options_1.ModeEnum.off);
-        }
-    }
-    /**
-     * @returns {boolean}
-     */
-    isCaptureLogs() {
-        return this.captureLogs ?? false;
+    async sendResults() {
+        if (this.fallback.isDisabled())
+            return;
+        await this.fallback.run((r) => r.sendResults(), 'send the results');
     }
-    /**
-     * @returns {Promise<void>}
-     */
     async publish() {
-        if (!this.disabled) {
+        if (!this.fallback.isDisabled()) {
             await this.startTestRunOperation;
             this.logger.logDebug('Publishing test run results');
-            if (this.useFallback) {
-                await this.publishFallback();
-            }
-            try {
-                await this.upstreamReporter?.publish();
-            }
-            catch (error) {
-                this.logger.logError('Unable to publish the run results to the upstream reporter:', error);
-                if (this.fallbackReporter == undefined) {
-                    this.disabled = true;
-                    if (this.withState) {
-                        state_1.StateManager.setMode(options_1.ModeEnum.off);
-                    }
-                    return;
-                }
-                if (!this.useFallback) {
-                    this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
-                    this.useFallback = true;
-                }
-                await this.publishFallback();
-            }
+            await this.fallback.run((r) => r.publish(), 'publish the run results');
         }
-        if (this.withState) {
+        if (this.withState)
             state_1.StateManager.clearState();
-        }
-    }
-    /**
-     * @returns {Promise<void>}
-     */
-    async publishFallback() {
-        try {
-            await this.fallbackReporter?.publish();
-            if (this.withState) {
-                state_1.StateManager.setMode(this.options.fallback);
-            }
-        }
-        catch (error) {
-            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;
-        }
-    }
-    /**
-     * @todo implement mode registry
-     * @param {ModeEnum} mode
-     * @param {OptionsType} options
-     * @returns {InternalReporterInterface}
-     * @private
-     */
-    createReporter(mode, options) {
-        switch (mode) {
-            case options_1.ModeEnum.testops: {
-                if (!options.testops?.api?.token) {
-                    throw new Error(`Either "testops.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "testops" mode`);
-                }
-                if (!options.testops.project) {
-                    throw new Error(`Either "testops.project" parameter or "${env_1.EnvTestOpsEnum.project}" environment variable is required in "testops" mode`);
-                }
-                const apiClient = new clientV2_1.ClientV2(this.logger, options.testops, options.environment, options.rootSuite, this.hostData, options.reporterName, options.frameworkPackage);
-                return new reporters_1.TestOpsReporter(this.logger, apiClient, this.withState, options.testops.project, options.testops.api.host, options.testops.batch?.size, options.testops.run?.id, options.testops.showPublicReportLink);
-            }
-            case options_1.ModeEnum.testops_multi: {
-                if (!options.testops?.api?.token) {
-                    throw new Error(`Either "testops.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "testops_multi" mode`);
-                }
-                const multi = options.testops_multi;
-                if (!multi?.projects?.length) {
-                    throw new Error('"testops_multi.projects" must contain at least one project with a "code" field');
-                }
-                for (const p of multi.projects) {
-                    if (!p?.code) {
-                        throw new Error('Each project in "testops_multi.projects" must have a "code" field');
-                    }
-                }
-                return new reporters_1.TestOpsMultiReporter(this.logger, options.testops, multi, this.withState, this.hostData, options.reporterName, options.frameworkPackage, options.environment, options.testops.api?.host, options.testops.batch?.size, options.testops.showPublicReportLink);
-            }
-            case options_1.ModeEnum.report: {
-                const localOptions = options.report?.connections?.[writer_1.DriverEnum.local];
-                const writer = new writer_1.FsWriter(localOptions);
-                return new reporters_1.ReportReporter(this.logger, writer, options.frameworkPackage, options.reporterName, options.environment, options.rootSuite, options.testops?.run?.id, this.hostData);
-            }
-            case options_1.ModeEnum.off:
-                throw new disabled_exception_1.DisabledException();
-            default:
-                throw new Error(`Unknown mode type`);
-        }
     }
-    /**
-     * @param {TestResultType} test
-     * @private
-     */
-    logTestItem(test) {
-        this.logger.log(resultLogMap[test.execution.status](test));
-    }
-    setWithState(options) {
-        return options.frameworkName === 'cypress' || !options.frameworkName;
-    }
-    maskToken(token) {
-        if (token.length <= 7) {
-            return '*'.repeat(token.length);
-        }
-        return `${token.slice(0, 3)}****${token.slice(-4)}`;
+    async complete() {
+        if (this.withState)
+            state_1.StateManager.clearState();
+        if (this.fallback.isDisabled())
+            return;
+        await this.fallback.run((r) => r.complete(), 'complete the run');
     }
-    sanitizeOptions(options) {
-        const sanitized = JSON.parse(JSON.stringify(options));
-        if (sanitized.testops?.api?.token) {
-            sanitized.testops.api.token = this.maskToken(sanitized.testops.api.token);
-        }
-        return sanitized;
+    isCaptureLogs() {
+        return this.captureLogs ?? false;
     }
 }
 exports.QaseReporter = QaseReporter;