Add several methods to set up default behaviors. These methods can be…

… placed anywhere in the mocking set up, including after other calledWith setups, unlike previous "default" behavior using `when(fn).mockReturnValue(z)`. You can now do: `when(fn).calledWith(x).mockReturnValue(y).defaultReturnValue(z)`.

README.md

@@ -284,10 +284,23 @@ fn(2); // Will throw a helpful jest assertion error with args diff
 
 #### Supports default behavior
 
-Use any of `mockReturnValue`, `mockResolvedValue`, `mockRejectedValue`, `mockImplementation` directly on the object
+Use any of `defaultReturnValue`, `defaultResolvedValue`, `defaultRejectedValue`, `defaultImplementation`
 to set up a default behavior, which will serve as fallback if no matcher fits.
 
 ```javascript
+when(fn)
+  .calledWith('foo').mockReturnValue('special')
+  .defaultReturnValue('default') // This line can be placed anywhere, doesn't have to be at the end
+
+expect(fn('foo')).toEqual('special')
+expect(fn('bar')).toEqual('default')
+```
+
+Or if you use any of `mockReturnValue`, `mockResolvedValue`, `mockRejectedValue`, `mockImplementation` directly on the object
+before using `calledWith` it will also behave as a default fallback.
+
+```javascript
+// Same as above example
 when(fn)
   .mockReturnValue('default')
   .calledWith('foo').mockReturnValue('special')
@@ -299,15 +312,15 @@ expect(fn('bar')).toEqual('default')
 One idea is to set up a default implementation that throws an error if an improper call is made to the mock.
 
 ```javascript
-// A default implementation that fails your test
-const unsupportedCallError = (...args) => {
-  throw new Error(`Wrong args: ${JSON.stringify(args, null, 2)}`);
-};
-
 when(fn)
-  .mockImplementation(unsupportedCallError)
   .calledWith(correctArgs)
-  .mockReturnValue(expectedValue);
+  .mockReturnValue(expectedValue)
+  .defaultImplementation(unsupportedCallError)
+
+// A default implementation that fails your test
+function unsupportedCallError(...args) {
+  throw new Error(`Wrong args: ${JSON.stringify(args, null, 2)}`);
+}
 ```
 
 #### Supports custom mockImplementation

src/when.js

@@ -62,11 +62,11 @@ class WhenMock {
     fn.__whenMock__ = this
     this.callMocks = []
     this._origMock = fn.getMockImplementation()
-    this.defaultImplementation = null
+    this._defaultImplementation = null
 
     const _mockImplementation = (matchers, expectCall, once = false) => (mockImplementation) => {
       if (matchers[0] === NO_CALLED_WITH_YET) {
-        this.defaultImplementation = mockImplementation
+        this._defaultImplementation = mockImplementation
       }
       // To enable dynamic replacement during a test:
       // * call mocks with equal matchers are removed
@@ -108,8 +108,8 @@ class WhenMock {
           }
         }
 
-        if (this.defaultImplementation) {
-          return this.defaultImplementation(...args)
+        if (this._defaultImplementation) {
+          return this._defaultImplementation(...args)
         }
         if (typeof fn.__whenMock__._origMock === 'function') {
           return fn.__whenMock__._origMock(...args)
@@ -131,18 +131,26 @@ class WhenMock {
       mockRejectedValue: err => _mockImplementation(matchers, expectCall)(() => Promise.reject(err)),
       mockRejectedValueOnce: err => _mockImplementation(matchers, expectCall, true)(() => Promise.reject(err)),
       mockImplementation: implementation => _mockImplementation(matchers, expectCall)(implementation),
-      mockImplementationOnce: implementation => _mockImplementation(matchers, expectCall, true)(implementation)
+      mockImplementationOnce: implementation => _mockImplementation(matchers, expectCall, true)(implementation),
+      defaultImplementation: implementation => this.defaultImplementation(implementation),
+      defaultReturnValue: returnValue => this.defaultReturnValue(returnValue),
+      defaultResolvedValue: returnValue => this.defaultResolvedValue(returnValue),
+      defaultRejectedValue: err => this.defaultRejectedValue(err)
     })
 
     // These four functions are only used when the dev has not used `.calledWith` before calling one of the mock return functions
-    this.mockImplementation = mockImplementation => {
+    this.defaultImplementation = mockImplementation => {
       // Set up an implementation with a special matcher that can never be matched because it uses a private symbol
       // Additionally the symbols existence can be checked to see if a calledWith was omitted.
       return _mockImplementation([NO_CALLED_WITH_YET], false)(mockImplementation)
     }
-    this.mockReturnValue = returnValue => this.mockImplementation(() => returnValue)
-    this.mockResolvedValue = returnValue => this.mockReturnValue(Promise.resolve(returnValue))
-    this.mockRejectedValue = err => this.mockReturnValue(Promise.reject(err))
+    this.defaultReturnValue = returnValue => this.defaultImplementation(() => returnValue)
+    this.defaultResolvedValue = returnValue => this.defaultReturnValue(Promise.resolve(returnValue))
+    this.defaultRejectedValue = err => this.defaultResolvedValue(Promise.reject(err))
+    this.mockImplementation = this.defaultImplementation
+    this.mockReturnValue = this.defaultReturnValue
+    this.mockResolvedValue = this.defaultResolvedValue
+    this.mockRejectedValue = this.defaultRejectedValue
 
     this.calledWith = (...matchers) => ({ ...mockFunctions(matchers, false) })
     this.expectCalledWith = (...matchers) => ({ ...mockFunctions(matchers, true) })