From 8473762c27e15551e5d0a433b9b7d0d1a9b5f9fe Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Thu, 5 May 2022 11:50:50 +0200
Subject: [PATCH 1/6] feat: predicate query POC implementation

---
 src/queries/__tests__/predicate.test.tsx | 36 ++++++++++++++
 src/queries/predicate.ts                 | 60 ++++++++++++++++++++++++
 src/within.ts                            |  2 +
 3 files changed, 98 insertions(+)
 create mode 100644 src/queries/__tests__/predicate.test.tsx
 create mode 100644 src/queries/predicate.ts

diff --git a/src/queries/__tests__/predicate.test.tsx b/src/queries/__tests__/predicate.test.tsx
new file mode 100644
index 000000000..8cb81ab5a
--- /dev/null
+++ b/src/queries/__tests__/predicate.test.tsx
@@ -0,0 +1,36 @@
+import React from 'react';
+import { View, Text, TextInput, Button } from 'react-native';
+import { ReactTestInstance } from 'react-test-renderer';
+import { render } from '../..';
+
+test('getByPredicate returns only native elements', () => {
+  const testIdPredicate = (testID: string) => (node: ReactTestInstance) => {
+    return node.props.testID === testID;
+  };
+
+  const { getByPredicate, getAllByPredicate } = render(
+    <View>
+      <Text testID="text">Text</Text>
+      <TextInput testID="textInput" />
+      <View testID="view" />
+      <Button testID="button" title="Button" onPress={jest.fn()} />
+    </View>
+  );
+
+  expect(getByPredicate(testIdPredicate('text'))).toBeTruthy();
+  expect(getByPredicate(testIdPredicate('textInput'))).toBeTruthy();
+  expect(getByPredicate(testIdPredicate('view'))).toBeTruthy();
+  expect(getByPredicate(testIdPredicate('button'))).toBeTruthy();
+
+  expect(getAllByPredicate(testIdPredicate('text'))).toHaveLength(1);
+  expect(getAllByPredicate(testIdPredicate('textInput'))).toHaveLength(1);
+  expect(getAllByPredicate(testIdPredicate('view'))).toHaveLength(1);
+  expect(getAllByPredicate(testIdPredicate('button'))).toHaveLength(1);
+
+  expect(() => getByPredicate(testIdPredicate('myComponent'))).toThrowError(
+    /^Unable to find an element matching predicate: /i
+  );
+  expect(() => getAllByPredicate(testIdPredicate('myComponent'))).toThrowError(
+    /^Unable to find an element matching predicate: /i
+  );
+});
diff --git a/src/queries/predicate.ts b/src/queries/predicate.ts
new file mode 100644
index 000000000..c13460b08
--- /dev/null
+++ b/src/queries/predicate.ts
@@ -0,0 +1,60 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import { makeQueries } from './makeQueries';
+import type {
+  FindAllByQuery,
+  FindByQuery,
+  GetAllByQuery,
+  GetByQuery,
+  QueryAllByQuery,
+  QueryByQuery,
+} from './makeQueries';
+
+type PredicateFn = (instance: ReactTestInstance) => boolean;
+// Not used so far
+type PredicateQueryOptions = void;
+
+const queryAllByPredicate = (
+  instance: ReactTestInstance
+): ((
+  predicate: PredicateFn,
+  options?: PredicateQueryOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByTestIdFn(predicate) {
+    const results = instance.findAll(
+      (node) => typeof node.type === 'string' && predicate(node)
+    );
+
+    return results;
+  };
+
+const getMultipleError = (predicate: PredicateFn) =>
+  `Found multiple elements matching predicate: ${predicate}`;
+
+const getMissingError = (predicate: PredicateFn) =>
+  `Unable to find an element matching predicate: ${predicate}`;
+
+const { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(
+  queryAllByPredicate,
+  getMissingError,
+  getMultipleError
+);
+
+export type ByTestIdQueries = {
+  getByPredicate: GetByQuery<PredicateFn, PredicateQueryOptions>;
+  getAllByPredicate: GetAllByQuery<PredicateFn, PredicateQueryOptions>;
+  queryByPredicate: QueryByQuery<PredicateFn, PredicateQueryOptions>;
+  queryAllByPredicate: QueryAllByQuery<PredicateFn, PredicateQueryOptions>;
+  findByPredicate: FindByQuery<PredicateFn, PredicateQueryOptions>;
+  findAllByPredicate: FindAllByQuery<PredicateFn, PredicateQueryOptions>;
+};
+
+export const bindByPredicateQueries = (
+  instance: ReactTestInstance
+): ByTestIdQueries => ({
+  getByPredicate: getBy(instance),
+  getAllByPredicate: getAllBy(instance),
+  queryByPredicate: queryBy(instance),
+  queryAllByPredicate: queryAllBy(instance),
+  findByPredicate: findBy(instance),
+  findAllByPredicate: findAllBy(instance),
+});
diff --git a/src/within.ts b/src/within.ts
index d4d36751f..ae8587388 100644
--- a/src/within.ts
+++ b/src/within.ts
@@ -10,6 +10,7 @@ import { bindByA11yStateQueries } from './queries/a11yState';
 import { bindByA11yValueQueries } from './queries/a11yValue';
 import { bindUnsafeByTypeQueries } from './queries/unsafeType';
 import { bindUnsafeByPropsQueries } from './queries/unsafeProps';
+import { bindByPredicateQueries } from './queries/predicate';
 
 export function within(instance: ReactTestInstance) {
   return {
@@ -22,6 +23,7 @@ export function within(instance: ReactTestInstance) {
     ...bindByRoleQueries(instance),
     ...bindByA11yStateQueries(instance),
     ...bindByA11yValueQueries(instance),
+    ...bindByPredicateQueries(instance),
     ...bindUnsafeByTypeQueries(instance),
     ...bindUnsafeByPropsQueries(instance),
   };

From 263dc1ac300a19abf80a1d35ae7f0df60049d130 Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Thu, 8 Dec 2022 22:40:31 +0100
Subject: [PATCH 2/6] chore: improve tests

---
 src/queries/__tests__/predicate.test.tsx | 67 +++++++++++++++++++++---
 src/queries/predicate.ts                 | 39 +++++++-------
 2 files changed, 81 insertions(+), 25 deletions(-)

diff --git a/src/queries/__tests__/predicate.test.tsx b/src/queries/__tests__/predicate.test.tsx
index 8cb81ab5a..764c89aad 100644
--- a/src/queries/__tests__/predicate.test.tsx
+++ b/src/queries/__tests__/predicate.test.tsx
@@ -4,8 +4,15 @@ import { ReactTestInstance } from 'react-test-renderer';
 import { render } from '../..';
 
 test('getByPredicate returns only native elements', () => {
-  const testIdPredicate = (testID: string) => (node: ReactTestInstance) => {
-    return node.props.testID === testID;
+  const testIdPredicate = (testID: string) => (element: ReactTestInstance) => {
+    return element.props.testID === testID;
+  };
+
+  const textInputPredicate = function matchTextInput(
+    element: ReactTestInstance
+  ) {
+    // @ts-expect-error - ReatTestInstance type is missing host element typing
+    return element.type === 'TextInput';
   };
 
   const { getByPredicate, getAllByPredicate } = render(
@@ -27,10 +34,56 @@ test('getByPredicate returns only native elements', () => {
   expect(getAllByPredicate(testIdPredicate('view'))).toHaveLength(1);
   expect(getAllByPredicate(testIdPredicate('button'))).toHaveLength(1);
 
-  expect(() => getByPredicate(testIdPredicate('myComponent'))).toThrowError(
-    /^Unable to find an element matching predicate: /i
-  );
-  expect(() => getAllByPredicate(testIdPredicate('myComponent'))).toThrowError(
-    /^Unable to find an element matching predicate: /i
+  expect(getByPredicate(textInputPredicate)).toBeTruthy();
+});
+
+test('getByPredicate error messages', () => {
+  function hasStylePredicate(element: ReactTestInstance) {
+    return element.props.style !== undefined;
+  }
+
+  const textInputPredicate = function textInputPredicate(
+    element: ReactTestInstance
+  ) {
+    // @ts-expect-error - ReatTestInstance type is missing host element typing
+    return element.type === 'TextInput';
+  };
+
+  const testIdPredicate = (testID: string) => (element: ReactTestInstance) => {
+    return element.props.testID === testID;
+  };
+
+  const { getByPredicate, getAllByPredicate } = render(
+    <View>
+      <Text testID="text">Text</Text>
+    </View>
   );
+
+  expect(() => getByPredicate(hasStylePredicate))
+    .toThrowErrorMatchingInlineSnapshot(`
+    "Unable to find an element matching predicate: function hasStylePredicate(element) {
+        return element.props.style !== undefined;
+      }"
+  `);
+
+  expect(() => getByPredicate(textInputPredicate))
+    .toThrowErrorMatchingInlineSnapshot(`
+    "Unable to find an element matching predicate: function textInputPredicate(element) {
+        // @ts-expect-error - ReatTestInstance type is missing host element typing
+        return element.type === 'TextInput';
+      }"
+  `);
+
+  expect(() => getByPredicate(testIdPredicate('myComponent')))
+    .toThrowErrorMatchingInlineSnapshot(`
+    "Unable to find an element matching predicate: element => {
+        return element.props.testID === testID;
+      }"
+  `);
+  expect(() => getAllByPredicate(testIdPredicate('myComponent')))
+    .toThrowErrorMatchingInlineSnapshot(`
+    "Unable to find an element matching predicate: element => {
+        return element.props.testID === testID;
+      }"
+  `);
 });
diff --git a/src/queries/predicate.ts b/src/queries/predicate.ts
index c13460b08..50a31522f 100644
--- a/src/queries/predicate.ts
+++ b/src/queries/predicate.ts
@@ -1,4 +1,6 @@
 import type { ReactTestInstance } from 'react-test-renderer';
+import { isHostElement } from '../helpers/component-tree';
+import { findAll } from '../helpers/findAll';
 import { makeQueries } from './makeQueries';
 import type {
   FindAllByQuery,
@@ -8,24 +10,25 @@ import type {
   QueryAllByQuery,
   QueryByQuery,
 } from './makeQueries';
+import { CommonQueryOptions } from './options';
 
 type PredicateFn = (instance: ReactTestInstance) => boolean;
-// Not used so far
-type PredicateQueryOptions = void;
-
-const queryAllByPredicate = (
-  instance: ReactTestInstance
-): ((
-  predicate: PredicateFn,
-  options?: PredicateQueryOptions
-) => Array<ReactTestInstance>) =>
-  function queryAllByTestIdFn(predicate) {
-    const results = instance.findAll(
-      (node) => typeof node.type === 'string' && predicate(node)
+type ByPredicateQueryOptions = CommonQueryOptions;
+
+function queryAllByPredicate(instance: ReactTestInstance) {
+  return function queryAllByPredicateFn(
+    predicate: PredicateFn,
+    options?: ByPredicateQueryOptions
+  ): Array<ReactTestInstance> {
+    const results = findAll(
+      instance,
+      (node) => isHostElement(node) && predicate(node),
+      options
     );
 
     return results;
   };
+}
 
 const getMultipleError = (predicate: PredicateFn) =>
   `Found multiple elements matching predicate: ${predicate}`;
@@ -40,12 +43,12 @@ const { getBy, getAllBy, queryBy, queryAllBy, findBy, findAllBy } = makeQueries(
 );
 
 export type ByTestIdQueries = {
-  getByPredicate: GetByQuery<PredicateFn, PredicateQueryOptions>;
-  getAllByPredicate: GetAllByQuery<PredicateFn, PredicateQueryOptions>;
-  queryByPredicate: QueryByQuery<PredicateFn, PredicateQueryOptions>;
-  queryAllByPredicate: QueryAllByQuery<PredicateFn, PredicateQueryOptions>;
-  findByPredicate: FindByQuery<PredicateFn, PredicateQueryOptions>;
-  findAllByPredicate: FindAllByQuery<PredicateFn, PredicateQueryOptions>;
+  getByPredicate: GetByQuery<PredicateFn, ByPredicateQueryOptions>;
+  getAllByPredicate: GetAllByQuery<PredicateFn, ByPredicateQueryOptions>;
+  queryByPredicate: QueryByQuery<PredicateFn, ByPredicateQueryOptions>;
+  queryAllByPredicate: QueryAllByQuery<PredicateFn, ByPredicateQueryOptions>;
+  findByPredicate: FindByQuery<PredicateFn, ByPredicateQueryOptions>;
+  findAllByPredicate: FindAllByQuery<PredicateFn, ByPredicateQueryOptions>;
 };
 
 export const bindByPredicateQueries = (

From 6779e66e56e389d7ab5ca21f5deaa0e8f4359bba Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Thu, 8 Dec 2022 22:40:41 +0100
Subject: [PATCH 3/6] chore: docs

---
 website/docs/Queries.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/website/docs/Queries.md b/website/docs/Queries.md
index 7ae87cbc3..b1ec65252 100644
--- a/website/docs/Queries.md
+++ b/website/docs/Queries.md
@@ -26,6 +26,7 @@ title: Queries
     - [Default state for: `disabled`, `selected`, and `busy` keys](#default-state-for-disabled-selected-and-busy-keys)
     - [Default state for: `checked` and `expanded` keys](#default-state-for-checked-and-expanded-keys)
   - [`ByA11Value`, `ByAccessibilityValue`](#bya11value-byaccessibilityvalue)
+  - [`ByPredicate`](#bypredicate)
 - [Common options](#common-options)
   - [`includeHiddenElements` option](#includehiddenelements-option)
 - [TextMatch](#textmatch)
@@ -391,6 +392,23 @@ const element = screen.getByA11yValue({ now: 25 });
 const element2 = screen.getByA11yValue({ text: /25/ });
 ```
 
+### `ByPredicate`
+
+> getByPredicate, getAllByPredicate, queryByPredicate, queryAllByPredicate, findByPredicate, findAllByPredicate
+
+```ts
+getByPredicate(
+  predicate: (element: ReactTestInstance) => boolean,
+  options?: {
+    includeHiddenElements?: boolean;
+  }
+): ReactTestInstance;
+```
+
+Returns a host element matching a custom `predicate` function.
+
+This query type is an escape hatch and should be used with care. In most cases you using the standard queries like `getByRole` or `getByText` will lead to test more-resembling user perspective. Use this query with care in rare cases where more flexibility is needed.
+
 ## Common options
 
 ### `includeHiddenElements` option

From 3da4c4aeeeb347d0728841f5ef1dcf17434c096f Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Thu, 8 Dec 2022 22:40:49 +0100
Subject: [PATCH 4/6] chore: flow typing

---
 typings/index.flow.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/typings/index.flow.js b/typings/index.flow.js
index 2bbf303c7..a97d975e4 100644
--- a/typings/index.flow.js
+++ b/typings/index.flow.js
@@ -389,6 +389,37 @@ interface A11yAPI {
   ) => FindAllReturn;
 }
 
+type ByPredicateOptions = CommonQueryOptions;
+
+interface ByPredicateQueries {
+  getByPredicate: (
+    placeholder: TextMatch,
+    options?: ByPredicateOptions
+  ) => ReactTestInstance;
+  getAllByPredicate: (
+    placeholder: TextMatch,
+    options?: ByPredicateOptions
+  ) => Array<ReactTestInstance>;
+  queryByPredicate: (
+    placeholder: TextMatch,
+    options?: ByPredicateOptions
+  ) => ReactTestInstance | null;
+  queryAllByPredicate: (
+    placeholder: TextMatch,
+    options?: ByPredicateOptions
+  ) => Array<ReactTestInstance> | [];
+  findByPredicate: (
+    placeholder: TextMatch,
+    queryOptions?: ByPredicateOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByPredicate: (
+    placeholder: TextMatch,
+    queryOptions?: ByPredicateOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
 interface Thenable {
   then: (resolve: () => any, reject?: () => any) => any;
 }
@@ -412,6 +443,7 @@ type Queries = ByTextQueries &
   ByTestIdQueries &
   ByDisplayValueQueries &
   ByPlaceholderTextQueries &
+  ByPredicateQueries &
   UnsafeByTypeQueries &
   UnsafeByPropsQueries &
   A11yAPI;

From 3742694dd5baf634084d0e47fae31d94aa0523e7 Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Thu, 8 Dec 2022 22:45:49 +0100
Subject: [PATCH 5/6] fix: missing screen guard methods

---
 src/screen.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/screen.ts b/src/screen.ts
index 34a1504d5..987fb7faf 100644
--- a/src/screen.ts
+++ b/src/screen.ts
@@ -107,6 +107,12 @@ const defaultScreen: RenderResult = {
   queryAllByText: notImplemented,
   findByText: notImplemented,
   findAllByText: notImplemented,
+  getByPredicate: notImplemented,
+  getAllByPredicate: notImplemented,
+  queryByPredicate: notImplemented,
+  queryAllByPredicate: notImplemented,
+  findByPredicate: notImplemented,
+  findAllByPredicate: notImplemented,
 };
 
 export let screen: RenderResult = defaultScreen;

From a9cb1c6426b7dbb2e88427a1726185dce04069a9 Mon Sep 17 00:00:00 2001
From: Maciej Jastrzebski <mdjastrzebski@gmail.com>
Date: Mon, 12 Dec 2022 11:40:57 +0100
Subject: [PATCH 6/6] fix: flow types

---
 typings/index.flow.js | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/typings/index.flow.js b/typings/index.flow.js
index a97d975e4..3387c796e 100644
--- a/typings/index.flow.js
+++ b/typings/index.flow.js
@@ -389,32 +389,33 @@ interface A11yAPI {
   ) => FindAllReturn;
 }
 
+type PredicateFn = (node: ReactTestInstance) => boolean;
 type ByPredicateOptions = CommonQueryOptions;
 
 interface ByPredicateQueries {
   getByPredicate: (
-    placeholder: TextMatch,
+    predicate: PredicateFn,
     options?: ByPredicateOptions
   ) => ReactTestInstance;
   getAllByPredicate: (
-    placeholder: TextMatch,
+    predicate: PredicateFn,
     options?: ByPredicateOptions
   ) => Array<ReactTestInstance>;
   queryByPredicate: (
-    placeholder: TextMatch,
+    predicate: PredicateFn,
     options?: ByPredicateOptions
   ) => ReactTestInstance | null;
   queryAllByPredicate: (
-    placeholder: TextMatch,
+    predicate: PredicateFn,
     options?: ByPredicateOptions
   ) => Array<ReactTestInstance> | [];
   findByPredicate: (
-    placeholder: TextMatch,
+    predicate: PredicateFn,
     queryOptions?: ByPredicateOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByPredicate: (
-    placeholder: TextMatch,
+    predicate: PredicateFn,
     queryOptions?: ByPredicateOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;