qase-javascript-commons 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/qase.d.ts

@@ -18,12 +18,22 @@ export declare class QaseReporter extends AbstractReporter {
      * @type {ReporterInterface}
      * @private
      */
-    private upstreamReporter?;
+    private readonly upstreamReporter?;
+    /**
+     * @type {ReporterInterface}
+     * @private
+     */
+    private readonly fallbackReporter?;
     /**
      * @type {boolean}
      * @private
      */
     private disabled;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private useFallback;
     /**
      * @param {OptionsType} options
      * @param {LoggerInterface} logger
@@ -33,18 +43,28 @@ export declare class QaseReporter extends AbstractReporter {
      * @param {TestResultType} result
      */
     addTestResult(result: TestResultType): void;
+    /**
+     * @param {TestResultType} result
+     * @private
+     */
+    private addTestResultToFallback;
     /**
      * @returns {Promise<void>}
      */
     publish(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    private publishFallback;
     /**
      * @todo implement mode registry
+     * @param {ModeEnum} mode
      * @param {OptionsType} options
      * @param {LoggerInterface} logger
      * @returns {ReporterInterface}
      * @private
      */
-    private createUpstreamReporter;
+    private createReporter;
     /**
      * @param {TestResultType} test
      * @private

package/dist/qase.js

@@ -13,7 +13,6 @@ const options_1 = require("./options");
 const env_1 = require("./env");
 const models_1 = require("./models");
 const writer_1 = require("./writer");
-const formatter_1 = require("./formatter");
 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");
@@ -21,12 +20,12 @@ const disabled_exception_1 = require("./utils/disabled-exception");
  * @type {Record<TestStatusEnum, (test: TestResultType) => string>}
  */
 const resultLogMap = {
-    [models_1.TestStatusEnum.failed]: (test) => (0, chalk_1.default) `{red Test ${test.title} ${test.status}}`,
-    [models_1.TestStatusEnum.passed]: (test) => (0, chalk_1.default) `{green Test ${test.title} ${test.status}}`,
-    [models_1.TestStatusEnum.skipped]: (test) => (0, chalk_1.default) `{blueBright Test ${test.title} ${test.status}}`,
-    [models_1.TestStatusEnum.blocked]: (test) => (0, chalk_1.default) `{blueBright Test ${test.title} ${test.status}}`,
-    [models_1.TestStatusEnum.disabled]: (test) => (0, chalk_1.default) `{grey Test ${test.title} ${test.status}}`,
-    [models_1.TestStatusEnum.invalid]: (test) => (0, chalk_1.default) `{yellowBright Test ${test.title} ${test.status}}`,
+    [models_1.TestStatusEnum.failed]: (test) => (0, chalk_1.default) `{red Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.passed]: (test) => (0, chalk_1.default) `{green Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.skipped]: (test) => (0, chalk_1.default) `{blueBright Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.blocked]: (test) => (0, chalk_1.default) `{blueBright Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.disabled]: (test) => (0, chalk_1.default) `{grey Test ${test.title} ${test.execution.status}}`,
+    [models_1.TestStatusEnum.invalid]: (test) => (0, chalk_1.default) `{yellowBright Test ${test.title} ${test.execution.status}}`,
 };
 /**
  * @class QaseReporter
@@ -58,7 +57,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
             client.push(`qase-core-reporter=${qaseReporterVersion}`);
         }
         if (qaseApiVersion) {
-            client.push(`qaseapi=${String(qaseApiVersion)}`);
+            client.push(`qaseio=${String(qaseApiVersion)}`);
         }
         return {
             'X-Client': client.join('; '),
@@ -78,15 +77,45 @@ class QaseReporter extends reporters_1.AbstractReporter {
          * @private
          */
         this.disabled = false;
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this.useFallback = false;
         try {
-            this.upstreamReporter = this.createUpstreamReporter(composedOptions, logger);
+            this.upstreamReporter = this.createReporter(
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            composedOptions.mode || options_1.ModeEnum.off, composedOptions, logger);
         }
         catch (error) {
             if (error instanceof disabled_exception_1.DisabledException) {
                 this.disabled = true;
             }
             else {
-                throw error;
+                this.logError('Unable to create upstream reporter:', error);
+                if (composedOptions.fallback != undefined) {
+                    this.disabled = true;
+                    return;
+                }
+                this.useFallback = true;
+            }
+        }
+        try {
+            this.fallbackReporter = this.createReporter(
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            composedOptions.fallback || options_1.ModeEnum.off, composedOptions, logger);
+        }
+        catch (error) {
+            if (error instanceof disabled_exception_1.DisabledException) {
+                if (this.useFallback) {
+                    this.disabled = true;
+                }
+            }
+            else {
+                this.logError('Unable to create fallback reporter:', error);
+                if (this.useFallback && this.upstreamReporter === undefined) {
+                    this.disabled = true;
+                }
             }
         }
     }
@@ -95,42 +124,91 @@ class QaseReporter extends reporters_1.AbstractReporter {
      */
     addTestResult(result) {
         if (!this.disabled) {
+            this.logTestItem(result);
+            if (this.useFallback) {
+                this.addTestResultToFallback(result);
+                return;
+            }
             try {
-                this.logTestItem(result);
                 this.upstreamReporter?.addTestResult(result);
             }
             catch (error) {
-                this.logError('Unable to process result:', error);
-                this.disabled = true;
+                this.logError('Unable to add the result to the upstream reporter:', error);
+                if (this.fallbackReporter == undefined) {
+                    this.disabled = true;
+                    return;
+                }
+                if (!this.useFallback) {
+                    this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
+                    this.useFallback = true;
+                }
+                this.addTestResultToFallback(result);
             }
         }
     }
+    /**
+     * @param {TestResultType} result
+     * @private
+     */
+    addTestResultToFallback(result) {
+        try {
+            this.fallbackReporter?.addTestResult(result);
+        }
+        catch (error) {
+            this.logError('Unable to add the result to the fallback reporter:', error);
+            this.disabled = true;
+        }
+    }
     /**
      * @returns {Promise<void>}
      */
     async publish() {
         if (!this.disabled) {
+            if (this.useFallback) {
+                await this.publishFallback();
+            }
             try {
                 await this.upstreamReporter?.publish();
             }
             catch (error) {
-                this.logError('Unable to publish run results:', error);
-                this.disabled = true;
+                this.logError('Unable to publish the run results to the upstream reporter:', error);
+                if (this.fallbackReporter == undefined) {
+                    this.disabled = true;
+                    return;
+                }
+                if (!this.useFallback) {
+                    this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
+                    this.useFallback = true;
+                }
+                await this.publishFallback();
             }
         }
     }
+    /**
+     * @returns {Promise<void>}
+     */
+    async publishFallback() {
+        try {
+            await this.fallbackReporter?.publish();
+        }
+        catch (error) {
+            this.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
      * @param {LoggerInterface} logger
      * @returns {ReporterInterface}
      * @private
      */
-    createUpstreamReporter(options, logger) {
-        const { frameworkPackage, frameworkName, reporterName, mode = options_1.ModeEnum.off, environment, report = {}, testops = {}, ...commonOptions } = options;
+    createReporter(mode, options, logger) {
+        const { frameworkPackage, frameworkName, reporterName, environment, report = {}, testops = {}, ...commonOptions } = options;
         switch (mode) {
             case options_1.ModeEnum.testops: {
-                const { api: { token, headers, ...api } = {}, baseUrl, project, run: { title, description, ...run } = {}, uploadAttachments, } = testops;
+                const { api: { token, headers, ...api } = {}, project, run: { title, description, ...run } = {}, plan = {}, chunk, uploadAttachments, } = testops;
                 if (!token) {
                     throw new Error(`Either "testops.api.token" parameter or "${env_1.EnvApiEnum.token}" environment variable is required in "testops" mode`);
                 }
@@ -143,25 +221,25 @@ class QaseReporter extends reporters_1.AbstractReporter {
                         ...headers,
                         ...QaseReporter.createHeaders(frameworkPackage, frameworkName, reporterName),
                     },
-                    ...api
+                    ...api,
                 }, custom_boundary_1.CustomBoundaryFormData);
                 return new reporters_1.TestOpsReporter({
-                    baseUrl,
                     project,
                     uploadAttachments,
                     run: {
                         title: title ?? `Automated run ${new Date().toISOString()}`,
                         description: description ?? `${reporterName} automated run`,
-                        environment: typeof environment === 'number' ? environment : undefined,
                         ...run,
                     },
+                    plan,
+                    chunk,
                     ...commonOptions,
-                }, apiClient, logger);
+                }, apiClient, logger, typeof environment === 'number' ? environment : undefined);
             }
             case options_1.ModeEnum.report: {
                 const localOptions = report.connections?.[writer_1.DriverEnum.local];
-                const writer = new writer_1.FsWriter(localOptions, new formatter_1.JsonFormatter());
-                return new reporters_1.ReportReporter(commonOptions, writer, logger);
+                const writer = new writer_1.FsWriter(localOptions);
+                return new reporters_1.ReportReporter(commonOptions, writer, logger, typeof environment === 'number' ? environment.toString() : environment, testops.run?.id);
             }
             case options_1.ModeEnum.off:
                 throw new disabled_exception_1.DisabledException();
@@ -174,7 +252,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
      * @private
      */
     logTestItem(test) {
-        this.log(resultLogMap[test.status](test));
+        this.log(resultLogMap[test.execution.status](test));
     }
 }
 exports.QaseReporter = QaseReporter;

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

@@ -4,12 +4,14 @@ export interface LoggerInterface {
     group(): void;
     groupEnd(): void;
 }
-export type ReporterOptionsType = {
+export interface ReporterOptionsType {
     debug?: boolean | undefined;
-};
+}
 export interface ReporterInterface {
     addTestResult(result: TestResultType): void;
     publish(): Promise<void>;
+    getTestResults(): TestResultType[];
+    setTestResults(results: TestResultType[]): void;
 }
 /**
  * @abstract
@@ -22,11 +24,8 @@ export declare abstract class AbstractReporter implements ReporterInterface {
      * @type {boolean | undefined}
      * @private
      */
-    private debug;
-    /**
-     * @param {TestResultType} result
-     */
-    abstract addTestResult(result: TestResultType): void;
+    private readonly debug;
+    protected results: TestResultType[];
     /**
      * @returns {Promise<void>}
      */
@@ -37,6 +36,18 @@ export declare abstract class AbstractReporter implements ReporterInterface {
      * @protected
      */
     protected constructor(options: ReporterOptionsType | undefined, logger?: LoggerInterface);
+    /**
+     * @returns {TestResultType[]}
+     */
+    getTestResults(): TestResultType[];
+    /**
+     * @param {TestResultType} result
+     */
+    addTestResult(result: TestResultType): void;
+    /**
+     * @param {TestResultType[]} results
+     */
+    setTestResults(results: TestResultType[]): void;
     /**
      * @param {string} message
      * @protected

package/dist/reporters/abstract-reporter.js

@@ -7,6 +7,7 @@ exports.AbstractReporter = void 0;
 const lodash_get_1 = __importDefault(require("lodash.get"));
 const qase_error_1 = require("../utils/qase-error");
 const is_axios_error_1 = require("../utils/is-axios-error");
+const uuid_1 = require("uuid");
 /**
  * @abstract
  * @class AbstractReporter
@@ -20,9 +21,43 @@ class AbstractReporter {
      */
     constructor(options, logger = console) {
         this.logger = logger;
+        this.results = [];
         const { debug } = options ?? {};
         this.debug = debug;
     }
+    /**
+     * @returns {TestResultType[]}
+     */
+    getTestResults() {
+        return this.results;
+    }
+    /**
+     * @param {TestResultType} result
+     */
+    addTestResult(result) {
+        if (result.testops_id === null || !Array.isArray(result.testops_id)) {
+            this.results.push(result);
+            return;
+        }
+        // if we have multiple ids, we need to create multiple test results and set duration to 0 for all but the first one
+        let firstCase = true;
+        for (const id of result.testops_id) {
+            const testResultCopy = { ...result };
+            testResultCopy.testops_id = id;
+            testResultCopy.id = (0, uuid_1.v4)();
+            if (!firstCase) {
+                testResultCopy.execution.duration = 0;
+            }
+            firstCase = false;
+            this.results.push(testResultCopy);
+        }
+    }
+    /**
+     * @param {TestResultType[]} results
+     */
+    setTestResults(results) {
+        this.results = results;
+    }
     /**
      * @param {string} message
      * @protected
@@ -49,13 +84,13 @@ class AbstractReporter {
         this.logger.log(message);
         this.logger.group();
         if (error instanceof Error) {
-            this.logger.log(`${error.stack || `${error.name}: ${error.message}`}`);
             if ((0, is_axios_error_1.isAxiosError)(error)) {
                 this.logApiError(error);
             }
             else if (error instanceof qase_error_1.QaseError && error.cause) {
                 this.doLogError('Caused by:', error.cause);
             }
+            this.logger.log(`${error.stack || `${error.name}: ${error.message}`}`);
         }
         else {
             this.logger.log(String(error));
@@ -72,7 +107,7 @@ class AbstractReporter {
             ?? (0, lodash_get_1.default)(error, 'response.statusText')
             ?? 'Unknown error';
         const errorFields = this.formatErrorFields((0, lodash_get_1.default)(error, 'response.data.errorFields'));
-        this.logger.log(String(errorMessage));
+        this.logger.log(`Message: ${String(errorMessage)}`);
         if (errorFields) {
             this.logger.group();
             this.logger.log(errorFields);

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

@@ -1,5 +1,4 @@
-import { AbstractReporter, ReporterOptionsType, LoggerInterface } from './abstract-reporter';
-import { TestResultType } from '../models';
+import { AbstractReporter, LoggerInterface, ReporterOptionsType } from './abstract-reporter';
 import { WriterInterface } from '../writer';
 /**
  * @class ReportReporter
@@ -7,25 +6,38 @@ import { WriterInterface } from '../writer';
  */
 export declare class ReportReporter extends AbstractReporter {
     private writer;
-    /**
-     * @type {TestResultType[]}
-     * @private
-     */
-    private results;
+    private readonly environment;
+    private readonly runId;
+    private readonly startTime;
     /**
      * @param {ReporterOptionsType} options
      * @param {WriterInterface} writer
      * @param {LoggerInterface} logger
+     * @param {string | undefined} environment
+     * @param {number | undefined} runId
      */
-    constructor(options: ReporterOptionsType | undefined, writer: WriterInterface, logger?: LoggerInterface);
-    /**
-     * @param {TestResultType} result
-     */
-    addTestResult(result: TestResultType): void;
+    constructor(options: ReporterOptionsType | undefined, writer: WriterInterface, logger?: LoggerInterface, environment?: string, runId?: number);
     /**
      * @returns {Promise<void>}
      *
      * eslint-disable-next-line @typescript-eslint/require-await
      */
     publish(): Promise<void>;
+    /**
+     * @param {TestStepType[]} steps
+     * @returns {TestStepType[]}
+     */
+    private copyStepAttachments;
+    /**
+     * @returns {HostData}
+     */
+    private getHostInfo;
+    /**
+     * @returns {string}
+     */
+    private getComputerName;
+    /**
+     * @returns {string}
+     */
+    private getDetailedOSInfo;
 }

package/dist/reporters/report-reporter.js

@@ -1,7 +1,34 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReportReporter = void 0;
 const abstract_reporter_1 = require("./abstract-reporter");
+const models_1 = require("../models");
+const os = __importStar(require("os"));
+const cp = __importStar(require("child_process"));
+const process = __importStar(require("process"));
 /**
  * @class ReportReporter
  * @extends AbstractReporter
@@ -11,21 +38,15 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
      * @param {ReporterOptionsType} options
      * @param {WriterInterface} writer
      * @param {LoggerInterface} logger
+     * @param {string | undefined} environment
+     * @param {number | undefined} runId
      */
-    constructor(options, writer, logger) {
+    constructor(options, writer, logger, environment, runId) {
         super(options, logger);
         this.writer = writer;
-        /**
-         * @type {TestResultType[]}
-         * @private
-         */
-        this.results = [];
-    }
-    /**
-     * @param {TestResultType} result
-     */
-    addTestResult(result) {
-        this.results.push(result);
+        this.startTime = Date.now();
+        this.environment = environment;
+        this.runId = runId;
     }
     /**
      * @returns {Promise<void>}
@@ -33,8 +54,126 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
      * eslint-disable-next-line @typescript-eslint/require-await
      */
     async publish() {
-        const path = await this.writer.write(this.results);
+        const report = {
+            title: 'Test report',
+            execution: {
+                start_time: this.startTime,
+                end_time: Date.now(),
+                duration: Date.now() - this.startTime,
+                cumulative_duration: 0,
+            },
+            stats: {
+                total: 0,
+                passed: 0,
+                failed: 0,
+                skipped: 0,
+                broken: 0,
+                muted: 0,
+            },
+            results: [],
+            threads: [],
+            suites: [],
+            environment: this.environment ?? '',
+            host_data: this.getHostInfo(),
+        };
+        for (const result of this.results) {
+            report.stats.total++;
+            switch (result.execution.status) {
+                case models_1.TestStatusEnum.passed:
+                    report.stats.passed++;
+                    break;
+                case models_1.TestStatusEnum.failed:
+                    report.stats.failed++;
+                    break;
+                case models_1.TestStatusEnum.skipped:
+                    report.stats.skipped++;
+                    break;
+                case models_1.TestStatusEnum.invalid:
+                    report.stats.broken++;
+                    break;
+                case models_1.TestStatusEnum.blocked:
+                    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,
+                id: result.id,
+                status: result.execution.status,
+                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;
+            await this.writer.writeTestResult(result);
+        }
+        const path = await this.writer.writeReport(report);
         this.log(`Report saved to ${path}`);
     }
+    /**
+     * @param {TestStepType[]} steps
+     * @returns {TestStepType[]}
+     */
+    copyStepAttachments(steps) {
+        for (const step of steps) {
+            if (step.attachments.length > 0) {
+                step.attachments = this.writer.writeAttachment(step.attachments);
+            }
+            if (step.steps.length > 0) {
+                step.steps = this.copyStepAttachments(step.steps);
+            }
+        }
+        return steps;
+    }
+    /**
+     * @returns {HostData}
+     */
+    getHostInfo() {
+        return {
+            system: process.platform,
+            node: this.getComputerName(),
+            release: os.release(),
+            version: this.getDetailedOSInfo(),
+            machine: os.arch(),
+            python: '',
+            pip: '',
+            node_version: cp.execSync('node --version').toString().trim(),
+            npm: cp.execSync('npm --version').toString().trim(),
+        };
+    }
+    /**
+     * @returns {string}
+     */
+    getComputerName() {
+        switch (process.platform) {
+            case 'win32':
+                return process.env['COMPUTERNAME'] ?? '';
+            case 'darwin':
+                return cp.execSync('scutil --get ComputerName').toString().trim();
+            case 'linux': {
+                const prettyname = cp.execSync('hostnamectl --pretty').toString().trim();
+                return prettyname === '' ? os.hostname() : prettyname;
+            }
+            default:
+                return os.hostname();
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    getDetailedOSInfo() {
+        if (process.platform === 'darwin') {
+            return cp.execSync('uname -a').toString().trim();
+        }
+        else {
+            return `${os.type()} ${os.release()} ${os.arch()}`;
+        }
+    }
 }
 exports.ReportReporter = ReportReporter;