cypress-qase-reporter 2.0.0-beta.0 → 2.0.0-beta.2

package/README.md

@@ -1,65 +1,64 @@
-> # Qase TMS Cypress reporter
->
-> Publish results simple and easy.
+# Qase TMS Cypress reporter
 
-## How to integrate
+Publish results simple and easy.
+
+## How to install
 
 ```
-npm install cypress-qase-reporter
+npm install -D cypress-qase-reporter@beta
 ```
 
-## Example of usage
+## Getting started
+
+The Cypress reporter can auto-generate test cases
+and suites from your test data.
+Test results of subsequent test runs will match the same test cases
+as long as their names and file paths don't change.
 
-If you want to decorate come test with Qase Case ID you could use qase function:
+You can also annotate the tests with the IDs of existing test cases
+from Qase.io before executing tests. It's a more reliable way to bind
+autotests to test cases, that persists when you rename, move, or
+parameterize your tests.
+
+For example:
 
 ```typescript
-import { qase } from 'cypress-qase-reporter';
+import { qase } from 'cypress-qase-reporter/mocha';
 
 describe('My First Test', () => {
-    qase([1,2],
-        it('Several ids', () => {
+  qase(1,
+          it('Several ids', () => {
             expect(true).to.equal(true);
-        })
-    );
-    qase(3,
-        it('Correct test', () => {
+          })
+  );
+  // a test can check multiple test cases
+  qase([2, 3],
+          it('Correct test', () => {
             expect(true).to.equal(true);
-        })
-    );
-    qase(4,
-        it.skip('Skipped test', () => {
+          })
+  );
+  qase(4,
+          it.skip('Skipped test', () => {
             expect(true).to.equal(true);
-        })
-    );
-    qase(5,
-        it('Failed test', () => {
-            expect(true).to.equal(false);
-        })
-    );
+          })
+  );
 });
-
-```
-If you are going to use several specifications for execution and you have in config 
-```json
-"testops": {
-  "run": {
-    "complete": true
-  }
-}
-```
-then it is necessary to additionally set in the project settings
-```
-Allow to add results for cases in closed runs.
 ```
 
-To run tests and create a test run, execute the command (for example from folder examples):
+To execute Cypress tests and report them to Qase.io, run the command:
+
 ```bash
 QASE_MODE=testops npx cypress run
 ```
+
 or
+
 ```bash
 npm test
 ```
+
+You can try it with the example project at [`examples/cypress`](../examples/cypress/).
+
 <p align="center">
   <img width="65%" src="./screenshots/screenshot.png">
 </p>
@@ -72,39 +71,65 @@ https://app.qase.io/run/QASE_PROJECT_CODE
 
 ## Configuration
 
