如何对需要其他模块的 Node.js 模块进行单元测试以及如何模拟全局 require 函数？

Question

这是一个简单的示例，说明了我的问题的症结：

var innerLib = require('./path/to/innerLib');

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

module.exports = underTest;

我正在尝试为此代码编写单元测试。如何在不完全模拟 require 函数的情况下模拟对 innerLib 的需求？

所以这是我试图模拟全局 require 并发现即使这样做也行不通：

var path = require('path'),
    vm = require('vm'),
    fs = require('fs'),
    indexPath = path.join(__dirname, './underTest');

var globalRequire = require;

require = function(name) {
    console.log('require: ' + name);
    switch(name) {
        case 'connect':
        case indexPath:
            return globalRequire(name);
            break;
    }
};

问题是 require 函数位于 >underTest.js 文件实际上还没有被模拟出来。它仍然指向全局 require 函数。所以看来我只能在我进行模拟的同一个文件中模拟 require 函数。如果我使用全局 require 来包含任何内容，即使在之后我已经覆盖了本地副本，所需的文件仍将具有全局 require 引用。

Answer 1

使用 NodeJS 很简单。这是我在这个名为 mock 的库中使用的整个模拟函数：

var Module = require('module')
var _require = Module.prototype.require

var mocks = {}

Module.prototype.require = function () {
  var name = arguments[0]

  if (typeof mocks[name] == 'function') {
    return mocks[name]()
  }

  return _require.apply(this, arguments)
}

function start(name, callback) {
  mocks[name] = callback
}

function stop(name) {
  if (name) {
    delete mocks[name]
  } else {
    mocks = {}
  }
}

module.exports = { start, stop }

像这样使用它：

var mokk = require('mokk')

// Start mocking 'waveorb'
mokk.start('waveorb', function() {
  var companies = [{ name: 'Firmalisten' }]
  return companies
})

// Stop mocking 'waveorb'
mokk.stop('waveorb')

// Stop all mocking
mokk.stop()

Answer 2

该函数调用一个具有其所有依赖项的函数：

/**
 * fnFactory
 * Returns a function that calls a function with all of its dependencies.
*/

"use strict";

const fnFactory = ({ target, dependencies }) => () => target(...dependencies);

module.exports = fnFactory;

想要测试以下函数：

/*
 * underTest
*/

"use strict";

const underTest = ( innerLib, millions ) => innerLib.doComplexStuff(millions);

module.exports = underTest;

我将按如下方式设置我的测试（我使用 Jest）：

"use strict";

const fnFactory = require("./fnFactory");
const _underTest = require("./underTest");

test("fnFactory can mock a function by returng a function that calls a function with all its dependencies", () => {
    const fake = millions => `Didn't do anything with ${millions} million dollars!`;
    const underTest = fnFactory({ target: _underTest, dependencies: [{ doComplexStuff: fake  }, 10] });
    expect(underTest()).toBe("Didn't do anything with 10 million dollars!");
});

我使用一个简单的工厂，它返回一个函数， sstatic.net/ZZNmY.png" rel="nofollow noreferrer">查看测试结果

在生产代码中，我将手动注入被调用者的依赖项，如下所示：

/**
 * main
 * Entry point for the real application.
*/

"use strict";

const underTest = require("./underTest");
const innerLib = require("./innerLib");

underTest(innerLib, 10);

我倾向于限制我编写的大多数模块的范围到一件事，这减少了测试并将其集成到项目中时必须考虑的依赖项数量。

这就是我处理依赖关系的方法。

Answer 3

现在你可以了！

我发布了 proxyquire ，它将在您测试模块时覆盖模块内的全局需求。

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

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

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

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

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

Answer 4

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

无论好坏，大多数 Node.js 模块都是单例的； require() 同一模块的两段代码获得对该模块的相同引用。

您可以利用这一点并使用诸如 sinon 之类的东西来模拟所需的项目。 mocha 测试如下：

