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

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

@@ -1,18 +1,22 @@
-import { QaseApiInterface, ResultExecutionStatusEnum, TestStepResultCreateStatusEnum } from 'qaseio';
+import { QaseApiInterface, ResultStepStatus } from 'qaseio';
 import { AbstractReporter, LoggerInterface, ReporterOptionsType } from './abstract-reporter';
-import { StepStatusEnum, TestResultType, TestStatusEnum } from '../models';
+import { StepStatusEnum, TestStatusEnum } from '../models';
 export type TestOpsRunType = {
     id?: number | undefined;
     title: string;
     description: string;
     complete?: boolean | undefined;
-    environment?: number | undefined;
+};
+export type TestOpsPlanType = {
+    id?: number | undefined;
 };
 export type TestOpsOptionsType = {
     project: string;
-    baseUrl?: string | undefined;
     uploadAttachments?: boolean | undefined;
     run: TestOpsRunType;
+    plan: TestOpsPlanType;
+    chunk?: number | undefined;
+    defect?: boolean | undefined;
 };
 /**
  * @class TestOpsReporter
@@ -21,90 +25,69 @@ export type TestOpsOptionsType = {
 export declare class TestOpsReporter extends AbstractReporter {
     private api;
     /**
-     * @type {Record<TestStatusEnum, ResultExecutionStatusEnum>}
+     * @type {Record<TestStatusEnum, string>}
      */
-    static statusMap: Record<TestStatusEnum, ResultExecutionStatusEnum>;
+    static statusMap: Record<TestStatusEnum, string>;
     /**
-     * @type {Record<StepStatusEnum, TestStepResultCreateStatusEnum>}
+     * @type {Record<StepStatusEnum, ResultStepStatus>}
      */
-    static stepStatusMap: Record<StepStatusEnum, TestStepResultCreateStatusEnum>;
+    static stepStatusMap: Record<StepStatusEnum, ResultStepStatus>;
     /**
      * @type {string}
      * @private
      */
-    private baseUrl;
+    private readonly baseUrl;
     /**
      * @type {string}
      * @private
      */
-    private projectCode;
+    private readonly projectCode;
     /**
      * @type {boolean | undefined}
      * @private
      */
-    private uploadAttachments;
+    private readonly isUploadAttachments;
     /**
      * @type {TestOpsRunType}
      * @private
      */
     private run;
     /**
-     * @type {TestResultType[]}
+     * @type { number | undefined}
      * @private
      */
-    private results;
+    private readonly environment;
     /**
-     * @type {Record<string, string[]>}
-     * @private
-     */
-    private attachments;
-    /**
-     * @type {Record<string, string[]>}
+     * @type {TestResultType[]}
      * @private
      */
-    private attachmentsMap;
+    private readonly chunk;
     /**
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
      * @param {LoggerInterface} logger
+     * @param {number} environment
      */
-    constructor(options: ReporterOptionsType & TestOpsOptionsType, api: QaseApiInterface, logger?: LoggerInterface);
-    /**
-     * @param {TestResultType} result
-     */
-    addTestResult(result: TestResultType): void;
-    private addAttachments;
+    constructor(options: ReporterOptionsType & TestOpsOptionsType, api: QaseApiInterface, logger?: LoggerInterface, environment?: number);
     /**
      * @returns {Promise<void>}
      */
     publish(): Promise<void>;
     /**
      * @param {TestResultType} result
-     * @returns {ResultCreate}
+     * @returns Promise<ResultCreateV2>
      * @private
      */
     private transformTestResult;
     /**
-     * @param {string | string[]} suiteTitle
-     * @returns {RelationSuiteItem[]}
-     * @private
-     */
-    private getSuites;
-    /**
-     * @param {TestResultType} result
      * @returns {ResultExecution}
      * @private
+     * @param {TestExecution} exec
      */
     private getExecution;
-    /**
-     * @param {string} id
-     * @returns {ResultAttachment[]}
-     * @private
-     */
-    private getAttachmentsFor;
     /**
      * @param {TestStepType[]} steps
-     * @returns {ResultStep[]}
+     * @returns Promise<ResultStep[]>
      * @private
      */
     private transformSteps;
