When it comes to writing Typescript tests using qUnit and Sinon, I can definitely relate to the challenges you're facing.

Imagine having a dependency on an interface like this:

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

To tackle this without relying on additional tools or libraries, I've adopted a couple of strategies involving sinon stubs/spies and casting.

• The first approach involves utilizing an empty object literal where you assign sinon stubs directly to the required functions:

  //Create an empty literal as your IDependency 
  let anotherDependencyStub = <IDependency>{};
  
  //Assign stubs for each method used in your code
  anotherDependencyStub.a = sandbox.stub();
  anotherDependencyStub.b = sandbox.stub().returns(true);
  
  //Proceed with your code execution and expectation verifications
  dependencyStub.a();
  ok(anotherDependencyStub.b());
  sinon.assert.calledOnce(<SinonStub>anotherDependencyStub.b);
  

• The second option involves employing an object literal with empty method implementations, subsequently wrapping these methods in sinon spies/stubs as needed:

  //Create a dummy interface implementation with only the necessary methods
  let dependencyStub = <IDependency>{
      a: () => { },
      b: () => { return false; }
  };
  
  //Set up spies/stubs
  let bStub = sandbox.stub(dependencyStub, "b").returns(true);
  
  //Execute your code and verify expectations
  dependencyStub.a();
  ok(dependencyStub.b());
  sinon.assert.calledOnce(bStub);
  

These approaches interact seamlessly when combined with sinon sandboxes and standard setup/teardown procedures provided by qUnit modules.

• Create a new sandbox and mock object literals for dependencies during setup.
• Specify the spies/stubs within the test itself.

This structure (illustrated using the first option) could look something like:

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");
});

While not a perfect solution, this method proves effective without the need for extra libraries while maintaining a manageable level of additional code.

The latest version of TypeMoq (ver 1.0.2) now has the ability to mock TypeScript interfaces, provided that the runtime environment (nodejs/browser) supports the ES6 introduced Proxy global object.

For instance, if we have an interface called IDependency defined as follows:

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

We can easily mock it using TypeMoq like 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");

Here is some information from npmjs:

• Learn more about mocking interfaces on npmjs

Mocking interfaces
You have the ability to mock interfaces as well by setting the generic type for the mock function, which requires Proxy implementation.

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

It's worth noting that ts-mockito started supporting mocking interfaces since version 2.4.0:

• Check out the release notes for version 2.4.0 on GitHub

If you're looking to mock libraries, there are a handful of options available such as TypeMoq, TeddyMocks, and Typescript-mockify which are quite popular choices.

For more information and to decide which one suits your needs best, you can explore their respective GitHub repositories: links:

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

If you prefer using more mainstream libraries like Sinon, make sure to initially define the type as <any>, then refine it to <IDependency> type (check this link for more details: How do I use Sinon with Typescript?)

If you're looking for a testing library, consider checking out moq.ts. It relies on the Proxy object for functionality.

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 Tool offers a great solution for safe mocking, but unfortunately, it appears to be inactive now. Just to be transparent, I have previously collaborated with the developer.

import SafeMock, {check} from "safe-mock-tool";

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

// set specific return values based on provided arguments
when(mock.someMethod(123, "some arg")).return("expectedReturn");

// define exceptions when method is called with certain arguments
when(mock.someMethod(123, "some arg")).throw(new Error("It's freezing!")); 

// configure the mock to return rejected promises 
when(mock.someMethod(123)).reject(new Error("It's freezing!"));

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

SafeMock Tool ensures that the correct data type is returned by mocks.

interface SomeService {
    createSomething(): string;
}

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

//The following won't compile as createSomething expects a string return value
when(mock.createSomething()).return(123);