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

    1.1.0 • Public • Published

    tsmockit

    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>
    Setup(
      member: (func: T) => any,
      returns: any = null
    ): void
    TimesMemberCalled(
      member: (func: T) => any
    ): number
    Verify(
      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>

    Usage

    Scenario

    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;
    
      constructor(
        engine: IEngine,
        odometer: IOdometer,
        stereo: IStereo
      ) {
        this.engine = engine;
        this.odometer = odometer;
        this.stereo = stereo;
      }
    
      public StartEngine(): void {
        this.engine.Start();
        this.poweredOn = true;
      }
    
      public StopEngine(): void {
        this.engine.Stop();
        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.

    Example

    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
    expect(car.Mileage).toEqual(100);
    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');

    Conventions

    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.

    Install

    npm i tsmockit

    DownloadsWeekly Downloads

    13

    Version

    1.1.0

    License

    MIT

    Unpacked Size

    37.2 kB

    Total Files

    24

    Last publish

    Collaborators

    • avatar