require-inject

A simple mock injector compatible needing no instrumentation in the libraries being tested

Example

var requireInject = require('require-inject');

var mymod = requireInject('mymod', {
    'fs': {
        stat: function (file,cb) {
            switch (file) {
            case 'testfile1': return cb(null,{})
            case 'testfile2': return cb(new Error('ENOENT'))
            }
        }
    }
})

var myglobal = requireInject.installGlobally('myglobal', { … })

Usage in your tests

• var mymod = requireInject( module, mocks )

module is the name of the module you want to require. This is what you'd
pass to require to load the module from your script. This means that for
relative paths, the path should be relative to your test script, not to the
thing you're injecting dependencies into.

mocks is an object with keys that are the names of the modules you want
to mock and values of the mock version of the objects.

requireInject makes it so that when module is required, any of its
calls to require for modules inclued in mocks will return the mocked
version. It takes care to not impact any other uses of module, any
calls to require for it will get a version without mocks.

• var mymod = requireInject.withEmptyCache(module, mocks)

As with requireInject but your require cache will be cleared before requring
the module to have mocks injected into it. This can be useful when your test shares
dependencies with the module to be mocked and you need to mock a transitive
dependency of one of those dependencies. That is:

Test → A → B

ModuleToTest → A → MockedB

If we we didn't clear the cache then ModuleToTest would get the already
cached version of A and the MockedB would never be injected. By clearing the cache
first it means that ModuleToTest will get it's own copy of A which will then pick
up any mocks we defined.

Previously to achieve this you would need to have provided a mock for A,
which, if that isn't what you were testing, could be frustrating busy work.

• var myglobal = requireInject.installGlobally( module, mocks)

As with requireInject, except that the module and its mocks are left in
the require cache and any future requires will end up using them too. This
is helpful particularly in the case of things that defer loading (that is,
do async loading).

• var myglobal = requireInject.installGlobally.andClearCache(module, mocks)

As with requireInject.installGlobally but clear the cache first as with
requireInject.withEmptyCache. Because this globally clears the cache it
means that any requires after this point will get fresh copies of their
required modules, even if you required them previously.