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

package/dist/reporters/testops-reporter.js

@@ -6,202 +6,293 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestOpsReporter = void 0;
 const fs_1 = require("fs");
 const chalk_1 = __importDefault(require("chalk"));
-const strip_ansi_1 = __importDefault(require("strip-ansi"));
 const qaseio_1 = require("qaseio");
 const abstract_reporter_1 = require("./abstract-reporter");
 const models_1 = require("../models");
 const qase_error_1 = require("../utils/qase-error");
+const defaultChunkSize = 200;
 /**
  * @class TestOpsReporter
  * @extends AbstractReporter
  */
 class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     /**
+     * @param {LoggerInterface} logger
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
-     * @param {LoggerInterface} logger
+     * @param {number} environment
      */
-    constructor(options, api, logger) {
-        const { project, baseUrl = 'https://app.qase.io', uploadAttachments, run, ...restOptions } = options;
-        super(restOptions, logger);
+    constructor(logger, options, api, environment) {
+        const { project, uploadAttachments, run, } = options;
+        super(logger);
         this.api = api;
         /**
-         * @type {TestResultType[]}
-         * @private
-         */
-        this.results = [];
-        /**
-         * @type {Record<string, string[]>}
+         * @type {number}
          * @private
          */
-        this.attachments = {};
+        this.firstIndex = 0;
         /**
-         * @type {Record<string, string[]>}
+         * @type {boolean}
          * @private
          */
-        this.attachmentsMap = {};
+        this.isTestRunReady = false;
+        const baseUrl = 'https://app.qase.io';
         this.baseUrl = baseUrl.replace(/\/$/, '');
         this.projectCode = project;
-        this.uploadAttachments = uploadAttachments;
+        this.isUploadAttachments = uploadAttachments;
         this.run = { complete: true, ...run };
+        this.environment = environment;
+        this.batchSize = options.batch?.size ?? defaultChunkSize;
+        this.useV2 = options.useV2 ?? false;
+        this.defect = options.defect ?? false;
     }
     /**
-     * @param {TestResultType} result
+     * @returns {Promise<void>}
      */
-    addTestResult(result) {
-        this.results.push(result);
-        this.addAttachments(result);
+    async startTestRun() {
+        await this.checkOrCreateTestRun();
     }
-    addAttachments(resultOrStep) {
-        if (resultOrStep.attachments) {
-            this.attachments[resultOrStep.id] = resultOrStep.attachments;
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    async addTestResult(result) {
+        await super.addTestResult(result);
+        if (!this.isTestRunReady) {
+            return;
         }
-        if (resultOrStep.steps) {
-            for (const step of resultOrStep.steps) {
-                this.addAttachments(step);
-            }
+        const countOfResults = this.batchSize + this.firstIndex;
+        if (this.results.length >= countOfResults) {
+            await this.publishResults(this.results.slice(this.firstIndex, countOfResults));
+            this.firstIndex = countOfResults;
         }
     }
     /**
      * @returns {Promise<void>}
      */
-    async publish() {
-        let runId;
+    async checkOrCreateTestRun() {
         if (this.run.id !== undefined) {
+            this.logger.logDebug('Check test run');
             await this.checkRun(this.run.id);
-            runId = this.run.id;
+            this.isTestRunReady = true;
+            return;
+        }
+        this.logger.logDebug('Create test run');
+        const { result } = await this.createRun(this.run.title, this.run.description, this.environment);
+        if (!result?.id) {
+            throw new Error('Cannot create run.');
+        }
+        this.logger.logDebug(`Test run created: ${result.id}`);
+        this.run.id = result.id;
+        process.env['QASE_TESTOPS_RUN_ID'] = String(result.id);
+        this.isTestRunReady = true;
+    }
+    /**
+     * @returns {Promise<void>}
+     * @param testResults
+     * @private
+     */
+    async publishResults(testResults) {
+        if (this.useV2) {
+            const results = [];
+            for (const result of testResults) {
+                const resultCreateV2 = await this.transformTestResult(result);
+                results.push(resultCreateV2);
+            }
+            await this.api.result.createResultsV2(this.projectCode, this.run.id, {
+                results: results,
+            });
         }
         else {
-            const { result } = await this.createRun(this.run.title, this.run.description, this.run.environment);
-            if (!result?.id) {
-                throw new Error('Cannot create run.');
+            const results = [];
+            for (const result of testResults) {
+                const resultCreate = await this.transformTestResultV1(result);
+                results.push(resultCreate);
             }
-            runId = result.id;
+            await this.api.results.createResultBulk(this.projectCode, this.run.id, {
+                results: results,
+            });
         }
-        if (!this.results.length) {
-            this.log('No test cases were matched. Ensure that your tests are declared correctly.');
+        this.logger.logDebug(`Results sent to Qase: ${testResults.length}`);
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async publish() {
+        if (this.results.length === 0) {
+            this.logger.log((0, chalk_1.default) `{yellow No results to send to Qase}`);
             return;
         }
-        if (this.uploadAttachments && Object.keys(this.attachments).length) {
-            await this.prepareAttachments();
+        if (this.firstIndex < this.results.length) {
+            await this.publishResults(this.results.slice(this.firstIndex));
         }
-        await this.api.result.createResultsV2(this.projectCode, runId, {
-            results: this.results.map((result) => this.transformTestResult(result)),
-        });
-        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.logger.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}`;
-        this.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
+        const runUrl = `${this.baseUrl}/run/${this.projectCode}/dashboard/${this.run.id}`;
+        this.logger.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
     }
     /**
      * @param {TestResultType} result
-     * @returns {ResultCreate}
+     * @returns Promise<ResultCreateV2>
      * @private
      */
-    transformTestResult(result) {
-        const resultObject = {
+    async transformTestResult(result) {
+        const attachments = await this.uploadAttachments(result.attachments);
+        const steps = await this.transformSteps(result.steps);
+        const model = {
             title: result.title,
-            attachments: this.getAttachmentsFor(result.id),
-            execution: this.getExecution(result),
+            execution: this.getExecution(result.execution),
+            testops_id: Array.isArray(result.testops_id) ? null : result.testops_id,
+            attachments: attachments,
+            steps: steps,
+            params: result.params,
+            relations: this.getRelation(result.relations),
+            message: result.message,
         };
-        if (result.suiteTitle) {
-            resultObject.relations = {
-                suite: {
-                    data: this.getSuites(result.suiteTitle),
-                },
-            };
-        }
-        if (result.testOpsId[0]) {
-            resultObject.testops_id = result.testOpsId[0];
-        }
-        if (result.error) {
-            resultObject.message = (0, strip_ansi_1.default)(result.error.message);
-        }
-        if (result.steps) {
-            resultObject.steps = this.transformSteps(result.steps);
-        }
-        return resultObject;
+        this.logger.logDebug(`Transformed result: ${JSON.stringify(model)}`);
+        return model;
     }
     /**
-     * @param {string | string[]} suiteTitle
-     * @returns {RelationSuiteItem[]}
+     * @param {TestResultType} result
+     * @returns Promise<ResultCreate>
      * @private
      */
-    getSuites(suiteTitle) {
-        const suiteTitles = Array.isArray(suiteTitle) ? suiteTitle : suiteTitle.split('\t');
-        return suiteTitles.map((title) => ({ title }));
+    async transformTestResultV1(result) {
+        const attachments = await this.uploadAttachments(result.attachments);
+        const steps = await this.transformStepsV1(result.steps);
+        const resultCreate = {
+            attachments: attachments,
+            comment: result.message,
+            defect: this.defect,
+            param: result.params,
+            stacktrace: result.execution.stacktrace,
+            start_time: result.execution.start_time ? result.execution.start_time | 0 : null,
+            status: result.execution.status,
+            steps: steps,
+            time: result.execution.end_time,
+            time_ms: result.execution.duration,
+        };
+        const id = Array.isArray(result.testops_id) ? null : result.testops_id;
+        if (id) {
+            resultCreate.case_id = id;
+            return resultCreate;
+        }
+        resultCreate.case = {
+            title: result.title,
+            suite_title: result.relations?.suite ? result.relations?.suite?.data.map((suite) => suite.title).join('\t') : null,
+        };
+        this.logger.logDebug(`Transformed result: ${JSON.stringify(resultCreate)}`);
+        return resultCreate;
     }
     /**
-     * @param {TestResultType} result
      * @returns {ResultExecution}
      * @private
+     * @param {TestExecution} exec
      */
-    getExecution(result) {
-        const execution = {
-            status: TestOpsReporter.statusMap[result.status],
+    getExecution(exec) {
+        return {
+            status: TestOpsReporter.statusMap[exec.status],
+            start_time: exec.start_time,
+            end_time: exec.end_time,
+            duration: exec.duration,
+            stacktrace: exec.stacktrace,
+            thread: exec.thread,
         };
-        if (result.startTime) {
-            execution.start_time = result.startTime;
-        }
-        if (result.duration) {
-            execution.duration = result.duration;
-        }
-        if (result.endTime) {
-            execution.end_time = result.endTime;
-        }
-        if (result.error) {
-            execution.stacktrace = (0, strip_ansi_1.default)(String(result.error.stack));
-        }
-        return execution;
     }
     /**
-     * @param {string} id
-     * @returns {ResultAttachment[]}
+     * @param {Relation | null} relation
+     * @returns {ResultRelations}
      * @private
      */
-    getAttachmentsFor(id) {
-        const attachments = this.attachmentsMap[id];
-        if (!attachments) {
-            return [];
+    getRelation(relation) {
+        if (!relation || !relation.suite) {
+            return {};
         }
-        return attachments.reduce((acc, attachment) => {
-            if (attachment.hash) {
-                acc.push({ id: attachment.hash });
-            }
-            return acc;
-        }, []);
+        const suiteData = [];
+        for (const data of relation.suite.data) {
+            suiteData.push({
+                public_id: null,
+                title: data.title,
+            });
+        }
+        return {
+            suite: {
+                data: suiteData,
+            },
+        };
     }
     /**
      * @param {TestStepType[]} steps
-     * @returns {ResultStep[]}
+     * @returns Promise<ResultStep[]>
      * @private
      */
-    transformSteps(steps) {
-        return steps.map(({ id, title, status, steps, }) => {
-            const step = {
-                step_type: 'text',
+    async transformSteps(steps) {
+        const resultsSteps = [];
+        for (const step of steps) {
+            const attachmentHashes = await this.uploadAttachments(step.attachments);
+            const resultStep = {
                 data: {
-                    action: title,
+                    action: '',
+                    attachments: attachmentHashes,
                 },
                 execution: {
-                    status: TestOpsReporter.stepStatusMap[status],
+                    status: TestOpsReporter.stepStatusMap[step.execution.status],
                 },
-                attachments: this.getAttachmentsFor(id),
             };
-            if (steps) {
-                step.steps = this.transformSteps(steps);
+            if (step.step_type === models_1.StepType.TEXT) {
+                if ('action' in step.data && resultStep.data != undefined) {
+                    resultStep.data.action = step.data.action;
+                }
+            }
+            if (step.step_type === models_1.StepType.GHERKIN) {
+                if ('keyword' in step.data && resultStep.data != undefined) {
+                    resultStep.data.action = step.data.keyword;
+                }
+            }
+            if (step.steps.length > 0) {
+                resultStep.steps = await this.transformSteps(step.steps);
+            }
+            resultsSteps.push(resultStep);
+        }
+        return resultsSteps;
+    }
+    /**
+     * @param {TestStepType[]} steps
+     * @returns Promise<TestStepResultCreate[]>
+     * @private
+     */
+    async transformStepsV1(steps) {
+        const resultsSteps = [];
+        for (const step of steps) {
+            const attachmentHashes = await this.uploadAttachments(step.attachments);
+            const resultStep = {
+                status: TestOpsReporter.stepStatusMapV1[step.execution.status],
+                attachments: attachmentHashes,
+            };
+            if (step.step_type === models_1.StepType.TEXT) {
+                if ('action' in step.data) {
+                    resultStep.action = step.data.action;
+                }
+            }
+            if (step.step_type === models_1.StepType.GHERKIN) {
+                if ('keyword' in step.data) {
+                    resultStep.action = step.data.keyword;
+                }
             }
-            return step;
-        });
+            if (step.steps.length > 0) {
+                resultStep.steps = await this.transformStepsV1(step.steps);
+            }
+            resultsSteps.push(resultStep);
+        }
+        return resultsSteps;
     }
     /**
      * @param {number} runId
@@ -211,7 +302,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     async checkRun(runId) {
         try {
             const resp = await this.api.runs.getRun(this.projectCode, runId);
-            this.log(`Get run result on checking run "${String(resp.data.result?.id)}"`);
+            this.logger.log(`Get run result on checking run "${String(resp.data.result?.id)}"`);
         }
         catch (error) {
             throw new qase_error_1.QaseError('Error on checking run', { cause: error });
@@ -221,7 +312,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      * @param {string} title
      * @param {string} description
      * @param {number | undefined} environment
-     * @returns {Promise<any>}
+     * @returns {Promise<IdResponse>}
      * @private
      */
     async createRun(title, description, environment) {
@@ -246,54 +337,61 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      * @returns {Promise<void>}
      * @private
      */
-    async prepareAttachments() {
-        this.log((0, chalk_1.default) `{yellow Uploading attachments to Qase}`);
-        const uploads = Object.keys(this.attachments).reduce((acc, id) => {
-            const attachment = this.attachments[id];
-            if (attachment) {
-                acc.push([id, this.doUploadAttachments(attachment)]);
-            }
-            return acc;
-        }, []);
-        this.attachmentsMap = Object.fromEntries(await Promise.all(uploads.map(async ([id, request]) => {
-            return [id, await request];
-        })));
-    }
-    /**
-     * @param {string[]} attachments
-     * @returns {Promise<AttachmentGet[]>}
-     * @private
-     */
-    async doUploadAttachments(attachments) {
-        return (await Promise.all(attachments.map(async (attachment) => {
+    async uploadAttachments(attachments) {
+        if (!this.isUploadAttachments) {
+            return [];
+        }
+        const acc = [];
+        for (const attachment of attachments) {
             try {
-                const data = (0, fs_1.createReadStream)(attachment);
+                let data;
+                if (attachment.file_path) {
+                    data = { name: attachment.file_name, value: (0, fs_1.createReadStream)(attachment.file_path) };
+                }
+                else {
+                    if (typeof attachment.content === 'string') {
+                        data = { name: attachment.file_name, value: Buffer.from(attachment.content) };
+                    }
+                    else {
+                        data = { name: attachment.file_name, value: attachment.content };
+                    }
+                }
                 const response = await this.api.attachments.uploadAttachment(this.projectCode, [data]);
-                return response.data.result?.[0];
+                if (response.data.result?.[0]?.hash != undefined) {
+                    acc.push(response.data.result[0].hash);
+                }
             }
             catch (error) {
-                this.logError('Cannot upload attachment:', error);
-                return undefined;
+                this.logger.logError('Cannot upload attachment:', error);
             }
-        }))).filter((attachments) => Boolean(attachments));
+        }
+        return acc;
     }
 }
 exports.TestOpsReporter = TestOpsReporter;
 /**
- * @type {Record<TestStatusEnum, ResultExecutionStatusEnum>}
+ * @type {Record<TestStatusEnum, string>}
  */
 TestOpsReporter.statusMap = {
-    [models_1.TestStatusEnum.passed]: qaseio_1.ResultExecutionStatusEnum.PASSED,
-    [models_1.TestStatusEnum.failed]: qaseio_1.ResultExecutionStatusEnum.FAILED,
-    [models_1.TestStatusEnum.skipped]: qaseio_1.ResultExecutionStatusEnum.SKIPPED,
-    [models_1.TestStatusEnum.disabled]: qaseio_1.ResultExecutionStatusEnum.SKIPPED,
-    [models_1.TestStatusEnum.blocked]: qaseio_1.ResultExecutionStatusEnum.BLOCKED,
-    [models_1.TestStatusEnum.invalid]: qaseio_1.ResultExecutionStatusEnum.INVALID,
+    [models_1.TestStatusEnum.passed]: 'passed',
+    [models_1.TestStatusEnum.failed]: 'failed',
+    [models_1.TestStatusEnum.skipped]: 'skipped',
+    [models_1.TestStatusEnum.disabled]: 'disabled',
+    [models_1.TestStatusEnum.blocked]: 'blocked',
+    [models_1.TestStatusEnum.invalid]: 'invalid',
 };
 /**
- * @type {Record<StepStatusEnum, TestStepResultCreateStatusEnum>}
+ * @type {Record<StepStatusEnum, ResultStepStatus>}
  */
 TestOpsReporter.stepStatusMap = {
+    [models_1.StepStatusEnum.passed]: qaseio_1.ResultStepStatus.PASSED,
+    [models_1.StepStatusEnum.failed]: qaseio_1.ResultStepStatus.FAILED,
+    [models_1.StepStatusEnum.blocked]: qaseio_1.ResultStepStatus.BLOCKED,
+};
+/**
+ * @type {Record<StepStatusEnum, ResultStepStatus>}
+ */
+TestOpsReporter.stepStatusMapV1 = {
     [models_1.StepStatusEnum.passed]: qaseio_1.TestStepResultCreateStatusEnum.PASSED,
     [models_1.StepStatusEnum.failed]: qaseio_1.TestStepResultCreateStatusEnum.FAILED,
     [models_1.StepStatusEnum.blocked]: qaseio_1.TestStepResultCreateStatusEnum.BLOCKED,

package/dist/utils/logger.d.ts

@@ -0,0 +1,29 @@
+export interface LoggerInterface {
+    log(message: string): void;
+    logError(message: string, error?: unknown): void;
+    logDebug(message: string): void;
+}
+export declare class Logger implements LoggerInterface {
+    private readonly debug;
+    private readonly filePath;
+    constructor(options: {
+        debug?: boolean | undefined;
+        dir?: string;
+    });
+    log(message: string): void;
+    logError(message: string, error?: unknown): void;
+    logDebug(message: string): void;
+    private logToFile;
+    private doLogError;
+    /**
+     * @param {AxiosError} error
+     * @private
+     */
+    private logApiError;
+    /**
+     * @param errorFields
+     * @returns {string | undefined}
+     * @private
+     */
+    private formatErrorFields;
+}

package/dist/utils/logger.js

@@ -0,0 +1,121 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const is_axios_error_1 = require("./is-axios-error");
+const qase_error_1 = require("./qase-error");
+const lodash_get_1 = __importDefault(require("lodash.get"));
+class Logger {
+    constructor(options) {
+        this.debug = options.debug;
+        const dir = options.dir ?? './logs';
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir);
+        }
+        this.filePath = path.join(dir, 'log.txt');
+    }
+    log(message) {
+        const logMessage = `[INFO] qase: ${message}`;
+        console.log(logMessage);
+        if (this.debug) {
+            this.logToFile(logMessage);
+        }
+    }
+    logError(message, error) {
+        const logMessage = `[ERROR] qase: ${this.doLogError(message, error)}`;
+        console.error(logMessage);
+        if (this.debug) {
+            this.logToFile(logMessage);
+        }
+    }
+    logDebug(message) {
+        if (this.debug) {
+            const logMessage = `[DEBUG] qase: ${message}`;
+            console.log(logMessage);
+            this.logToFile(logMessage);
+        }
+    }
+    logToFile(message) {
+        const formattedMessage = `[${new Date().toISOString()}] ${message}\n`;
+        fs.appendFileSync(this.filePath, formattedMessage);
+    }
+    doLogError(message, error) {
+        let logMessage = message;
+        if (error instanceof Error) {
+            if ((0, is_axios_error_1.isAxiosError)(error)) {
+                logMessage += this.logApiError(error);
+            }
+            else if (error instanceof qase_error_1.QaseError && error.cause) {
+                logMessage += this.doLogError('\n Caused by:', error.cause);
+            }
+            logMessage += `\n ${error.stack || `${error.name}: ${error.message}`}`;
+        }
+        else {
+            logMessage += `\n ${String(error)}`;
+        }
+        return logMessage;
+    }
+    /**
+     * @param {AxiosError} error
+     * @private
+     */
+    logApiError(error) {
+        let logMessage = '\n';
+        const errorMessage = (0, lodash_get_1.default)(error, 'response.data.errorMessage')
+            ?? (0, lodash_get_1.default)(error, 'response.data.error')
+            ?? (0, lodash_get_1.default)(error, 'response.statusText')
+            ?? 'Unknown error';
+        const errorFields = this.formatErrorFields((0, lodash_get_1.default)(error, 'response.data.errorFields'));
+        logMessage += `Message: ${String(errorMessage)}`;
+        if (errorFields) {
+            logMessage += `\n ${errorFields}`;
+        }
+        return logMessage;
+    }
+    /**
+     * @param errorFields
+     * @returns {string | undefined}
+     * @private
+     */
+    formatErrorFields(errorFields) {
+        if (Array.isArray(errorFields)) {
+            return errorFields.reduce((acc, item) => {
+                const field = (0, lodash_get_1.default)(item, 'field');
+                const error = (0, lodash_get_1.default)(item, 'error');
+                if (field && error) {
+                    return acc + `${String(field)}: ${String(error)}\n`;
+                }
+                return acc;
+            }, '');
+        }
+        return undefined;
+    }
+}
+exports.Logger = Logger;

package/dist/utils/mimeTypes.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Get mime type of the file
+ * @param {string} filePath
+ */
+export declare function getMimeTypes(filePath: string): string;