Feature/455/non image find (#461)

* (#455) Made MatchRequest class generic to allow for generic needle types as well as additional generic provider data that gets passed to the provider implementation

* (#455) BREAKING: Remove both searchMultipleScales and confidence from OptionalSearchParameters since these properties would be provider specific and should be handled via providerData

* (#455) Handle generic provider data in ImageFinder interface

* (#455) New query types to enable searching for things other than images

* (#455) New interfaces to search for text or windows

* (#455) Added new provider interfaces to registry, changed log level of register events to trace

* (#455) Revert removing confidence property from OptionalSearchParameters

* (#455) Extended find implementation conforms all existing tests

* (#455) Increase coverage

* (#455) Allow broader input on toShow jest matcher

* (#455) Refactor handling of finder implementations, add tests

* (#455) Added tests for different find queries

* (#455) Added find input validation and tests

* (#455) Query tests

* (#455) Tests for DefaultProviderRegistry

* (#455) Remove commented lines

Author: s1hofmann

Diff for: index.ts

@@ -8,6 +8,7 @@ import { LineHelper } from "./lib/util/linehelper.class";
 import { createWindowApi } from "./lib/window.function";
 import providerRegistry from "./lib/provider/provider-registry.class";
 import { loadImageResource } from "./lib/imageResources.function";
+import { LineQuery, WindowQuery, WordQuery } from "./lib/query.class";
 
 export {
   AssertClass,
@@ -70,6 +71,35 @@ const imageResource = (fileName: string) =>
     fileName
   );
 
+const singleWord = (word: string | RegExp): WordQuery => {
+  return {
+    type: "text",
+    id: `word-query-${word}`,
+    by: {
+      word,
+    },
+  };
+};
+const textLine = (line: string | RegExp): LineQuery => {
+  return {
+    type: "text",
+    id: `line-query-${line}`,
+    by: {
+      line,
+    },
+  };
+};
+
+const windowWithTitle = (title: string | RegExp): WindowQuery => {
+  return {
+    type: "window",
+    id: `window-by-title-query-${title}`,
+    by: {
+      title,
+    },
+  };
+};
+
 export { fetchFromUrl } from "./lib/imageResources.function";
 
 export {
@@ -88,4 +118,7 @@ export {
   loadImage,
   saveImage,
   imageResource,
+  singleWord,
+  textLine,
+  windowWithTitle,
 };

Diff for: lib/assert.class.spec.ts

@@ -15,7 +15,7 @@ describe("Assert", () => {
     // GIVEN
     ScreenClass.prototype.find = jest.fn(() =>
       Promise.resolve(new Region(0, 0, 100, 100))
-    );
+    ) as any;
     const screenMock = new ScreenClass(providerRegistry);
     const SUT = new AssertClass(screenMock);
     const needle = mockPartial<Image>({
@@ -30,7 +30,7 @@ describe("Assert", () => {
 
   it("isVisible should throw if a match is found.", async () => {
     // GIVEN
-    ScreenClass.prototype.find = jest.fn(() => Promise.reject("foo"));
+    ScreenClass.prototype.find = jest.fn(() => Promise.reject("foo")) as any;
     const screenMock = new ScreenClass(providerRegistry);
     const SUT = new AssertClass(screenMock);
     const needle = mockPartial<Image>({
@@ -47,7 +47,7 @@ describe("Assert", () => {
 
   it("isVisible should throw if a match is found.", async () => {
     // GIVEN
-    ScreenClass.prototype.find = jest.fn(() => Promise.reject("foo"));
+    ScreenClass.prototype.find = jest.fn(() => Promise.reject("foo")) as any;
     const screenMock = new ScreenClass(providerRegistry);
     const SUT = new AssertClass(screenMock);
     const searchRegion = new Region(10, 10, 10, 10);
@@ -67,7 +67,7 @@ describe("Assert", () => {
     // GIVEN
     ScreenClass.prototype.find = jest.fn(() =>
       Promise.resolve(new Region(0, 0, 100, 100))
-    );
+    ) as any;
     const screenMock = new ScreenClass(providerRegistry);
     const SUT = new AssertClass(screenMock);
     const needle = mockPartial<Image>({
@@ -84,7 +84,7 @@ describe("Assert", () => {
 
   it("isVisible should throw if a match is found.", async () => {
     // GIVEN
-    ScreenClass.prototype.find = jest.fn(() => Promise.reject("foo"));
+    ScreenClass.prototype.find = jest.fn(() => Promise.reject("foo")) as any;
     const screenMock = new ScreenClass(providerRegistry);
     const SUT = new AssertClass(screenMock);
     const needle = mockPartial<Image>({

Diff for: lib/assert.class.ts

@@ -1,23 +1,23 @@
 import { Region } from "./region.class";
-import { ScreenClass } from "./screen.class";
-import { FirstArgumentType } from "./typings";
+import { FindInput, ScreenClass } from "./screen.class";
 import { OptionalSearchParameters } from "./optionalsearchparameters.class";
 
 export class AssertClass {
   constructor(private screen: ScreenClass) {}
 
   public async isVisible(
-    needle: FirstArgumentType<typeof ScreenClass.prototype.find>,
-    searchRegion?: Region,
+    searchInput: FindInput | Promise<FindInput>,
+    searchRegion?: Region | Promise<Region>,
     confidence?: number
-  ) {
-    const identifier = (await needle).id;
+  ): Promise<void> {
+    const needle = await searchInput;
+    const identifier = needle.id;
 
     try {
       await this.screen.find(needle, {
         searchRegion,
         confidence,
-      } as OptionalSearchParameters);
+      } as OptionalSearchParameters<never>);
     } catch (err) {
       if (searchRegion !== undefined) {
         throw new Error(
@@ -30,17 +30,18 @@ export class AssertClass {
   }
 
   public async notVisible(
-    needle: FirstArgumentType<typeof ScreenClass.prototype.find>,
-    searchRegion?: Region,
+    searchInput: FindInput | Promise<FindInput>,
+    searchRegion?: Region | Promise<Region>,
     confidence?: number
   ) {
-    const identifier = (await needle).id;
+    const needle = await searchInput;
+    const identifier = needle.id;
 
     try {
       await this.screen.find(needle, {
         searchRegion,
         confidence,
-      } as OptionalSearchParameters);
+      } as OptionalSearchParameters<never>);
     } catch (err) {
       return;
     }

Diff for: lib/expect/jest.matcher.function.ts

@@ -3,18 +3,14 @@ import { Region } from "../region.class";
 import { toBeAt } from "./matchers/toBeAt.function";
 import { toBeIn } from "./matchers/toBeIn.function";
 import { toShow } from "./matchers/toShow.function";
-import { FirstArgumentType } from "../typings";
-import { ScreenClass } from "../screen.class";
+import { FindInput } from "../screen.class";
 
 declare global {
   namespace jest {
     interface Matchers<R> {
       toBeAt: (position: Point) => {};
       toBeIn: (region: Region) => {};
-      toShow: (
-        needle: FirstArgumentType<typeof ScreenClass.prototype.find>,
-        confidence?: number
-      ) => {};
+      toShow: (needle: FindInput, confidence?: number) => {};
     }
   }
 }

Diff for: lib/expect/matchers/toShow.function.ts

@@ -1,10 +1,9 @@
-import { ScreenClass } from "../../screen.class";
-import { FirstArgumentType } from "../../typings";
+import { FindInput, ScreenClass } from "../../screen.class";
 import { OptionalSearchParameters } from "../../optionalsearchparameters.class";
 
 export const toShow = async (
   received: ScreenClass,
-  needle: FirstArgumentType<typeof ScreenClass.prototype.find>,
+  needle: FindInput,
   confidence?: number
 ) => {
   let locationParams;

Diff for: lib/match-request.class.spec.ts

@@ -1,16 +1,78 @@
 import { Image } from "./image.class";
-import { MatchRequest } from "./match-request.class";
+import {
+  createMatchRequest,
+  isImageMatchRequest,
+  isTextMatchRequest,
+} from "./match-request.class";
+import { mockPartial } from "sneer";
+import { ProviderRegistry } from "./provider/provider-registry.class";
+import { LogProviderInterface } from "./provider";
+import { NoopLogProvider } from "./provider/log/noop-log-provider.class";
+import { Region } from "./region.class";
+import { TextQuery } from "./query.class";
 
-jest.mock("jimp", () => {});
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+const providerRegistryMock = mockPartial<ProviderRegistry>({
+  getLogProvider(): LogProviderInterface {
+    return new NoopLogProvider();
+  },
+});
+
+const screenImage = new Image(0, 0, Buffer.of(0), 3, "dummy", 0, 0);
+const dummyRegion = new Region(0, 0, 0, 0);
 
 describe("MatchRequest", () => {
-  it("should default to multi-scale matching", () => {
-    const SUT = new MatchRequest(
-      new Image(100, 100, Buffer.from([]), 3, "haystack_image", 4, 100 * 4),
-      new Image(100, 100, Buffer.from([]), 3, "needle_image", 4, 100 * 4),
-      0.99
+  it("should create an image match request for images", () => {
+    // GIVEN
+    const needle = new Image(0, 0, Buffer.of(0), 3, "dummy", 0, 0);
+
+    // WHEN
+    const matchRequest = createMatchRequest(
+      providerRegistryMock,
+      needle,
+      dummyRegion,
+      0,
+      screenImage
     );
 
-    expect(SUT.searchMultipleScales).toBeTruthy();
+    // THEN
+    expect(isImageMatchRequest(matchRequest)).toBeTruthy();
   });
+
+  it.each<TextQuery>([
+    {
+      id: "dummy",
+      type: "text",
+      by: {
+        word: "dummy-query",
+      },
+    },
+    {
+      id: "dummy",
+      type: "text",
+      by: {
+        line: "dummy-query",
+      },
+    },
+  ])(
+    "should create a text match request for text queries",
+    (needle: TextQuery) => {
+      // GIVEN
+
+      // WHEN
+      const matchRequest = createMatchRequest(
+        providerRegistryMock,
+        needle,
+        dummyRegion,
+        0,
+        screenImage
+      );
+
+      // THEN
+      expect(isTextMatchRequest(matchRequest)).toBeTruthy();
+    }
+  );
 });

Diff for: lib/match-request.class.ts

@@ -1,10 +1,95 @@
-import { Image } from "./image.class";
+import { Image, isImage } from "./image.class";
+import { Region } from "./region.class";
+import { OptionalSearchParameters } from "./optionalsearchparameters.class";
+import { isLineQuery, isTextQuery, TextQuery } from "./query.class";
+import { RegionResultFindInput } from "./screen.class";
+import { ProviderRegistry } from "./provider/provider-registry.class";
 
-export class MatchRequest {
-  constructor(
+export class MatchRequest<NEEDLE_TYPE, PROVIDER_DATA_TYPE> {
+  public constructor(
     public readonly haystack: Image,
-    public readonly needle: Image,
+    public readonly needle: NEEDLE_TYPE,
     public readonly confidence: number,
-    public readonly searchMultipleScales: boolean = true
+    public readonly providerData?: PROVIDER_DATA_TYPE
   ) {}
 }
+
+export function isImageMatchRequest<PROVIDER_DATA_TYPE>(
+  matchRequest: any
+): matchRequest is MatchRequest<Image, PROVIDER_DATA_TYPE> {
+  return isImage(matchRequest.needle);
+}
+
+export function isTextMatchRequest<PROVIDER_DATA_TYPE>(
+  matchRequest: any
+): matchRequest is MatchRequest<TextQuery, PROVIDER_DATA_TYPE> {
+  return isTextQuery(matchRequest.needle);
+}
+
+export function createMatchRequest<PROVIDER_DATA_TYPE>(
+  providerRegistry: ProviderRegistry,
+  needle: TextQuery | Promise<TextQuery>,
+  searchRegion: Region,
+  minMatch: number,
+  screenImage: Image,
+  params?: OptionalSearchParameters<PROVIDER_DATA_TYPE>
+): MatchRequest<TextQuery, PROVIDER_DATA_TYPE>;
+export function createMatchRequest<PROVIDER_DATA_TYPE>(
+  providerRegistry: ProviderRegistry,
+  needle: Image | Promise<Image>,
+  searchRegion: Region,
+  minMatch: number,
+  screenImage: Image,
+  params?: OptionalSearchParameters<PROVIDER_DATA_TYPE>
+): MatchRequest<Image, PROVIDER_DATA_TYPE>;
+export function createMatchRequest<PROVIDER_DATA_TYPE>(
+  providerRegistry: ProviderRegistry,
+  needle: RegionResultFindInput | Promise<RegionResultFindInput>,
+  searchRegion: Region,
+  minMatch: number,
+  screenImage: Image,
+  params?: OptionalSearchParameters<PROVIDER_DATA_TYPE>
+):
+  | MatchRequest<TextQuery, PROVIDER_DATA_TYPE>
+  | MatchRequest<Image, PROVIDER_DATA_TYPE>;
+export function createMatchRequest<PROVIDER_DATA_TYPE>(
+  providerRegistry: ProviderRegistry,
+  needle: RegionResultFindInput | Promise<RegionResultFindInput>,
+  searchRegion: Region,
+  minMatch: number,
+  screenImage: Image,
+  params?: OptionalSearchParameters<PROVIDER_DATA_TYPE>
+):
+  | MatchRequest<Image, PROVIDER_DATA_TYPE>
+  | MatchRequest<TextQuery, PROVIDER_DATA_TYPE> {
+  if (isImage(needle)) {
+    providerRegistry
+      .getLogProvider()
+      .info(
+        `Searching for image ${
+          needle.id
+        } in region ${searchRegion.toString()}. Required confidence: ${minMatch}`
+      );
+
+    return new MatchRequest(
+      screenImage,
+      needle,
+      minMatch,
+      params?.providerData
+    );
+  } else if (isTextQuery(needle)) {
+    providerRegistry.getLogProvider().info(
+      `Searching for ${isLineQuery(needle) ? "line" : "word"} {
+                        ${isLineQuery(needle) ? needle.by.line : needle.by.word}
+                    } in region ${searchRegion.toString()}. Required confidence: ${minMatch}`
+    );
+
+    return new MatchRequest(
+      screenImage,
+      needle,
+      minMatch,
+      params?.providerData
+    );
+  }
+  throw new Error(`Unknown input type: ${JSON.stringify(needle)}`);
+}