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.
