我发现了一种非常简单的方法，可以让你在测试中测试、监视和模拟这些内部函数:

假设我们有一个这样的节点模块:

mymodule.js:
------------
"use strict";

function myInternalFn() {

}

function myExportableFn() {
    myInternalFn();   
}

exports.myExportableFn = myExportableFn;

如果我们现在想测试并监视和模拟myInternalFn，而不是在生产中导出它，我们必须像这样改进文件:

my_modified_module.js:
----------------------
"use strict";

var testable;                          // <-- this is new

function myInternalFn() {

}

function myExportableFn() {
    testable.myInternalFn();           // <-- this has changed
}

exports.myExportableFn = myExportableFn;

                                       // the following part is new
if( typeof jasmine !== "undefined" ) {
    testable = exports;
} else {
    testable = {};
}

testable.myInternalFn = myInternalFn;

现在你可以测试，间谍和模拟myInternalFn在任何地方，你使用它作为测试。myInternalFn和在生产中它是不导出的。

编辑:

使用vm加载模块可能会导致意外的行为(例如，instanceof操作符不再适用于在这样的模块中创建的对象，因为全局原型与通常使用require加载的模块中使用的对象不同)。我不再使用下面的技术，而是使用rewire模块。它工作得很好。这是我最初的回答:

详细阐述srosh的回答……

这感觉有点粗糙，但我写了一个简单的“test_utils.js”模块，它应该允许你做你想做的事情，而不用在你的应用程序模块中有条件导出:

var Script = require('vm').Script,
    fs     = require('fs'),
    path   = require('path'),
    mod    = require('module');

exports.expose = function(filePath) {
  filePath = path.resolve(__dirname, filePath);
  var src = fs.readFileSync(filePath, 'utf8');
  var context = {
    parent: module.parent, paths: module.paths, 
    console: console, exports: {}};
  context.module = context;
  context.require = function (file){
    return mod.prototype.require.call(context, file);};
  (new Script(src)).runInNewContext(context);
  return context;};

还有一些更多的东西包含在一个节点模块的全局模块对象中，可能也需要进入上面的上下文对象，但这是我需要它工作的最小集。

这里有一个摩卡BDD的例子:

var util   = require('./test_utils.js'),
    assert = require('assert');

var appModule = util.expose('/path/to/module/modName.js');

describe('appModule', function(){
  it('should test notExposed', function(){
    assert.equal(6, appModule.notExported(3));
  });
});

我发现了一种非常简单的方法，可以让你在测试中测试、监视和模拟这些内部函数:

假设我们有一个这样的节点模块:

mymodule.js:
------------
"use strict";

function myInternalFn() {

}

function myExportableFn() {
    myInternalFn();   
}

exports.myExportableFn = myExportableFn;

如果我们现在想测试并监视和模拟myInternalFn，而不是在生产中导出它，我们必须像这样改进文件:

my_modified_module.js:
----------------------
"use strict";

var testable;                          // <-- this is new

function myInternalFn() {

}

function myExportableFn() {
    testable.myInternalFn();           // <-- this has changed
}

exports.myExportableFn = myExportableFn;

                                       // the following part is new
if( typeof jasmine !== "undefined" ) {
    testable = exports;
} else {
    testable = {};
}

testable.myInternalFn = myInternalFn;

现在你可以测试，间谍和模拟myInternalFn在任何地方，你使用它作为测试。myInternalFn和在生产中它是不导出的。

重新布线模块绝对是答案。

下面是我使用Mocha访问未导出函数并测试它的代码。

application.js:

function logMongoError(){
  console.error('MongoDB Connection Error. Please make sure that MongoDB is running.');
}

. js:

var rewire = require('rewire');
var chai = require('chai');
var should = chai.should();


var app = rewire('../application/application.js');


var logError = app.__get__('logMongoError'); 

describe('Application module', function() {

  it('should output the correct error', function(done) {
      logError().should.equal('MongoDB Connection Error. Please make sure that MongoDB is running.');
      done();
  });
});

与Jasmine合作，我试图深入研究Anthony Mayfield提出的基于重新布线的解决方案。

我实现了以下函数(注意:还没有完全测试，只是作为一个可能的策略分享):

function spyOnRewired() {
    const SPY_OBJECT = "rewired"; // choose preferred name for holder object
    var wiredModule = arguments[0];
    var mockField = arguments[1];

    wiredModule[SPY_OBJECT] = wiredModule[SPY_OBJECT] || {};
    if (wiredModule[SPY_OBJECT][mockField]) // if it was already spied on...
        // ...reset to the value reverted by jasmine
        wiredModule.__set__(mockField, wiredModule[SPY_OBJECT][mockField]);
    else
        wiredModule[SPY_OBJECT][mockField] = wiredModule.__get__(mockField);

    if (arguments.length == 2) { // top level function
        var returnedSpy = spyOn(wiredModule[SPY_OBJECT], mockField);
        wiredModule.__set__(mockField, wiredModule[SPY_OBJECT][mockField]);
        return returnedSpy;
    } else if (arguments.length == 3) { // method
        var wiredMethod = arguments[2];

        return spyOn(wiredModule[SPY_OBJECT][mockField], wiredMethod);
    }
}

使用这样的函数，你可以同时监视非导出对象和非导出顶级函数的方法，如下所示:

var dbLoader = require("rewire")("../lib/db-loader");
// Example: rewired module dbLoader
// It has non-exported, top level object 'fs' and function 'message'

spyOnRewired(dbLoader, "fs", "readFileSync").and.returnValue(FULL_POST_TEXT); // method
spyOnRewired(dbLoader, "message"); // top level function

然后你可以设定这样的期望:

expect(dbLoader.rewired.fs.readFileSync).toHaveBeenCalled();
expect(dbLoader.rewired.message).toHaveBeenCalledWith(POST_DESCRIPTION);

诀窍是将NODE_ENV环境变量设置为test之类的东西，然后有条件地导出它。

假设你没有全局安装mocha，你可以在你的应用目录的根目录下有一个Makefile，它包含以下内容:

REPORTER = dot

test:
    @NODE_ENV=test ./node_modules/.bin/mocha \
        --recursive --reporter $(REPORTER) --ui bbd

.PHONY: test

这个make文件在运行mocha之前设置NODE_ENV。然后可以在命令行中使用make test运行mocha测试。

现在，您可以有条件地导出您的函数，通常只有当您的mocha测试正在运行时才会导出:

function exported(i) {
   return notExported(i) + 1;
}

function notExported(i) {
   return i*2;
}

if (process.env.NODE_ENV === "test") {
   exports.notExported = notExported;
}
exports.exported = exported;

另一个答案建议使用vm模块计算文件，但这不起作用，并抛出一个错误，指出exports未定义。