ts-mockito

To create a mock, use the mock() function with the class or type you want to mock. To get a usable instance of that mock to pass into your application code, use the instance() function. This allows you to control the behavior of the object and verify how it is used.

// Creating mock
let mockedFoo:Foo = mock(Foo);

// Getting instance from mock
let foo:Foo = instance(mockedFoo);

// Using instance in source code
foo.getBar(3);
foo.getBar(5);

// Explicit, readable verification
verify(mockedFoo.getBar(3)).called();
verify(mockedFoo.getBar(anything())).called();

Install ts-mockito as a development dependency using npm.

npm install ts-mockito --save-dev

Use capture() to inspect the arguments passed to a mocked method. You can retrieve specific calls using methods like .last(), .first(), .second(), or .byCallIndex(n).

let mockedFoo:Foo = mock(Foo);
let foo:Foo = instance(mockedFoo);

// Call method
foo.sumTwoNumbers(1, 2);

// Check first arg captor values
const [firstArg, secondArg] = capture(mockedFoo.sumTwoNumbers).last();
console.log(firstArg);    // prints 1
console.log(secondArg);    // prints 2

Mocking Interfaces

To mock an interface, pass the interface type as a generic to the mock<T>() function. This requires a Proxy implementation.

Mocking Abstract Classes

Abstract classes can be mocked just like regular classes using mock(AbstractClass).

Mocking Generic Classes

Generic classes can be mocked by providing the generic type in the mock definition.

// Interface
let mockedFoo:FooInterface = mock<FooInterface>();

// Abstract Class
const mockedFoo: SampleAbstractClass = mock(SampleAbstractClass);

// Generic Class
const mockedFoo: SampleGeneric<SampleInterface> = mock(SampleGeneric);

Use when() combined with thenReturn() to define what a mocked method should return when called with specific arguments. If a method is called with arguments that were not stubbed, it will return null by default.

// Creating mock
let mockedFoo:Foo = mock(Foo);

// stub method before execution
when(mockedFoo.getBar(3)).thenReturn('three');

// Getting instance
let foo:Foo = instance(mockedFoo);

// prints three
console.log(foo.getBar(3));

// prints null, because "getBar(999)" was not stubbed
console.log(foo.getBar(999));

Use thenThrow() to make a mocked method throw an error when called.

let mockedFoo:Foo = mock(Foo);

when(mockedFoo.getBar(10)).thenThrow(new Error('fatal error'));

let foo:Foo = instance(mockedFoo);
try {
    foo.getBar(10);
} catch (error:Error) {
    console.log(error.message); // 'fatal error'
}

You can verify the relative order of calls between different mocks using calledBefore() and calledAfter().

let mockedFoo:Foo = mock(Foo);
let mockedBar:Bar = mock(Bar);

// Getting instance
let foo:Foo = instance(mockedFoo);
let bar:Bar = instance(mockedBar);

// Some calls
foo.getBar(1);
bar.getFoo(2);

// Call order verification
verify(mockedFoo.getBar(1)).calledBefore(mockedBar.getFoo(2));    // foo.getBar(1) has been called before bar.getFoo(2)
verify(mockedBar.getFoo(2)).calledAfter(mockedFoo.getBar(1));    // bar.getFoo(2) has been called before foo.getBar(1)

Use thenCall() to provide a custom function implementation for a mocked method. This allows you to execute logic based on the arguments passed to the call.

let mockedFoo:Foo = mock(Foo);
let foo:Foo = instance(mockedFoo);

when(mockedFoo.sumTwoNumbers(anyNumber(), anyNumber())).thenCall((arg1:number, arg2:number) => {
    return arg1 * arg2; 
});

// prints '50' because we've changed sum method implementation to multiply!
console.log(foo.sumTwoNumbers(5, 10));

You can reset parts of a mock's state:

• resetCalls(mock): Resets only the call counters (verification state). The stubs remain intact.
• reset(mock): Resets both the call counters and all defined stubs.

// Reset just mock call counter
resetCalls(mockedFoo);

// Reset mock call counter AND all stubs
reset(mockedFoo);

You can chain multiple thenReturn() calls to return different values sequentially for the same matching arguments. The last defined behavior will be repeated infinitely once the sequence is exhausted.

You can also use the shorthand syntax by passing multiple arguments to a single thenReturn() call.

// Chained syntax
when(mockedFoo.getBar(anyNumber())).thenReturn('one').thenReturn('two').thenReturn('three');

// Shorthand syntax
when(mockedFoo.getBar(anyNumber())).thenReturn('one', 'two', 'three');

You can stub getter values using the same when().thenReturn() syntax used for methods. This also works for properties that do not have explicit getters, provided that an ES6 Proxy is available in your environment.

// Creating mock
let mockedFoo:Foo = mock(Foo);

// stub getter before execution
when(mockedFoo.sampleGetter).thenReturn('three');

// Getting instance
let foo:Foo = instance(mockedFoo);

// prints three
console.log(foo.sampleGetter);