How to stub a Typescript-Interface / Type-definition?

I have been writing Typescript tests using qUnit and Sinon, and I have experienced exactly the same pain you are describing.

Let's assume you have a dependency on an interface like:

interface IDependency {
    a(): void;
    b(): boolean;
}

I have managed to avoid the need of additional tools/libraries by using a couple of approaches based on sinon stubs/spies and casting.

• Use an empty object literal, then directly assign sinon stubs to the functions used in the code:

  //Create empty literal as your IDependency (usually in the common "setup" method of the test file)
  let anotherDependencyStub = <IDependency>{};
  
  //Set stubs for every method used in your code 
  anotherDependencyStub.a = sandbox.stub(); //If not used, you won't need to define it here
  anotherDependencyStub.b = sandbox.stub().returns(true); //Specific behavior for the test
  
  //Exercise code and verify expectations
  dependencyStub.a();
  ok(anotherDependencyStub.b());
  sinon.assert.calledOnce(<SinonStub>anotherDependencyStub.b);
  

• Use object literal with empty implementations of the methods needed by your code, then wrap methods in sinon spies/stubs as required

  //Create dummy interface implementation with only the methods used in your code (usually in the common "setup" method of the test file)
  let dependencyStub = <IDependency>{
      a: () => { }, //If not used, you won't need to define it here
      b: () => { return false; }
  };
  
  //Set spies/stubs
  let bStub = sandbox.stub(dependencyStub, "b").returns(true);
  
  //Exercise code and verify expectations
  dependencyStub.a();
  ok(dependencyStub.b());
  sinon.assert.calledOnce(bStub);
  

They work quite nice when you combine them with sinon sandboxes and common setup/teardown like the one provided by qUnit modules.

• In the common setup you create a new sandbox and the mock object literals for your dependencies.
• In the test you just specify the spies/stubs.

Something like this (using the first option, but would work the same way if you were using the second option):

QUnit["module"]("fooModule", {
    setup: () => {
        sandbox = sinon.sandbox.create();
        dependencyMock = <IDependency>{};
    },
    teardown: () => {
        sandbox.restore();
    }
});

test("My foo test", () => {
    dependencyMock.b = sandbox.stub().returns(true);

    var myCodeUnderTest = new Bar(dependencyMock);
    var result = myCodeUnderTest.doSomething();

    equal(result, 42, "Bar.doSomething returns 42 when IDependency.b returns true");
});

I would agree this is still not the ideal solution but it works reasonably well, doesn't require extra libraries and keeps the amount of extra code needed to a low manageable level.

Latest TypeMoq (ver 1.0.2) supports mocking TypeScript interfaces, as long as the runtime (nodejs/browser) supports the Proxy global object introduced by ES6.

So, assuming IDependency looks like this:

interface IDependency {
    a(): number;
    b(): string;
}

then mocking it with TypeMoq would be as simple as this:

import * as TypeMoq from "typemoq";
...
let mock = TypeMoq.Mock.ofType<IDependency>();

mock.setup(x => x.b()).returns(() => "Hello World");

expect(mock.object.a()).to.eq(undefined);
expect(mock.object.b()).to.eq("Hello World");

From npmjs:

• https://www.npmjs.com/package/ts-mockito#mocking-interfaces

Mocking interfaces
You can mock interfaces too, just instead of passing type to mock function, set mock function generic type Mocking interfaces requires Proxy implementation

let mockedFoo:Foo = mock<FooInterface>(); // instead of mock(FooInterface)
const foo: SampleGeneric<FooInterface> = instance(mockedFoo);

ts-mockito supports mocking interfaces since version 2.4.0:

• https://github.com/NagRock/ts-mockito/releases/tag/v2.4.0

There are few libraries that allows to do that TypeMoq, TeddyMocks and Typescript-mockify are probably one of the more popular ones.

Check the github repositories and pick the one you like better : links:

• TeddyMocks: https://github.com/mbraude/TeddyMocks
• TypeMoq: https://github.com/florinn/typemoq
• TypeScriptMockify: https://github.com/brechtbilliet/typescript-mockify

You can also use more popular libs like Sinon, but first you have to use an <any> type and then narrow it to <IDependency> type (How do I use Sinon with Typescript?)

You can try moq.ts, but it depends on Proxy object

interface IDependency {
  a(): number;
  b(): string;
}


import {Mock, It, Times} from 'moq.ts';

const mock = new Mock<IDependency>()
  .setup(instance => instance.a())
  .returns(1);

mock.object().a(); //returns 1

mock.verify(instance => instance.a());//pass
mock.verify(instance => instance.b());//fail

SafeMock is quite nice, but sadly seems like it is unmaintained now. Full disclosure, I used to work with the author.

import SafeMock, {verify} from "safe-mock";

const mock = SafeMock.build<SomeService>();

// specify return values only when mocks are called with certain arguments like this
when(mock.someMethod(123, "some arg")).return("expectedReturn");

// specify thrown exceptions only when mocks are called with certain arguments like this
when(mock.someMethod(123, "some arg")).throw(new Error("BRR! Its cold!")); 

// specify that the mock returns rejected promises with a rejected value with reject
when(mock.someMethod(123)).reject(new Error("BRR! Its cold!"));

//use verify.calledWith to check the exact arguments to a mocked method
verify(mock.someMethod).calledWith(123, "someArg");

SafeMock won't let you return the wrong type from mocks.

interface SomeService {
    createSomething(): string;
}

const mock: Mock<SomeService> = SafeMock.build<SomeService>();

//Won't compile createSomething returns a string
when(mock.createSomething()).return(123);