feat: Print promise values in error messages

Previously all expectations on promises were being printed as
`thenReturn({})`. Now the promise inner value will be correctly printed
for `thenResolve` and `thenReject` expectations. `thenReturn(promise)`
will still print `{}` as there's no way to peek inside the promise.

src/base-repository.ts

@@ -51,7 +51,7 @@ export abstract class BaseRepository implements ExpectationRepository {
       if (propertyExpectation) {
         this.countAndConsume(propertyExpectation);
 
-        return propertyExpectation.expectation.returnValue;
+        return propertyExpectation.expectation.returnValue.value;
       }
 
       return (...args: any[]) => {
@@ -63,7 +63,7 @@ export abstract class BaseRepository implements ExpectationRepository {
           this.recordExpected(property, args);
           this.countAndConsume(callExpectation);
 
-          return callExpectation.expectation.returnValue;
+          return callExpectation.expectation.returnValue.value;
         }
 
         this.recordUnexpected(property, args);

src/expectation-repository.ts

@@ -1,7 +1,5 @@
 import { Expectation } from './expectation';
 
-export type ReturnValue = { returnValue: any };
-
 export type Call = {
   arguments: any[] | undefined;
 };

src/expectation.ts

@@ -1,3 +1,10 @@
+export type ReturnValue = {
+  value: any;
+  isPromise?: boolean;
+  promiseValue?: any;
+  isError?: boolean;
+};
+
 export interface Expectation {
   property: PropertyKey;
 
@@ -7,7 +14,7 @@ export interface Expectation {
    */
   args: any[] | undefined;
 
-  returnValue: any;
+  returnValue: ReturnValue;
 
   min: number;
 

src/pending-expectation.ts

@@ -1,19 +1,19 @@
 import { MissingWhen, UnfinishedExpectation } from './errors';
-import { Expectation } from './expectation';
+import { Expectation, ReturnValue } from './expectation';
 import { ExpectationRepository } from './expectation-repository';
 import { printWhen } from './print';
 
 export type ExpectationFactory = (
   property: PropertyKey,
   args: any[] | undefined,
-  returnValue: any
+  returnValue: ReturnValue
 ) => Expectation;
 
 export interface PendingExpectation {
   // TODO: get rid of repo
   start(repo: ExpectationRepository): void;
 
-  finish(returnValue: any): Expectation;
+  finish(returnValue: ReturnValue): Expectation;
 
   clear(): void;
 
@@ -54,7 +54,7 @@ export class RepoSideEffectPendingExpectation implements PendingExpectation {
     this._args = value;
   }
 
-  finish(returnValue: any): Expectation {
+  finish(returnValue: ReturnValue): Expectation {
     if (!this._repo) {
       throw new MissingWhen();
     }

src/print.ts

@@ -1,5 +1,5 @@
 import { EXPECTED_COLOR, printExpected } from 'jest-matcher-utils';
-import { ApplyProp, Expectation } from './expectation';
+import { ApplyProp, Expectation, ReturnValue } from './expectation';
 import { isMatcher } from './matcher';
 
 export const printProperty = (property: PropertyKey) => {
@@ -24,11 +24,27 @@ export const printCall = (property: PropertyKey, args: any[]) => {
   return `${prettyProperty}(${prettyArgs})`;
 };
 
-export const printReturns = (returnValue: any, min: number, max: number) => {
-  const isError = returnValue instanceof Error;
+export const printReturns = (
+  { isError, isPromise, value, promiseValue }: ReturnValue,
+  min: number,
+  max: number
+) => {
+  let thenPrefix = '';
+
+  if (isPromise) {
+    if (isError) {
+      thenPrefix += 'thenReject';
+    } else {
+      thenPrefix += 'thenResolve';
+    }
+  } else if (isError) {
+    thenPrefix += 'thenThrow';
+  } else {
+    thenPrefix += 'thenReturn';
+  }
 
-  return `.${isError ? 'thenThrow' : 'thenReturn'}(${printExpected(
-    isError ? returnValue.message : returnValue
+  return `.${thenPrefix}(${printExpected(
+    promiseValue || value
   )}).between(${min}, ${max})`;
 };
 
@@ -43,7 +59,7 @@ export const printWhen = (property: PropertyKey, args: any[] | undefined) => {
 export const printExpectation = (
   property: PropertyKey,
   args: any[] | undefined,
-  returnValue: any,
+  returnValue: ReturnValue,
   min: number,
   max: number
 ) => `${printWhen(property, args)}${printReturns(returnValue, min, max)}`;

src/returns.ts

@@ -1,3 +1,4 @@
+import { ReturnValue } from './expectation';
 import { createInvocationCount, InvocationCount } from './invocation-count';
 import { PendingExpectation } from './pending-expectation';
 
@@ -83,7 +84,7 @@ export type Stub<T> = [T] extends [Promise<infer U>]
  * Set a return value for the currently pending expectation.
  */
 const finishPendingExpectation = (
-  returnValue: any,
+  returnValue: ReturnValue,
   pendingExpectation: PendingExpectation
 ) => {
   const finishedExpectation = pendingExpectation.finish(returnValue);
@@ -115,30 +116,55 @@ export const createReturns = <R>(
       // TODO: should probably fix this
       /* istanbul ignore next: because it will be overridden by
        * promiseStub and the types are compatible */
-      return finishPendingExpectation(returnValue, pendingExpectation);
+      return finishPendingExpectation(
+        { value: returnValue, isError: false, isPromise: false },
+        pendingExpectation
+      );
     },
     thenThrow: (errorOrMessage?: Error | string): InvocationCount =>
-      finishPendingExpectation(getError(errorOrMessage), pendingExpectation),
+      finishPendingExpectation(
+        { value: getError(errorOrMessage), isError: true, isPromise: false },
+        pendingExpectation
+      ),
   };
 
   const promiseStub: PromiseStub<any> = {
     thenReturn: (promise: Promise<any>): InvocationCount =>
-      finishPendingExpectation(promise, pendingExpectation),
+      finishPendingExpectation(
+        {
+          value: promise,
+          isError: false,
+          // We're setting this to false because we can't distinguish between a
+          // promise thenReturn and a normal thenReturn.
+          isPromise: false,
+        },
+        pendingExpectation
+      ),
 
     thenResolve: (promiseValue: any): InvocationCount =>
       finishPendingExpectation(
-        Promise.resolve(promiseValue),
+        {
+          value: Promise.resolve(promiseValue),
+          promiseValue,
+          isError: false,
+          isPromise: true,
+        },
         pendingExpectation
       ),
 
     thenReject: (errorOrMessage?: Error | string): InvocationCount =>
       finishPendingExpectation(
-        Promise.reject(getError(errorOrMessage)),
+        {
+          value: Promise.reject(getError(errorOrMessage)),
+          promiseValue: getError(errorOrMessage),
+          isError: true,
+          isPromise: true,
+        },
         pendingExpectation
       ),
   };
 
-  // @ts-ignore TODO: because the return type is a conditional and
+  // @ts-expect-error TODO: because the return type is a conditional and
   // we're doing something fishy here that TS doesn't like
   return { ...nonPromiseStub, ...promiseStub };
 };

src/strong-expectation.ts

@@ -1,5 +1,5 @@
 import isEqual from 'lodash/isEqual';
-import { Expectation } from './expectation';
+import { Expectation, ReturnValue } from './expectation';
 import { isMatcher } from './matcher';
 import { printExpectation } from './print';
 
@@ -25,7 +25,7 @@ export class StrongExpectation implements Expectation {
   constructor(
     public property: PropertyKey,
     public args: any[] | undefined,
-    public returnValue: any
+    public returnValue: ReturnValue
   ) {}
 
   setInvocationCount(min: number, max = 1) {

tests/errors.spec.ts

@@ -130,8 +130,12 @@ foobar`
 
   describe('UnexpectedCalls', () => {
     it('should print the unexpected calls and remaining expectations', () => {
-      const e1 = new NotMatchingExpectation(':irrelevant:', undefined);
-      const e2 = new NotMatchingExpectation(':irrelevant:', undefined);
+      const e1 = new NotMatchingExpectation(':irrelevant:', {
+        value: undefined,
+      });
+      const e2 = new NotMatchingExpectation(':irrelevant:', {
+        value: undefined,
+      });
       e1.toJSON = () => 'e1';
       e2.toJSON = () => 'e2';
 

tests/expectation-repository.ts

@@ -1,9 +1,6 @@
 /* eslint-disable class-methods-use-this */
-import { Expectation } from '../src/expectation';
-import {
-  ExpectationRepository,
-  ReturnValue,
-} from '../src/expectation-repository';
+import { Expectation, ReturnValue } from '../src/expectation';
+import { ExpectationRepository } from '../src/expectation-repository';
 
 export class OneIncomingExpectationRepository implements ExpectationRepository {
   public expectation: Expectation | undefined;
@@ -13,7 +10,7 @@ export class OneIncomingExpectationRepository implements ExpectationRepository {
   }
 
   get(): ReturnValue | undefined {
-    return this.expectation && { returnValue: this.expectation.returnValue };
+    return this.expectation?.returnValue;
   }
 
   getUnmet() {

tests/expectations.ts

@@ -1,4 +1,4 @@
-import { Expectation } from '../src/expectation';
+import { Expectation, ReturnValue } from '../src/expectation';
 import { ExpectationRepository } from '../src/expectation-repository';
 import {
   ExpectationFactory,
@@ -18,7 +18,7 @@ export class NeverMatchingExpectation implements Expectation {
 
   property = 'bar';
 
-  returnValue = undefined;
+  returnValue = { value: undefined };
 
   matches = () => false;
 }
@@ -36,7 +36,7 @@ export class OneUseAlwaysMatchingExpectation implements Expectation {
 
   property = 'bar';
 
-  returnValue = 42;
+  returnValue = { value: 42 };
 
   matches = () => true;
 }
@@ -56,7 +56,7 @@ export class SpyExpectation implements Expectation {
   constructor(
     public property: PropertyKey,
     public args: any[] | undefined,
-    public returnValue: any
+    public returnValue: ReturnValue
   ) {}
 
   matches = () => false;
@@ -75,7 +75,7 @@ export class SpyPendingExpectation implements PendingExpectation {
 
   public clearCalled = false;
 
-  public finishCalledWith: any;
+  public finishCalledWith: ReturnValue | undefined;
 
   public propertyCalledWith: PropertyKey | undefined;
 
@@ -89,7 +89,7 @@ export class SpyPendingExpectation implements PendingExpectation {
     this.clearCalled = true;
   }
 
-  finish(returnValue: any) {
+  finish(returnValue: ReturnValue) {
     this.finishCalledWith = returnValue;
     return new OneUseAlwaysMatchingExpectation();
   }
@@ -104,7 +104,7 @@ export class SpyPendingExpectation implements PendingExpectation {
 }
 
 export class MatchingPropertyExpectation implements Expectation {
-  constructor(public property: PropertyKey, public returnValue: any) {}
+  constructor(public property: PropertyKey, public returnValue: ReturnValue) {}
 
   args = undefined;
 
@@ -123,7 +123,7 @@ export class MatchingPropertyExpectation implements Expectation {
 }
 
 export class MatchingCallExpectation implements Expectation {
-  constructor(public property: PropertyKey, public returnValue: any) {}
+  constructor(public property: PropertyKey, public returnValue: ReturnValue) {}
 
   args = [];
 

tests/invocation-count.spec.ts

@@ -5,7 +5,9 @@ import { SpyExpectation } from './expectations';
 
 describe('invocation count', () => {
   it('between should set the min and max', () => {
-    const expectation = new SpyExpectation('bar', undefined, undefined);
+    const expectation = new SpyExpectation('bar', undefined, {
+      value: undefined,
+    });
 
     const invocationCount = createInvocationCount(expectation);
     invocationCount.between(2, 8);