implement createPromise

multiple levels of anon funcs: PAINFUL. Had to use
a captor to spec it, then b/c of how much setup
there was i ended up with two layers of beforeEach
to DRY it.

not happy rn

Author: searls

src/when/warn-if-promiseless.js renamed to src/log/ensure-promise.js

@@ -1,9 +1,9 @@
 import config from '../config'
 import log from '../log'
 
-export default function warnIfPromiseless () {
+export default function ensurePromise (level) {
   if (config().promiseConstructor == null) {
-    log.warn('td.when', `\
+    log[level]('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:

src/share/create-promise.js

@@ -1,2 +1,14 @@
-export default function createPromise () {
+import config from '../config'
+import ensurePromise from '../log/ensure-promise'
+import callLater from '../share/call-later'
+
+export default function createPromise (stubbing, willResolve) {
+  const Promise = config().promiseConstructor
+  ensurePromise('error')
+  const value = stubbing.currentOutcome
+  return new Promise((resolve, reject) => {
+    callLater(() =>
+      willResolve ? resolve(value) : reject(value)
+    , [value], stubbing.options.defer, stubbing.options.delay)
+  })
 }

src/when/chain-stubbing.js

@@ -1,4 +1,4 @@
-import warnIfPromiseless from './warn-if-promiseless'
+import ensurePromise from '../log/ensure-promise'
 
 export default function chainStubbing (double, completeStubbing) {
   return {
@@ -19,12 +19,12 @@ export default function chainStubbing (double, completeStubbing) {
       return double.fake
     },
     thenResolve (...stubbedValues) {
-      warnIfPromiseless()
+      ensurePromise('warn')
       completeStubbing('thenResolve', stubbedValues)
       return double.fake
     },
     thenReject (...stubbedErrors) {
-      warnIfPromiseless()
+      ensurePromise('warn')
       completeStubbing('thenReject', stubbedErrors)
       return double.fake
     }

test/unit/log/ensure-promise.test.js

@@ -0,0 +1,58 @@
+let config, log, subject
+module.exports = {
+  beforeEach: () => {
+    config = td.replace('../../../src/config').default
+    log = td.replace('../../../src/log').default
+
+    subject = require('../../../src/log/ensure-promise').default
+  },
+  'config has no promise set': () => {
+    td.when(config()).thenReturn({promiseConstructor: null})
+
+    subject('warn')
+
+    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('warn')
+
+    assert.equal(td.explain(log.warn).callCount, 0)
+    assert.equal(td.explain(log.error).callCount, 0)
+  },
+  'config has no promise set (error level)': () => {
+    td.when(config()).thenReturn({promiseConstructor: null})
+
+    subject('error')
+
+    td.verify(log.error('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 (on error level)': () => {
+    td.when(config()).thenReturn({promiseConstructor: function () {}})
+
+    subject('error')
+
+    assert.equal(td.explain(log.warn).callCount, 0)
+    assert.equal(td.explain(log.error).callCount, 0)
+  }
+}

test/unit/share/create-promise.test.js

@@ -0,0 +1,59 @@
+import Stubbing from '../../../src/value/stubbing'
+
+let ensurePromise, callLater, config, subject
+let fakePromise, resolver, rejecter, stubbing
+module.exports = {
+  beforeEach: () => {
+    ensurePromise = td.replace('../../../src/log/ensure-promise').default
+    callLater = td.replace('../../../src/share/call-later').default
+    config = td.replace('../../../src/config').default
+
+    subject = require('../../../src/share/create-promise').default
+  },
+  'resolve & reject': {
+    beforeEach: () => {
+      resolver = td.func('resolve')
+      rejecter = td.func('reject')
+      fakePromise = class FakePromise {
+        constructor (handler) {
+          handler(resolver, rejecter)
+        }
+      }
+      td.when(config()).thenReturn({promiseConstructor: fakePromise})
+      stubbing = new Stubbing(null, null, ['pants'], {
+        defer: 'a defer',
+        delay: 'a delay'
+      })
+    },
+    'resolve': () => {
+      const result = subject(stubbing, true)
+
+      assert(result instanceof fakePromise)
+      td.verify(ensurePromise('error'))
+
+      // Phase 2: make sure call later invokes the resolver
+      const captor = td.matchers.captor()
+      td.verify(callLater(captor.capture(), ['pants'], 'a defer', 'a delay'))
+
+      captor.value()
+
+      td.verify(resolver('pants'))
+      assert.equal(td.explain(rejecter).callCount, 0)
+    },
+    'reject': () => {
+      const result = subject(stubbing, false)
+
+      assert(result instanceof fakePromise)
+      td.verify(ensurePromise('error'))
+
+      // Phase 2: make sure call later invokes the rejecter
+      const captor = td.matchers.captor()
+      td.verify(callLater(captor.capture(), ['pants'], 'a defer', 'a delay'))
+
+      captor.value()
+
+      td.verify(rejecter('pants'))
+      assert.equal(td.explain(resolver).callCount, 0)
+    },
+  }
+}

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

@@ -1,10 +1,10 @@
 import Double from '../../../src/value/double'
 
-let warnIfPromiseless, subject
+let ensurePromise, subject
 let double, type, outcomes, callback
 module.exports = {
   beforeEach: () => {
-    warnIfPromiseless = td.replace('../../../src/when/warn-if-promiseless').default
+    ensurePromise = td.replace('../../../src/log/ensure-promise').default
 
     subject = require('../../../src/when/chain-stubbing').default
 
@@ -49,7 +49,7 @@ module.exports = {
   '.thenResolve': () => {
     const result = subject(double, callback).thenResolve('pants')
 
-    td.verify(warnIfPromiseless())
+    td.verify(ensurePromise('warn'))
     assert.equal(result, 'a fake')
     assert.equal(type, 'thenResolve')
     assert.deepEqual(outcomes, ['pants'])
@@ -59,7 +59,7 @@ module.exports = {
 
     const result = subject(double, callback).thenReject(error)
 
-    td.verify(warnIfPromiseless())
+    td.verify(ensurePromise('warn'))
     assert.equal(result, 'a fake')
     assert.equal(type, 'thenReject')
     assert.deepEqual(outcomes, [error])