/* These utilities help manipulate time by controlling the order of resolution of promises */ 


export interface IResume<T> {
    withSuccess: (val: T) => void;
    withFailure: (reason: any) => void;
}

export function pauseOn<T>(fn: (...args: any[]) => Promise<T>): PromiseLike<IResume<T>> {
    const mock = fn as jest.Mock<void>;

    return new Promise((resolve) => {
        mock.mockImplementationOnce(() => new Promise<T>((success, failure) => {
            resolve({
                withFailure: failure,
                withSuccess: success
            });
        }));
    });
}

export class LatchedPromise<T> extends Promise<T> {
    public didFire: boolean = false;
}

export function latch<T>(p: PromiseLike<T>): LatchedPromise<T> {
    const ret = new LatchedPromise<T>((resolve, reject) => {
        p.then((_) => {
            ret.didFire = true;
            resolve(_);
        }, (_) => {
            ret.didFire = true;
            reject(_);
        });
    });
    return ret;
}