mocha-typescript

  • Version 1.1.17
  • Published
  • 125 kB
  • 4 dependencies
  • Apache-2.0 license

Install

npm i mocha-typescript
yarn add mocha-typescript
pnpm add mocha-typescript

Overview

TypeScript decorators based wrapper over mocha's interface

Index

Namespaces

namespace Mocha

namespace Mocha {}

    interface ExclusiveSuiteFunction

    interface ExclusiveSuiteFunction {}

      call signature

      (args: any): any;

        call signature

        (): ClassDecorator;

          call signature

          (name: string): ClassDecorator;

            call signature

            (name: string, ...traits: MochaTypeScript.SuiteTrait[]): ClassDecorator;

              call signature

              (
              trait: MochaTypeScript.SuiteTrait,
              ...traits: MochaTypeScript.SuiteTrait[]
              ): ClassDecorator;

                interface ExclusiveTestFunction

                interface ExclusiveTestFunction {}

                  call signature

                  (target: Object, propertyKey: string | symbol): void;

                    call signature

                    (name: string): PropertyDecorator;

                      call signature

                      (name: string, ...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                        call signature

                        (...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                          interface ISuite

                          interface ISuite {}

                            call signature

                            <TFunction extends Function>(target: TFunction): TFunction | void;

                              interface ITest

                              interface ITest {}

                                call signature

                                <T>(
                                target: Object,
                                propertyKey: string | symbol,
                                descriptor: TypedPropertyDescriptor<T>
                                ): TypedPropertyDescriptor<T> | void;

                                  interface PendingSuiteFunction

                                  interface PendingSuiteFunction {}

                                    call signature

                                    (args: any): any;

                                      call signature

                                      (): ClassDecorator;

                                        call signature

                                        (name: string): ClassDecorator;

                                          call signature

                                          (name: string, ...traits: MochaTypeScript.SuiteTrait[]): ClassDecorator;

                                            call signature

                                            (
                                            trait: MochaTypeScript.SuiteTrait,
                                            ...traits: MochaTypeScript.SuiteTrait[]
                                            ): ClassDecorator;

                                              interface PendingTestFunction

                                              interface PendingTestFunction {}

                                                call signature

                                                (target: Object, propertyKey: string | symbol): void;

                                                  call signature

                                                  (name: string): PropertyDecorator;

                                                    call signature

                                                    (name: string, ...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                                                      call signature

                                                      (...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                                                        interface Suite

                                                        interface Suite {}

                                                          call signature

                                                          <TFunction extends Function>(target: TFunction): TFunction | void;

                                                            interface SuiteFunction

                                                            interface SuiteFunction {}

                                                              call signature

                                                              (args: any): any;

                                                                call signature

                                                                (): ClassDecorator;

                                                                  call signature

                                                                  (name: string): ClassDecorator;

                                                                    call signature

                                                                    (name: string, ...traits: MochaTypeScript.SuiteTrait[]): ClassDecorator;

                                                                      call signature

                                                                      (
                                                                      trait: MochaTypeScript.SuiteTrait,
                                                                      ...traits: MochaTypeScript.SuiteTrait[]
                                                                      ): ClassDecorator;

                                                                        interface Test

                                                                        interface Test {}

                                                                          call signature

                                                                          <T>(
                                                                          target: Object,
                                                                          propertyKey: string | symbol,
                                                                          descriptor: TypedPropertyDescriptor<T>
                                                                          ): TypedPropertyDescriptor<T> | void;

                                                                            interface TestFunction

                                                                            interface TestFunction {}

                                                                              call signature

                                                                              (target: Object, propertyKey: string | symbol): void;

                                                                                call signature

                                                                                (name: string): PropertyDecorator;

                                                                                  call signature

                                                                                  (name: string, ...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                                                                                    call signature

                                                                                    (...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                                                                                      namespace mocha-typescript

                                                                                      module 'mocha-typescript' {}

                                                                                        variable describe

                                                                                        const describe: Mocha.IContextDefinition & MochaTypeScript.IContextDefinition;

                                                                                          variable it

                                                                                          const it: Mocha.ITestDefinition & MochaTypeScript.ITestDefinition;

                                                                                            variable skipOnError

                                                                                            const skipOnError: MochaTypeScript.SuiteTrait;

                                                                                              variable suite

                                                                                              const suite: Mocha.IContextDefinition & MochaTypeScript.IContextDefinition;

                                                                                                variable test

                                                                                                const test: Mocha.ITestDefinition & MochaTypeScript.ITestDefinition;

                                                                                                  function context

                                                                                                  context: (target: Object, propertyKey: string | symbol) => void;

                                                                                                    function only

                                                                                                    only: <TFunction extends Function>(
                                                                                                    target: Object,
                                                                                                    propertyKey?: string | symbol
                                                                                                    ) => void;

                                                                                                      function pending

                                                                                                      pending: <TFunction extends Function>(
                                                                                                      target: Object | TFunction,
                                                                                                      propertyKey?: string | symbol
                                                                                                      ) => void;

                                                                                                        function registerDI

                                                                                                        registerDI: (instantiator: MochaTypeScript.DependencyInjectionSystem) => boolean;

                                                                                                          function retries

                                                                                                          retries: (
                                                                                                          count: number
                                                                                                          ) => PropertyDecorator &
                                                                                                          ClassDecorator &
                                                                                                          MochaTypeScript.SuiteTrait &
                                                                                                          MochaTypeScript.TestTrait;

                                                                                                            function skip

                                                                                                            skip: <TFunction extends Function>(
                                                                                                            target: Object | TFunction,
                                                                                                            propertyKey?: string | symbol
                                                                                                            ) => void;

                                                                                                              function slow

                                                                                                              slow: (
                                                                                                              time: number
                                                                                                              ) => PropertyDecorator &
                                                                                                              ClassDecorator &
                                                                                                              MochaTypeScript.SuiteTrait &
                                                                                                              MochaTypeScript.TestTrait;

                                                                                                                function timeout

                                                                                                                timeout: (
                                                                                                                time: number
                                                                                                                ) => PropertyDecorator &
                                                                                                                ClassDecorator &
                                                                                                                MochaTypeScript.SuiteTrait &
                                                                                                                MochaTypeScript.TestTrait;

                                                                                                                  namespace MochaTypeScript

                                                                                                                  namespace MochaTypeScript {}

                                                                                                                    interface DependencyInjectionSystem

                                                                                                                    interface DependencyInjectionSystem {}

                                                                                                                      method create

                                                                                                                      create: <T>(cls: TestClass<T>) => typeof cls.prototype;

                                                                                                                        method handles

                                                                                                                        handles: <T>(cls: TestClass<T>) => boolean;

                                                                                                                          interface IContextDefinition

                                                                                                                          interface IContextDefinition {}

                                                                                                                            method only

                                                                                                                            only: {
                                                                                                                            (arg: any): any;
                                                                                                                            (): ClassDecorator;
                                                                                                                            (name: string): ClassDecorator;
                                                                                                                            (name: string, ...traits: SuiteTrait[]): ClassDecorator;
                                                                                                                            (...traits: SuiteTrait[]): ClassDecorator;
                                                                                                                            };

                                                                                                                              method skip

                                                                                                                              skip: {
                                                                                                                              (arg: any): any;
                                                                                                                              (): ClassDecorator;
                                                                                                                              (name: string): ClassDecorator;
                                                                                                                              (name: string, ...traits: SuiteTrait[]): ClassDecorator;
                                                                                                                              (...traits: SuiteTrait[]): ClassDecorator;
                                                                                                                              };

                                                                                                                                call signature

                                                                                                                                (args: any): any;
                                                                                                                                • This is either a single trait overload (trait: MochaTypeScript.SuiteTrait): ClassDecorator or a class decorator overload (target: Function): void. Can't figure out proper typing.

                                                                                                                                call signature

                                                                                                                                (): ClassDecorator;

                                                                                                                                  call signature

                                                                                                                                  (name: string): ClassDecorator;

                                                                                                                                    call signature

                                                                                                                                    (name: string, ...traits: MochaTypeScript.SuiteTrait[]): ClassDecorator;

                                                                                                                                      call signature

                                                                                                                                      (
                                                                                                                                      trait: MochaTypeScript.SuiteTrait,
                                                                                                                                      ...traits: MochaTypeScript.SuiteTrait[]
                                                                                                                                      ): ClassDecorator;

                                                                                                                                        interface ITestDefinition

                                                                                                                                        interface ITestDefinition {}

                                                                                                                                          method only

                                                                                                                                          only: {
                                                                                                                                          (target: Object, propertyKey: string | symbol): void;
                                                                                                                                          (name: string): PropertyDecorator;
                                                                                                                                          (name: string, ...traits: TestTrait[]): PropertyDecorator;
                                                                                                                                          (...traits: TestTrait[]): PropertyDecorator;
                                                                                                                                          };

                                                                                                                                            method skip

                                                                                                                                            skip: {
                                                                                                                                            (target: Object, propertyKey: string | symbol): void;
                                                                                                                                            (name: string): PropertyDecorator;
                                                                                                                                            (name: string, ...traits: TestTrait[]): PropertyDecorator;
                                                                                                                                            (...traits: TestTrait[]): PropertyDecorator;
                                                                                                                                            };

                                                                                                                                              call signature

                                                                                                                                              (target: Object, propertyKey: string | symbol): void;

                                                                                                                                                call signature

                                                                                                                                                (name: string): PropertyDecorator;

                                                                                                                                                  call signature

                                                                                                                                                  (name: string, ...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                                                                                                                                                    call signature

                                                                                                                                                    (...traits: MochaTypeScript.TestTrait[]): PropertyDecorator;

                                                                                                                                                      interface Suite

                                                                                                                                                      interface Suite {}

                                                                                                                                                        property after

                                                                                                                                                        after?: (done?: MochaDone) => void;

                                                                                                                                                          property before

                                                                                                                                                          before?: (done?: MochaDone) => void;

                                                                                                                                                            property prototype

                                                                                                                                                            prototype: {
                                                                                                                                                            before?: (done?: MochaDone) => void;
                                                                                                                                                            after?: (done?: MochaDone) => void;
                                                                                                                                                            };

                                                                                                                                                              construct signature

                                                                                                                                                              new (): any;

                                                                                                                                                                interface SuiteTrait

                                                                                                                                                                interface SuiteTrait {}

                                                                                                                                                                  call signature

                                                                                                                                                                  (
                                                                                                                                                                  this: Mocha.ISuiteCallbackContext,
                                                                                                                                                                  ctx: Mocha.ISuiteCallbackContext,
                                                                                                                                                                  ctor: Function
                                                                                                                                                                  ): void;

                                                                                                                                                                    interface TestClass

                                                                                                                                                                    interface TestClass<T> {}

                                                                                                                                                                      property prototype

                                                                                                                                                                      prototype: T;

                                                                                                                                                                        construct signature

                                                                                                                                                                        new (...args: any[]): T;

                                                                                                                                                                          interface TestTrait

                                                                                                                                                                          interface TestTrait {}

                                                                                                                                                                            call signature

                                                                                                                                                                            (
                                                                                                                                                                            this: Mocha.ITestCallbackContext,
                                                                                                                                                                            ctx: Mocha.ITestCallbackContext,
                                                                                                                                                                            instance: Object,
                                                                                                                                                                            method: Function
                                                                                                                                                                            ): void;

                                                                                                                                                                              Package Files (1)

                                                                                                                                                                              Dependencies (4)

                                                                                                                                                                              Dev Dependencies (12)

                                                                                                                                                                              Peer Dependencies (0)

                                                                                                                                                                              No peer dependencies.

                                                                                                                                                                              Badge

                                                                                                                                                                              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/mocha-typescript.

                                                                                                                                                                              • Markdown
                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/mocha-typescript)
                                                                                                                                                                              • HTML
                                                                                                                                                                                <a href="https://www.jsdocs.io/package/mocha-typescript"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>