Question

What is the best practice for injecting dependencies into models? And especially, what if their getter are asynchronous, as with mongodb.getCollection()?

The point is to inject dependencies once with

var model = require('./model')({dep1: foo, dep2: bar});

and call all member methods without having to pass them as arguments. Neither do I want to have each method to begin with a waterfall of async getters.

I ended up with a dedicated exports wrapper that proxies all calls and passes the async dependencies.

However, this creates a lot of overhead, it’s repetitive a lot and I generally do not like it.

var Entity = require('./entity');

function findById(id, callback, collection) {
    // ...
    // callback(null, Entity(...));
};

module.exports = function(di) {
    function getCollection(callback) {
        di.database.collection('users', callback);
    };

    return {
        findById: function(id, callback) {
            getCollection(function(err, collection) {
                findById(id, callback, collection);
            });
        },
        // ... more methods, all expecting `collection`
    };
};

What is the best practice for injecting dependencies, especially those with async getters?

Answer 1

If your need is to support unit testing, dependency injection in a dynamic language like javascript is probably more trouble than it’s worth. Note that just about none of the modules you require from others are likely to use the patterns for DI you see in Java, .NET, and with other statically compiled languages.

If you want to mock out behavior in order to isolate specific units of code for testing, see the ‘sinon’ module http://sinonjs.org/. It allows you to dynamically swap in/out interceptors that can either spy on method calls or replace them altogether. In practice, you would write a mocha test where you require your module, then require a module that’s leveraged in your code. Use sinon to spy or stub a method on that module and as a result, you can isolate your code.

There is one scenario where I’ve not been able to completely isolate 3rd party code with sinon, and this is when the act of require()ing a module executes some behavior that you don’t want to run in your test. For that scenario, I made a super simple module called ‘mockrequire’ https://github.com/mateodelnorte/mockrequire that allows you to provide an inline mock to be required instead of the actual module. You can provide a mock that uses spy or stub from sinon and have the same syntax and patterns as all the rest of your tests.

Hopefully this answers the underlying question from your post. 😉