or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

index.md

tile.json

tessl/npm-cypress-multi-reporters

Generate multiple mocha reports in a single mocha execution.

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:npm/cypress-multi-reporters@1.6.x

To install, run

npx @tessl/cli install tessl/npm-cypress-multi-reporters@1.6.0

Cypress Multi Reporters

Cypress Multi Reporters enables generating multiple Mocha test reports simultaneously in a single test execution. It supports various output formats including spec, JSON, TAP, xUnit, and JUnit reports through a configurable system that allows users to specify which reporters to enable and their individual options.

Package Information

Package Name: cypress-multi-reporters
Package Type: npm
Language: JavaScript
Installation: npm install cypress-multi-reporters --save-dev

Core Imports

const MultiReporters = require('cypress-multi-reporters');

For ES6/TypeScript:

import MultiReporters from 'cypress-multi-reporters';

Basic Usage

Command Line Usage

# Basic usage with default configuration
./node_modules/.bin/mocha --reporter cypress-multi-reporters

# With custom configuration file
./node_modules/.bin/mocha --reporter cypress-multi-reporters --reporter-options configFile=config.json

Programmatic Usage

const Mocha = require('mocha');

const mocha = new Mocha({
  reporter: 'cypress-multi-reporters',
  reporterOptions: {
    reporterEnabled: 'spec, json',
    jsonReporterOptions: {
      output: 'test-results.json'
    }
  }
});

mocha.addFile('./test/sample.test.js');
mocha.run();

Architecture

Cypress Multi Reporters is built around several key components:

MultiReporters Class: Main reporter class that coordinates multiple Mocha reporters
Configuration System: Flexible configuration via JSON/JavaScript files or direct options
Reporter Discovery: Automatic loading of built-in Mocha reporters, external npm packages, and local files
Dynamic Output: Template-based file naming with variable substitution
Completion Coordination: Manages the completion lifecycle across multiple reporters

Capabilities

Multi-Reporter Coordination

The core functionality that enables multiple Mocha reporters to run simultaneously.

/**
 * Main MultiReporters class constructor
 * @param {Object} runner - Mocha test runner instance
 * @param {Object} options - Configuration options
 */
function MultiReporters(runner, options);

Configuration Management

Handles loading and merging configuration from multiple sources.

/**
 * Get merged configuration options
 * @param {Object} options - Raw options object
 * @returns {Object} Merged configuration options
 */
MultiReporters.prototype.getOptions = function(options);

/**
 * Load custom configuration from file or reporterOptions
 * @param {Object} options - Options containing configFile or direct reporterOptions
 * @returns {Object} Custom configuration object
 */
MultiReporters.prototype.getCustomOptions = function(options);

/**
 * Load default configuration from CONFIG_FILE
 * @returns {Object} Default configuration object
 */
MultiReporters.prototype.getDefaultOptions = function();

/**
 * Resolve configuration for individual reporters
 * @param {Object} options - Global options object
 * @param {string} name - Reporter name
 * @returns {Object} Reporter-specific configuration object
 */
MultiReporters.prototype.getReporterOptions = function(options, name);

Completion Handling

Coordinates completion across all registered reporters.

/**
 * Handle completion when all reporters finish
 * @param {number} failures - Number of test failures
 * @param {Function} fn - Callback function to execute when all reporters complete
 */
MultiReporters.prototype.done = function(failures, fn);

Static Properties

/**
 * Default configuration file path
 * @type {string}
 */
MultiReporters.CONFIG_FILE = '../config.json';

Configuration Schema

Basic Configuration Structure

interface Configuration {
  /** Comma-delimited list of reporters to enable */
  reporterEnabled: string | string[];
  /** Common options shared across all reporters */
  reporterOptions?: ReporterOptions;
  /** Dynamic output configuration for templating */
  cmrOutput?: string | string[][];
  /** Reporter-specific options using camelCase naming */
  [reporterName + 'ReporterOptions']?: ReporterOptions;
}

interface ReporterOptions {
  /** Reporter identifier */
  id?: string;
  /** Output file path */
  output?: string;
  /** Custom options specific to the reporter */
  [key: string]: any;
}

Configuration Sources

Configuration can be provided through multiple sources (in order of precedence):

Direct reporterOptions: Passed directly to Mocha constructor
Configuration File: JSON or JavaScript file specified via configFile option
Default Configuration: Built-in config.json file

// Example: JSON configuration file
{
  "reporterEnabled": "spec, xunit, json",
  "reporterOptions": {
    "id": "default"
  },
  "xunitReporterOptions": {
    "output": "test-results.xml"
  },
  "jsonReporterOptions": {
    "output": "test-results.json"
  }
}

// Example: JavaScript configuration file
module.exports = {
  reporterEnabled: "mochawesome, mocha-junit-reporter",
  mochawesomeReporterOptions: {
    reportDir: `.reports/${process.env.SITE_LOCALE}`
  },
  mochaJunitReporterReporterOptions: {
    mochaFile: `./junit/${process.env.SITE_LOCALE}/[hash].xml`
  }
};

Dynamic Output Configuration (cmrOutput)

The cmrOutput option enables dynamic file naming using template substitution:

# Command line usage
mocha --reporter cypress-multi-reporters --reporterOptions configFile=config.json,cmrOutput=json+output+specialID

// Configuration with template
{
  "jsonReporterOptions": {
    "output": "results/test-{id}.json"
  }
}
// Results in: results/test-specialID.json

Reporter Name Conversion

Reporter names are converted to camelCase for configuration keys:

@my-org/custom → myOrgCustomReporterOptions
mocha-junit-reporter → mochaJunitReporterReporterOptions
xunit → xunitReporterOptions

Supported Reporters

Built-in Mocha Reporters

spec - Hierarchical view of test results
json - JSON format output
tap - Test Anything Protocol format
xunit - xUnit XML format
dot - Dot matrix output

External Reporters

Any npm package (e.g., mocha-junit-reporter, mochawesome)
Local file paths (absolute or relative)
Scoped packages (e.g., @org/reporter)

Usage Examples

Multiple Built-in Reporters

// Configuration
{
  "reporterEnabled": "spec, json, tap",
  "jsonReporterOptions": {
    "output": "test-results.json"
  }
}

External Reporter with Custom Options

{
  "reporterEnabled": "mocha-junit-reporter",
  "mochaJunitReporterReporterOptions": {
    "mochaFile": "junit-results.xml",
    "properties": {
      "CI": "true"
    }
  }
}

Dynamic Multi-Environment Configuration

// Environment-specific configuration
const locale = process.env.SITE_LOCALE || 'US';

module.exports = {
  reporterEnabled: "mochawesome, mocha-junit-reporter",
  mochawesomeReporterOptions: {
    reportDir: `.reports/${locale}`,
    reportFilename: `test-results-${locale}`
  },
  mochaJunitReporterReporterOptions: {
    mochaFile: `./junit/${locale}/results.xml`
  }
};

Error Handling

The package gracefully handles various error conditions:

Missing Reporters: Logs warning and continues with available reporters
Configuration Errors: Throws exceptions for invalid JSON/JS configuration files
Reporter Initialization Failures: Logs error details and continues
No Reporters Available: Logs error when no reporters can be registered

Integration with Test Runners

Cypress Integration

// cypress.config.js
module.exports = {
  e2e: {
    setupNodeEvents(on, config) {
      return require('./cypress/plugins/index.js')(on, config);
    },
  },
  reporter: 'cypress-multi-reporters',
  reporterOptions: {
    configFile: 'reporter-config.json'
  }
};

Programmatic Mocha Integration

const Mocha = require('mocha');

const mocha = new Mocha({
  reporter: 'cypress-multi-reporters',
  timeout: 60000,
  reporterOptions: {
    reporterEnabled: 'spec, json, mocha-junit-reporter',
    jsonReporterOptions: {
      output: 'test-results.json'
    },
    mochaJunitReporterReporterOptions: {
      mochaFile: 'junit-results.xml'
    }
  }
});

mocha.addFile('./test/suite.test.js');
mocha.run((failures) => {
  process.exitCode = failures ? 1 : 0;
});