CODEWITHSUNDEEP
javascriptnode.js
PositiveGuy
PositiveGuy

Reputation: 20262

Dependency Injection and Interfaces in Node

Coming from a C# background, I used interfaces to base my mock objects off of. I created custom mock objects myself and created the mock implementation off a C# interface.

How do you do something like this in JS or node? Create an interface that you can "mock" off of and also the interface would serve for the real class that would also be able to implement that interface? Does this even make sense in JS or or the Node World?

For example in Java, same deal, define an interface with method stubs and use that as the basis to create real class or mock class off of.

Upvotes: 1

Views: 1445

Answers (1)

Josh Beam
Josh Beam

Reputation: 19812

Unfortunately you're not going to find the standard interface as a part of JavaScript. I've never used C#, but I've used Java, and correct me if I'm wrong, but it looks like you're talking about creating interfaces and overriding methods for both mock testing purposes, as well as being able to implement those interfaces in other classes.

Because this isn't a standard JavaScript feature, I think you'll find that there are going to be a lot of very broad answers here. However, to get an idea of how some popular libraries implement this, I might suggest looking at how AngularJS looks at mock testing (there are many resources online, just Google it. As a starting point, look at how they use the ngMock module with Karma and Jasmine.)

Also, because of JavaScript's very flexible nature, you'll find that you can override any sort of "class method" (that is, any function object that is a member of another object, whether that be a new'ed "class" or a plain object) by simply re-implementing it wherever you need to... there's no special syntax for it. To understand where and how you would accomplish this, I'd suggest looking from the ground up at how JavaScript using prototypal/prototypical inheritance. A starting point might be considering an example like this:

function Cat(config) {
  if(typeof config !== 'undefined') {
    this.meow = config.meow; // where config can possibly implement certain mock methods
  }
}

Cat.prototype = {
  this.meow = function() {
    // the meow that you want to use as part of your "production" code
  };
};

var config = {};

config.meow = function() {
  // some mock "meow" stuff
};

var testCat = new Cat(config); // this one will use the mock "Cat#meow"

var realCat = new Cat(); // this one will use the prototype "Cat#meow"

In the above example, because of how JavaScript looks up the prototype chain, if it sees an implementation in the class itself, it'll stop there and use that method (thus, you've "overridden" the prototype method). However, in that example, if you don't pass in a config, then it'll look all the way up to the prototype for the Cat#meow method, and use that one.

TL;DR: there's not one good way to implement JavaScript interfaces, especially ones that double as mocks (there's not even a best way to implement dependency injection... that's also a foreign concept to JavaScript itself, even though many libraries do successfully implement it for cetain use-cases.)

Upvotes: 1

Related Questions