testcafe-reporter-qase 2.0.0-beta.1 → 2.0.0

package/README.md

@@ -1,12 +1,19 @@
-> # Qase TMS TestCafe reporter
->
-> Publish results simple and easy.
+# Qase TMS TestCafe reporter
 
-## How to integrate
+Publish results simple and easy.
 
+To install the latest version, run:
+
+```sh
+npm install -D testcafe-reporter-qase
 ```
-npm install testcafe testcafe-reporter-qase
-```
+
+## Updating from v1
+
+To update a test project using testcafe-reporter-qaser@v1 to version 2:
+
+1. Update reporter configuration in `qase.config.json` and/or environment variables —
+   see the [configuration reference](#configuration) below.
 
 ## Example of usage
 
@@ -22,7 +29,12 @@ test.meta('CID', [1])('Text typing basics', async (t) => {
   await t;
 });
 
-test.meta({ CID: [2, 3] })(
+const q = qase.id(1)
+  .title('Text typing basics')
+  .field({ 'severity': 'high' })
+  .parameters({ 'browser': 'chrome' })
+  .create();
+test.meta({ ...q })(
   'Click check boxes and then verify their state',
   async (t) => {
     await t;
@@ -60,36 +72,28 @@ https://app.qase.io/run/QASE_PROJECT_CODE
 
 ## Configuration
 
-Qase reporter supports passing parameters using two ways:
-using `.qaserc`/`qase.config.json` file and using ENV variables.
+Qase Testcafe reporter can be configured in multiple ways:
 
-`.qaserc` parameters, (* - required):
+- using a separate config file `qase.config.json`,
+- using environment variables (they override the values from the configuration files).
 
-- `mode` - `testops`/`off` Enables reporter, default - `off`
-- `debug` - Enables debug logging, defaule - `false`
-- `environment` - To execute with the sending of the envinroment information 
-- *`testops.api.token` - Token for API access, you can find more information
-  [here](https://developers.qase.io/#authentication)
-- *`testops.project` - Code of your project (can be extracted from main
-  page of your project: `https://app.qase.io/project/DEMOTR` -
-  `DEMOTR` is project code here)
-- `testops.uploadAttachments` - Permission to send screenshots to Qase TMS
-- `testops.run.id` - Pass Run ID
-- `testops.run.title` - Set custom Run name, when new run is created
-- `testops.run.description` - Set custom Run description, when new run is created
-- `testops.run.complete` - Whether the run should be completed
+For a full list of configuration options, see
+the [Configuration reference](../qase-javascript-commons/README.md#configuration).
 
-Example configuration file:
+Example `qase.config.json` file:
 
 ```json
 {
+  "mode": "testops",
   "debug": true,
-  "environment": 1,
   "testops": {
     "api": {
       "token": "api_key"
     },
-    "project": "project_code"
+    "project": "project_code",
+    "run": {
+      "complete": true
+    }
   }
 }
 ```
@@ -98,7 +102,7 @@ Supported ENV variables:
 
 - `QASE_MODE` - Same as `mode`
 - `QASE_DEBUG` - Same as `debug`
-- `QASE_ENVIRONMENT` - Same as `environment` 
+- `QASE_ENVIRONMENT` - Same as `environment`
 - `QASE_TESTOPS_API_TOKEN` - Same as `testops.api.token`
 - `QASE_TESTOPS_PROJECT` - Same as `testops.project`
 - `QASE_TESTOPS_RUN_ID` - Pass Run ID from ENV and override reporter option `testops.run.id`
@@ -107,7 +111,7 @@ Supported ENV variables:
 
 ## Requirements
 
-We maintain the reporter on LTS versions of Node. You can find the current versions by following the [link](https://nodejs.org/en/about/releases/)
+We maintain the reporter on [LTS versions of Node](https://nodejs.org/en/about/releases/).
 
 `testcafe >= 2.0.0`
 

package/changelog.md

@@ -0,0 +1,31 @@
+# qase-testcafe@2.0.0
+
+## What's new
+
+This is the first release in the 2.x series of the TestCafe reporter.
+It brings a new annotation syntax with test parametrization and field values,
+new and more flexible configs, uploading results in parallel with running tests,
+and other powerful features.
+
+This changelog entry will be updated soon.
+For more information about the new features and a guide for migration from v1, refer to the
+[reporter documentation](https://github.com/qase-tms/qase-javascript/tree/main/qase-testcafe#readme)
+
+# qase-testcafe@2.0.0-beta.2
+
+## What's new
+
+Add new syntax to annotate the following fields: `QaseID`, `QaseTitle`, `QaseFields`, `QaseParameters`:
+
+```diff
++ import { qase } from 'testcafe-reporter-qase/qase';
+- test.meta('CID', '2')('Test name', async t => {...});
++ const q = qase.id(2).title('Test name').fields('field1', 'field2').parameters('param1', 'param2').create();
++ test.meta(q)('Test name', async t => {...});
+```
+
+# qase-testcafe@2.0.0-beta.1
+
+## What's new
+
+First major beta release for the version 2 series of the Qase TestCafe reporter.

package/dist/factory.d.ts

@@ -1,12 +1,12 @@
-import { TestcafeQaseOptionsType, TestcafeQaseReporter } from './reporter';
+import { TestcafeQaseOptionsType, TestRunInfoType } from './reporter';
 /**
  * @param {TestcafeQaseOptionsType} options
- * @returns {object}
+ * @returns
  */
 export declare const factory: (options: TestcafeQaseOptionsType) => {
+    noColors: boolean;
     reportTaskStart: () => void;
     reportFixtureStart: () => void;
-    reportTestDone: (title: string, testRunInfo: import("./reporter").TestRunInfoType, meta: Record<string, string>) => void;
+    reportTestDone: (name: string, testRunInfo: TestRunInfoType, meta: Record<string, string>) => Promise<void>;
     reportTaskDone: () => Promise<void>;
-    reporter: TestcafeQaseReporter;
 };

package/dist/factory.js

@@ -4,20 +4,24 @@ exports.factory = void 0;
 const reporter_1 = require("./reporter");
 /**
  * @param {TestcafeQaseOptionsType} options
- * @returns {object}
+ * @returns
  */
 const factory = (options) => {
     const reporter = new reporter_1.TestcafeQaseReporter(options);
     return {
+        noColors: false,
         reportTaskStart: () => {
-            /* empty */
+            reporter.startTestRun();
         },
         reportFixtureStart: () => {
             /* empty */
         },
-        reportTestDone: reporter.reportTestDone,
-        reportTaskDone: reporter.reportTaskDone,
-        reporter,
+        reportTestDone: async (name, testRunInfo, meta) => {
+            await reporter.reportTestDone(name, testRunInfo, meta);
+        },
+        reportTaskDone: async () => {
+            await reporter.reportTaskDone();
+        },
     };
 };
 exports.factory = factory;

package/dist/qase.d.ts

@@ -0,0 +1,66 @@
+export declare class qase {
+    private static _qaseID;
+    private static _qaseTitle;
+    private static _qaseFields;
+    private static _qaseParameters;
+    /**
+     * Set a Qase ID for the test case
+     * Don't forget to call `create` method after setting all the necessary parameters
+     * @param {number | number[]} value
+     * @example
+     * const q = qase.id(1).create();
+     * test.meta(q)('Test case title', async t => { ... });
+     * or
+     * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+     */
+    static id: (value: number | number[]) => typeof qase;
+    /**
+     * Set a title for the test case
+     * Don't forget to call `create` method after setting all the necessary parameters
+     * @param {string} value
+     * @example
+     * const q = qase.title('Test case title').create();
+     * test.meta(q)('Test case title', async t => { ... });
+     * or
+     * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+     */
+    static title: (value: string) => typeof qase;
+    /**
+     * Set a fields for the test case
+     * Don't forget to call `create` method after setting all the necessary parameters
+     * @param {Record<string, string>} values
+     * @example
+     * const q = qase.fields({ 'severity': 'high', 'priority': 'medium' }).create();
+     * test.meta(q)('Test case title', async t => { ... });
+     * or
+     * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+     */
+    static fields: (values: Record<string, string>) => typeof qase;
+    /**
+     * Set a parameters for the test case
+     * Don't forget to call `create` method after setting all the necessary parameters
+     * @param {Record<string, string>} values
+     * @example
+     * const q = qase.parameters({ 'severity': 'high', 'priority': 'medium' }).create();
+     * test.meta(q)('Test case title', async t => { ... });
+     * or
+     * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+     */
+    static parameters: (values: Record<string, string>) => typeof qase;
+    /**
+     * Create a Qase metadata
+     * Call this method after setting all the necessary parameters
+     * @example
+     * const q = qase.id(1).title('Test case title').fields({ 'severity': 'high', 'priority': 'medium' }).create();
+     * test.meta(q)('Test case title', async t => { ... });
+     * or
+     * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+     */
+    static create: () => {
+        QaseID: string;
+        QaseTitle: string;
+        QaseFields: string;
+        QaseParameters: string;
+    };
+    private static toNormalizeRecord;
+}

package/dist/qase.js

@@ -0,0 +1,98 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qase = void 0;
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+class qase {
+}
+exports.qase = qase;
+_a = qase;
+qase._qaseID = '';
+qase._qaseTitle = '';
+qase._qaseFields = '';
+qase._qaseParameters = '';
+/**
+ * Set a Qase ID for the test case
+ * Don't forget to call `create` method after setting all the necessary parameters
+ * @param {number | number[]} value
+ * @example
+ * const q = qase.id(1).create();
+ * test.meta(q)('Test case title', async t => { ... });
+ * or
+ * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+ */
+qase.id = (value) => {
+    _a._qaseID = Array.isArray(value) ? value.join(',') : String(value);
+    return _a;
+};
+/**
+ * Set a title for the test case
+ * Don't forget to call `create` method after setting all the necessary parameters
+ * @param {string} value
+ * @example
+ * const q = qase.title('Test case title').create();
+ * test.meta(q)('Test case title', async t => { ... });
+ * or
+ * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+ */
+qase.title = (value) => {
+    _a._qaseTitle = value;
+    return _a;
+};
+/**
+ * Set a fields for the test case
+ * Don't forget to call `create` method after setting all the necessary parameters
+ * @param {Record<string, string>} values
+ * @example
+ * const q = qase.fields({ 'severity': 'high', 'priority': 'medium' }).create();
+ * test.meta(q)('Test case title', async t => { ... });
+ * or
+ * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+ */
+qase.fields = (values) => {
+    _a._qaseFields = _a.toNormalizeRecord(values);
+    return _a;
+};
+/**
+ * Set a parameters for the test case
+ * Don't forget to call `create` method after setting all the necessary parameters
+ * @param {Record<string, string>} values
+ * @example
+ * const q = qase.parameters({ 'severity': 'high', 'priority': 'medium' }).create();
+ * test.meta(q)('Test case title', async t => { ... });
+ * or
+ * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+ */
+qase.parameters = (values) => {
+    _a._qaseParameters = _a.toNormalizeRecord(values);
+    return _a;
+};
+/**
+ * Create a Qase metadata
+ * Call this method after setting all the necessary parameters
+ * @example
+ * const q = qase.id(1).title('Test case title').fields({ 'severity': 'high', 'priority': 'medium' }).create();
+ * test.meta(q)('Test case title', async t => { ... });
+ * or
+ * test.meta({userField: 123, ...q})('Test case title', async t => { ... });
+ */
+qase.create = () => {
+    const meta = {
+        QaseID: _a._qaseID,
+        QaseTitle: _a._qaseTitle,
+        QaseFields: _a._qaseFields,
+        QaseParameters: _a._qaseParameters,
+    };
+    _a._qaseID = '';
+    _a._qaseTitle = '';
+    _a._qaseFields = '';
+    _a._qaseParameters = '';
+    return meta;
+};
+qase.toNormalizeRecord = (record) => {
+    const stringRecord = {};
+    for (const [key, value] of Object.entries(record)) {
+        stringRecord[String(key)] = String(value);
+    }
+    return JSON.stringify(stringRecord);
+};

package/dist/reporter.d.ts

@@ -1,12 +1,12 @@
 import { ConfigLoader, ConfigType } from 'qase-javascript-commons';
-type CallsiteRecordType = {
+interface CallsiteRecordType {
     filename?: string;
     lineNum?: number;
     callsiteFrameIdx?: number;
-    stackFrames?: Array<unknown>;
+    stackFrames?: unknown[];
     isV8Frames?: boolean;
-};
-type TestRunErrorFormattableAdapterType = {
+}
+interface TestRunErrorFormattableAdapterType {
     userAgent: string;
     screenshotPath: string;
     testRunId: string;
@@ -17,21 +17,21 @@ type TestRunErrorFormattableAdapterType = {
     errMsg?: string;
     diff?: boolean;
     id?: string;
-};
-type ScreenshotType = {
+}
+interface ScreenshotType {
     screenshotPath: string;
     thumbnailPath: string;
     userAgent: string;
     quarantineAttempt: number;
     takenOnFail: boolean;
-};
-type FixtureType = {
+}
+interface FixtureType {
     id: string;
     name: string;
     path?: string;
     meta: Record<string, unknown>;
-};
-export type TestRunInfoType = {
+}
+export interface TestRunInfoType {
     errs: TestRunErrorFormattableAdapterType[];
     warnings: string[];
     durationMs: number;
@@ -41,18 +41,12 @@ export type TestRunInfoType = {
     quarantine: Record<string, Record<'passed', boolean>>;
     skipped: boolean;
     fixture: FixtureType;
-};
+}
 export type TestcafeQaseOptionsType = ConfigType;
 /**
  * @class TestcafeQaseReporter
  */
 export declare class TestcafeQaseReporter {
-    /**
-     * @param {Record<string, string>} meta
-     * @returns {number[]}
-     * @private
-     */
-    private static getCaseId;
     /**
      * @param {TestRunInfoType} testRunInfo
      * @returns {TestStatusEnum}
@@ -66,8 +60,8 @@ export declare class TestcafeQaseReporter {
      */
     private static transformErrors;
     /**
-     * @param {ScreenshotType[]} attachments
-     * @returns {string[]}
+     * @param {ScreenshotType[]} screenshots
+     * @returns {Attachment[]}
      * @private
      */
     private static transformAttachments;
@@ -81,15 +75,20 @@ export declare class TestcafeQaseReporter {
      * @param {ConfigLoaderInterface} configLoader
      */
     constructor(options: TestcafeQaseOptionsType, configLoader?: ConfigLoader<Partial<ConfigType> & Record<string, unknown>>);
+    /**
+     * @returns {Promise<void>}
+     */
+    startTestRun: () => void;
     /**
      * @param {string} title
      * @param {TestRunInfoType} testRunInfo
      * @param {Record<string, string>} meta
      */
-    reportTestDone: (title: string, testRunInfo: TestRunInfoType, meta: Record<string, string>) => void;
+    reportTestDone: (title: string, testRunInfo: TestRunInfoType, meta: Record<string, string>) => Promise<void>;
     /**
      * @returns {Promise<void>}
      */
     reportTaskDone: () => Promise<void>;
+    private getMeta;
 }
 export {};

package/dist/reporter.js

@@ -3,24 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestcafeQaseReporter = void 0;
 const uuid_1 = require("uuid");
 const qase_javascript_commons_1 = require("qase-javascript-commons");
+var metadataEnum;
+(function (metadataEnum) {
+    metadataEnum["id"] = "QaseID";
+    metadataEnum["title"] = "QaseTitle";
+    metadataEnum["fields"] = "QaseFields";
+    metadataEnum["parameters"] = "QaseParameters";
+    metadataEnum["oldID"] = "CID";
+})(metadataEnum || (metadataEnum = {}));
 /**
  * @class TestcafeQaseReporter
  */
 class TestcafeQaseReporter {
-    /**
-     * @param {Record<string, string>} meta
-     * @returns {number[]}
-     * @private
-     */
-    static getCaseId(meta) {
-        if (!meta['CID']) {
-            return [];
-        }
-        const ids = Array.isArray(meta['CID'])
-            ? meta['CID']
-            : meta['CID'].split(',');
-        return ids.map((id) => Number(id));
-    }
     /**
      * @param {TestRunInfoType} testRunInfo
      * @returns {TestStatusEnum}
@@ -52,32 +46,73 @@ class TestcafeQaseReporter {
         return error;
     }
     /**
-     * @param {ScreenshotType[]} attachments
-     * @returns {string[]}
+     * @param {ScreenshotType[]} screenshots
+     * @returns {Attachment[]}
      * @private
      */
-    static transformAttachments(attachments) {
-        return attachments.map(({ screenshotPath }) => screenshotPath);
+    static transformAttachments(screenshots) {
+        const attachments = [];
+        for (const screenshot of screenshots) {
+            attachments.push({
+                file_name: screenshot.screenshotPath,
+                file_path: screenshot.screenshotPath,
+                mime_type: '',
+                content: '',
+                size: 0,
+                id: (0, uuid_1.v4)(),
+            });
+        }
+        return attachments;
     }
     /**
      * @param {TestcafeQaseOptionsType} options
      * @param {ConfigLoaderInterface} configLoader
      */
     constructor(options, configLoader = new qase_javascript_commons_1.ConfigLoader()) {
+        /**
+         * @returns {Promise<void>}
+         */
+        this.startTestRun = () => {
+            this.reporter.startTestRun();
+        };
         /**
          * @param {string} title
          * @param {TestRunInfoType} testRunInfo
          * @param {Record<string, string>} meta
          */
-        this.reportTestDone = (title, testRunInfo, meta) => {
-            this.reporter.addTestResult({
+        this.reportTestDone = async (title, testRunInfo, meta) => {
+            const error = TestcafeQaseReporter.transformErrors(testRunInfo.errs);
+            const metadata = this.getMeta(meta);
+            await this.reporter.addTestResult({
+                author: null,
+                execution: {
+                    status: TestcafeQaseReporter.getStatus(testRunInfo),
+                    start_time: null,
+                    end_time: null,
+                    duration: testRunInfo.durationMs,
+                    stacktrace: error.stack ?? null,
+                    thread: null,
+                },
+                fields: metadata[metadataEnum.fields],
+                message: error.message,
+                muted: false,
+                params: metadata[metadataEnum.parameters],
+                relations: {
+                    suite: {
+                        data: [
+                            {
+                                title: testRunInfo.fixture.name,
+                                public_id: null,
+                            },
+                        ],
+                    },
+                },
+                run_id: null,
+                signature: `${testRunInfo.fixture.name}::${title}`,
+                steps: [],
                 id: (0, uuid_1.v4)(),
-                testOpsId: TestcafeQaseReporter.getCaseId(meta),
-                title: title,
-                suiteTitle: testRunInfo.fixture.name,
-                status: TestcafeQaseReporter.getStatus(testRunInfo),
-                error: TestcafeQaseReporter.transformErrors(testRunInfo.errs),
-                duration: testRunInfo.durationMs,
+                testops_id: metadata[metadataEnum.id].length > 0 ? metadata[metadataEnum.id] : null,
+                title: metadata[metadataEnum.title] != undefined ? metadata[metadataEnum.title] : title,
                 attachments: TestcafeQaseReporter.transformAttachments(testRunInfo.screenshots),
             });
         };
@@ -88,12 +123,38 @@ class TestcafeQaseReporter {
             await this.reporter.publish();
         };
         const config = configLoader.load();
-        this.reporter = new qase_javascript_commons_1.QaseReporter({
+        this.reporter = qase_javascript_commons_1.QaseReporter.getInstance({
             ...(0, qase_javascript_commons_1.composeOptions)(options, config),
             frameworkPackage: 'testcafe',
             frameworkName: 'testcafe',
             reporterName: 'testcafe-reporter-qase',
         });
     }
+    getMeta(meta) {
+        const metadata = {
+            QaseID: [],
+            QaseTitle: undefined,
+            QaseFields: {},
+            QaseParameters: {},
+        };
+        if (meta[metadataEnum.oldID] !== undefined && meta[metadataEnum.oldID] !== '') {
+            const v = meta[metadataEnum.oldID].split(',');
+            metadata.QaseID = Array.isArray(v) ? v.map(Number) : [Number(v)];
+        }
+        if (meta[metadataEnum.id] !== undefined && meta[metadataEnum.id] !== '') {
+            const v = meta[metadataEnum.id].split(',');
+            metadata.QaseID = Array.isArray(v) ? v.map(Number) : [Number(v)];
+        }
+        if (meta[metadataEnum.title] !== undefined && meta[metadataEnum.title] !== '') {
+            metadata.QaseTitle = meta[metadataEnum.title];
+        }
+        if (meta[metadataEnum.fields] !== undefined && meta[metadataEnum.fields] !== '') {
+            metadata.QaseFields = JSON.parse(meta[metadataEnum.fields]);
+        }
+        if (meta[metadataEnum.parameters] !== undefined && meta[metadataEnum.parameters] !== '') {
+            metadata.QaseParameters = JSON.parse(meta[metadataEnum.parameters]);
+        }
+        return metadata;
+    }
 }
 exports.TestcafeQaseReporter = TestcafeQaseReporter;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "testcafe-reporter-qase",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0",
   "description": "Qase TMS TestCafe Reporter",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": "./dist/index.js",
+    "./qase": "./dist/qase.js",
     "./reporter": "./dist/reporter.js",
     "./package.json": "./package.json"
   },
@@ -36,10 +37,10 @@
     "test": "jest --passWithNoTests",
     "clean": "rm -rf dist"
   },
-  "author": "Parviz Khavari <havaripa@gmail.com>",
+  "author": "Qase Team <support@qase.io>",
   "license": "Apache-2.0",
   "dependencies": {
-    "qase-javascript-commons": "^2.0.0-beta.1",
+    "qase-javascript-commons": "^2.0.9",
     "uuid": "^9.0.0"
   },
   "peerDependencies": {