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
}

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

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替换为将调用原始obj.B的另一个函数（间谍）并记录它是如何被调用的（其中args等）。

但是，A根本不会调用obj.B，而是调用B。当然，obj.B是对该函数的引用，但这并不重要：Sinon只能用间谍替换obj.B，而不能替换原来的B。

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

或者，在您的情况下：

return exports.apiCall(options, body);

测试是否返回函数中的函数

1 个答案: