如何存根require() / expect调用"根"模块的功能

rewire for this

var rewire = require('rewire');
describe("something.act()", function() {
  it("calls the 'root' function of my module", function() {
    var mod = rewire('my_module');
    var mockRootFunction = jasmine.createSpy('mockRootFunction');
    var requireSpy = {
      mockRequire: function() {
        return mockRootFunction;
      }
    };
    spyOn(requireSpy, 'mockRequire').andCallThrough();
    origRequire = mod.__get__('require');
    mod.__set__('require', requireSpy.mockRequire);
    something.act();
    expect(requireSpy.mockRequire).toHaveBeenCalledWith('my_module');
    expect(mockRootFunction).toHaveBeenCalled();
    mod.__set__('require', origRequire);
  });
});

看起来我找到了一个可以接受的解决方案。

规范帮助器:

var moduleSpies = {};
var originalJsLoader = require.extensions['.js'];
spyOnModule = function spyOnModule(module) {
  var path          = require.resolve(module);
  var spy           = createSpy("spy on module '"" + module + "'"");
  moduleSpies[path] = spy;
  delete require.cache[path];
  return spy;
};
require.extensions['.js'] = function (obj, path) {
  if (moduleSpies[path])
    obj.exports = moduleSpies[path];
  else
    return originalJsLoader(obj, path);
}
afterEach(function() {
  for (var path in moduleSpies) {
    delete moduleSpies[path];
  }
});

规范:

describe("something.act()", function() {
  it("calls the 'root' function of my module", function() {
    var mod = spyOnModule('my_module');
    something.act();
    expect(mod).toHaveBeenCalled(); // mod is a spy
  });
});

这不是完美的，但做得很好。它甚至不会与测试源代码混淆，这对我来说是一种标准。

我今天需要这样做，并且看到了这篇文章。我的解决方案如下:

在规范帮助器中:

var originalRequire = require;
var requireOverrides = {};
stubModule = function(name) {
  var double = originalRequire(name);
  double['double'] = name;
  requireOverrides[name] = double;
  return double;
}
require = function(name) {
  if (requireOverrides[name]) {
    return requireOverrides[name];
  } else {
    return originalRequire(name);
  }
}
afterEach(function() {
  requireOverrides = {};
});

说明:

AWS = stubModule('aws-sdk');
spyOn(AWS.S3, 'Client');
// do something
expect(AWS.S3.Client).toHaveBeenCalled();

这是非常有用的，但它不支持通过.andCallThrough()调用。

我能够适应它，所以我想我应该分享:

function clone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  var key;
  var temp = new obj.constructor();
  for (key in obj) {
    if (obj.hasOwnProperty(key)) {
      temp[key] = clone(obj[key]);
    }
  }
  return temp;
};
spyOnModule = function spyOnModule(name) {
  var path          = require.resolve(name);
  var spy           = createSpy("spy on module '"" + name + "'"");
  moduleSpies[path] = spy;
  // Fake calling through
  spy.andCallThrough = function() {
    // Create a module object
    var mod = clone(module);
    mod.parent = module;
    mod.id = path;
    mod.filename = path;
    // Load it backdoor
    originalJsLoader(mod, path);
    // And set it's export as a faked call
    return this.andCallFake(mod.exports);
  }
  delete require.cache[path];
  return spy;
};

您可以使用温和模块(https://github.com/felixge/node-gently)。示例中提到了劫持require，并且dirty NPM模块主动使用它，所以我认为它是有效的。

还有另一种方法。您可以通过在需要时不使用var来将模块置于全局作用域:

someModule = require('someModule');
describe('whatever', function() {
  it('does something', function() {
    spyOn(global, 'someModule');
    someFunctionThatShouldCallTheModule();
    expect(someModule).toHaveBeenCalled();
  }
}

您也可以将模块封装在另一个模块中:

//someModuleWrapper.js
require('someModule');
function callModule(arg) {
  someModule(arg);
}
exports.callModule = callModule;
//In the spec file:
someModuleWrapper = require('someModuleWrapper');
describe('whatever', function() {
  it('does something', function() {
    spyOn(someModuleWrapper, 'callModule');
    someFunctionThatShouldCallTheModule();
    expect(someModuleWrapper.callModule).toHaveBeenCalled();
  }
}

然后显然要确保无论someFunctionThatShouldCallTheModule在哪里，你都需要包装器而不是真正的模块。