• Version 6.2.4
  • Published
  • 7.18 kB
  • 1 dependency
  • MIT license


npm i @types/mochawesome
yarn add @types/mochawesome
pnpm add @types/mochawesome


TypeScript definitions for mochawesome



class Mochawesome

class Mochawesome {}
  • This class is used to create a new Mochawesome reporter instance to be used with mochawesome-report-generator to generate visual reports based off of Mocha test data.


constructor(runner: Mocha.Runner, options?: Mochawesome.Options);
  • Initialize a new reporter.


property config

config: Mochawesome.Config;
  • The parsed configuration options for this Mochawesome instance.

property done

done: Mochawesome.Done;

    property output

    output?: Mochawesome.Output;
    • Information related to the results of the test suite ran by the supplied Mocha.Runner instance. Will be populated after the suite is run.


    interface Config

    interface Config {}

      property code

      code: boolean;

        property consoleReporter

        consoleReporter: string;

          property quiet

          quiet: boolean;

            property reportFilename

            reportFilename: string;

              property saveHtml

              saveHtml: boolean;

                property saveJson

                saveJson: boolean;

                  property useInlineDiffs

                  useInlineDiffs: boolean;

                    interface Options

                    interface Options {}

                      property inlineDiffs

                      inlineDiffs?: boolean | undefined;

                        property reporterOptions

                        reporterOptions?: Partial<ReporterOptions> | undefined;

                          interface Output

                          interface Output {}

                            property meta

                            meta: OutputMeta;

                              property results

                              results: OutputResults;

                                property stats

                                stats: OutputStats;

                                  interface OutputMeta

                                  interface OutputMeta {}
                                  • Metadata about the versions and configuration of the current mocha, mochawesome and marge (mochawesome-report-generator) packages.

                                  property marge

                                  marge: {
                                  options: ReporterOptions;
                                  version: string;

                                    property mocha

                                    mocha: {
                                    version: string;

                                      property mochawesome

                                      mochawesome: {
                                      options: Config;
                                      version: string;

                                        interface PlainSuite

                                        interface PlainSuite {}
                                        • Plain JS object representation of Mocha.Suite, stripped of methods and circular references.

                                        property afterHooks

                                        afterHooks: PlainTest[];

                                          property beforeHooks

                                          beforeHooks: PlainTest[];

                                            property duration

                                            duration: number;

                                              property failures

                                              failures: string[];

                                                property file

                                                file: string;

                                                  property fullFile

                                                  fullFile: string;

                                                    property passes

                                                    passes: string[];

                                                      property pending

                                                      pending: string[];

                                                        property root

                                                        root: boolean;

                                                          property rootEmpty

                                                          rootEmpty: boolean;

                                                            property skipped

                                                            skipped: string[];

                                                              property suites

                                                              suites: PlainSuite[];

                                                                property tests

                                                                tests: PlainTest[];

                                                                  property title

                                                                  title: string;

                                                                    property uuid

                                                                    uuid: string;

                                                                      interface PlainTest

                                                                      interface PlainTest {}
                                                                      • Plain JS object representation of Mocha.Test, stripped of methods and circular references.

                                                                      property code

                                                                      code?: string | undefined;

                                                                        property context

                                                                        context?: string | undefined;

                                                                          property duration

                                                                          duration?: number | undefined;

                                                                            property err

                                                                            err: TestError | {};

                                                                              property fail

                                                                              fail: boolean;

                                                                                property fullTitle

                                                                                fullTitle: string;

                                                                                  property isHook

                                                                                  isHook: boolean;

                                                                                    property parentUUID

                                                                                    parentUUID?: string | undefined;

                                                                                      property pass

                                                                                      pass: boolean;

                                                                                        property pending

                                                                                        pending: boolean;

                                                                                          property skipped

                                                                                          skipped: boolean;

                                                                                            property speed

                                                                                            speed?: 'slow' | 'medium' | 'fast' | undefined;

                                                                                              property state

                                                                                              state?: 'failed' | 'passed' | undefined;

                                                                                                property timedOut

                                                                                                timedOut: boolean;

                                                                                                  property title

                                                                                                  title: string;

                                                                                                    property uuid

                                                                                                    uuid: string;

                                                                                                      interface ReporterOptions

                                                                                                      interface ReporterOptions {}

                                                                                                        property "no-code"

                                                                                                        'no-code': boolean;

                                                                                                          property code

                                                                                                          code: boolean;

                                                                                                            property consoleReporter

                                                                                                            consoleReporter: string;

                                                                                                              property html

                                                                                                              html: boolean;

                                                                                                                property json

                                                                                                                json: boolean;

                                                                                                                  property quiet

                                                                                                                  quiet: boolean;

                                                                                                                    property reportFilename

                                                                                                                    reportFilename: string;

                                                                                                                      interface Stats

                                                                                                                      interface Stats {}

                                                                                                                        property hasOther

                                                                                                                        hasOther: boolean;

                                                                                                                          property hasSkipped

                                                                                                                          hasSkipped: boolean;

                                                                                                                            property other

                                                                                                                            other: number;

                                                                                                                              property passPercent

                                                                                                                              passPercent: number;

                                                                                                                                property pendingPercent

                                                                                                                                pendingPercent: number;

                                                                                                                                  property skipped

                                                                                                                                  skipped: number;

                                                                                                                                    property testsRegistered

                                                                                                                                    testsRegistered: number;

                                                                                                                                      interface TestError

                                                                                                                                      interface TestError {}

                                                                                                                                        property diff

                                                                                                                                        diff: string | string[];

                                                                                                                                          property estack

                                                                                                                                          estack?: string | undefined;

                                                                                                                                            property message

                                                                                                                                            message: string;

                                                                                                                                              Type Aliases

                                                                                                                                              type Done

                                                                                                                                              type Done = (failures: number, exit: ExitFunction) => Promise<void>;

                                                                                                                                                type ExitFunction

                                                                                                                                                type ExitFunction = (code: number) => void;

                                                                                                                                                  type OutputResults

                                                                                                                                                  type OutputResults = PlainSuite[];

                                                                                                                                                    type OutputStats

                                                                                                                                                    type OutputStats = Mocha.Stats & Stats;
                                                                                                                                                    • Test run statistics

                                                                                                                                                    Package Files (1)

                                                                                                                                                    Dependencies (1)

                                                                                                                                                    Dev Dependencies (0)

                                                                                                                                                    No dev dependencies.

                                                                                                                                                    Peer Dependencies (0)

                                                                                                                                                    No peer dependencies.


                                                                                                                                                    To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                    You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/mochawesome.

                                                                                                                                                    • Markdown
                                                                                                                                                    • HTML
                                                                                                                                                      <a href="https://www.jsdocs.io/package/@types/mochawesome"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>