qase-javascript-commons 2.0.0-beta.5 → 2.0.0-beta.7

package/changelog.md

@@ -1,8 +1,74 @@
+# qase-javascript-commons@2.0.0-beta.7
+
+## What's new
+
+TestOps reporter supports uploading test result in real-time.
+It can be useful for long-running tests, where you want to see the results as soon as they are available.
+You can use chunk size to control the size of the data sent to the Qase.
+
+To enable real-time reporting, set an environment variable before running the tests or use the reporter's configuration:
+
+```bash
+QASE_TESTOPS_CHUNK=10
+```
+
+```diff
+{
+  ...
+  "testops": {
++   "chunk": 10
+    ...
+  },
+  ...
+}
+```
+
+where `10` is the size of the chunk in test result's count.
+
+# qase-javascript-commons@2.0.0-beta.6
+
+## What's new
+
+### Select the API version to use for reporting
+
+Qase TestOps API has two endpoints for reporting test results:
+
+- Version 1, stable and used my most test reporters.
+  https://developers.qase.io/reference/create-result-bulk
+- Version 2, currently in beta access, and currently supported only
+  in the `playwright-qase-reporter`.
+  https://developers.qase.io/v2.0/reference/create-results-v2
+
+This commit introduces a way to select the API version to use.
+It enables using all new features of v2 JS reporters with the stable v1 API,
+and elso experimenting with the new v2 API.
+
+**Warning**: v2 API is still in beta. 
+If you want to try the v2 JS reporters, you don't have to enable the new API.
+
+To enable using API v2, set an environment variable before running the tests:
+
+```bash
+QASE_TESTOPS_API_V2=true
+```
+
+### Support adding test suite description to a test report.
+
+Test reporters can now test suite description to test results.
+Such description can be collected from test's location and attributes
+or explicitly declared in the test.
+
+Add new data models:
+- Relation
+- Suite
+- SuiteData
+
+
 # qase-javascript-commons@2.0.0-beta.5
 
 ## What's new
 
-* Update the config of reporters. Added `framework.captureLogs` field. If it is set to `true`, the reporter will capture logs from the test framework.
+* Update the config of reporters. Added `captureLogs` field. If it is set to `true`, the reporter will capture logs from the test framework.
 * Added `getMimeType` function to the commons package. It returns the MIME type of the file by its extension.
 
 # qase-javascript-commons@2.0.0-beta.4

package/dist/config/config-validation-schema.js

@@ -115,6 +115,10 @@ exports.configValidationSchema = {
                     type: 'boolean',
                     nullable: true,
                 },
+                useV2: {
+                    type: 'boolean',
+                    nullable: true,
+                },
             },
         },
         report: {

package/dist/env/env-enum.d.ts

@@ -15,7 +15,8 @@ export declare enum EnvTestOpsEnum {
     project = "QASE_TESTOPS_PROJECT",
     uploadAttachments = "QASE_TESTOPS_UPLOAD_ATTACHMENTS",
     chunk = "QASE_TESTOPS_CHUNK",
-    defect = "QASE_TESTOPS_DEFECT"
+    defect = "QASE_TESTOPS_DEFECT",
+    useV2 = "QASE_TESTOPS_API_V2"
 }
 /**
  * @enum {string}

package/dist/env/env-enum.js

@@ -21,6 +21,7 @@ var EnvTestOpsEnum;
     EnvTestOpsEnum["uploadAttachments"] = "QASE_TESTOPS_UPLOAD_ATTACHMENTS";
     EnvTestOpsEnum["chunk"] = "QASE_TESTOPS_CHUNK";
     EnvTestOpsEnum["defect"] = "QASE_TESTOPS_DEFECT";
+    EnvTestOpsEnum["useV2"] = "QASE_TESTOPS_API_V2";
 })(EnvTestOpsEnum || (exports.EnvTestOpsEnum = EnvTestOpsEnum = {}));
 /**
  * @enum {string}

package/dist/env/env-to-config.js

@@ -30,6 +30,7 @@ const envToConfig = (env) => ({
         },
         chunk: env[env_enum_1.EnvTestOpsEnum.chunk],
         defect: env[env_enum_1.EnvTestOpsEnum.defect],
+        useV2: env[env_enum_1.EnvTestOpsEnum.useV2],
     },
     report: {
         connections: {

package/dist/env/env-type.d.ts

@@ -11,6 +11,7 @@ export type EnvType = {
     [EnvTestOpsEnum.uploadAttachments]?: boolean;
     [EnvTestOpsEnum.chunk]?: number;
     [EnvTestOpsEnum.defect]?: boolean;
+    [EnvTestOpsEnum.useV2]?: boolean;
     [EnvApiEnum.token]?: string;
     [EnvApiEnum.baseUrl]?: string;
     [EnvRunEnum.id]?: number;

package/dist/env/env-validation-schema.js

@@ -48,6 +48,10 @@ exports.envValidationSchema = {
             type: 'boolean',
             nullable: true,
         },
+        [env_enum_1.EnvTestOpsEnum.useV2]: {
+            type: 'boolean',
+            nullable: true,
+        },
         [env_enum_1.EnvApiEnum.token]: {
             type: 'string',
             nullable: true,

package/dist/models/index.d.ts

@@ -1,4 +1,4 @@
-export { type TestResultType } from './test-result';
+export { type TestResultType, Relation, Suite, SuiteData } from './test-result';
 export { TestExecution, TestStatusEnum } from './test-execution';
 export { type TestStepType } from './test-step';
 export { StepStatusEnum } from './step-execution';

package/dist/models/test-result.d.ts

@@ -13,7 +13,17 @@ export type TestResultType = {
     steps: TestStepType[];
     params: Record<string, string>;
     author: string | null;
-    relations: any[];
+    relations: Relation | null;
     muted: boolean;
     message: string | null;
 };
+export type Relation = {
+    suite?: Suite;
+};
+export type Suite = {
+    data: SuiteData[];
+};
+export type SuiteData = {
+    title: string;
+    public_id: number | null;
+};

package/dist/qase.d.ts

@@ -39,10 +39,14 @@ export declare class QaseReporter extends AbstractReporter {
      * @param {LoggerInterface} logger
      */
     constructor(options: OptionsType, logger?: LoggerInterface);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result: TestResultType): void;