-Reporter options (* - required):
-
-- `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
-- `framework.cypress.screenshotFolder` - Folder for save screenshot cypress
-
-#### You can check example configuration with multiple reporters in [demo project](../examples/cypress/cypress.config.js).
-
-Supported ENV variables:
-
-- `QASE_MODE` - Same as `mode`
-- `QASE_DEBUG` - Same as `debug`
-- `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`
-- `QASE_TESTOPS_RUN_TITLE` - Same as `testops.run.title`
-- `QASE_TESTOPS_RUN_DESCRIPTION` - Same as `testops.run.description`
+Qase Cypress reporter can be configured in multiple ways:
+- by adding configuration block in `cypress.config.js`,
+- using a separate config file `qase.config.json`,
+- using environment variables (they override the values from the configuration files).
+
+For a full list of configuration options, see the [Configuration reference](../qase-javascript-commons/README.md#configuration).
+
+Example `cypress.config.js` config:
+
+```js
+import cypress from 'cypress';
+
+import plugins from './cypress/plugins/index.js';
+
+module.exports = cypress.defineConfig({
+  reporter: 'cypress-multi-reporters',
+  reporterOptions: {
+    reporterEnabled: 'cypress-mochawesome-reporter, cypress-qase-reporter',
+    cypressMochawesomeReporterReporterOptions: {
+      charts: true,
+    },
+    cypressQaseReporterReporterOptions: {
+      debug: true,
+
+      testops: {
+        api: {
+          token: 'api_key',
+        },
+
+        project: 'project_code',
+        uploadAttachments: true,
+
+        run: {
+          complete: true,
+        },
+      },
+
+      framework: {
+        cypress: {
+          screenshotsFolder: 'cypress/screenshots',
+        }
+      }
+    },
+  },
+  video: false,
+  e2e: {
+    setupNodeEvents(on, config) {
+      return plugins(on, config);
+    },
+  },
+});
+```
+
+Check out the example of configuration for multiple reporters in the
+[demo project](../examples/cypress/cypress.config.js).
 
 ## 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/).
 
 `cypress >= 8.0.0`
 

package/dist/configSchema.d.ts

@@ -0,0 +1,4 @@
+import { JSONSchemaType } from 'ajv';
+import { FrameworkOptionsType } from 'qase-javascript-commons';
+import { ReporterOptionsType } from './options';
+export declare const configSchema: JSONSchemaType<FrameworkOptionsType<'cypress', ReporterOptionsType>>;

package/dist/configSchema.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = void 0;
+exports.configSchema = {
+    type: 'object',
+    nullable: true,
+    properties: {
+        framework: {
+            type: 'object',
+            nullable: true,
+            properties: {
+                cypress: {
+                    type: 'object',
+                    nullable: true,
+                    properties: {
+                        screenshotsFolder: {
+                            type: 'string',
+                            nullable: true,
+                        }
+                    }
+                }
+            }
+        }
+    }
+};

package/dist/index.cjs.d.ts

@@ -0,0 +1 @@
+export { qase } from './mocha';

package/dist/index.cjs.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qase = void 0;
+var mocha_1 = require("./mocha");
+Object.defineProperty(exports, "qase", { enumerable: true, get: function () { return mocha_1.qase; } });

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { CypressQaseReporter } from './reporter';
+export = CypressQaseReporter;

package/dist/index.js

@@ -0,0 +1,3 @@
+"use strict";
+const reporter_1 = require("./reporter");
+module.exports = reporter_1.CypressQaseReporter;

package/dist/mocha.d.ts

@@ -0,0 +1,2 @@
+import { Test } from 'mocha';
+export declare const qase: (caseId: number | string | number[] | string[], test: Test) => Test;

package/dist/mocha.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.qase = void 0;
+const qase = (caseId, test) => {
+    const caseIds = Array.isArray(caseId) ? caseId : [caseId];
+    test.title = `${test.title} (Qase ID: ${caseIds.join(',')})`;
+    return test;
+};
+exports.qase = qase;

package/dist/options.d.ts

@@ -0,0 +1,3 @@
+export type ReporterOptionsType = {
+    screenshotsFolder?: string;
+};

package/dist/options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/reporter.d.ts

@@ -0,0 +1,65 @@
+import { MochaOptions, reporters, Runner } from 'mocha';
+import { ConfigLoader, TestStatusEnum } from 'qase-javascript-commons';
+import { ReporterOptionsType } from './options';
+type CypressState = 'failed' | 'passed' | 'pending';
+export type CypressQaseOptionsType = Omit<MochaOptions, 'reporterOptions'> & {
+    reporterOptions: ReporterOptionsType;
+};
+/**
+ * @class CypressQaseReporter
+ * @extends reporters.Base
+ */
+export declare class CypressQaseReporter extends reporters.Base {
+    /**
+     * @type {RegExp}
+     */
+    static qaseIdRegExp: RegExp;
+    /**
+     * @type {Record<CypressState, TestStatusEnum>}
+     */
+    static statusMap: Record<CypressState, TestStatusEnum>;
+    /**
+     * @param {string} title
+     * @returns {number[]}
+     * @private
+     */
+    private static getCaseId;
+    /**
+     * @param {number[]} ids
+     * @param {string} dir
+     * @returns {Attachment[]}
+     * @private
+     */
+    private static findAttachments;
+    /**
+     * @type {string | undefined}
+     * @private
+     */
+    private screenshotsFolder;
+    /**
+     * @type {ReporterInterface}
+     * @private
+     */
+    private reporter;
+    /**
+     * @param {Runner} runner
+     * @param {CypressQaseOptionsType} options
+     * @param {ConfigLoaderInterface} configLoader
+     */
+    constructor(runner: Runner, options: CypressQaseOptionsType, configLoader?: ConfigLoader<import("qase-javascript-commons").FrameworkOptionsType<"cypress", ReporterOptionsType>>);
+    /**
+     * @param {Runner} runner
+     * @private
+     */
+    private addRunnerListeners;
+    /**
+     * @param {Test} test
+     * @private
+     */
+    private addTestResult;
+    /**
+     * @private
+     */
+    private preventExit;
+}
+export {};

package/dist/reporter.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CypressQaseReporter = void 0;
+const path_1 = __importDefault(require("path"));
+const uuid_1 = require("uuid");
+const mocha_1 = require("mocha");
+const qase_javascript_commons_1 = require("qase-javascript-commons");
+const traverse_dir_1 = require("./utils/traverse-dir");
+const configSchema_1 = require("./configSchema");
+const { EVENT_TEST_FAIL, EVENT_TEST_PASS, EVENT_TEST_PENDING, EVENT_RUN_END, EVENT_RUN_BEGIN, } = mocha_1.Runner.constants;
+/**
+ * @class CypressQaseReporter
+ * @extends reporters.Base
+ */
+class CypressQaseReporter extends mocha_1.reporters.Base {
+    /**
+     * @param {string} title
+     * @returns {number[]}
+     * @private
+     */
+    static getCaseId(title) {
+        const [, ids] = title.match(CypressQaseReporter.qaseIdRegExp) ?? [];
+        return ids ? ids.split(',').map((id) => Number(id)) : [];
+    }
+    /**
+     * @param {number[]} ids
+     * @param {string} dir
+     * @returns {Attachment[]}
+     * @private
+     */
+    static findAttachments(ids, dir) {
+        const idSet = new Set(ids);
+        const attachments = [];
+        try {
+            (0, traverse_dir_1.traverseDir)(path_1.default.join(process.cwd(), dir), (filePath) => {
+                if (CypressQaseReporter.getCaseId(filePath).some((item) => idSet.has(item))) {
+                    attachments.push({
+                        content: '',
+                        id: (0, uuid_1.v4)(),
+                        mime_type: '', size: 0,
+                        file_name: path_1.default.basename(filePath),
+                        file_path: filePath,
+                    });
+                }
+            });
+        }
+        catch (error) { /* ignore */
+        }
+        return attachments;
+    }
+    /**
+     * @param {Runner} runner
+     * @param {CypressQaseOptionsType} options
+     * @param {ConfigLoaderInterface} configLoader
+     */
+    constructor(runner, options, configLoader = new qase_javascript_commons_1.ConfigLoader(configSchema_1.configSchema)) {
+        super(runner, options);
+        const { reporterOptions } = options;
+        const config = configLoader.load();
+        const { framework, ...composedOptions } = (0, qase_javascript_commons_1.composeOptions)(reporterOptions, config);
+        this.screenshotsFolder = framework?.cypress?.screenshotsFolder;
+        this.reporter = new qase_javascript_commons_1.QaseReporter({
+            ...composedOptions,
+            frameworkPackage: 'cypress',
+            frameworkName: 'cypress',
+            reporterName: 'cypress-qase-reporter',
+        });
+        this.addRunnerListeners(runner);
+    }
+    /**
+     * @param {Runner} runner
+     * @private
+     */
+    addRunnerListeners(runner) {
+        runner.on(EVENT_TEST_PASS, (test) => this.addTestResult(test));
+        runner.on(EVENT_TEST_PENDING, (test) => this.addTestResult(test));
+        runner.on(EVENT_TEST_FAIL, (test) => this.addTestResult(test));
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        runner.on(EVENT_RUN_BEGIN, () => this.reporter.startTestRun());
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        runner.once(EVENT_RUN_END, async () => {
+            this.preventExit();
+            await this.reporter.publish();
+            if (process.exitCode !== undefined) {
+                process.exit(process.exitCode);
+            }
+        });
+    }
+    /**
+     * @param {Test} test
+     * @private
+     */
+    addTestResult(test) {
+        const ids = CypressQaseReporter.getCaseId(test.title);
+        const attachments = this.screenshotsFolder
+            ? CypressQaseReporter.findAttachments(ids, this.screenshotsFolder)
+            : undefined;
+        const result = {
+            attachments: attachments ?? [],
+            author: null,
+            fields: {},
+            message: test.err?.message ?? null,
+            muted: false,
+            params: {},
+            relations: {},
+            run_id: null,
+            signature: '',
+            steps: [],
+            id: test.id,
+            execution: {
+                status: test.state
+                    ? CypressQaseReporter.statusMap[test.state]
+                    : qase_javascript_commons_1.TestStatusEnum.invalid,
+                start_time: null,
+                end_time: null,
+                duration: test.duration ?? 0,
+                stacktrace: test.err?.stack ?? null,
+                thread: null,
+            },
+            testops_id: ids.length > 0 ? ids : null,
+            title: test.title,
+            // suiteTitle: test.parent?.titlePath(),
+        };
+        void this.reporter.addTestResult(result);
+    }
+    /**
+     * @private
+     */
+    preventExit() {
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const _exit = process.exit;
+        const mutableProcess = process;
+        mutableProcess.exit = (code) => {
+            process.exitCode = code || 0;
+            process.exit = _exit;
+        };
+    }
+}
+exports.CypressQaseReporter = CypressQaseReporter;
+/**
+ * @type {RegExp}
+ */
+CypressQaseReporter.qaseIdRegExp = /\(Qase ID:? ([\d,]+)\)/;
+/**
+ * @type {Record<CypressState, TestStatusEnum>}
+ */
+CypressQaseReporter.statusMap = {
+    failed: qase_javascript_commons_1.TestStatusEnum.failed,
+    passed: qase_javascript_commons_1.TestStatusEnum.passed,
+    pending: qase_javascript_commons_1.TestStatusEnum.blocked,
+};

package/dist/utils/traverse-dir.d.ts

@@ -0,0 +1 @@
+export declare const traverseDir: (dirPath: string, callback: (filePath: string) => void) => void;

package/dist/utils/traverse-dir.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseDir = void 0;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+// TODO: get rid of recursion
+const traverseDir = (dirPath, callback) => {
+    const items = (0, fs_1.readdirSync)(dirPath, { withFileTypes: true });
+    items.forEach((item) => {
+        const itemPath = path_1.default.join(dirPath, item.name);
+        if (item.isFile()) {
+            callback(itemPath);
+        }
+        else if (item.isDirectory()) {
+            try {
+                (0, exports.traverseDir)(itemPath, callback);
+            }
+            catch (error) { /* ignore */ }
+        }
+    });
+};
+exports.traverseDir = traverseDir;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cypress-qase-reporter",
-  "version": "2.0.0-beta.0",
+  "version": "2.0.0-beta.2",
   "description": "Qase Cypress Reporter",
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "sideEffects": false,
@@ -44,7 +44,8 @@
   "author": "Nikita Fedorov <nik333r@gmail.com>",
   "license": "Apache-2.0",
   "dependencies": {
-    "qase-javascript-commons": "^2.0.0-beta.0"
+    "qase-javascript-commons": "^2.0.0-beta.8",
+    "uuid": "^9.0.1"
   },
   "peerDependencies": {
     "cypress": ">=8.0.0"