TypeScript icon, indicating that this package has built-in type declarations

    1.1.0 • Public • Published


    Easy to use generic mocking library

    This library exposes a generic class, Mock<T>, which allows you to mock dependencies and verify usage in an intuitive and type safe manner.

    Public interface:

    class Mock<T>
      member: (func: T) => any,
      returns: any = null
    ): void
      member: (func: T) => any
    ): number
      member: (func: T) => any,
      times: Times | number
    ): void
    class TestHelpers
    static EmitEventAtElement(element: HTMLElement, eventType: string): void
    static EmitKeyEventAtElement(
      element: HTMLInputElement,
      key: string,
      keyEvent: 'keydown' | 'keypress' | 'keyup' | 'input'
    ): void
    static async TimeLapsedCondition(condition: () => boolean, interval = 10): Promise<boolean>



    Consider this dependency injection scenario.

    interface IEngine {
      Start(): void;
      Stop(): void;
    interface IOdometer {
      GetMileage(): number;
    interface IStereo {
      SetStation(frequency: number): string;
    class Car {
      private poweredOn = false;
      public get PoweredOn(): boolean {
        return this.poweredOn;
      public get Mileage(): number {
        return this.odometer.GetMileage();
      private engine: IEngine;
      private odometer: IOdometer;
      private stereo: IStereo;
        engine: IEngine,
        odometer: IOdometer,
        stereo: IStereo
      ) {
        this.engine = engine;
        this.odometer = odometer;
        this.stereo = stereo;
      public StartEngine(): void {
        this.poweredOn = true;
      public StopEngine(): void {
        this.poweredOn = false;
      public ChangeRadioStation(frequency: number): string {
        return this.stereo.SetStation(frequency);

    The Car class above uses dependency injection for its engine, odometer, and stereo dependencies.

    It's a best practice to use dependency injection over 'newing' up concretions inside a class instance. This allows true unit testing as well as widely opening the door to future extendability.


    Here's how you would use tsmockit to mock the above dependencies and test the Car class.

    // Instantiate mocks
    const mockIEngine = new Mock<IEngine>();
    const mockIOdometer = new Mock<IOdometer>();
    const mockIStereo = new Mock<IStereo>();
    // Instantiate car, passing mock 'Objects' as its dependencies
    const car = new Car(mockIEngine.Object, mockIOdometer.Object, mockIStereo.Object);
    // 'Setup' the mock odometer to return 100
    mockIOdometer.Setup(o => o.GetMileage(), 100);
    // Assert that the Car's mileage property returns 100 and that our mock GetMileage method is called exactly once
    mockIOdometer.Verify(o => o.GetMileage(), 1);
    // Setup mock stereo to return different strings for different arguments
    mockIStereo.Setup(s => s.SetStation(1), 'Station set to 1');
    mockIStereo.Setup(s => s.SetStation(2), 'Station set to 2');


    You'll often want a mock to return the same response regardless of input parameters. This library accommodates this through these conventions:

    • If only one 'Setup' is made for a given method, the return value will be used for any combination of parameters (i.e. parameter values other than those specified in the setup).
    • If a method is called and no exact setup is available, the first 'Setup' will be returned. In other words, if you have multiple setups for a method and this method is called using parameters that none of those setups accounted for, the return value will be the one specified in the first setup.


    npm i tsmockit

    DownloadsWeekly Downloads






    Unpacked Size

    37.2 kB

    Total Files


    Last publish


    • avatar