mocha-qase-reporter 1.1.4 → 1.1.5

package/README.md

@@ -94,6 +94,23 @@ After the tests are finished, you can complete the run:
 qasectl testops run complete --project DEMO --token token --id $(echo $QASE_TESTOPS_RUN_ID)
 ```
 
+### Extra Reporters
+
+The reporter supports additional reporters alongside the main Qase reporter. This allows you to use multiple output formats (e.g., console output and JSON reports) without the hanging issues that can occur with `mocha-multi-reporters` in parallel mode.
+
+```bash
+# Single extra reporter
+QASE_MODE=testops mocha --reporter mocha-qase-reporter --reporter-options extraReporters=spec
+
+# Multiple extra reporters
+QASE_MODE=testops mocha --reporter mocha-qase-reporter --reporter-options extraReporters=spec,json
+
+# With parallel execution
+QASE_MODE=testops mocha --reporter mocha-qase-reporter --reporter-options extraReporters=spec --parallel
+```
+
+For detailed configuration options and examples, see the [Extra Reporters section](docs/usage.md#using-extra-reporters) in the usage guide.
+
 ## Configuration
 
 Qase Mocha reporter can be configured in multiple ways:

package/changelog.md

@@ -1,3 +1,9 @@
+# qase-mocha@1.1.5
+
+## What's new
+
+- Added support for extra reporters in the reporter. You can find more information in the [usage guide](docs/usage.md#using-extra-reporters).
+
 # qase-mocha@1.1.4
 
 ## What's new

package/dist/extraReporters.d.ts

@@ -0,0 +1,27 @@
+import type * as Mocha from 'mocha';
+export interface ExtraReporterConfig {
+    name: string;
+    options?: Record<string, unknown>;
+}
+export type ExtraReportersConfig = string | ExtraReporterConfig | (string | ExtraReporterConfig)[];
+/**
+ * Parses extraReporters configuration from Mocha options
+ * Supports both string format and object format
+ */
+export declare function parseExtraReporters(options: Mocha.MochaOptions): ExtraReportersConfig | undefined;
+/**
+ * Creates and configures additional reporters based on extraReporters config
+ */
+export declare function createExtraReporters(runner: Mocha.Runner, options: Mocha.MochaOptions, extraReportersConfig: ExtraReportersConfig): Mocha.reporters.Base[];
+/**
+ * Checks if a reporter is compatible with parallel mode
+ * Some reporters are known to be incompatible with parallel execution
+ */
+export declare function isReporterCompatibleWithParallel(reporterName: string): boolean;
+/**
+ * Validates extraReporters configuration for parallel mode
+ */
+export declare function validateExtraReportersForParallel(extraReportersConfig: ExtraReportersConfig): {
+    valid: boolean;
+    incompatibleReporters: string[];
+};

package/dist/extraReporters.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseExtraReporters = parseExtraReporters;
+exports.createExtraReporters = createExtraReporters;
+exports.isReporterCompatibleWithParallel = isReporterCompatibleWithParallel;
+exports.validateExtraReportersForParallel = validateExtraReportersForParallel;
+/**
+ * Parses extraReporters configuration from Mocha options
+ * Supports both string format and object format
+ */
+function parseExtraReporters(options) {
+    const reporterOptions = options.reporterOptions;
+    if (!reporterOptions) {
+        return undefined;
+    }
+    // Handle different formats of extraReporters
+    if (typeof reporterOptions['extraReporters'] === 'string') {
+        return reporterOptions['extraReporters'];
+    }
+    if (Array.isArray(reporterOptions['extraReporters'])) {
+        return reporterOptions['extraReporters'];
+    }
+    if (typeof reporterOptions['extraReporters'] === 'object' && reporterOptions['extraReporters'] !== null) {
+        return reporterOptions['extraReporters'];
+    }
+    return undefined;
+}
+/**
+ * Creates and configures additional reporters based on extraReporters config
+ */
+function createExtraReporters(runner, options, extraReportersConfig) {
+    const reporters = [];
+    if (!extraReportersConfig) {
+        return reporters;
+    }
+    const configs = Array.isArray(extraReportersConfig) ? extraReportersConfig : [extraReportersConfig];
+    for (const config of configs) {
+        try {
+            let reporterName;
+            let reporterOptions = {};
+            if (typeof config === 'string') {
+                reporterName = config;
+            }
+            else if (typeof config === 'object' && config.name) {
+                reporterName = config.name;
+                reporterOptions = config.options ?? {};
+            }
+            else {
+                console.warn('Invalid extraReporter configuration:', config);
+                continue;
+            }
+            // Load the reporter
+            let ReporterClass;
+            try {
+                // Try to load built-in reporter first
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                ReporterClass = require(`mocha/lib/reporters/${reporterName}`);
+            }
+            catch {
+                try {
+                    // Try to load as external package
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    ReporterClass = require(reporterName);
+                }
+                catch {
+                    console.warn(`Failed to load reporter: ${reporterName}`);
+                    continue;
+                }
+            }
+            if (ReporterClass && typeof ReporterClass === 'function') {
+                // Create reporter instance with options
+                const reporterOptionsForMocha = { ...options, ...reporterOptions };
+                const reporter = new ReporterClass(runner, reporterOptionsForMocha);
+                reporters.push(reporter);
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to create reporter:`, error);
+        }
+    }
+    return reporters;
+}
+/**
+ * Checks if a reporter is compatible with parallel mode
+ * Some reporters are known to be incompatible with parallel execution
+ */
+function isReporterCompatibleWithParallel(reporterName) {
+    const incompatibleReporters = [
+        'markdown',
+        'progress',
+        'json-stream',
+        'mocha-multi-reporters', // This is the main culprit
+        'mocha-jenkins-reporter',
+        'mocha-junit-reporter'
+    ];
+    return !incompatibleReporters.includes(reporterName);
+}
+/**
+ * Validates extraReporters configuration for parallel mode
+ */
+function validateExtraReportersForParallel(extraReportersConfig) {
+    const incompatibleReporters = [];
+    if (!extraReportersConfig) {
+        return { valid: true, incompatibleReporters: [] };
+    }
+    const configs = Array.isArray(extraReportersConfig) ? extraReportersConfig : [extraReportersConfig];
+    for (const config of configs) {
+        let reporterName;
+        if (typeof config === 'string') {
+            reporterName = config;
+        }
+        else if (typeof config === 'object' && config.name) {
+            reporterName = config.name;
+        }
+        else {
+            continue;
+        }
+        if (!isReporterCompatibleWithParallel(reporterName)) {
+            incompatibleReporters.push(reporterName);
+        }
+    }
+    return {
+        valid: incompatibleReporters.length === 0,
+        incompatibleReporters
+    };
+}

