您现在可以！

我发布了proxyquire它将在您测试module时负责覆盖module内的全局需求。

这意味着您无需更改代码即可为所需module注入模拟。

Proxyquire 有一个非常简单的 api，它允许通过一个简单的步骤解析您尝试测试的module并传递其所需module的模拟/存根。

@Raynos 是对的，传统上您必须求助于不太理想的解决方案才能实现这一目标或进行自下而上的开发

这是我创建 proxyquire 的主要原因 - 允许自上而下的测试驱动开发没有任何麻烦。

查看文档和示例，以判断它是否适合您的需求。

在这种情况下，更好的选择是模拟返回module的方法。

不管好坏，大多数 node.js module都是单例的；require() 相同module的两段代码获得对该module的相同引用。

您可以利用它并使用类似sinon 之类的东西来模拟所需的项目。 摩卡测试如下：

// in your testfile
var innerLib  = require('./path/to/innerLib');
var underTest = require('./path/to/underTest');
var sinon     = require('sinon');

describe("underTest", function() {
  it("does something", function() {
    sinon.stub(innerLib, 'toCrazyCrap').callsFake(function() {
      // whatever you would like innerLib.toCrazyCrap to do under test
    });

    underTest();

    sinon.assert.calledOnce(innerLib.toCrazyCrap); // sinon assertion

    innerLib.toCrazyCrap.restore(); // restore original functionality
  });
});

Sinon与 chai进行了很好的集成以进行断言，我编写了一个module将 sinon 与 mocha 集成在一起，以便更轻松地清理 spy/stub（以避免测试污染）。

请注意，underTest 不能以相同的方式模拟，因为 underTest 仅返回一个函数。

另一种选择是使用 Jest 模拟。在他们的页面上跟进

我使用mock-require。确保在require要测试的module之前定义模拟。

嘲笑require对我来说就像一个讨厌的黑客。我个人会尽量避免它并重构代码以使其更易于测试。有多种方法来处理依赖关系。

1) 将依赖项作为参数传递

function underTest(innerLib) {
    return innerLib.doComplexStuff();
}

这将使代码普遍可测试。缺点是您需要传递依赖项，这会使代码看起来更复杂。

2) 将module实现为类，然后使用类的方法/属性获取依赖

（这是一个人为的例子，其中类的使用不合理，但它传达了这个想法）（ES6 示例）

const innerLib = require('./path/to/innerLib')

class underTestClass {
    getInnerLib () {
        return innerLib
    }

    underTestMethod () {
        return this.getInnerLib().doComplexStuff()
    }
}

现在您可以轻松地存根getInnerLib方法来测试您的代码。代码变得更加冗长，但也更容易测试。

为好奇的人模拟module的简单代码

注意您操作require.cache和注意require.resolve方法的部分，因为这是秘诀。

class MockModules {  
  constructor() {
    this._resolvedPaths = {} 
  }
  add({ path, mock }) {
    const resolvedPath = require.resolve(path)
    this._resolvedPaths[resolvedPath] = true
    require.cache[resolvedPath] = {
      id: resolvedPath,
      file: resolvedPath,
      loaded: true,
      exports: mock
    }
  }
  clear(path) {
    const resolvedPath = require.resolve(path)
    delete this._resolvedPaths[resolvedPath]
    delete require.cache[resolvedPath]
  }
  clearAll() {
    Object.keys(this._resolvedPaths).forEach(resolvedPath =>
      delete require.cache[resolvedPath]
    )
    this._resolvedPaths = {}
  }
}

使用像：

describe('#someModuleUsingTheThing', () => {
  const mockModules = new MockModules()
  beforeAll(() => {
    mockModules.add({
      // use the same require path as you normally would
      path: '../theThing',
      // mock return an object with "theThingMethod"
      mock: {
        theThingMethod: () => true
      }
    })
  })
  afterAll(() => {
    mockModules.clearAll()
  })
  it('should do the thing', async () => {
    const someModuleUsingTheThing = require('./someModuleUsingTheThing')
    expect(someModuleUsingTheThing.theThingMethod()).to.equal(true)
  })
})

但是...... proxyquire 非常棒，你应该使用它。它使您的需求覆盖仅本地化为测试，我强烈推荐它。