+    addTestResult(result: TestResultType): Promise<void>;
     /**
      * @param {TestResultType} result
      * @private

package/dist/qase.js

@@ -119,18 +119,42 @@ class QaseReporter extends reporters_1.AbstractReporter {
             }
         }
     }
+    /**
+     * @returns {Promise<void>}
+     */
+    async startTestRun() {
+        if (!this.disabled) {
+            try {
+                await this.upstreamReporter?.startTestRun();
+            }
+            catch (error) {
+                this.logError('Unable to start test run in the upstream reporter: ', error);
+                if (this.fallbackReporter == undefined) {
+                    this.disabled = true;
+                    return;
+                }
+                try {
+                    await this.fallbackReporter?.startTestRun();
+                }
+                catch (error) {
+                    this.logError('Unable to start test run in the fallback reporter: ', error);
+                    this.disabled = true;
+                }
+            }
+        }
+    }
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result) {
+    async addTestResult(result) {
         if (!this.disabled) {
             this.logTestItem(result);
             if (this.useFallback) {
-                this.addTestResultToFallback(result);
+                await this.addTestResultToFallback(result);
                 return;
             }
             try {
-                this.upstreamReporter?.addTestResult(result);
+                await this.upstreamReporter?.addTestResult(result);
             }
             catch (error) {
                 this.logError('Unable to add the result to the upstream reporter:', error);
@@ -142,7 +166,7 @@ class QaseReporter extends reporters_1.AbstractReporter {
                     this.fallbackReporter.setTestResults(this.upstreamReporter?.getTestResults() ?? []);
                     this.useFallback = true;
                 }
-                this.addTestResultToFallback(result);
+                await this.addTestResultToFallback(result);
             }
         }
     }
@@ -150,9 +174,9 @@ class QaseReporter extends reporters_1.AbstractReporter {
      * @param {TestResultType} result
      * @private
      */
-    addTestResultToFallback(result) {
+    async addTestResultToFallback(result) {
         try {
-            this.fallbackReporter?.addTestResult(result);
+            await this.fallbackReporter?.addTestResult(result);
         }
         catch (error) {
             this.logError('Unable to add the result to the fallback reporter:', error);

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

@@ -9,8 +9,9 @@ export interface ReporterOptionsType {
     captureLogs?: boolean | undefined;
 }
 export interface ReporterInterface {
-    addTestResult(result: TestResultType): void;
+    addTestResult(result: TestResultType): Promise<void>;
     publish(): Promise<void>;
+    startTestRun(): Promise<void>;
     getTestResults(): TestResultType[];
     setTestResults(results: TestResultType[]): void;
     isCaptureLogs(): boolean;
@@ -41,6 +42,10 @@ export declare abstract class AbstractReporter implements ReporterInterface {
      * @returns {Promise<void>}
      */
     abstract publish(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    abstract startTestRun(): Promise<void>;
     /**
      * @param {ReporterOptionsType} options
      * @param {LoggerInterface} logger
@@ -58,7 +63,7 @@ export declare abstract class AbstractReporter implements ReporterInterface {
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result: TestResultType): void;
+    addTestResult(result: TestResultType): Promise<void>;
     /**
      * @param {TestResultType[]} results
      */

package/dist/reporters/abstract-reporter.js

@@ -45,7 +45,8 @@ class AbstractReporter {
     /**
      * @param {TestResultType} result
      */
-    addTestResult(result) {
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async addTestResult(result) {
         if (result.testops_id === null || !Array.isArray(result.testops_id)) {
             this.results.push(result);
             return;

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

@@ -8,7 +8,7 @@ export declare class ReportReporter extends AbstractReporter {
     private writer;
     private readonly environment;
     private readonly runId;
-    private readonly startTime;
+    private startTime;
     /**
      * @param {ReporterOptionsType} options
      * @param {WriterInterface} writer
@@ -17,10 +17,13 @@ export declare class ReportReporter extends AbstractReporter {
      * @param {number | undefined} runId
      */
     constructor(options: ReporterOptionsType | undefined, writer: WriterInterface, logger?: LoggerInterface, environment?: string, runId?: number);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
     /**
      * @returns {Promise<void>}
      *
-     * eslint-disable-next-line @typescript-eslint/require-await
      */
     publish(): Promise<void>;
     /**

package/dist/reporters/report-reporter.js

@@ -48,10 +48,16 @@ class ReportReporter extends abstract_reporter_1.AbstractReporter {
         this.environment = environment;
         this.runId = runId;
     }
+    /**
+     * @returns {Promise<void>}
+     */
+    // eslint-disable-next-line @typescript-eslint/require-await
+    async startTestRun() {
+        this.startTime = Date.now();
+    }
     /**
      * @returns {Promise<void>}
      *
-     * eslint-disable-next-line @typescript-eslint/require-await
      */
     async publish() {
         const report = {

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

@@ -1,6 +1,6 @@
-import { QaseApiInterface, ResultStepStatus } from 'qaseio';
+import { QaseApiInterface, ResultStepStatus, TestStepResultCreateStatusEnum } from 'qaseio';
 import { AbstractReporter, LoggerInterface, ReporterOptionsType } from './abstract-reporter';
-import { StepStatusEnum, TestStatusEnum } from '../models';
+import { StepStatusEnum, TestResultType, TestStatusEnum } from '../models';
 export type TestOpsRunType = {
     id?: number | undefined;
     title: string;
@@ -17,6 +17,7 @@ export type TestOpsOptionsType = {
     plan: TestOpsPlanType;
     chunk?: number | undefined;
     defect?: boolean | undefined;
+    useV2?: boolean | undefined;
 };
 /**
  * @class TestOpsReporter
@@ -32,6 +33,10 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @type {Record<StepStatusEnum, ResultStepStatus>}
      */
     static stepStatusMap: Record<StepStatusEnum, ResultStepStatus>;
+    /**
+     * @type {Record<StepStatusEnum, ResultStepStatus>}
+     */
+    static stepStatusMapV1: Record<StepStatusEnum, TestStepResultCreateStatusEnum>;
     /**
      * @type {string}
      * @private
@@ -62,6 +67,26 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @private
      */
     private readonly chunk;
+    /**
+     * @type {boolean | undefined}
+     * @private
+     */
+    private readonly useV2;
+    /**
+     * @type {boolean | undefined}
+     * @private
+     */
+    private readonly defect;
+    /**
+     * @type {number}
+     * @private
+     */
+    private firstIndex;
+    /**
+     * @type {boolean}
+     * @private
+     */
+    private isTestRunReady;
     /**
      * @param {ReporterOptionsType & TestOpsOptionsType} options
      * @param {QaseApiInterface} api
@@ -69,6 +94,25 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @param {number} environment
      */
     constructor(options: ReporterOptionsType & TestOpsOptionsType, api: QaseApiInterface, logger?: LoggerInterface, environment?: number);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun(): Promise<void>;
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    addTestResult(result: TestResultType): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    private checkOrCreateTestRun;
+    /**
+     * @returns {Promise<void>}
+     * @param testResults
+     * @private
+     */
+    private publishResults;
     /**
      * @returns {Promise<void>}
      */
@@ -79,18 +123,36 @@ export declare class TestOpsReporter extends AbstractReporter {
      * @private
      */
     private transformTestResult;
+    /**
+     * @param {TestResultType} result
+     * @returns Promise<ResultCreate>
+     * @private
+     */
+    private transformTestResultV1;
     /**
      * @returns {ResultExecution}
      * @private
      * @param {TestExecution} exec
      */
     private getExecution;
+    /**
+     * @param {Relation | null} relation
+     * @returns {ResultRelations}
+     * @private
+     */
+    private getRelation;
     /**
      * @param {TestStepType[]} steps
      * @returns Promise<ResultStep[]>
      * @private
      */
     private transformSteps;
+    /**
+     * @param {TestStepType[]} steps
+     * @returns Promise<TestStepResultCreate[]>
+     * @private
+     */
+    private transformStepsV1;
     /**
      * @param {number} runId
      * @returns {Promise<void>}

package/dist/reporters/testops-reporter.js

@@ -26,6 +26,16 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         const { project, uploadAttachments, run, ...restOptions } = options;
         super(restOptions, logger);
         this.api = api;
+        /**
+         * @type {number}
+         * @private
+         */
+        this.firstIndex = 0;
+        /**
+         * @type {boolean}
+         * @private
+         */
+        this.isTestRunReady = false;
         const baseUrl = 'https://app.qase.io';
         this.baseUrl = baseUrl.replace(/\/$/, '');
         this.projectCode = project;
@@ -33,49 +43,96 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         this.run = { complete: true, ...run };
         this.environment = environment;
         this.chunk = options.chunk ?? defaultChunkSize;
+        this.useV2 = options.useV2 ?? false;
+        this.defect = options.defect ?? false;
     }
     /**
      * @returns {Promise<void>}
      */
-    async publish() {
-        let runId;
+    async startTestRun() {
+        await this.checkOrCreateTestRun();
+    }
+    /**
+     * @param {TestResultType} result
+     * @returns {Promise<void>}
+     */
+    async addTestResult(result) {
+        await super.addTestResult(result);
+        if (!this.isTestRunReady) {
+            return;
+        }
+        const countOfResults = this.chunk + this.firstIndex;
+        if (this.results.length >= countOfResults) {
+            await this.publishResults(this.results.slice(this.firstIndex, countOfResults));
+            this.firstIndex = countOfResults;
+        }
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async checkOrCreateTestRun() {
         if (this.run.id !== undefined) {
             await this.checkRun(this.run.id);
-            runId = this.run.id;
+            this.isTestRunReady = true;
+            return;
+        }
+        const { result } = await this.createRun(this.run.title, this.run.description, this.environment);
+        if (!result?.id) {
+            throw new Error('Cannot create run.');
+        }
+        this.run.id = 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.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.');
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async publish() {
+        if (this.results.length === 0) {
+            this.log((0, chalk_1.default) `{yellow No results to send to Qase}`);
             return;
         }
-        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),
-            });
+        if (this.firstIndex < this.results.length) {
+            await this.publishResults(this.results.slice(this.firstIndex));
         }
         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.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}`;
+        const runUrl = `${this.baseUrl}/run/${this.projectCode}/dashboard/${this.run.id}`;
         this.log((0, chalk_1.default) `{blue Test run link: ${runUrl}}`);
     }
     /**
@@ -93,14 +150,41 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             attachments: attachments,
             steps: steps,
             params: result.params,
-            relations: {
-            // suite: {
-            //   data: result.suiteTitle ? this.getSuites(result.suiteTitle) : [],
-            // },
-            },
+            relations: this.getRelation(result.relations),
             message: result.message,
         };
     }
+    /**
+     * @param {TestResultType} result
+     * @returns Promise<ResultCreate>
+     * @private
+     */
+    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,
+        };
+        return resultCreate;
+    }
     /**
      * @returns {ResultExecution}
      * @private
@@ -116,6 +200,28 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
             thread: exec.thread,
         };
     }
+    /**
+     * @param {Relation | null} relation
+     * @returns {ResultRelations}
+     * @private
+     */
+    getRelation(relation) {
+        if (!relation || !relation.suite) {
+            return {};
+        }
+        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 Promise<ResultStep[]>
@@ -141,6 +247,27 @@ class TestOpsReporter extends abstract_reporter_1.AbstractReporter {
         }
         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],
+                action: step.data.action,
+                attachments: attachmentHashes,
+            };
+            if (step.steps.length > 0) {
+                resultStep.steps = await this.transformStepsV1(step.steps);
+            }
+            resultsSteps.push(resultStep);
+        }
+        return resultsSteps;
+    }
     /**
      * @param {number} runId
      * @returns {Promise<void>}
@@ -235,3 +362,11 @@ TestOpsReporter.stepStatusMap = {
     [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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qase-javascript-commons",
-  "version": "2.0.0-beta.5",
+  "version": "2.0.0-beta.7",
   "description": "Qase JS Reporters",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",