@@ -118,7 +101,7 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @param {string} title
      * @param {string} description
      * @param {number | undefined} environment
-     * @returns {Promise<any>}
+     * @returns {Promise<IdResponse>}
      * @private
      */
     private createRun;
@@ -126,11 +109,5 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @returns {Promise<void>}
      * @private
      */
-    private prepareAttachments;
-    /**
-     * @param {string[]} attachments
-     * @returns {Promise<AttachmentGet[]>}
-     * @private
-     */
-    private doUploadAttachments;
+    private uploadAttachments;
 }

package/dist/reporters/testops-reporter.js

@@ -6,11 +6,11 @@ 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
@@ -20,47 +20,19 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
      * @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;
+    constructor(options, api, logger, environment) {
+        const { project, uploadAttachments, run, ...restOptions } = options;
         super(restOptions, logger);
         this.api = api;
-        /**
-         * @type {TestResultType[]}
-         * @private
-         */
-        this.results = [];
-        /**
-         * @type {Record<string, string[]>}
-         * @private
-         */
-        this.attachments = {};
-        /**
-         * @type {Record<string, string[]>}
-         * @private
-         */
-        this.attachmentsMap = {};
+        const baseUrl = 'https://app.qase.io';
         this.baseUrl = baseUrl.replace(/\/$/, '');
         this.projectCode = project;
-        this.uploadAttachments = uploadAttachments;
+        this.isUploadAttachments = uploadAttachments;
         this.run = { complete: true, ...run };
-    }
-    /**
-     * @param {TestResultType} result
-     */
-    addTestResult(result) {
-        this.results.push(result);
-        this.addAttachments(result);
-    }
-    addAttachments(resultOrStep) {
-        if (resultOrStep.attachments) {
-            this.attachments[resultOrStep.id] = resultOrStep.attachments;
-        }
-        if (resultOrStep.steps) {
-            for (const step of resultOrStep.steps) {
-                this.addAttachments(step);
-            }
-        }
+        this.environment = environment;
+        this.chunk = options.chunk ?? defaultChunkSize;
     }
     /**
      * @returns {Promise<void>}
@@ -72,7 +44,7 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             runId = this.run.id;
         }
         else {
-            const { result } = await this.createRun(this.run.title, this.run.description, this.run.environment);
+            const { result } = await this.createRun(this.run.title, this.run.description, this.environment);
             if (!result?.id) {
                 throw new Error('Cannot create run.');
             }
@@ -82,12 +54,16 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             this.log('No test cases were matched. Ensure that your tests are declared correctly.');
             return;
         }
-        if (this.uploadAttachments && Object.keys(this.attachments).length) {
-            await this.prepareAttachments();
+        const results = [];
+        for (const result of this.results) {
+            const resultCreateV2 = await this.transformTestResult(result);
+            results.push(resultCreateV2);
+        }
+        for (let i = 0; i < results.length; i += this.chunk) {
+            await this.api.result.createResultsV2(this.projectCode, runId, {
+                results: results.slice(i, i + this.chunk),
+            });
         }
-        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;
@@ -104,104 +80,66 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
     }
     /**
      * @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);
+        return {
             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: {},
+            relations: {
+            // suite: {
+            //   data: result.suiteTitle ? this.getSuites(result.suiteTitle) : [],
+            // },
+            },
+            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;
     }
     /**
-     * @param {string | string[]} suiteTitle
-     * @returns {RelationSuiteItem[]}
-     * @private
-     */
-    getSuites(suiteTitle) {
-        const suiteTitles = Array.isArray(suiteTitle) ? suiteTitle : suiteTitle.split('\t');
-        return suiteTitles.map((title) => ({ title }));
-    }
-    /**
-     * @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[]}
-     * @private
-     */
-    getAttachmentsFor(id) {
-        const attachments = this.attachmentsMap[id];
-        if (!attachments) {
-            return [];
-        }
-        return attachments.reduce((acc, attachment) => {
-            if (attachment.hash) {
-                acc.push({ id: attachment.hash });
-            }
-            return acc;
-        }, []);
     }
     /**
      * @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: step.data.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.steps.length > 0) {
+                resultStep.steps = await this.transformSteps(step.steps);
             }
-            return step;
-        });
+            resultsSteps.push(resultStep);
+        }
+        return resultsSteps;
     }
     /**
      * @param {number} runId
@@ -221,7 +159,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,55 +184,49 @@ 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 = (0, fs_1.createReadStream)(attachment.file_path);
+                }
+                else {
+                    data = 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;
             }
-        }))).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.TestStepResultCreateStatusEnum.PASSED,
-    [models_1.StepStatusEnum.failed]: qaseio_1.TestStepResultCreateStatusEnum.FAILED,
-    [models_1.StepStatusEnum.blocked]: qaseio_1.TestStepResultCreateStatusEnum.BLOCKED,
+    [models_1.StepStatusEnum.passed]: qaseio_1.ResultStepStatus.PASSED,
+    [models_1.StepStatusEnum.failed]: qaseio_1.ResultStepStatus.FAILED,
+    [models_1.StepStatusEnum.blocked]: qaseio_1.ResultStepStatus.BLOCKED,
 };

package/dist/writer/driver-enum.d.ts

@@ -4,3 +4,10 @@
 export declare enum DriverEnum {
     local = "local"
 }
+/**
+ * @enum {string}
+ */
+export declare enum FormatEnum {
+    json = "json",
+    jsonp = "jsonp"
+}

