Experimental alternatives to Dependency Injection in Javascript

monkey-cage-test.js

'use strict';

require('chai').should();

var sinon = require('sinon');
var cage = require('./monkey-cage.js');

describe(__filename, function() {
  
  describe('openCage', function() {
    
    beforeEach(function() {
      sinon.stub(cage.deps.fs, 'writeFile').yieldsAsync();
    });
    
    afterEach(function() {
      cage.deps.fs.restore();
    });
    
    it('should invoke fs.writeFile() with message', function(done) {
      cage.openCage(function(err) {
        var first_call = cage.deps.fs.writeFile.getCall(0), 
            expected_message = 'Unleashed 🐒 @ 23:27';
        cage.deps.fs.writeFile.callCount.should.eql(1);
        first_call.args[1].should.eql(expected_message);
        done(err);
      });
    });
    
  });
  
});

monkey-cage-with-bind.js

'use strict';

// Alternative with a create() function where deps are injected and bound to functions outside of closure (to make file easier to manage).

var externals = {};

exports.create = function(fs, path, error_factory) {
  return {
    openCage: externals.openCage.bind(null, fs)
  };
};

externals.openCage = function(fs, callback) {
  var caretakers_log_path = '/dev/null', 
      action = 'Unleashed 🐒 @ 23:27';
  fs.writeFile(caretakers_log_path, action, callback);
};

if (process.env.NODE_ENV === 'test') {
  exports.externals = externals;
}

monkey-cage-with-create.js

'use strict';

// Alternative with a create() function where deps are injected

exports.create = function(fs, path, error_factory) {
  return {
    openCage: function(callback) {
      var caretakers_log_path = '/dev/null', 
          action = 'Unleashed 🐒 @ 23:27';
          fs.writeFile(caretakers_log_path, action, callback);
    }
  };
};

monkey-cage.js

'use strict';

// Dependencies defined inside of exportable object for mocking during test, 
// since it's a bit tedious to manage DI in Javascript. Ugly or Smart?

var deps = {
  fs: require('fs'),
  path: require('path'),
  error_factory: require('error-factory')
};


exports.openCage = function(callback) {
  var caretakers_log_path = '/dev/null', 
      action = 'Unleashed 🐒 @ 23:27';
  deps.fs.writeFile(caretakers_log_path, action, callback);
};


if (process.env.NODE_ENV === 'test') {
  exports.deps = deps;
}

Background story is that it doesn't feel fantastic to do regular dependency injection to modules (e.g. through a create() "construct").

Maybe this is a less obtrusive way of doing things? Or is it more messy to follow such a convention?