西农存根在引擎盖下是如何工作的？

Question

但我对西农在台面下是如何工作仍有一些疑问。我想我是在说Sinon，但这个问题可能适用于所有其他设计为mock/stub/spy的库。

在过去的几年里，我工作最多的语言是Java。在Java中，我使用Mockito来模拟/存根依赖项和依赖项注入。我曾经导入这个类，用@mock注释这个字段，并将这个mock作为param传递给被测试的类。对我来说，很容易看出我在做什么：模仿一个类，并将模仿作为param传递。

当我第一次开始使用SinonJS时，我看到了这样的情况：

moduleundertest.spec.js

const request = require('request')

describe('Some tests', () => {
  let requestStub

  beforeEach(() => {
    requestStub = sinon.stub(request, 'get')
  })

  afterEach(() => {
    request.get.restore()
  })

  it('A test case', (done) => {
    const err = undefined
    const res = { statusCode: 200 }
    const body = undefined
    requestStub
      .withArgs("some_url")
      .yields(err, res, body)

    const moduleUnderTest = moduleUnderTest.someFunction()

    // some assertions
    })
})

moduleundertest.js

const request = require('request')
// some code
  request
    .get("some_url", requestParams, onResponse)

而且管用。当我们运行测试时，实现moduleundertest.js中的request调用request模块的stubbed版本。

我尝试了Sinon repo中stub.js代码中的逻辑，但我对JavaScript还不是很熟悉。抱歉这篇文章太长了，如果这是一个假问题，我很抱歉。：）

Answer 1

如果我们不将stubbed对象作为param传递（注入），Sinon（和其他mock/stub/spy库）如何使实现调用stub？

让我们自己编写简单的stubbing util，好吗？

为了简洁起见，它非常有限，没有提供stubbing API，每次只返回42。但这应该足以说明Sinon是如何工作的。

function stub(obj, methodName) {
    // Get a reference to the original method by accessing
    // the property in obj named by methodName.
    var originalMethod = obj[methodName];

    // This is actually called on obj.methodName();
    function replacement() {
        // Always returns this value
        return 42;

        // Note that in this scope, we are able to call the
        // orignal method too, so that we'd be able to 
        // provide callThrough();
    }

    // Remember reference to the original method to be able 
    // to unstub (this is *one*, actually a little bit dirty 
    // way to reference the original function)
    replacement.originalMethod = originalMethod;

    // Assign the property named by methodName to obj to 
    // replace the method with the stub replacement
    obj[methodName] = replacement;

    return {
        // Provide the stub API here
    };
}

// We want to stub bar() away
var foo = {
    bar: function(x) { return x * 2; }
};

function underTest(x) {
    return foo.bar(x);
}

stub(foo, "bar");
// bar is now the function "replacement"
// foo.bar.originalMethod references the original method

underTest(3);

Sinon在测试执行期间替换整个请求模块（或部分），使存根通过require('request')可用，然后在测试完成后恢复它？

require('request')将返回在每次调用“request”模块中创建的相同的（对象）引用。

请参见NodeJS文档：

模块在第一次加载后缓存。这意味着（除其他外）对require('foo')的每次调用都将返回完全相同的对象，如果它将解析为相同的文件。

多次调用require('foo')可能不会导致多次执行模块代码。这是一个重要的特点。使用它，可以返回“部分完成”的对象，从而允许在传递依赖项会导致循环的情况下加载传递依赖项。

如果它还没有变得清楚：它只替换从“requested”模块返回的对象引用的一个方法，它不会替换该模块。

这就是为什么你不打电话

stub(obj.method)

因为这只传递对函数方法的引用。Sinon将无法更改对象obj。

文件还说：

如果您想让一个模块多次执行代码，那么导出一个函数，并调用该函数。

这意味着，如果模块如下所示：

module.exports = function() {
    return {
        // New object everytime the required "factory" is called
    };
};

        // The function returned by require("foo") does not change
const   moduleFactory = require("./foo"),
        // This will change on every call
        newFooEveryTime = moduleFactory();

这样的模块工厂函数不能存根，因为您不能从模块内替换require()导出的函数。

在Java中，我使用Mockito来模拟/存根依赖项和依赖项注入。我曾经导入这个类，用@mock注释这个字段，并将这个mock作为param传递给被测试的类。对我来说，很容易看出我在做什么：模仿一个类，并将模仿作为param传递。

在Java中，您（没有任何东西）不能将一个方法重新分配到一个新的值，这是不能做到的。取而代之的是生成新的字节码，使mock提供与mocked类相同的接口。与Sinon相反，在Mockito中，所有的方法都被嘲笑，并且应该被明确地指示调用真正的方法。

Mockito将有效地调用mock()，并最终将结果分配给带注释的字段。

但是您仍然需要将模拟替换/分配给被测试类中的一个字段，或者将它传递给一个被测试的方法，因为模拟本身没有帮助。

@Mock
Type field;

或

Type field = mock(Type.class)

var myAPI = { method: function () {} };
var mock = sinon.mock(myAPI);

mock.expects("method").once().throws();

wrapMethod(this.object, method, function () {
    return mockObject.invokeMethod(method, this, arguments);
});