package/dist/writer/driver-enum.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DriverEnum = void 0;
+exports.FormatEnum = exports.DriverEnum = void 0;
 /**
  * @enum {string}
  */
@@ -8,3 +8,11 @@ var DriverEnum;
 (function (DriverEnum) {
     DriverEnum["local"] = "local";
 })(DriverEnum || (exports.DriverEnum = DriverEnum = {}));
+/**
+ * @enum {string}
+ */
+var FormatEnum;
+(function (FormatEnum) {
+    FormatEnum["json"] = "json";
+    FormatEnum["jsonp"] = "jsonp";
+})(FormatEnum || (exports.FormatEnum = FormatEnum = {}));

package/dist/writer/fs-writer.d.ts

@@ -1,26 +1,35 @@
 import { WriterInterface } from './writer-interface';
-import { TestResultType } from '../models';
-import { FormatterInterface } from '../formatter';
+import { TestResultType, Attachment, Report } from '../models';
+import { FormatEnum } from './driver-enum';
 export type FsWriterOptionsType = {
     path?: string | undefined;
-    ext?: string | undefined;
+    format?: `${FormatEnum}` | undefined;
 };
 /**
  * @class FsWriter
  * @implements WriterInterface
  */
 export declare class FsWriter implements WriterInterface {
+    private readonly path;
+    private readonly format;
     private formatter;
-    private path;
-    private ext;
     /**
      * @param {FsWriterOptionsType | undefined} options
-     * @param {FormatterInterface} formatter
      */
-    constructor(options: FsWriterOptionsType | undefined, formatter: FormatterInterface);
+    constructor(options: FsWriterOptionsType | undefined);
+    /**
+     * @param {Attachment[]} attachments
+     * @returns {Attachment[]}
+     */
+    writeAttachment(attachments: Attachment[]): Attachment[];
     /**
      * @param {TestResultType[]} results
      * @returns {Promise<string>}
      */
-    write(results: TestResultType[]): Promise<string>;
+    writeReport(results: Report): Promise<string>;
+    /**
+     * @returns {Promise<void>}
+     * @param {TestResultType} result
+     */
+    writeTestResult(result: TestResultType): Promise<void>;
 }

package/dist/writer/fs-writer.js

@@ -26,6 +26,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FsWriter = void 0;
 const fs_1 = require("fs");
 const path = __importStar(require("path"));
+const formatter_1 = require("../formatter");
+const driver_enum_1 = require("./driver-enum");
 /**
  * @class FsWriter
  * @implements WriterInterface
@@ -33,27 +35,72 @@ const path = __importStar(require("path"));
 class FsWriter {
     /**
      * @param {FsWriterOptionsType | undefined} options
-     * @param {FormatterInterface} formatter
      */
