使用 Mocha 和 Node.js 对私有函数进行单元测试

Question

我正在使用Mocha 来对为 Node.js 编写的应用程序进行单元测试。

我想知道是否可以对尚未在模块中导出的函数进行单元测试。

示例：

我在foobar.js中有很多这样定义的函数：

function private_foobar1(){
    ...
}

function private_foobar2(){
    ...
}

还有一些导出为公共的函数：

exports.public_foobar3 = function(){
    ...
}

测试用例的结构如下：

describe("private_foobar1", function() {
    it("should do stuff", function(done) {
        var stuff = foobar.private_foobar1(filter);
        should(stuff).be.ok;
        should(stuff).....

显然这不起作用，因为private_foobar1 没有被导出。

对私有方法进行单元测试的正确方法是什么？ Mocha 是否有一些内置方法可以做到这一点？

Answer 1

我知道这不一定是您要寻找的答案，但我发现大多数时候如果私有函数值得测试，则值得将其放在自己的文件中。

例如，而不是将私有方法与公共方法放在同一个文件中，就像这样......

src/thing/PublicInterface.js

function helper1 (x) {
    return 2 * x;
}

function helper2 (x) {
    return 3 * x;
}

export function publicMethod1(x) {
    return helper1(x);
}

export function publicMethod2(x) {
    return helper1(x) + helper2(x);
}

...你这样拆分它：

src/thing/PublicInterface.js

import {helper1} from './internal/helper1.js';
import {helper2} from './internal/helper2.js';

export function publicMethod1(x) {
    return helper1(x);
}

export function publicMethod2(x) {
    return helper1(x) + helper2(x);
}

src/thing/internal/helper1.js

export function helper1 (x) {
    return 2 * x;
}

src/thing/internal/helper2.js

export function helper2 (x) {
    return 3 * x;
}

这样，您可以轻松地按原样测试helper1 和helper2，而无需使用 Rewire 和其他“魔法”（我发现，在调试或尝试制作你转向 TypeScript，更不用说对新同事的理解性变差了）。并且它们位于名为 internal 或类似名称的子文件夹中，将有助于避免在非预期的地方意外使用它们。

---

P.S.：“私有”方法的另一个常见问题是，如果您想测试 publicMethod1 和 publicMethod2 并再次模拟助手，您通常需要像 Rewire 这样的东西来做到这一点。但是，如果它们位于单独的文件中，您可以使用 Proxyquire 来执行此操作，与 Rewire 不同，它不需要对构建过程进行任何更改，易于阅读和调试，即使使用 TypeScript 也能很好地工作。

Answer 2

我关注barwin's answer 并检查了如何使用 rewire 模块进行单元测试。我可以确认这个解决方案很有效。

该模块应该分为两部分 - 公共部分和私有部分。对于公共功能，您可以以标准方式执行此操作：

const { public_foobar3 } = require('./foobar');

对于私有范围：

const privateFoobar = require('rewire')('./foobar');
const private_foobar1 = privateFoobar .__get__('private_foobar1');
const private_foobar2 = privateFoobar .__get__('private_foobar2');

为了更多地了解这个主题，我创建了一个包含完整模块测试的工作示例，测试包括私有和公共范围。

有关详细信息，我鼓励您查看完整描述该主题的文章 (How to test private functions of a CommonJS module)。它包括代码示例。

Answer 3

Here is a really good workflow to test your private methods 由 Google 工程师 Philip Walton 在其博客中解释。

原则

• 正常编写代码
• 将您的私有方法绑定到单独代码块中的对象，并用_ 标记（例如）
• 用开始和结束 cmets 包围该代码块

然后使用构建任务或您自己的构建系统（例如 grunt-strip-code）剥离此块以进行生产构建。

您的测试版本可以访问您的私有 API，而您的生产版本没有。

片段

这样写你的代码：

var myModule = (function() {

  function foo() {
    // Private function `foo` inside closure
    return "foo"
  }

  var api = {
    bar: function() {
      // Public function `bar` returned from closure
      return "bar"
    }
  }

  /* test-code */
  api._foo = foo
  /* end-test-code */

  return api
}())

您的Grunt 任务如下：

grunt.registerTask("test", [
  "concat",
  "jshint",
  "jasmine"
])
grunt.registerTask("deploy", [
  "concat",
  "strip-code",
  "jshint",
  "uglify"
])

更深入

In a later article，它解释了“测试私有方法”的“为什么”

Answer 4

我为此目的制作了一个 npm 包，您可能会发现它很有用：require-from

基本上，您通过以下方式公开非公共方法：

module.testExports = {
    private_foobar1: private_foobar1,
    private_foobar2: private_foobar2,
    ...
}

注意：testExports 可以是您想要的任何有效名称，当然 exports 除外。

从另一个模块：

var requireFrom = require('require-from');
var private_foobar1 = requireFrom('testExports', './path-to-module').private_foobar1;

Answer 5

如果该函数不是由模块导出的，则不能被模块外的测试代码调用。这是由于 JavaScript 的工作原理，而 Mocha 本身无法规避这一点。

在我确定测试私有函数是正确的事情的少数情况下，我设置了一些环境变量，我的模块检查以确定它是否在测试设置中运行。如果它在测试设置中运行，那么它会导出我可以在测试期间调用的其他函数。

“环境”这个词在这里用得很松散。这可能意味着检查process.env 或其他可以与“您现在正在接受测试”的模块通信的东西。我必须这样做的实例是在RequireJS 环境中，为此我使用了module.config。

Answer 6

为了使私有方法可用于测试，我这样做：

const _myPrivateMethod: () => {};

const methods = {
    myPublicMethod1: () => {},
    myPublicMethod2: () => {},
}

if (process.env.NODE_ENV === 'test') {
    methods._myPrivateMethod = _myPrivateMethod;
}

module.exports = methods;

Answer 7

我添加了一个名为 Internal() 的额外函数，并从那里返回所有私有函数。然后导出这个 Internal() 函数。示例：

function Internal () {
  return { Private_Function1, Private_Function2, Private_Function2}
}

// Exports --------------------------
module.exports = { PublicFunction1, PublicFunction2, Internal }

你可以这样调用内部函数：

let test = require('.....')
test.Internal().Private_Function1()

我最喜欢这个解决方案，因为：

• 始终只导出一个函数Internal()。此 Internal() 函数始终用于测试私有函数。
• 实现起来很简单
• 对生产代码的影响很小（只有一个额外的功能）

Answer 8

如果您希望保持简单，也只需导出私有成员，但通过一些约定明确与公共 API 分开，例如在它们前面加上 _ 或将它们嵌套在单个 private 对象下。

var privateWorker = function() {
    return 1
}

var doSomething = function() {
    return privateWorker()
}

module.exports = {
    doSomething: doSomething,
    _privateWorker: privateWorker
}

Answer 9

查看rewire 模块。它允许您在模块中获取（和操作）私有变量和函数。

所以在你的情况下，用法是这样的：

var rewire = require('rewire'),
    foobar = rewire('./foobar'); // Bring your module in with rewire

describe("private_foobar1", function() {

    // Use the special '__get__' accessor to get your private function.
    var private_foobar1 = foobar.__get__('private_foobar1');

    it("should do stuff", function(done) {
        var stuff = private_foobar1(filter);
        should(stuff).be.ok;
        should(stuff).....