Add td.instance()

README.md

@@ -242,7 +242,7 @@ signup = td.replace(app, 'signup', {
 })
 ```
 
-### `td.func()`, `td.object()`, `td.constructor()`, and `td.imitate()` to create test doubles
+### `td.func()`, `td.object()`, `td.constructor()`, `td.instance()` and `td.imitate()` to create test doubles
 
 `td.replace()`'s imitation and injection convenience is great when your
 project's build configuration allows for it, but in many cases you'll want or
@@ -332,6 +332,28 @@ const subject = function (SomeConstructor) {
 }
 ```
 
+#### `td.instance()`
+
+If your code depends on ES classes or functions, then the `td.instance()` function 
+will create a mock constructor and return a new instance of that mock constructor.
+
+The following code snippets are functionally equiavalent:
+
+```js
+const fakeObject = td.instance(RealConstructor)
+td.when(fakeObject.doStuff()).thenReturn('just did it')
+
+fakeObject.doStuff() // returns "just did it"
+```
+
+```js
+const FakeConstructor = td.constructor(RealConstructor)
+const fakeObject = new FakeConstructor()
+td.when(fakeObject.doStuff()).thenReturn('just did it')
+
+fakeObject.doStuff() // returns "just did it"
+```
+
 #### `td.imitate()`
 
 **`td.imitate(realThing[, name])`**

examples/node-ava/test/lib/instance-of-test.js

@@ -25,4 +25,11 @@ test('instance-of', function (t) {
   t.true(td.explain(eightiesGuy.hairspray).isTestDouble)
   t.true(eightiesGuy instanceof EightiesGuy)
   t.true(eightiesGuy instanceof Person)
+
+  const otherGuy = td.instance(EightiesGuy)
+
+  t.true(td.explain(otherGuy.age).isTestDouble)
+  t.true(td.explain(otherGuy.hairspray).isTestDouble)
+  t.true(otherGuy instanceof EightiesGuy)
+  t.true(otherGuy instanceof Person)
 })

examples/node/test/lib/instance-of-test.js

@@ -19,4 +19,11 @@ module.exports = function () {
   assert.ok(td.explain(eightiesGuy.hairspray).isTestDouble)
   assert.ok(eightiesGuy instanceof EightiesGuy)
   assert.ok(eightiesGuy instanceof Person)
+
+  const otherGuy = td.instance(EightiesGuy)
+
+  assert.ok(td.explain(otherGuy.age).isTestDouble)
+  assert.ok(td.explain(otherGuy.hairspray).isTestDouble)
+  assert.ok(otherGuy instanceof EightiesGuy)
+  assert.ok(otherGuy instanceof Person)
 }

examples/plain-html/test/math-problem-test.js

@@ -34,3 +34,22 @@ describe('MathProblem', function () {
     expect(result).toEqual('neat')
   })
 })
+
+describe('MathProblem (td.instance)', function () {
+  var subject, createRandomProblem, submitProblem
+  beforeEach(function () {
+    createRandomProblem = td.function('createRandomProblem')
+    submitProblem = td.function('submitProblem')
+    subject = new MathProblem(createRandomProblem, td.instance(SavesProblem), submitProblem)
+  })
+
+  it('POSTs a random problem', function () {
+    td.when(createRandomProblem()).thenReturn('some problem')
+    td.when(subject.savesProblem.save('some problem')).thenReturn('saved problem')
+
+    var result = subject.generate()
+
+    td.verify(submitProblem('saved problem'))
+    expect(result).toEqual('neat')
+  })
+})

examples/webpack/test/math-problem-test.js

@@ -17,7 +17,8 @@ MathProblem.prototype.generate = function(){
 }
 
 var td = require('testdouble')