-    constructor(options, formatter) {
-        this.formatter = formatter;
-        const { path: pathOptions = path.join('build', 'qase-report'), ext = 'json', } = options ?? {};
+    constructor(options) {
+        const { path: pathOptions = path.join('build', 'qase-report'), format = options?.format ?? driver_enum_1.FormatEnum.json, } = options ?? {};
         this.path = pathOptions;
-        this.ext = ext;
+        this.format = format;
+        if (this.format === driver_enum_1.FormatEnum.json) {
+            this.formatter = new formatter_1.JsonFormatter();
+        }
+        else {
+            this.formatter = new formatter_1.JsonpFormatter();
+        }
+    }
+    /**
+     * @param {Attachment[]} attachments
+     * @returns {Attachment[]}
+     */
+    writeAttachment(attachments) {
+        const attachmentsPath = path.join(this.path, 'attachments');
+        try {
+            (0, fs_1.mkdirSync)(attachmentsPath, { recursive: true });
+        }
+        catch (error) { /* ignore */
+        }
+        for (const attachment of attachments) {
+            if (attachment.file_path) {
+                attachment.file_name = path.basename(attachment.file_path);
+            }
+            const filePath = path.join(attachmentsPath, `${attachment.id}-${attachment.file_name}`);
+            if (attachment.file_path) {
+                (0, fs_1.copyFileSync)(attachment.file_path, filePath);
+                attachment.file_path = filePath;
+                continue;
+            }
+            (0, fs_1.writeFileSync)(filePath, attachment.content);
+            attachment.file_path = filePath;
+        }
+        return attachments;
     }
     /**
      * @param {TestResultType[]} results
      * @returns {Promise<string>}
      */
     // eslint-disable-next-line @typescript-eslint/require-await
-    async write(results) {
+    async writeReport(results) {
         try {
             (0, fs_1.mkdirSync)(this.path, { recursive: true });
         }
-        catch (error) { /* ignore */ }
-        const filePath = path.join(this.path, `results-${Date.now()}.${this.ext}`);
+        catch (error) { /* ignore */
+        }
+        const filePath = path.join(this.path, `report.${this.format}`);
         (0, fs_1.writeFileSync)(filePath, await this.formatter.format(results));
         return filePath;
     }
+    /**
+     * @returns {Promise<void>}
+     * @param {TestResultType} result
+     */
+    async writeTestResult(result) {
+        const resultsPath = path.join(this.path, 'results');
+        try {
+            (0, fs_1.mkdirSync)(resultsPath, { recursive: true });
+        }
+        catch (error) { /* ignore */
+        }
+        const filePath = path.join(resultsPath, `${result.id}.${this.format}`);
+        (0, fs_1.writeFileSync)(filePath, await this.formatter.format(result));
+    }
 }
 exports.FsWriter = FsWriter;

package/dist/writer/index.d.ts

@@ -1,3 +1,3 @@
 export { type WriterInterface } from './writer-interface';
 export { FsWriter, type FsWriterOptionsType } from './fs-writer';
-export { DriverEnum } from './driver-enum';
+export { DriverEnum, FormatEnum } from './driver-enum';

package/dist/writer/index.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DriverEnum = exports.FsWriter = void 0;
+exports.FormatEnum = exports.DriverEnum = exports.FsWriter = void 0;
 var fs_writer_1 = require("./fs-writer");
 Object.defineProperty(exports, "FsWriter", { enumerable: true, get: function () { return fs_writer_1.FsWriter; } });
 var driver_enum_1 = require("./driver-enum");
 Object.defineProperty(exports, "DriverEnum", { enumerable: true, get: function () { return driver_enum_1.DriverEnum; } });
+Object.defineProperty(exports, "FormatEnum", { enumerable: true, get: function () { return driver_enum_1.FormatEnum; } });

package/dist/writer/writer-interface.d.ts

@@ -1,4 +1,6 @@
-import { TestResultType } from '../models';
+import { TestResultType, Attachment, Report } from '../models';
 export interface WriterInterface {
-    write(results: TestResultType[]): Promise<string>;
+    writeReport(results: Report): Promise<string>;
+    writeTestResult(result: TestResultType): Promise<void>;
+    writeAttachment(attachments: Attachment[]): Attachment[];
 }