package/dist/interceptor.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { Writable } from 'stream';
 export interface TestOutput {
     stdout: string;

package/dist/reporter.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { MochaOptions, reporters, Runner } from 'mocha';
 import { ConfigLoader, TestStatusEnum } from 'qase-javascript-commons';
 type MochaState = 'failed' | 'passed' | 'pending';

package/dist/reporter.js

@@ -11,6 +11,7 @@ const deasync_promise_1 = __importDefault(require("deasync-promise"));
 const node_path_1 = require("node:path");
 const uuid_1 = require("uuid");
 const interceptor_1 = require("./interceptor");
+const extraReporters_1 = require("./extraReporters");
 const Events = mocha_1.Runner.constants;
 class currentTest {
     steps = [];
@@ -23,6 +24,7 @@ class MochaQaseReporter extends mocha_1.reporters.Base {
     originalStdoutWrite;
     originalStderrWrite;
     testOutputs;
+    // readonly #extraReporters: reporters.Base[] = [];
     /**
      * @type {Record<CypressState, TestStatusEnum>}
      */
@@ -47,12 +49,30 @@ class MochaQaseReporter extends mocha_1.reporters.Base {
     constructor(runner, options, configLoader = new qase_javascript_commons_1.ConfigLoader()) {
         super(runner, options);
         const config = configLoader.load();
+        // Parse and validate extraReporters configuration
+        const extraReportersConfig = (0, extraReporters_1.parseExtraReporters)(options);
         this.reporter = qase_javascript_commons_1.QaseReporter.getInstance({
             ...(0, qase_javascript_commons_1.composeOptions)(options, config),
             frameworkPackage: 'mocha',
             frameworkName: 'mocha',
             reporterName: 'mocha-qase-reporter',
         });
+        // Create extra reporters in both modes, but validate compatibility for parallel mode
+        if (extraReportersConfig) {
+            if (options.parallel) {
+                const validation = (0, extraReporters_1.validateExtraReportersForParallel)(extraReportersConfig);
+                if (validation.valid) {
+                    (0, extraReporters_1.createExtraReporters)(runner, options, extraReportersConfig);
+                }
+                else {
+                    console.warn(`Warning: The following reporters are incompatible with parallel mode: ${validation.incompatibleReporters.join(', ')}. ` +
+                        'They will be ignored in parallel mode to prevent hanging issues.');
+                }
+            }
+            else {
+                (0, extraReporters_1.createExtraReporters)(runner, options, extraReportersConfig);
+            }
+        }
         if (options.parallel) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             options.require = [...(options.require ?? []), resolveParallelModeSetupFile()];

package/dist/types.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="mocha" />
-/// <reference types="node" />
 import { Attachment } from 'qase-javascript-commons';
 declare module 'mocha' {
     interface Context extends Methods {

package/docs/usage.md

@@ -271,6 +271,94 @@ describe('User Authentication', function() {
 
 ---
 
+## Using Extra Reporters
+
+The Qase reporter supports additional reporters alongside the main Qase reporter. This is useful when you need multiple output formats (e.g., console output and JSON reports) without using `mocha-multi-reporters`, which can cause hanging issues in parallel mode.
+
+### Configuration
+
+You can configure extra reporters using the `extraReporters` option in the reporter options:
+
+#### Command Line
+
+```bash
+# Single extra reporter
+QASE_MODE=testops mocha --reporter mocha-qase-reporter --reporter-options extraReporters=spec
+
+# Multiple extra reporters
+QASE_MODE=testops mocha --reporter mocha-qase-reporter --reporter-options extraReporters=spec,json
+
+# With parallel execution
+QASE_MODE=testops mocha --reporter mocha-qase-reporter --reporter-options extraReporters=spec --parallel
+```
+
+#### Configuration File
+
+```json
+{
+  "reporter": "mocha-qase-reporter",
+  "reporterOptions": {
+    "extraReporters": "spec"
+  }
+}
+```
+
+#### Multiple Reporters
+
+```json
+{
+  "reporter": "mocha-qase-reporter",
+  "reporterOptions": {
+    "extraReporters": ["spec", "json"]
+  }
+}
+```
+
+#### Reporters with Options
+
+```json
+{
+  "reporter": "mocha-qase-reporter",
+  "reporterOptions": {
+    "extraReporters": [
+      "spec",
+      {
+        "name": "json",
+        "options": {
+          "output": "results.json"
+        }
+      }
+    ]
+  }
+}
+```
+
+### Parallel Mode Compatibility
+
+Some reporters are incompatible with parallel mode and will be automatically filtered out with a warning:
+
+- `markdown`
+- `progress`
+- `json-stream`
+- `mocha-multi-reporters`
+- `mocha-jenkins-reporter`
+- `mocha-junit-reporter`
+
+### Example Usage
+
+```bash
+# Basic usage with spec reporter
+npm run test:extra
+
+# Parallel execution with spec reporter
+npm run test:extra-parallel
+
+# Multiple reporters
+QASE_MODE=testops mocha --reporter mocha-qase-reporter --reporter-options extraReporters=spec,json --parallel
+```
+
+---
+
 ### Parallel Execution
 
 The reporter supports parallel execution of tests. First, create a new run in Qase.io using the Qase CLI:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocha-qase-reporter",
-  "version": "1.1.4",
+  "version": "1.1.5",
   "description": "Mocha Cypress Reporter",
   "homepage": "https://github.com/qase-tms/qase-javascript",
   "sideEffects": false,
@@ -43,7 +43,7 @@
   "dependencies": {
     "mocha": "^11.0.0",
     "deasync-promise": "^1.0.1",
-    "qase-javascript-commons": "~2.4.4",
+    "qase-javascript-commons": "~2.4.8",
     "uuid": "^9.0.1"
   },
   "devDependencies": {