javascript - 测试函数中的函数是否被返回

Question

我有一个函数，它最后返回另一个函数，根据第一个函数中所做的事情来调用。

function createOption(endPoint, options, body, post) {
  if(!options) {
    options = {
      hostname: 'testurl.com',
      path: '/rest/api/content/' + endPoint,
      port: 443,
      headers: {
        'Accept': 'application/json',
        'Content-Type': 'application/json',
        'Authorization': getAuthorization()
      }
   }
   if(body) {
     if(post) options.method = 'POST';
     else options.method = 'PUT';
   }
   else options.method = 'GET';

   return apiCall(options, body)
}

function apiCall(options, body) {
    var deferred = Q.defer();

    var request = https.request(options, function (res) {
        var resBody = '';
        res.on('data', function appendData(responseChunk) {
            resBody += responseChunk;
        });
        res.on('end', function useBody() {
            try {
                var parsed = JSON.parse(resBody);
                if(parsed.statusCode)
                    deferred.reject(new Error('Request failed'));
                else
                    deferred.resolve(parsed);
            }
            catch(error){
                deferred.reject(new Error(resBody));
            }
        });
    });
    if(body)
        request.write(body);
    request.end();
    request.on('error', function (errorData) {
        deferred.reject(new Error('Error making call - :\n' + errorData));
    });

    return deferred.promise;
}

module.exports = {
  createOption: createOption,
  apiCall: apiCall
}

为了测试这一点，我试图断言 apiCall 是使用 sinon spies 调用的，但它不会检测到这一点。

var api = require('../src/api');
var chai = require('chai');
var sinon = require('sinon');

var expect = chai.expect;

describe('api test procedure', function() {
  it('should create e based on inputs a, b, c, d and call e', function() {
    var spy = sinon.spy(api, 'apiCall');

    api.createOption('', null, null, null);

    expect(spy.called).to.be.true;
  });
});

我在这里做错了什么？当我监视一个不是在末尾调用的函数时，它会检测到它正在被调用，但不是在末尾调用。

编辑:更新代码

Answer 1

极其简化，您的代码如下所示:

var sinon = require('sinon');

function A() {
  B();
}

function B() {
  console.log('hello world');
}

var obj = {
  A : A,
  B : B
};

// Spy on B
var spy = sinon.spy(obj, 'B');

// Call A
A();

// This should be true!
console.log( spy.called );

但是，它记录false。

原因是Sinon正在监视obj.B，这意味着它将obj.B替换为另一个函数( spy )，该函数将调用原始obj.B 并记录它是如何被调用的(哪些参数等)。

但是，A 根本不调用obj.B，它调用B。当然，obj.B 是对该函数的引用，但这并不重要:Sinon 只能用 spy 替换 obj.B，但不能替换原始的 B 也是如此。

要解决这个问题，A 也应该调用 obj.B。

或者，就您而言:

return exports.apiCall(options, body);