implement most of the td.when rewrite children

Author: searls

src/when/add-implied-callback-arg-if-necessary.js

@@ -1 +1,2 @@
-export default () => {}
+export default function (type, args) {
+}

src/when/chain-stubbing.js

@@ -1 +1,32 @@
-export default () => {}
+import warnIfPromiseless from './warn-if-promiseless'
+
+export default function chainStubbing (double, completeStubbing) {
+  return {
+    thenReturn (...stubbedValues) {
+      completeStubbing('thenReturn', stubbedValues)
+      return double.fake
+    },
+    thenCallback (...stubbedValues) {
+      completeStubbing('thenCallback', stubbedValues)
+      return double.fake
+    },
+    thenDo (...stubbedActions) {
+      completeStubbing('thenDo', stubbedActions)
+      return double.fake
+    },
+    thenThrow (...stubbedErrors) {
+      completeStubbing('thenThrow', stubbedErrors)
+      return double.fake
+    },
+    thenResolve (...stubbedValues) {
+      warnIfPromiseless()
+      completeStubbing('thenResolve', stubbedValues)
+      return double.fake
+    },
+    thenReject (...stubbedErrors) {
+      warnIfPromiseless()
+      completeStubbing('thenReject', stubbedErrors)
+      return double.fake
+    }
+  }
+}

src/when/ensure-rehearsal.js

@@ -1 +1,13 @@
-export default () => {}
+import log from '../log'
+
+export default function ensureRehearsal (rehearsal) {
+  if (!rehearsal) {
+    log.error('td.when', `\
+No test double invocation call detected for \`when()\`.
+
+  Usage:
+    when(myTestDouble('foo')).thenReturn('bar')\
+`
+    )
+  }
+}

src/when/index.js

