implement top-level satisfy/invoke-callbacks

Author: searls

src/satisfy/invoke-callbacks.js

@@ -1,35 +1,28 @@
+import _ from '../wrap/lodash'
+
+import isCallback from '../matchers/is-callback'
+import callLater from '../share/call-later'
+
 export default function invokeCallbacks (stubbing, call) {
-}
-/*
-var invokeCallbackFor = (stubbing, actualArgs) => {
-  if (_.some(stubbing.args, isCallback)) {
-    _.each(stubbing.args, (expectedArg, i) => {
-      if (isCallback(expectedArg)) {
-        callCallback(stubbing, actualArgs[i], callbackArgs(stubbing, expectedArg))
-      }
-    })
-  }
+  _.each(stubbing.args, (stubbingArg, i) => {
+    if (isCallback(stubbingArg)) {
+      const actualCallback = call.args[i]
+      callLater(
+        actualCallback,
+        callbackArgs(stubbing, stubbingArg),
+        stubbing.options.delay,
+        stubbing.options.defer
+      )
+    }
+  })
 }
 
-var callbackArgs = (stubbing, expectedArg) => {
-  if (expectedArg.args != null) {
-    return expectedArg.args
-  } else if (stubbing.config.plan === 'thenCallback') {
-    return stubbing.stubbedValues
+function callbackArgs (stubbing, callbackMatcher) {
+  if (callbackMatcher.args != null) {
+    return callbackMatcher.args
+  } else if (stubbing.type === 'thenCallback') {
+    return stubbing.outcomes
   } else {
     return []
   }
 }
-
-// stick this in a shared place?
-// callLater(func, delay, defer)
-var callCallback = (stubbing, callback, args) => {
-  if (stubbing.config.delay) {
-    return _.delay(callback, stubbing.config.delay, ...args)
-  } else if (stubbing.config.defer) {
-    return _.defer(callback, ...args)
-  } else {
-    return callback(...args) // eslint-disable-line
-  }
-}
-*/

src/share/call-later.js

@@ -0,0 +1,2 @@
+export default function callLater () {
+}

test/unit/satisfy/invoke-callbacks.test.js

@@ -0,0 +1,80 @@
+import Call from '../../../src/value/call'
+import Stubbing from '../../../src/value/stubbing'
+
+let isCallback, callLater, subject
+module.exports = {
+  beforeEach: () => {
+    isCallback = td.replace('../../../src/matchers/is-callback').default
+    callLater = td.replace('../../../src/share/call-later').default
+
+    subject = require('../../../src/satisfy/invoke-callbacks').default
+  },
+  'invokes a basic callback matcher with args': () => {
+    // TODO: once matchers & callbacks are ported to value types, replace w/that
+    const callbackMatcher = {args: ['pants']}
+    const stubbing = new Stubbing('thenBlah', [42, callbackMatcher])
+    const realCallback = () => {}
+    const call = new Call(null, [42, realCallback])
+    td.when(isCallback(callbackMatcher)).thenReturn(true)
+
+    subject(stubbing, call)
+
+    td.verify(callLater(realCallback, ['pants'], undefined, undefined))
+  },
+  'invokes an arg-less callback matcher marker': () => {
+    const callbackMatcher = {}
+    const stubbing = new Stubbing('thenBlah', [callbackMatcher, 12])
+    const realCallback = () => {}
+    const call = new Call(null, [realCallback, 12])
+    td.when(isCallback(callbackMatcher)).thenReturn(true)
+
+    subject(stubbing, call)
+
+    td.verify(callLater(realCallback, [], undefined, undefined))
+  },
+  'invoked a thenCallback': () => {
+    const callbackMatcher = {}
+    const stubbing = new Stubbing('thenCallback', [callbackMatcher], ['kaka', 2])
+    const realCallback = () => {}
+    const call = new Call(null, [realCallback])
+    td.when(isCallback(callbackMatcher)).thenReturn(true)
+
+    subject(stubbing, call)
+
+    td.verify(callLater(realCallback, ['kaka', 2], undefined, undefined))
+  },
+  'invokes two callback matchers': () => {
+    const callbackMatcher1 = 'a'
+    const callbackMatcher2 = 'b'
+    const stubbing = new Stubbing('thenBlah', [callbackMatcher1, callbackMatcher2])
+    const realCallback1 = () => {}
+    const realCallback2 = () => {}
+    const call = new Call(null, [realCallback1, realCallback2])
+    td.when(isCallback(callbackMatcher1)).thenReturn(true)
+    td.when(isCallback(callbackMatcher2)).thenReturn(true)
+
+    subject(stubbing, call)
+
+    td.verify(callLater(realCallback1, [], undefined, undefined))
+    td.verify(callLater(realCallback2, [], undefined, undefined))
+  },
+  'calls nothing if nothing is a callback': () => {
+    const stubbing = new Stubbing('thenBlah', ['foo', 'bar'], ['pants'])
+    const call = new Call(null, ['foo', 'bar'])
+
+    subject(stubbing, call)
+
+    assert.equal(td.explain(callLater).callCount, 0)
+  },
+  'passes delay & defer settings to callLater': () => {
+    const callbackMatcher = {}
+    const stubbing = new Stubbing('thenBlah', [callbackMatcher], [], {delay: 42, defer: true})
+    const realCallback = () => {}
+    const call = new Call(null, [realCallback])
+    td.when(isCallback(callbackMatcher)).thenReturn(true)
+
+    subject(stubbing, call)
+
+    td.verify(callLater(realCallback, [], 42, true))
+  }
+}