unify usage of sleepAsync and add tests

The tests mock JS setTimeout API. However promise.resolve() is not working without flushing the promise queue (which could be done just by awaiting Promise.resolve()), similar issue has been discussed in facebook/jest#2157.

tests/unit/infrastructure/Threading/AsyncLazy.spec.ts

@@ -1,6 +1,7 @@
 import 'mocha';
 import { expect } from 'chai';
 import { AsyncLazy } from '@/infrastructure/Threading/AsyncLazy';
+import { sleepAsync } from '@/infrastructure/Threading/AsyncSleep';
 
 describe('AsyncLazy', () => {
     it('returns value from lambda', async () => {
@@ -33,7 +34,6 @@ describe('AsyncLazy', () => {
         });
         it('when running long-running task in parallel', async () => {
             // act
-            const sleepAsync = (time: number) => new Promise(((resolve) => setTimeout(resolve, time)));
             const sut = new AsyncLazy(async () => {
                 await sleepAsync(100);
                 totalExecuted++;

tests/unit/infrastructure/Threading/AsyncSleep.spec.ts

@@ -0,0 +1,79 @@
+import 'mocha';
+import { expect } from 'chai';
+import { sleepAsync, SchedulerType } from '@/infrastructure/Threading/AsyncSleep';
+
+describe('AsyncSleep', () => {
+    it('fulfills after delay', async () => {
+        // arrange
+        const delayInMs = 10;
+        const scheduler = new SchedulerMock();
+        // act
+        const sleep = sleepAsync(delayInMs, scheduler.mock);
+        const promiseState = watchPromiseState(sleep);
+        scheduler.tickNext(delayInMs);
+        await flushPromiseResolutionQueue();
+        // assert
+        const actual = promiseState.isFulfilled();
+        expect(actual).to.equal(true);
+    });
+    it('pending before delay', async () => {
+        // arrange
+        const delayInMs = 10;
+        const scheduler = new SchedulerMock();
+        // act
+        const sleep = sleepAsync(delayInMs, scheduler.mock);
+        const promiseState = watchPromiseState(sleep);
+        scheduler.tickNext(delayInMs / 5);
+        await flushPromiseResolutionQueue();
+        // assert
+        const actual = promiseState.isPending();
+        expect(actual).to.equal(true);
+    });
+});
+
+function flushPromiseResolutionQueue() {
+    return Promise.resolve();
+}
+
+class SchedulerMock {
+    public readonly mock: SchedulerType;
+    private currentTime = 0;
+    private scheduledActions = new Array<{time: number, action: (...args: any[]) => void}>();
+    constructor() {
+        this.mock = (callback: (...args: any[]) => void, ms: number) => {
+            this.scheduledActions.push({ time: this.currentTime + ms, action: callback });
+        };
+    }
+    public tickNext(ms: number) {
+        const newTime = this.currentTime + ms;
+        let newActions = this.scheduledActions;
+        for (const action of this.scheduledActions) {
+            if (newTime >= action.time) {
+                newActions = newActions.filter((a) => a !== action);
+                action.action();
+            }
+        }
+        this.scheduledActions = newActions;
+    }
+}
+
+function watchPromiseState<T>(promise: Promise<T>) {
+    let isPending = true;
+    let isRejected = false;
+    let isFulfilled = false;
+    promise.then(
+        () => {
+            isFulfilled = true;
+            isPending = false;
+        },
+        () => {
+            isRejected = true;
+            isPending = false;
+        },
+    );
+    return {
+        isFulfilled: () => isFulfilled,
+        isPending: () => isPending,
+        isRejected: () => isRejected,
+    };
+}