rewire allows you to modify the behaviour of modules for better unit testing. You may

-provide mocks for other modules

-introduce mocks for other modules

- leak private variables

- override variables within the module

- inject your own scripts

var rewire=require("rewire"),

rewiredModule;

var rewire=require("rewire");

rewire("./myModuleA.js")===require("./myModuleA.js");// = true

var mockedModuleB= {},

mockedFs= {},

mocks= {

"fs": mockedFs,

"path/to/moduleB.js": mockedModuleB

};

rewiredModule=rewire("./myModuleA.js", {

"fs": {

readFile:function (path,encoding,cb) {cb(null,"Success!"); }

},

"../path/to/moduleB.js": myMockForModuleB

});

rewiredModule=rewire("./myModuleA.js", mocks);

var injections= {

console: {

log:function () {/* be quiet*/ }

},

process: { argv: ["someArgs"] },

__filename:"some/other/dir"

};

rewiredModule=rewire("./myModuleA.js",null, {

console: {

log:function () {/* be quiet*/ }

},

process: { argv: ["some","other","args"] },

__filename:"some/other/dir"

});

rewiredModule=rewire("./myModuleA.js",null, injections);

rewiredModule=

rewire("./myModuleA.js",null,"console.log('hellooo');");// prints "hellooo"

rewiredModule=rewire("./myModuleA.js",null,"console.log('hello');");

var leaks= ["myPrivateVar1","myPrivateVar2"];

rewiredModule=rewire("./myModuleA.js",null,null, ["myVar1","myVar2");

rewiredModule=rewire("./myModuleA.js",null,null, leaks);

rewiredModule.__.myPrivateVar1;// returns former private variable myPrivateVar1

rewiredModule.__.myPrivateVar2;// returns former private variable myPrivateVar2

console.log(rewiredModule.__.myVar1);

console.log(rewiredModule.__.myVar2);

rewire("./myModuleA.js",null,null,null,false)!==

rewire("./myModuleA.js",null,null,null,false)===require("./myModuleA.js");

rewire.reset();

Path to the module that shall be rewired. Use it exactly like require().

-*{Object} mocks (optional)*: <br/>

An object with mocks.

An object withmodulemocks. Keys should reflect the required path of the module.

-*{Object|String} injections (optional)*: <br />

If you pass an object, all keys of the object will be`var`s within the module. You can also eval a string.

<br />

Keys should be exactly the same like they're required in the target module.

So if you write`require("../../myModules/myModuleA.js")` you need to pass

`{"../../myModules/myModuleA.js": myModuleAMock}`.

All scripts are injected at the end of the module.So if there is any code in your module

that is executed during`require()`, yourinjected variables will be undefined at this point.

So if there is any code in your module that is executed during`require()`, your

injected variables will be undefined at this point.

Imagine`rewire("./myModule.js", null, {console: null});`:

varconsole=null;

Leaks are executed at the end of the module. If a`var` is undefined at this point you

won't be able to access the leak (because`undefined`-values are[copied by value](http://stackoverflow.com/questions/518000/is-javascript-a-pass-by-reference-or-pass-by-value-language)).

A good approach to this is:

All variables, that are[copied by value](http://stackoverflow.com/questions/518000/is-javascript-a-pass-by-reference-or-pass-by-value-language)

will not be updated anymore.

A good approach to solve this would be:

var myLeaks= {};

module.exports=function (someValue) {

myLeaks.someValue= someValue;

};

module.exports.__= {myLeaks: myLeaks};

And then:```rewire("myModuleA.js", null, null, ["myLeaks"]);```

Because```myLeaks``` is defined at the end of the module, you're able to access the leak object and all leaks that

are attached to it later during runtime. Because myLeaks is not exposed under regular circumstances your

module interface stays clean.

are attached to it later during runtime.

You should call this before every unit test to ensure a clean test environment.

All```require()```s will now return the original module again.

<br />