带有 es6 承诺对象的 sinon 存根

Question

好的，我的设置如下： 使用 node 6.2、es6-promisify、sinon、sinon-as-promised 和 babel 转译对 es6 导入/导出的支持。

我的测试代码如下所示：

const client = restify.createJsonClient({
    url: 'http://www.example.com'
});
export let get = promisify(client.get, {thisArg: client, multiArgs: true});

export default function* () {
    yield get('/some/path');
}

然后在我的测试文件中我有这样的东西：

import * as m from mymodule;
it('should fail', function(done) {
    let stub = sinon.stub(m, 'get').rejects('i failed');
    client.get('/endpoint/that/leads/to/mymodule/call', function(err, req, res, data) {
        stub.called.should.be.eql(true); // assertion fails!!
        done();
    }
});

我也尝试过对原始的 client.get 调用存根，但这也不起作用。我唯一要做的就是在每次调用时即时做出承诺，并将原始的 client.get 存根，这看起来很蹩脚。例如：

export const client = restify.createJsonClient({
    url: 'http://www.example.com'
});
function get() {
    return promisify(client.get, {thisArg: client, multiArgs: true});
}

export default function* () {
    yield get('/some/path');
}

然后测试代码：

import {module_client} from mymodule;
it('should fail', function(done) {
    let stub = sinon.stub(module_client, 'get').yields('i failed');
    client.get('/endpoint/that/leads/to/mymodule/call', function(err, req, res, data) {
        stub.called.should.be.eql(true); // assertion succeeds
        done();
    }
});

所以问题是，如果不是很明显，为什么我的原始代码不起作用？有没有办法让存根工作而不用每次都承诺原始的restify（例如，其他人如何让这种事情工作）？

编辑：

当前代码如下所示：

const client = restify.createJsonClient({
    url: 'http://www.example.com'
});

export let get = promisify(client.get, {thisArg: client, multiArgs: true});

export default function*() {
    try {
        console.log(exports.get); // <= a large sinon stub object, I'll post that below
        yield exports.get(); // <= throws here, "exports.get is not a function"
    }
    catch(ex) {
        log.error('got an error', ex);
        throw ex;
    }
}

console.log 打印以下内容：

{ [Function: proxy]
  isSinonProxy: true,
  reset: [Function],
  invoke: [Function: invoke],
  named: [Function: named],
  getCall: [Function: getCall],
  getCalls: [Function],
  calledBefore: [Function: calledBefore],
  calledAfter: [Function: calledAfter],
  withArgs: [Function],
  matches: [Function],
  printf: [Function],
  calledOn: [Function],
  alwaysCalledOn: [Function],
  calledWith: [Function],
  calledWithMatch: [Function],
  alwaysCalledWith: [Function],
  ....

EDIT2：

FWIW，babel 生成的代码正在生成：

let get = exports.get = (0, _es6Promisify2.default)(client.get, { thisArg: client, multiArgs: true });

EDIT3：

好吧，超级奇怪。我改变了我的来源来做到这一点：

const client = restify.createJsonClient({
    url: 'http://www.example.com'
});

export let get = promisify(client.get, {thisArg: client, multiArgs: true});

export default function*() {
    try {
        let thePromise = exports.get(); // e.g. call exports.get on separate line from the yield
        yield thePromise; // and the throw now says 'undefined is not a function'. I should note that in both cases, the stack trace shows the error on node_modules/co/index.js at line 65.
    }
    catch(ex) {
        log.error('got an error', ex);
        throw ex;
    }
}

Answer 1

问题最终与 ES6 导入/导出的工作方式有关，特别是它们如何使您的代码看起来更好但阻止了轻松的间谍/存根。

以这个模块为例：

// my-module.js
function someFunction() {
  console.log('original');
};

export let get = someFunction;

export default function() {
  get();
};

该代码的测试用例可能如下所示：

import * as sinon from 'sinon';
import * as should from 'should';
import setup, * as myModule from './my-module';

it('should call get()', () => {
  let stub = sinon.stub(myModule, 'get');
  setup();
  stub.called.should.eql(true);
});

您会看到原始的get() 被调用，而不是存根。这是因为在模块中，get 是本地（对模块）引用。 Sinon 正在导出对象中对同一函数的 另一个 引用。

要做到这一点，您需要在导出的对象中使用本地引用，而不是在模块中使用本地引用：

export default function() {
  exports.get();
};

唉，这导致代码更丑。