Replace constructors with constructors

[searls]

Since starting the library, when you've done td.object(SomeConstructorFunction) or used td.replace to replace a constructor, td.js has returned a function bag to the test of the instance methods on the constructor. This PR reverses course, and instead returns a fake constructor instead. It's also the first breaking change to the API since we went 1.0, so releasing this will require a major version bump.

Benefits to you, dear reader:

• Stubbing "static" functions properties on the function itself (as opposed to its prototype) is now possible (Unable to stub static method on ES6 classes #164)
• Stubbing the constructor itself is now possible (note that stubbing the return value doesn't make much sense, but thenDo and thenThrow might be handy)
• Verifying the constructor was called with td.verify is now possible, in case you want to ensure the item was instantiated just-so (Make the constructor property of td.replaced() instantiable types useful #121)
• Our previous fake constructor implementation was hidden behind the td.replace API as an implementation detail, that will no longer be necessary, as anyone will be able to fake a constructor with td.object(SomeConstructorFunction) (td.constructor() feature for creating fake constructors #54)
• "Deep mocks" will be possible for the first time; that is, we can now implement a td.replace function that deeply replaces nested function properties on whatever we're replacing, since there will no longer be an impedance mismatch (i.e. we won't be returning an object where the subject receives a constructor) (Classes with overridden methods not doubling properly since 1.10.0 #159)
• Instances of the fake constructor will now pass instanceof checks against the original constructor type (Pass instanceof checks for constructor replacement #108)

Stuff to-be-done:

• calling td.object(SomeConstructorFunction) will return a fake constructor which inherits from it, and for which all its functions are replaced by test double functions
  • ✅ any "static" functions defined on the function itself (e.g. SomeConstructorFunction.create())
  • ✅ any "instance" functions defined on prototype
  • ✅ any inherited static/instance functions from types the constructor extends
  • ✅ constructor which should be a reference to the fake constructor itself
  • ✅ toString which will tell you it's a "test double constructor"
  • ❌ built-in functions inherited from Function.prototype and Object.prototype (like valueOf, hasOwnProperty)
• calling td.replace('../some/constructor/exporting/module') will now replace both the actual module with these (new and improved!) fake constructors and return the same fake constructor to the test
• fix unit tests under node
• fix unit tests in browser
• fix tons of example tests
• update docs
• plan what we want to bundle in this major bump with other team members (e.g. ES6 port? dropping Node<4? Yarn?)

Required style changes

This means you'll have to sprinkle a prototype onto any existing stubbings in your test code base of constructor-replaced functions. For example:

// production code
var Dog = function Dog()
Dog.prototype.woof = function () {}

// the *OLD* 1.x behavior
var dog = td.object(Dog)
td.when(dog.woof()).thenReturn('bark')
dog.woof() // => returns 'bark'

// the *NEW* 2.x behavior
var FakeDog = td.object(Dog)
td.when(FakeDog.prototype.woof()).thenReturn('bark')
FakeDog.prototype.woof() // => returns 'bark'
new FakeDog().woof() // => returns 'bark'

Conclusion

To be honest, for my own practice 1.x worked better, but it was less obvious and it required me to contort the codebase into knots to facilitate other people's styles, like support for static methods. Whichever style you prefer, I apologize for not having the foresight to have implemented this API in the first place.

Because I understand some people have a lot of existing tests and (as tests are untested), they'll be wary of transitioning them, I plan on maintaining a 1.x-specific release branch with the objective of backporting critical bugfixes.

Fixes #166