executePlan needed breakdown => too much indirect

Decided to pull up the imperative stuff to the satisfy/index instead

* Stubbing now responsible for telling you its current outcome based
on how many calls it's gotten
* Stubbing now stores satisfying calls for easier traceability by 
td.explain (future proofing)

Author: searls

src/satisfy/execute-plan.js renamed to src/satisfy/deliver-outcome.js

@@ -1,8 +1,5 @@
-export default function executePlan (double, call, stubbing) {
-  // 1. get stubbed value
-  // 2. stubbing.incrementSatisfactions()
-  // 2a. invoke any callback matchers
-  // 3. switch stubbing.type
+export default function executePlan (stubbing, call) {
+  // switch stubbing.type
     // case 'thenReturn': return value
     // case 'thenDo': return value.apply(actualContext, actualArgs)
     // case 'thenThrow': throw value

src/satisfy/index.js

@@ -1,9 +1,12 @@
 import findLastStubbingMatch from './find-last-stubbing-match'
-import executePlan from './execute-plan'
+import invokeCallbacks from './invoke-callbacks'
+import deliverOutcome from './deliver-outcome'
 
 export default function satisfy (double, call) {
   const stubbing = findLastStubbingMatch(double, call)
   if (stubbing) {
-    return executePlan(double, call, stubbing)
+    stubbing.addSatisfyingCall(call)
+    invokeCallbacks(stubbing, call)
+    return deliverOutcome(stubbing, call)
   }
 }

src/satisfy/invoke-callbacks.js

@@ -0,0 +1,35 @@
+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))
+      }
+    })
+  }
+}
+
+var callbackArgs = (stubbing, expectedArg) => {
+  if (expectedArg.args != null) {
+    return expectedArg.args
+  } else if (stubbing.config.plan === 'thenCallback') {
+    return stubbing.stubbedValues
+  } 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/value/stubbing.js

@@ -1,18 +1,29 @@
+import _ from '../wrap/lodash'
+
 export default class Stubbing {
   constructor (type, args, outcomes, options = {}) {
     this.type = type
     this.args = args
     this.outcomes = outcomes
     this.options = options
-    this.satisfactionCount = 0
+    this.satisfyingCalls = new Set()
   }
 
   get hasTimesRemaining () {
     if (this.options.times == null) return true
-    return this.satisfactionCount < this.options.times
+    return this.satisfyingCalls.size < this.options.times
+  }
+
+  get currentOutcome () {
+    const outcomeIndex = Math.max(0, this.satisfyingCalls.size - 1)
+    if (outcomeIndex < this.outcomes.length) {
+      return this.outcomes[outcomeIndex]
+    } else {
+      return _.last(this.outcomes)
+    }
   }
 
-  incrementSatisfactions () {
-    this.satisfactionCount++
+  addSatisfyingCall (call) {
+    this.satisfyingCalls.add(call)
   }
 }

test/unit/satisfy/find-last-stubbing-match.test.js

@@ -53,8 +53,8 @@ module.exports = {
     stubbingRegister.add(double, stubbing1)
     stubbingRegister.add(double, stubbing2)
     stubbingRegister.add(double, stubbing3)
-    stubbing3.incrementSatisfactions()
-    stubbing3.incrementSatisfactions()
+    stubbing3.addSatisfyingCall(new Call())
+    stubbing3.addSatisfyingCall(new Call())
 
     const result = subject(double, call)
 

test/unit/satisfy/index.test.js

@@ -2,11 +2,12 @@ import Double from '../../../src/value/double'
 import Call from '../../../src/value/call'
 import Stubbing from '../../../src/value/stubbing'
 
-let findLastStubbingMatch, executePlan, subject
+let findLastStubbingMatch, invokeCallbacks, deliverOutcome, subject
 module.exports = {
   beforeEach: () => {
     findLastStubbingMatch = td.replace('../../../src/satisfy/find-last-stubbing-match').default
-    executePlan = td.replace('../../../src/satisfy/execute-plan').default
+    invokeCallbacks = td.replace('../../../src/satisfy/invoke-callbacks').default
+    deliverOutcome = td.replace('../../../src/satisfy/deliver-outcome').default
 
     subject = require('../../../src/satisfy').default
   },
@@ -15,11 +16,13 @@ module.exports = {
     const call = new Call()
     const stubbing = new Stubbing()
     td.when(findLastStubbingMatch(double, call)).thenReturn(stubbing)
-    td.when(executePlan(double, call, stubbing)).thenReturn('huzzah')
+    td.when(deliverOutcome(stubbing, call)).thenReturn('huzzah')
 
     const result = subject(double, call)
 
     assert.equal(result, 'huzzah')
+    assert.deepEqualSet(stubbing.satisfyingCalls, [call])
+    td.verify(invokeCallbacks(stubbing, call))
   },
   'does nothing if no matching stubbing found': () => {
     const double = Double.create()
@@ -29,6 +32,7 @@ module.exports = {
     const result = subject(double, call)
 
     assert.equal(result, undefined)
-    assert.equal(td.explain(executePlan).callCount, 0)
+    assert.equal(td.explain(deliverOutcome).callCount, 0)
+    assert.equal(td.explain(invokeCallbacks).callCount, 0)
   }
 }

test/unit/value/stubbing.test.js

@@ -1,3 +1,4 @@
+import Call from '../../../src/value/call'
 import Stubbing from '../../../src/value/stubbing'
 
 module.exports = {
@@ -7,7 +8,7 @@ module.exports = {
 
       assert.equal(subject.hasTimesRemaining, true)
 
-      subject.incrementSatisfactions()
+      subject.addSatisfyingCall(new Call())
 
       assert.equal(subject.hasTimesRemaining, true)
     },
@@ -16,7 +17,7 @@ module.exports = {
 
       assert.equal(subject.hasTimesRemaining, false)
 
-      subject.incrementSatisfactions()
+      subject.addSatisfyingCall(new Call())
 
       assert.equal(subject.hasTimesRemaining, false)
     },
@@ -25,7 +26,7 @@ module.exports = {
 
       assert.equal(subject.hasTimesRemaining, true)
 
-      subject.incrementSatisfactions()
+      subject.addSatisfyingCall(new Call())
 
       assert.equal(subject.hasTimesRemaining, false)
     },
@@ -34,14 +35,61 @@ module.exports = {
 
       assert.equal(subject.hasTimesRemaining, true)
 
-      subject.incrementSatisfactions()
+      subject.addSatisfyingCall(new Call())
 
       assert.equal(subject.hasTimesRemaining, true)
 
-      subject.incrementSatisfactions()
+      subject.addSatisfyingCall(new Call())
+
+      assert.equal(subject.hasTimesRemaining, false)
+    },
+    'guards against duplicate calls (only count once)': () => {
+      const subject = new Stubbing(null, null, null, {times: 2})
+
+      assert.equal(subject.hasTimesRemaining, true)
+
+      const call = new Call()
+      subject.addSatisfyingCall(call)
+      subject.addSatisfyingCall(call)
+      subject.addSatisfyingCall(call)
+
+      assert.equal(subject.hasTimesRemaining, true)
+
+      subject.addSatisfyingCall(new Call())
 
       assert.equal(subject.hasTimesRemaining, false)
     }
+  },
+  '.currentOutcome': {
+    'one outcome set': () => {
+      const subject = new Stubbing(null, null, ['pants'])
+
+      assert.equal(subject.currentOutcome, 'pants')
+
+      subject.addSatisfyingCall(new Call())
 
+      assert.equal(subject.currentOutcome, 'pants')
+
+      subject.addSatisfyingCall(new Call())
+
+      assert.equal(subject.currentOutcome, 'pants')
+    },
+    'two outcomes set': () => {
+      const subject = new Stubbing(null, null, ['pants', 'hat'])
+
+      assert.equal(subject.currentOutcome, 'pants')
+
+      subject.addSatisfyingCall(new Call())
+
+      assert.equal(subject.currentOutcome, 'pants')
+
+      subject.addSatisfyingCall(new Call())
+
+      assert.equal(subject.currentOutcome, 'hat')
+
+      subject.addSatisfyingCall(new Call())
+
+      assert.equal(subject.currentOutcome, 'hat')
+    }
   }
 }