如何存根打字稿接口/类型定义？

Question

我在 AngularJS 1.X 项目中使用 Typescript。我将不同的 Javascript 库用于不同的目的。为了对我的源代码进行单元测试，我想使用 Typings（= 接口）来存根一些依赖项。我不想使用 ANY 类型，也不想为每个接口方法写一个空方法。

我正在寻找一种方法来做这样的事情：

let dependency = stub(IDependency);
stub(dependency.b(), () => {console.log("Hello World")});
dependency.a(); // --> Compile, do nothing, no exception
dependency.b(); // --> Compile, print "Hello World", no exception

我现在的痛苦是我要么使用any 并实现在我的测试用例中调用的所有方法，要么我实现接口并实现完整的接口。没用的代码太多了:(。

如何生成每个方法的实现都为空且类型化的对象？我使用 Sinon 进行模拟，但我也可以使用其他库。

PS：我知道 Typescript 会删除接口...但我仍然想解决这个问题:)。

Answer 1

我一直在使用 qUnit 和 Sinon 编写 Typescript 测试，我经历了与您描述的完全相同的痛苦。

让我们假设您依赖于如下接口：

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

通过使用基于 sinon 存根/间谍和强制转换的几种方法，我设法避免了对其他工具/库的需求。

• 使用空对象字面量，然后直接将 sinon stubs 赋值给代码中使用的函数：

  //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);
  

• 将对象字面量与代码所需方法的空实现一起使用，然后根据需要将方法包装在 sinon spies/stubs 中

  //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);
  

当您将它们与 sinon 沙箱和常见的设置/拆卸（如 qUnit 模块提供的设置/拆卸）结合使用时，它们会非常好用。

• 在通用设置中，您可以为依赖项创建一个新沙箱和模拟对象字面量。
• 在测试中，您只需指定间谍/存根。

类似的事情（使用第一个选项，但如果您使用第二个选项，则工作方式相同）：

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

我同意这仍然不是理想的解决方案，但它工作得相当好，不需要额外的库并将所需的额外代码量保持在可管理的低水平。

Answer 2

最新的TypeMoq (ver 1.0.2) 支持 mocking TypeScript 接口，只要运行时（nodejs/browser）支持 ES6 引入的 Proxy 全局对象。

所以，假设IDependency 看起来像这样：

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

然后用 TypeMoq 模拟它就像这样简单：

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

Answer 3

我认为简短的回答是这在 Typescript 中不可能，因为该语言不提供编译时或运行时“反射”。模拟库不可能迭代接口的成员。

查看帖子：https://github.com/Microsoft/TypeScript/issues/1549

这对于 TDD 开发人员来说是不幸的，因为模拟依赖项是开发工作流程的核心部分。

但是，如其他答案所述，有许多技术可以快速存根方法。这些选项可能会完成这项工作，只需稍加调整即可。

编辑：Typescript 抽象语法树 AST 是一种编译时“内省”——它可能用于生成模拟。不过不知道有没有人做过实用的库。

Answer 4

来自 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 从 2.4.0 版本开始支持模拟接口：

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

Answer 5

很少有库允许这样做，TypeMoq、TeddyMocks 和 Typescript-mockify 可能是更受欢迎的库之一。

检查 github 存储库并选择您更喜欢的一个： 链接：

• 泰迪莫克斯：https://github.com/mbraude/TeddyMocks
• 起订量：https://github.com/florinn/typemoq
• TypeScriptMockify：https://github.com/brechtbilliet/typescript-mockify

您也可以使用更流行的库，例如 Sinon，但首先您必须使用 <any> 类型，然后将其缩小为 <IDependency> 类型（How do I use Sinon with Typescript?）

Answer 6

你可以试试moq.ts，不过要依赖Proxy对象

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

Answer 7

SafeMock 相当不错，但遗憾的是它现在似乎没有维护。 完全披露，我曾经和作者合作过。

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 不会让您从模拟中返回错误的类型。

interface SomeService {
    createSomething(): string;
}

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

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

Answer 8

现在可以了。我发布了 typescript 编译器的增强版本，它使接口元数据在运行时可用。例如，你可以写：

interface Something {

}

interface SomethingElse {
    id: number;
}

interface MyService {
    simpleMethod(): void;
    doSomething(p1: number): string;
    doSomethingElse<T extends SomethingElse>(p1: Something): T;
}

function printMethods(interf: Interface) {
    let fields = interf.members.filter(m => m.type.kind === 'function'); //exclude methods.
    for(let field of fields) {
        let method = <FunctionType>field.type;
        console.log(`Method name: ${method.name}`);
        for(let signature of method.signatures) {
            //you can go really deeper here, see the api: reflection.d.ts
            console.log(`\tSignature parameters: ${signature.parameters.length} - return type kind: ${signature.returns.kind}`);
            if(signature.typeParameters) {
                for(let typeParam of signature.typeParameters) {
                    console.log(`\tSignature type param: ${typeParam.name}`); //you can get constraints with typeParam.constraints
                }
            }
            console.log('\t-----')
        }
    }
}

printMethods(MyService); //now can be used as a literal!!

这是输出：

$ node main.js
Method name: simpleMethod
        Signature parameters: 0 - return type kind: void
        -----
Method name: doSomething
        Signature parameters: 1 - return type kind: string
        -----
Method name: doSomethingElse
        Signature parameters: 1 - return type kind: parameter
        Signature type param: T
        -----

利用所有这些信息，您可以按照自己的喜好以编程方式构建存根。

你可以找到我的项目here。