Rewrite the td.function() rewrite

Key insight here was that the public API really shouldn't be the same
as the private API, because we want to encourage passing around Double
objects internally and only expose the fake externally. Additionally,
the imitation module is doing a lot of the heavy lifting now and this
isn't nearly as complicated as it was once going to be.

Author: searls

src/function/create.js

@@ -1,25 +1,6 @@
-import _ from '../wrap/lodash'
-
 import Double from '../value/double'
-import CallLog from '../value/call-log'
-import Call from '../value/call'
-import StubbingRegister from '../value/stubbing-register'
-
-export default (nameOrFunc) => {
-  const name = deriveName(nameOrFunc)
-  const real = _.isFunction(nameOrFunc) ? nameOrFunc : null
-  const double = new Double(name, real, _.tap(function testDouble (...args) {
-    const call = new Call(this, args)
-    CallLog.instance.log(double, call)
-    return StubbingRegister.instance.satisfy(double, call)
-  }, (fakeFunction) => {
-    fakeFunction.toString = () =>
-      double.fullName == null ? '[test double (unnamed)]' : `[test double for "${double.fullName}"]`
-  }))
-  return double
-}
+import generateFakeFunction from './generate-fake-function'
 
-const deriveName = (nameOrFunc) => {
-  const name = _.isFunction(nameOrFunc) ? nameOrFunc.name : nameOrFunc
-  return _.isEmpty(name) ? null : name
+export default function create (name, real, parent) {
+  return Double.create(name, real, parent, generateFakeFunction)
 }

src/function/generate-fake-function.js

@@ -0,0 +1,14 @@
+import CallLog from '../value/call-log'
+import Call from '../value/call'
+import StubbingRegister from '../value/stubbing-register'
+
+export default function generateFakeFunction (double) {
+  const testDouble = function testDouble (...args) {
+    const call = new Call(this, args)
+    CallLog.instance.log(double, call)
+    return StubbingRegister.instance.satisfy(double, call)
+  }
+  testDouble.toString = double.toString.bind(double)
+
+  return testDouble
+}

src/function/index.js

@@ -1,12 +1,11 @@
 import _ from '../wrap/lodash'
 
 import create from './create'
-import imitate from '../imitate'
-import remember from './remember'
 
-export default (nameOrFunc) => {
-  if (_.isFunction(nameOrFunc)) return imitate(nameOrFunc)
-  const double = create(nameOrFunc)
-  remember(double)
-  return double.fake
+export default function func (nameOrFunc) {
+  if (_.isFunction(nameOrFunc)) {
+    return create(_.isEmpty(nameOrFunc.name) ? null : nameOrFunc.name, nameOrFunc).fake
+  } else {
+    return create(nameOrFunc, null).fake
+  }
 }

src/function/remember.js

@@ -1,12 +1,20 @@
 import _ from '../wrap/lodash'
 
 export default class Double {
-  constructor (name, real, fake) {
+  static create (name, real, parent, fakeCreator) {
+    const double = new Double(name, real, parent)
+    if (fakeCreator) double.fake = fakeCreator(double)
+    return double
+  }
+
+  constructor (name, real, parent) {
     this.name = name
     this.real = real
-    this.fake = fake
-    this.parent = undefined
     this.children = new Set()
+    if (parent) {
+      this.parent = parent
+      parent.addChild(this)
+    }
   }
 
   addChild (child) {
@@ -25,4 +33,8 @@ export default class Double {
     if (!this.parent) return []
     return this.parent.ancestors.concat(this.parent)
   }
+
+  toString () {
+    return this.fullName == null ? '[test double (unnamed)]' : `[test double for "${this.fullName}"]`
+  }
 }

src/value/double.js

@@ -9,7 +9,9 @@ var CallLog = require('../src/value/call-log').default
 var StubbingRegister = require('../src/value/stubbing-register').default
 
 module.exports = {
-  beforeAll: function () {},
+  beforeAll: function () {
+    require('./support/custom-assertions').default(assert)
+  },
   beforeEach: function () {},
   afterEach: function () {
     td.reset()

test/helper.js

@@ -0,0 +1,5 @@
+export default function customAssertions (assert) {
+  assert.deepEqualSet = (actual, expected) => {
+    assert.deepEqual(Array.from(actual), expected)
+  }
+}

test/support/custom-assertions.js

@@ -1,67 +1,17 @@
-import Double from '../../../src/value/double'
-import CallLog from '../../../src/value/call-log'
-import StubbingRegister from '../../../src/value/stubbing-register'
-import Stubbing from '../../../src/value/stubbing'
-import subject from '../../../src/function/create'
-
+let Double, generateFakeFunction,subject
 module.exports = {
-  'passed a string name': () => {
-    const result = subject('foo')
-
-    assert(result instanceof Double)
-    assert.strictEqual(result.real, null)
-    assert.equal(result.name, 'foo')
-    assert.equal(typeof result.fake, 'function')
-    assert.equal(result.fake.toString(), '[test double for "foo"]')
-  },
-  'passed a function with a name': () => {
-    function bar () {}
-    const result = subject(bar)
-
-    assert.equal(result.real, bar)
-    assert.equal(result.name, 'bar')
-    assert.equal(result.fake.toString(), '[test double for "bar"]')
-  },
-  'passed an unnamed function': () => {
-    const result = subject(function () {})
-
-    assert.strictEqual(result.name, null)
-    assert.equal(result.fake.toString(), '[test double (unnamed)]')
-  },
-  'passed nothing': () => {
-    const result = subject()
+  beforeEach: () => {
+    Double = td.replace('../../../src/value/double').default
+    generateFakeFunction = td.replace('../../../src/function/generate-fake-function').default
 
-    assert.strictEqual(result.name, null)
-    assert.strictEqual(result.real, null)
-    assert.equal(result.fake.toString(), '[test double (unnamed)]')
+    subject = require('../../../src/function/create').default
   },
-  'the fake function itself': {
-    'logs calls': () => {
-      const double = subject()
+  'puts the lime in the coconut': () => {
+    td.when(Double.create('a name', 'a real', 'a parent', generateFakeFunction)).thenReturn('yasss')
 
-      double.fake.call('fake this', 1, 2, 3)
+    const result = subject('a name', 'a real', 'a parent', generateFakeFunction)
 
-      var calls = CallLog.instance.for(double)
-      assert.equal(calls.length, 1)
-      assert.equal(calls[0].context, 'fake this')
-      assert.deepEqual(calls[0].args, [1, 2, 3])
-    },
-    'registers stubbing': () => {
-      const double = subject()
-      const stubbing = new Stubbing('return', ['a', 'b'], ['c'])
-      StubbingRegister.instance.add(double, stubbing)
-
-      const result = double.fake('a', 'b')
-
-      assert.equal(result, 'c')
-    }
-  },
-  'toString supports mutation (necessary sometimes for td.replace() to depend on td.func()': () => {
-    const double = subject()
-
-    double.name = 'new name'
-
-    assert.equal(double.name, 'new name')
-    assert.equal(double.fake.toString(), '[test double for "new name"]')
+    assert.equal(result, 'yasss')
   }
+
 }

test/unit/function/create.test.js

@@ -0,0 +1,36 @@
+import Double from '../../../src/value/double'
+import CallLog from '../../../src/value/call-log'
+import StubbingRegister from '../../../src/value/stubbing-register'
+import Stubbing from '../../../src/value/stubbing'
+import subject from '../../../src/function/generate-fake-function'
+
+module.exports = {
+  'the fake function itself': {
+    'logs calls': () => {
+      const double = Double.create()
+
+      subject(double).call('fake this', 1, 2, 3)
+
+      var calls = CallLog.instance.for(double)
+      assert.equal(calls.length, 1)
+      assert.equal(calls[0].context, 'fake this')
+      assert.deepEqual(calls[0].args, [1, 2, 3])
+    },
+    'registers stubbing': () => {
+      const double = Double.create()
+      const stubbing = new Stubbing('return', ['a', 'b'], ['c'])
+      StubbingRegister.instance.add(double, stubbing)
+
+      const result = subject(double)('a', 'b')
+
+      assert.equal(result, 'c')
+    }
+  },
+  'sets toString to that of the double': () => {
+    const double = Double.create('name')
+
+    const result = subject(double)
+
+    assert.equal(result.toString(), double.toString())
+  }
+}

test/unit/function/generate-fake-function.test.js

@@ -1,29 +1,36 @@
 import Double from '../../../src/value/double'
 
-let create, imitate, remember, subject
+let create, subject
 module.exports = {
   beforeEach: () => {
     create = td.replace('../../../src/function/create').default
-    imitate = td.replace('../../../src/imitate').default
-    remember = td.replace('../../../src/function/remember').default
 
     subject = require('../../../src/function/index').default
   },
   'pass in a name': () => {
-    const double = new Double(null, null, 'fake thing')
-    td.when(create('foo')).thenReturn(double)
+    const double = Double.create(null, null, null, () => 'fake thing')
+    td.when(create('foo', null)).thenReturn(double)
 
     const result = subject('foo')
 
-    assert.equal(result, double.fake)
-    td.verify(remember(double))
+    assert.equal(result, 'fake thing')
   },
-  'pass in a function': () => {
+  'pass in a named function': () => {
     function bar () {}
-    td.when(imitate(bar)).thenReturn('fake bar')
+    const double = Double.create(null, null, null, () => 'fake bar')
+    td.when(create('bar', bar)).thenReturn(double)
 
     const result = subject(bar)
 
     assert.equal(result, 'fake bar')
+  },
+  'pass in an unnamed function': () => {
+    const unnamedFunc = eval('(function () {})') //eslint-disable-line
+    const double = Double.create(null, null, null, () => 'fake')
+    td.when(create(null, unnamedFunc)).thenReturn(double)
+
+    const result = subject(unnamedFunc)
+
+    assert.equal(result, 'fake')
   }
 }