Add defer() for testing deferred promise resolution

README.md

@@ -179,6 +179,17 @@ when(mockedFoo.fetchData("a")).thenResolve({id: "a", value: "Hello world"});
 when(mockedFoo.fetchData("b")).thenReject(new Error("b does not exist"));
 ```
 
+### Defer resolving promises
+
+The actions `.thenResolve()` and `.thenReject()` are returning promises that are already resolved or rejected. Sometimes you want to control the order or timing of when promises are resolved. In that case it is useful to return a deferred promise, and resolve it from the test code, when appropriate.
+
+```typescript
+let d = defer<number>();
+when(obj.method()).thenReturn(d); // Return a promise that is not resolved yet
+
+d.resolve(1); // Later, the promise is resolved or rejected
+```
+
 ### Resetting mock calls
 
 You can reset just mock call counter

src/ts-mockito.ts

@@ -123,6 +123,22 @@ export function objectContaining(expectedValue: Object): any {
     return new ObjectContainingMatcher(expectedValue) as any;
 }
 
+export type Deferred<T> = Promise<T> & {
+    resolve: (value: T) => void;
+    reject: (err: any) => void;
+};
+
+export function defer<T>(): Deferred<T> {
+    let resolve: (value: T) => void;
+    let reject: (err: any) => void;
+
+    const d = new Promise<T>((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return Object.assign(d, { resolve, reject });
+}
+
 // Export default object with all members (ember-browserify doesn't support named exports).
 export default {
     spy,
@@ -144,4 +160,5 @@ export default {
     strictEqual,
     match,
     objectContaining,
+    defer,
 };

test/defer.spec.ts

@@ -0,0 +1,35 @@
+import { anything, defer, fnmock, instance, mock, verify, when } from "../src/ts-mockito";
+
+class MockObject {
+    public method(): Promise<number> {
+        return Promise.resolve(100);
+    }
+}
+
+describe("defer", () => {
+    it("resolves a promise", async () => {
+        const resolved: (value: number) => void = fnmock();
+        const obj: MockObject = mock(MockObject);
+        const d = defer<number>();
+        when(obj.method()).thenReturn(d);
+
+        instance(obj).method().then(instance(resolved));
+        verify(resolved(anything())).never();
+
+        d.resolve(1);
+        await verify(resolved(1)).timeout(100);
+    });
+
+    it("rejects a promise", async () => {
+        const rejected: (err: any) => void = fnmock();
+        const obj: MockObject = mock(MockObject);
+        const d = defer<number>();
+        when(obj.method()).thenReturn(d);
+
+        instance(obj).method().catch(instance(rejected));
+        verify(rejected(anything())).never();
+
+        d.reject(1);
+        await verify(rejected(1)).timeout(100);
+    });
+});