Add rejects() method

Author: abdala

README.md

@@ -55,14 +55,20 @@ console.log(calculator.add(1, 2)); //prints undefined
 ```
 
 ## Working with promises
-When working with promises you can also use the method `resolves()` to return a promise.
+When working with promises you can also use `resolves()` and `rejects()` to return a promise.
 
 ```typescript
 calculator.heavyOperation(1, 2).resolves(4); 
 //same as calculator.heavyOperation(1, 2).returns(Promise.resolve(4));
 console.log(await calculator.heavyOperation(1, 2)); //prints 4
 ```
 
+```typescript
+calculator.heavyOperation(1, 2).rejects(new Error());
+//same as calculator.heavyOperation(1, 2).returns(Promise.reject(new Error()));
+console.log(await calculator.heavyOperation(1, 2)); //throws Error
+```
+
 ## Verifying calls
 ```typescript
 calculator.enabled = true;

spec/throws.spec.ts

@@ -5,6 +5,7 @@ import { Substitute, Arg } from '../src/index'
 interface Calculator {
   add(a: number, b: number): number
   divide(a: number, b: number): number
+  heavyOperation(): Promise<number>
   mode: boolean
   fakeSetting: boolean
 }
@@ -16,6 +17,13 @@ test('throws on a method with arguments', t => {
   t.throws(() => calculator.divide(1, 0), { instanceOf: Error, message: 'Cannot divide by 0' })
 })
 
+test('rejects on a method', async t => {
+  const calculator = Substitute.for<Calculator>()
+  calculator.heavyOperation().rejects(new Error('Error'))
+
+  await t.throwsAsync(calculator.heavyOperation, { instanceOf: Error, message: 'Error' })
+})
+
 test('throws on a property being called', t => {
   const calculator = Substitute.for<Calculator>()
   calculator.mode.throws(new Error('Property not set'))

src/Transformations.ts

@@ -33,10 +33,12 @@ type MockObjectMixin<TArguments extends any[], TReturnType> = BaseMockObjectMixi
 
 type NoArgumentMockObjectPromise<TReturnType> = NoArgumentMockObjectMixin<TReturnType> & {
     resolves: (...args: Unpacked<TReturnType>[]) => void;
+    rejects: (exception: any) => void;
 }
 
 type MockObjectPromise<TArguments extends any[], TReturnType> = MockObjectMixin<TArguments, TReturnType> & {
     resolves: (...args: Unpacked<TReturnType>[]) => void;
+    rejects: (exception: any) => void;
 }
 
 export type ObjectSubstitute<T extends Object, K extends Object = T> = ObjectSubstituteTransformation<T> & {

src/Utilities.ts

@@ -17,7 +17,8 @@ export enum SubstituteMethods {
     mimicks = 'mimicks',
     throws = 'throws',
     returns = 'returns',
-    resolves = 'resolves'
+    resolves = 'resolves',
+    rejects = 'rejects'
 }
 
 export const Nothing = Symbol();

src/states/FunctionState.ts

@@ -130,16 +130,27 @@ export class FunctionState implements ContextState {
             }
         }
 
-        if (property === SubstituteMethods.returns) {
+        if (property === SubstituteMethods.returns
+            || property === SubstituteMethods.resolves
+            || property === SubstituteMethods.rejects
+        ) {
             return (...returns: any[]) => {
                 if (!this._lastArgs) {
                     throw SubstituteException.generic('Eh, there\'s a bug, no args recorded for this return :/')
                 }
-                this.returns.push({
-                    returnValues: returns,
-                    returnIndex: 0,
-                    args: this._lastArgs
-                })
+                const returnMock: Partial<ReturnMock> = { returnIndex: 0, args: this._lastArgs };
+                switch (property) {
+                    case SubstituteMethods.returns:
+                        returnMock.returnValues = returns;
+                        break;
+                    case SubstituteMethods.resolves:
+                        returnMock.returnValues = returns.map(value => Promise.resolve(value));
+                        break;
+                    case SubstituteMethods.rejects:
+                        returnMock.returnValues = returns.map(value => Promise.reject(value));
+                        break;
+                }
+                this.returns.push(<ReturnMock>returnMock);
                 this._calls.pop()
 
                 if (this.callCount === 0) {
@@ -156,23 +167,6 @@ export class FunctionState implements ContextState {
             };
         }
 
-        if (property === SubstituteMethods.resolves) {
-            return (...returns: any[]) => {
-                if (!this._lastArgs) {
-                    throw SubstituteException.generic('Eh, there\'s a bug, no args recorded for this return :/')
-                }
-                returns = returns.map(value => Promise.resolve(value))
-                this.returns.push({
-                    returnValues: returns,
-                    returnIndex: 0,
-                    args: this._lastArgs
-                })
-                this._calls.pop()
-
-                context.state = context.initialState;
-            };
-        }
-
         return context.proxy;
     }
 }