@@ -8,7 +8,7 @@ import Stubbing from '../value/stubbing'
 export default (__rehearseInvocationHere__, options) => {
   const rehearsal = CallLog.instance.pop()
   ensureRehearsal(rehearsal)
-  return chainStubbing((type, outcomes) => {
+  return chainStubbing(rehearsal.double, (type, outcomes) => {
     StubbingRegister.instance.add(rehearsal.double, new Stubbing(
       type,
       addImpliedCallbackArgIfNecessary(type, rehearsal.call.args),

src/when/warn-if-promiseless.js

@@ -0,0 +1,17 @@
+import config from '../config'
+import log from '../log'
+
+export default function warnIfPromiseless () {
+  if (config().promiseConstructor == null) {
+    log.warn('td.when', `\
+no promise constructor is set, so this \`thenResolve\` or \`thenReject\` stubbing
+will fail if it's satisfied by an invocation on the test double. You can tell
+testdouble.js which promise constructor to use with \`td.config\`, like so:
+
+  td.config({
+    promiseConstructor: require('bluebird')
+  })\
+`
+    )
+  }
+}

test/unit/when/add-implied-callback-arg-if-necessary.test.js

@@ -0,0 +1,3 @@
+module.exports = {
+
+}

test/unit/when/chain-stubbing.test.js

@@ -0,0 +1,67 @@
+import Double from '../../../src/value/double'
+
+let warnIfPromiseless, subject
+let double, type, outcomes, callback
+module.exports = {
+  beforeEach: () => {
+    warnIfPromiseless = td.replace('../../../src/when/warn-if-promiseless').default
+
+    subject = require('../../../src/when/chain-stubbing').default
+
+    // Common setup across tests:
+    double = Double.create(null, null, null, () => 'a fake')
+    callback = (t, o) => { type = t; outcomes = o }
+  },
+  '.thenReturn': () => {
+    const result = subject(double, callback).thenReturn(12, 23)
+
+    assert.equal(result, 'a fake')
+    assert.equal(type, 'thenReturn')
+    assert.deepEqual(outcomes, [12, 23])
+  },
+  '.thenCallback': () => {
+    const func = () => {}
+
+    const result = subject(double, callback).thenCallback(func)
+
+    assert.equal(result, 'a fake')
+    assert.equal(type, 'thenCallback')
+    assert.deepEqual(outcomes, [func])
+  },
+  '.thenDo': () => {
+    const func = () => {}
+
+    const result = subject(double, callback).thenDo(func)
+
+    assert.equal(result, 'a fake')
+    assert.equal(type, 'thenDo')
+    assert.deepEqual(outcomes, [func])
+  },
+  '.thenThrow': () => {
+    const error = new Error('hi')
+
+    const result = subject(double, callback).thenThrow(error)
+
+    assert.equal(result, 'a fake')
+    assert.equal(type, 'thenThrow')
+    assert.deepEqual(outcomes, [error])
+  },
+  '.thenResolve': () => {
+    const result = subject(double, callback).thenResolve('pants')
+
+    td.verify(warnIfPromiseless())
+    assert.equal(result, 'a fake')
+    assert.equal(type, 'thenResolve')
+    assert.deepEqual(outcomes, ['pants'])
+  },
+  '.thenReject': () => {
+    const error = new Error('hi')
+
+    const result = subject(double, callback).thenReject(error)
+
+    td.verify(warnIfPromiseless())
+    assert.equal(result, 'a fake')
+    assert.equal(type, 'thenReject')
+    assert.deepEqual(outcomes, [error])
+  }
+}

test/unit/when/ensure-rehearsal.test.js

@@ -0,0 +1,29 @@
+import Call from '../../../src/value/call'
+
+let log, subject
+module.exports = {
+  beforeEach: () => {
+    log = td.replace('../../../src/log').default
+
+    subject = require('../../../src/when/ensure-rehearsal').default
+  },
+  'no rehearsal raises error': () => {
+    subject(null)
+
+    td.verify(log.error('td.when', `\
+No test double invocation call detected for \`when()\`.
+
+  Usage:
+    when(myTestDouble('foo')).thenReturn('bar')\
+`
+    ))
+  },
+  'with rehearsal does nothing': () => {
+    const call = new Call()
+
+    subject(call)
+
+    assert.equal(td.explain(log.error).callCount, 0)
+  }
+
+}

test/unit/when/index.test.js

@@ -15,7 +15,7 @@ module.exports = {
     const double = Double.create()
     const call = new Call(null, ['arg1', 'arg2'])
     CallLog.instance.log(double, call)
-    td.when(chainStubbing(td.callback('a type', ['a stub']))).thenReturn('chained methods')
+    td.when(chainStubbing(double, td.callback('a type', ['a stub']))).thenReturn('chained methods')
     td.when(addImpliedCallbackArgIfNecessary('a type', ['arg1', 'arg2'])).thenReturn('good args')
 
     const result = subject('_fake rehearsal arg_', 'some options')

test/unit/when/warn-if-promiseless.test.js

@@ -0,0 +1,32 @@
+let config, log, subject
+module.exports = {
+  beforeEach: () => {
+    config = td.replace('../../../src/config').default
+    log = td.replace('../../../src/log').default
+
+    subject = require('../../../src/when/warn-if-promiseless').default
+  },
+  'config has no promise set': () => {
+    td.when(config()).thenReturn({promiseConstructor: null})
+
+    subject()
+
+    td.verify(log.warn('td.when', `\
+no promise constructor is set, so this \`thenResolve\` or \`thenReject\` stubbing
+will fail if it's satisfied by an invocation on the test double. You can tell
+testdouble.js which promise constructor to use with \`td.config\`, like so:
+
+  td.config({
+    promiseConstructor: require('bluebird')
+  })\
+`
+    ))
+  },
+  'config has a promise set': () => {
+    td.when(config()).thenReturn({promiseConstructor: function () {}})
+
+    subject()
+
+    assert.equal(td.explain(log.warn).callCount, 0)
+  }
+}