-describe('MathProblem', function(){
+
+describe('MathProblem', function() {
   var subject, createRandomProblem, FakeSavesProblem, submitProblem;
   beforeEach(function(){
     createRandomProblem = td.function('createRandomProblem')
@@ -35,3 +36,21 @@ describe('MathProblem', function(){
     expect(result).toEqual('neat')
   })
 })
+
+describe('MathProblem (td.instance)', function() {
+  var subject, createRandomProblem, submitProblem;
+  beforeEach(function(){
+    createRandomProblem = td.function('createRandomProblem')
+    submitProblem = td.function('submitProblem')
+    subject = new MathProblem(createRandomProblem, td.instance(SavesProblem), submitProblem)
+  })
+  it('POSTs a random problem', function() {
+    td.when(createRandomProblem()).thenReturn('some problem')
+    td.when(subject.savesProblem.save('some problem')).thenReturn('saved problem')
+
+    var result = subject.generate()
+
+    td.verify(submitProblem('saved problem'))
+    expect(result).toEqual('neat')
+  })
+})

index.d.ts

@@ -135,6 +135,23 @@ export function constructor<T>(
   constructor: Constructor<T>
 ): TestDoubleConstructor<T>;
 
+//
+// fake: instance objects
+//
+
+/**
+ * Construct an instance of a faked class.
+ *
+ * @export
+ * @template T
+ * @param {{ new (...args: any[]): T }} constructor
+ * @returns {DoubledObject<typeof T>}
+ */
+export function instance<T>(
+  constructor: Constructor<T>
+): DoubledObject<T>;
+
+
 //
 // fake: functions
 // ----------------------------------------------------------------------------
@@ -252,7 +269,7 @@ export function imitate<T>(original: T, name?: string): TestDouble<T>;
 export function callback(...args: any[]): void;
 
 /**
- * Swap out real dependenencies with fake one. Intercept calls to `require`
+ * Swap out real dependencies with fake one. Intercept calls to `require`
  * that dependency module and ensure your subject is handed a fake instead.
  *
  * @export
@@ -262,7 +279,7 @@ export function callback(...args: any[]): void;
  */
 export function replace(path: string, f?: any): any;
 /**
- * Swap out real dependenencies with fake one. Intercept calls to `require`
+ * Swap out real dependencies with fake one. Intercept calls to `require`
  * that dependency module and ensure your subject is handed a fake instead.
  *
  * @export
@@ -272,7 +289,7 @@ export function replace(path: string, f?: any): any;
  */
 export function replaceCjs(path: string, f?: any): any;
 /**
- * Swap out real dependenencies with fake one. Intercept calls to `import`
+ * Swap out real dependencies with fake one. Intercept calls to `import`
  * that dependency module and ensure your subject is handed a fake instead.
  *
  * @export
@@ -285,7 +302,7 @@ export function replaceEsm(path: string, namedExportStubs?: any, defaultExportSt
   Promise<{default?: any, [namedExport: string]: any}>;
 
 /**
- * Swap out real dependenencies with fake one. Reference to the property will
+ * Swap out real dependencies with fake one. Reference to the property will
  * be replace it during your test.
  *
  * @export

src/index.js

@@ -1,6 +1,7 @@
 import tdFunction from './function'
 import object from './object'
 import constructor from './constructor'
+import instance from './instance'
 import imitate from './imitate'
 import when from './when'
 import verify from './verify'
@@ -18,6 +19,7 @@ module.exports = {
   func: tdFunction,
   object,
   constructor,
+  instance,
   imitate,
   when,
   verify,

src/index.mjs

@@ -1,6 +1,7 @@
 import function2 from './function.js'
 import object2 from './object.js'
 import constructor2 from './constructor.js'
+import instance2 from './instance.js'
 import imitate2 from './imitate/index.js'
 import when2 from './when.js'
 import verify2 from './verify.js'
@@ -14,6 +15,7 @@ import version2 from './version.js'
 export const func = function2.default
 export const object = object2.default
 export const constructor = constructor2.default
+export const instance = instance2.default
 export const imitate = imitate2.default
 export const when = when2.default
 export const verify = verify2.default

src/instance.js

@@ -0,0 +1,5 @@
+import constructor from './constructor.js'
+
+export default function instance (typeOrNames) {
+  return new (constructor(typeOrNames))()
+}

src/object.js

@@ -32,7 +32,7 @@ var createTestDoublesForFunctionNames = (names) =>
   }, {})
 
 var ensureFunctionIsNotPassed = () =>
-  log.error('td.object', 'Functions are not valid arguments to `td.object` (as of testdouble@2.0.0). Please use `td.function()` or `td.constructor()` instead for creating fake functions.')
+  log.error('td.object', 'Functions are not valid arguments to `td.object` (as of testdouble@2.0.0). Please use `td.function()`, `td.constructor()` or `td.instance()` instead for creating fake functions.')
 
 var ensureOtherGarbageIsNotPassed = () =>
   log.error('td.object', `\

test/safe/instance.test.js

@@ -0,0 +1,55 @@
+let Thing, SuperThing, fakeInstance
+
+module.exports = {
+  'being given an mock object instance': {
+    beforeEach () {
+      SuperThing = function SuperThing () {}
+      SuperThing.prototype.biz = () => 1
+      Object.defineProperties(SuperThing.prototype, {
+        secretFunc: {
+          value () {},
+          enumerable: false,
+          writable: true
+        }
+      })
+
+      Thing = function Thing () {}
+      Thing.prototype = new SuperThing()
+      Thing.prototype.foo = () => 2
+      Thing.bar = () => 3
+      Thing.prototype.instanceAttr = 'baz'
+      Thing.staticAttr = 'qux'
+      Object.defineProperties(Thing, {
+        secretStaticFunc: {
+          value () {},
+          enumerable: false,
+          writable: true
+        }
+      })
+
+      fakeInstance = td.instance(Thing)
+    },
+    'instance methods can be stubbed' () {
+      td.when(fakeInstance.foo()).thenReturn(7)
+
+      assert._isEqual(fakeInstance.foo(), 7)
+    },
+    'super type methods can be stubbed, too' () {
+      td.when(fakeInstance.biz()).thenReturn(6)
+
+      assert._isEqual(fakeInstance.biz(), 6)
+    },
+    'things print OK' () {
+      assert._isEqual(fakeInstance.foo.toString(), '[test double for "Thing.prototype.foo"]')
+    },
+    'non-enumerables are covered' () {
+      assert._isEqual(td.explain(fakeInstance.secretFunc).isTestDouble, true)
+    },
+    'instanceof checks out' () {
+      assert._isEqual(fakeInstance instanceof Thing, true)
+    },
+    'original attributes are carried over' () {
+      assert._isEqual(fakeInstance.instanceAttr, 'baz')
+    }
+  }
+}

test/safe/object.test.js

@@ -50,7 +50,7 @@ module.exports = {
       td.object(function () {})
       assert.fail('This should have errored!')
     } catch (e) {
-      assert.ok(/Please use `td\.function\(\)` or `td\.constructor\(\)` instead/.test(e.message))
+      assert.ok(/Please use `td\.function\(\)`, `td\.constructor\(\)` or `td\.instance\(\)` instead/.test(e.message))
     }
   },
   'passing an Object.create()d thing' () {

test/safe/testdouble.test.js

@@ -7,6 +7,7 @@ module.exports = {
     assert._isEqual(td.imitate, require('../../src/imitate').default)
     assert._isEqual(td.object, require('../../src/object').default)
     assert._isEqual(td.constructor, require('../../src/constructor').default)
+    assert._isEqual(td.instance, require('../../src/instance').default)
     assert._isEqual(td.matchers, require('../../src/matchers').default)
     assert._isEqual(td.callback, require('../../src/callback').default)
     assert._isEqual(td.explain, require('../../src/explain').default)

test/safe/typescript-typings.test.ts

@@ -56,6 +56,13 @@ export = {
       td.when(bear.sleep()).thenReturn('zzzzzz')
 
       assert.strictEqual(bear.sleep(), 'zzzzzz')
+
+      const instanceBear = td.instance<Bear>(Bear)
+      assert.strictEqual(instanceBear instanceof Bear, true)
+      assert.strictEqual(
+        td.explain(instanceBear.sleep).isTestDouble,
+        true
+      )
     }
 
     const testObject = {

test/safe/verify.test.js

@@ -79,6 +79,13 @@ module.exports = {
       td.verify(testDoubleObj.prototype.baz())
     }, /verification on test double `Foo.prototype.baz`/)
     assert._isEqual(testDoubleObj.prototype.biz, 'not a function!')
+
+    const testDoubleInstance = td.instance(SomeType)
+
+    assert.throws(() => {
+      td.verify(testDoubleInstance.baz())
+    }, /verification on test double `Foo.prototype.baz`/)
+    assert._isEqual(testDoubleInstance.biz, 'not a function!')
   },
   'with a test double *as an arg* to another': {
     'with an unnamed double function _as an arg_' () {

test/unit/index.test.js

@@ -5,6 +5,7 @@ module.exports = () => {
   const func = td.replace('../../src/function').default
   const object = td.replace('../../src/object').default
   const constructor = td.replace('../../src/constructor').default
+  const instance = td.replace('../../src/instance').default
   const { default: replace, replaceEsm } = td.replace('../../src/replace')
   const imitate = td.replace('../../src/imitate').default
   // Stubbing & Verifying
@@ -26,6 +27,7 @@ module.exports = () => {
     function: func,
     object: object,
     constructor: constructor,
+    instance: instance,
     replace: replace,
     replaceEsm: replaceEsm,
     imitate: imitate,