Merge pull request #50 from nut-tree/feature/49/waitFor

Closes #49

Author: s1hofmann

README.md

@@ -88,7 +88,7 @@ It's work in progress and will undergo constant modification.
 ## Screen
 
 - [x] findOnScreen
-- [ ] waitFor
+- [x] waitFor
 - [ ] Hooks to trigger actions based on images
 
 ## Integration

lib/screen.class.e2e.spec.ts

@@ -87,4 +87,26 @@ describe("Screen.", () => {
       });
     });
   });
+
+  it("should reject after timeout", async () => {
+    // GIVEN
+    jest.setTimeout(10000);
+    const timeout = 5000;
+    const visionAdapter = new VisionAdapter();
+    const SUT = new Screen(visionAdapter);
+    SUT.config.resourceDirectory = "./e2e/assets";
+
+    // WHEN
+    const start = Date.now();
+    try {
+      await SUT.waitFor("calculator.png", timeout);
+    } catch (e) {
+      // THEN
+      expect(e).toBe(`Action timed out after ${timeout} ms`);
+    }
+    const end = Date.now();
+
+    // THEN
+    expect(end - start).toBeGreaterThanOrEqual(timeout);
+  });
 });

lib/screen.class.ts

@@ -6,6 +6,7 @@ import { generateOutputPath } from "./generate-output-path.function";
 import { LocationParameters } from "./locationparameters.class";
 import { MatchRequest } from "./match-request.class";
 import { Region } from "./region.class";
+import { timeout } from "./util/poll-action.function";
 
 export class Screen {
   public config = {
@@ -64,6 +65,14 @@ export class Screen {
     });
   }
 
+  public async waitFor(
+    pathToNeedle: string,
+    timeoutMs: number = 5000,
+    params?: LocationParameters,
+  ): Promise<Region> {
+    return timeout(500, timeoutMs, () => this.find(pathToNeedle, params));
+  }
+
   public async capture(
     fileName: string,
     fileFormat: FileType = FileType.PNG,

lib/util/poll-action.function.spec.ts

@@ -0,0 +1,128 @@
+import {timeout} from "./poll-action.function";
+
+describe("poll-action", () => {
+    it("should timeout after maxDuration if action rejects", async () => {
+        // GIVEN
+        const updateInterval = 200;
+        const maxDuration = 1000;
+        const action = jest.fn(() => {
+            console.log(`Polling...`);
+            return Promise.reject(false);
+        });
+
+        // WHEN
+        const start = Date.now();
+        try {
+            await timeout(updateInterval, maxDuration, action);
+        } catch (e) {
+            expect(e).toBe(`Action timed out after ${maxDuration} ms`);
+        }
+        const end = Date.now();
+
+        // THEN
+        expect((end - start)).toBeGreaterThanOrEqual(maxDuration);
+        expect(action).toBeCalledTimes((maxDuration / updateInterval));
+    });
+
+    it("should timeout after maxDuration if action resolve != true", async () => {
+        // GIVEN
+        const updateInterval = 200;
+        const maxDuration = 1000;
+        const action = jest.fn(async () => {
+            console.log(`Polling...`);
+            return false;
+        });
+
+        // WHEN
+        const start = Date.now();
+        try {
+            await timeout(updateInterval, maxDuration, action);
+        } catch (e) {
+            expect(e).toEqual(`Action timed out after ${maxDuration} ms`);
+        }
+        const end = Date.now();
+
+        // THEN
+        expect((end - start)).toBeGreaterThanOrEqual(maxDuration);
+        expect(action).toBeCalledTimes((maxDuration / updateInterval));
+    });
+
+    it("should resolve after updateInterval if action resolves", async () => {
+        // GIVEN
+        const updateInterval = 200;
+        const maxDuration = 1000;
+        const action = jest.fn(() => {
+            console.log(`Polling...`);
+            return Promise.resolve(true);
+        });
+
+        // WHEN
+        const start = Date.now();
+        await timeout(updateInterval, maxDuration, action);
+        const end = Date.now();
+
+        // THEN
+        expect((end - start)).toBeLessThan(updateInterval);
+        expect(action).toBeCalledTimes(1);
+    });
+
+    it("should resolve after updateInterval if action resolves != true", async () => {
+        // GIVEN
+        const updateInterval = 200;
+        const maxDuration = 1000;
+        const action = jest.fn(async () => {
+            console.log(`Polling...`);
+            return true;
+        });
+
+        // WHEN
+        const start = Date.now();
+        await timeout(updateInterval, maxDuration, action);
+        const end = Date.now();
+
+        // THEN
+        expect((end - start)).toBeLessThan(updateInterval);
+        expect(action).toBeCalledTimes(1);
+    });
+
+    it("should retry until action succeeds", async () => {
+        // GIVEN
+        const updateInterval = 200;
+        const maxDuration = 1000;
+        const delay = 2.2 * updateInterval;
+        const action = jest.fn(() => {
+            console.log(`Polling...`);
+            const interval = (Date.now() - start);
+            return new Promise<boolean>((resolve, reject) => (interval > delay) ? resolve(true) : reject());
+        });
+
+        // WHEN
+        const start = Date.now();
+        await timeout(updateInterval, maxDuration, action);
+        const end = Date.now();
+
+        // THEN
+        expect((end - start)).toBeGreaterThanOrEqual(delay);
+        expect(action).toBeCalledTimes(4);
+    });
+
+    it("should fail after timeout if timeout < retry interval", async () => {
+        // GIVEN
+        const updateInterval = 1000;
+        const maxDuration = 200;
+        const action = jest.fn(() => Promise.resolve(false));
+
+        // WHEN
+        const start = Date.now();
+        try {
+            await timeout(updateInterval, maxDuration, action);
+        } catch (e) {
+            expect(e).toEqual(`Action timed out after ${maxDuration} ms`);
+        }
+        const end = Date.now();
+
+        // THEN
+        expect(action).toBeCalledTimes(1);
+        expect((end - start)).toBeLessThan(updateInterval);
+    });
+});

lib/util/poll-action.function.ts

@@ -0,0 +1,41 @@
+export function timeout<R>(updateIntervalMs: number, maxDurationMs: number, action: (...params: any) => Promise<R>): Promise<R> {
+  return new Promise<R>((resolve, reject) => {
+    let interval: NodeJS.Timeout;
+    const timeout = setTimeout(
+      () => {
+        clearTimeout(timeout);
+        if (interval) {
+          clearTimeout(interval);
+        }
+        reject(`Action timed out after ${maxDurationMs} ms`);
+      },
+      maxDurationMs
+    );
+    const startInterval = () => {
+      interval = setTimeout(function intervalFunc() {
+        action().then((result) => {
+          if (!result) {
+            interval = setTimeout(intervalFunc, updateIntervalMs);
+          } else {
+            clearTimeout(timeout);
+            clearTimeout(interval);
+            resolve(result);
+          }
+        }).catch(() => {
+          interval = setTimeout(intervalFunc, updateIntervalMs);
+        });
+      }, updateIntervalMs);
+    };
+
+    action().then((result) => {
+      if (!result) {
+        startInterval();
+      } else {
+        clearTimeout(timeout);
+        resolve(result);
+      }
+    }).catch(() => {
+      startInterval();
+    });
+  });
+}