// 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 集成用于进行断言，我编写了一个模块 将 sinon 与 mocha 集成，以便更轻松地进行间谍/存根清理（以避免测试污染。）

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

另一种选择是使用 Jest 模拟。关注他们的页面

Answer 5

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

Answer 6

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

请注意操作 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)
  })
})

但是... jest 内置了此功能，我建议您使用测试框架来进行测试。

Answer 7

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

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

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

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

2）将模块实现为类，然后使用类方法/属性来获取依赖项

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

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

class underTestClass {
    getInnerLib () {
        return innerLib
    }

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

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

Answer 8

如果您曾经使用过 jest，那么您可能会熟悉 jest 的模拟功能。

使用“jest.mock(...)”，您可以简单地指定代码中某处的 require 语句中出现的字符串，并且每当需要使用该字符串的模块时，都会返回一个模拟对象。

例如，

jest.mock("firebase-admin", () => {
    const a = require("mocked-version-of-firebase-admin");
    a.someAdditionalMockedMethod = () => {}
    return a;
})

将用从该“工厂”函数返回的对象完全替换“firebase-admin”的所有导入/需求。

好吧，你可以在使用 jest 时这样做，因为 jest 围绕它运行的每个模块创建一个运行时，并将“挂钩”版本的 require 注入到模块中，但如果没有 jest，你将无法做到这一点。

我尝试使用 mock-require 来实现此目的，但对我来说它不起作用对于我的源代码中的嵌套级别。查看 github 上的以下问题： mock-require 并不总是用 Mocha 调用。

为了解决这个问题，我创建了两个 npm 模块，您可以使用它们来实现您想要的目标。

你需要一个 babel-plugin 和一个 module mocker。

• babel-plugin-mock-require
• jestlike-mock

在你的 .babelrc 中使用带有以下选项的 babel-plugin-mock-require 插件：

...
"plugins": [
        ["babel-plugin-mock-require", { "moduleMocker": "jestlike-mock" }],
        ...
]
...

并在你的测试中文件使用 jestlike-mock 模块，如下所示：

import {jestMocker} from "jestlike-mock";
...
jestMocker.mock("firebase-admin", () => {
            const firebase = new (require("firebase-mock").MockFirebaseSdk)();
            ...
            return firebase;
});
...

jestlike-mock 模块仍然非常初级，没有很多文档，但也没有太多代码。我很感谢任何 PR 提供更完整的功能集。目标是重新创建整个“jest.mock”功能。

为了了解 jest 是如何实现的，可以查找“jest-runtime”包中的代码。请参阅 https://github.com例如 /facebook/jest/blob/master/packages/jest-runtime/src/index.js#L734，这里它们生成模块的“automock”。

希望有帮助；）

Answer 9

你不能。您必须构建单元测试套件，以便首先测试最低的模块，然后再测试需要模块的较高级别的模块。

您还必须假设任何第 3 方代码和 Node.js 本身都经过了良好的测试。

我想您会在不久的将来看到模拟框架，它们会覆盖 global.require

如果您确实必须注入模拟，您可以更改代码以公开模块化范围。

// underTest.js
var innerLib = require('./path/to/innerLib');

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

module.exports = underTest;
module.exports.__module = module;

// test.js
function test() {
    var underTest = require("underTest");
    underTest.__module.innerLib = {
        toCrazyCrap: function() { return true; }
    };
    assert.ok(underTest());
}

请注意，这会将 .__module 暴露到您的 API 中，任何代码都可以访问模块化范围，但会带来危险。

Answer 10

您可以使用 mockery 库：

describe 'UnderTest', ->
  before ->
    mockery.enable( warnOnUnregistered: false )
    mockery.registerMock('./path/to/innerLib', { doComplexStuff: -> 'Complex result' })
    @underTest = require('./path/to/underTest')

  it 'should compute complex value', ->
    expect(@underTest()).to.eq 'Complex result'