From 9871677b8749e817f38b21bf7839f2e71279e171 Mon Sep 17 00:00:00 2001
From: MattAgn <matthieua@bam.tech>
Date: Sat, 28 Nov 2020 16:31:49 +0100
Subject: [PATCH 1/9] refactor: add makeQueries functions

---
 src/helpers/makeQueries.js | 78 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 src/helpers/makeQueries.js

diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
new file mode 100644
index 000000000..11b94cbd0
--- /dev/null
+++ b/src/helpers/makeQueries.js
@@ -0,0 +1,78 @@
+// @flow
+import waitFor from '../waitFor';
+import type { WaitForOptions } from '../waitFor';
+import { ErrorWithStack } from './errors';
+
+type AllQuery = (
+  instance: ReactTestInstance
+) => (args: any) => Array<ReactTestInstance>;
+
+export const makeGetAllQuery = (
+  allQuery: AllQuery,
+  instance: ReactTestInstance,
+  getMissingElementError: (args: any) => string
+) =>
+  function getAllFn(...args: Array<any>) {
+    const results = allQuery(instance)(...args);
+    if (!results.length) {
+      throw new ErrorWithStack(getMissingElementError(...args), getAllFn);
+    }
+
+    return results;
+  };
+
+export const makeSingleQuery = (
+  allQuery: AllQuery,
+  instance: ReactTestInstance,
+  getMissingElementError: (args: any, nbResults: number) => string
+) =>
+  function singleQueryFn(...args: Array<any>) {
+    const results = allQuery(instance)(...args);
+
+    if (results.length > 1) {
+      throw new ErrorWithStack(
+        getMissingElementError(...args, results.length),
+        singleQueryFn
+      );
+    }
+
+    if (results.length === 0) {
+      return null;
+    }
+
+    return results[0];
+  };
+
+export const makeGetQuery = (
+  allQuery: AllQuery,
+  instance: ReactTestInstance,
+  getMissingElementError: (args: any, nbResults: number) => string
+) =>
+  function getFn(...args: Array<any>) {
+    const results = allQuery(instance)(...args);
+
+    if (results.length !== 1) {
+      throw new ErrorWithStack(
+        getMissingElementError(...args, results.length),
+        getFn
+      );
+    }
+
+    return results[0];
+  };
+
+export const makeFindAllQuery = (
+  getAllQuery: AllQuery,
+  instance: ReactTestInstance
+) =>
+  function findAllFn(args: any, waitForOptions: WaitForOptions = {}) {
+    return waitFor(() => getAllQuery(instance)(args), waitForOptions);
+  };
+
+export const makeFindQuery = (
+  getQuery: (instance: ReactTestInstance) => (args: any) => ReactTestInstance,
+  instance: ReactTestInstance
+) =>
+  function findFn(args: any, waitForOptions: WaitForOptions = {}) {
+    return waitFor(() => getQuery(instance)(args), waitForOptions);
+  };

From 791c5d5a3bd0522bf9fcc50cb1d6b60878b452a0 Mon Sep 17 00:00:00 2001
From: MattAgn <matthieua@bam.tech>
Date: Sat, 28 Nov 2020 16:32:27 +0100
Subject: [PATCH 2/9] refactor: use new query builders on byTestId

---
 src/__tests__/byTestId.test.js  | 171 ++++++++++++++++++++++++++++++++
 src/__tests__/findByApi.test.js |   6 --
 src/__tests__/render.test.js    |  30 ------
 src/helpers/byTestId.js         |  58 +++++++++++
 src/helpers/findByAPI.js        |  23 +----
 src/helpers/getByAPI.js         |  45 +--------
 src/helpers/queryByAPI.js       |  26 +----
 7 files changed, 232 insertions(+), 127 deletions(-)
 create mode 100644 src/__tests__/byTestId.test.js
 create mode 100644 src/helpers/byTestId.js

diff --git a/src/__tests__/byTestId.test.js b/src/__tests__/byTestId.test.js
new file mode 100644
index 000000000..7c95a97cd
--- /dev/null
+++ b/src/__tests__/byTestId.test.js
@@ -0,0 +1,171 @@
+// @flow
+import React from 'react';
+import { View, Text, TextInput, TouchableOpacity, Button } from 'react-native';
+import { render } from '..';
+
+const PLACEHOLDER_FRESHNESS = 'Add custom freshness';
+const PLACEHOLDER_CHEF = 'Who inspected freshness?';
+const INPUT_FRESHNESS = 'Custom Freshie';
+const INPUT_CHEF = 'I inspected freshie';
+
+class MyButton extends React.Component<any> {
+  render() {
+    return (
+      <TouchableOpacity onPress={this.props.onPress}>
+        <Text>{this.props.children}</Text>
+      </TouchableOpacity>
+    );
+  }
+}
+
+class Banana extends React.Component<any, any> {
+  state = {
+    fresh: false,
+  };
+
+  componentDidUpdate() {
+    if (this.props.onUpdate) {
+      this.props.onUpdate();
+    }
+  }
+
+  componentWillUnmount() {
+    if (this.props.onUnmount) {
+      this.props.onUnmount();
+    }
+  }
+
+  changeFresh = () => {
+    this.setState((state) => ({
+      fresh: !state.fresh,
+    }));
+  };
+
+  render() {
+    const test = 0;
+    return (
+      <View>
+        <Text>Is the banana fresh?</Text>
+        <Text testID="bananaFresh">
+          {this.state.fresh ? 'fresh' : 'not fresh'}
+        </Text>
+        <TextInput
+          testID="bananaCustomFreshness"
+          placeholder={PLACEHOLDER_FRESHNESS}
+          value={INPUT_FRESHNESS}
+        />
+        <TextInput
+          testID="bananaChef"
+          placeholder={PLACEHOLDER_CHEF}
+          value={INPUT_CHEF}
+        />
+        <MyButton onPress={this.changeFresh} type="primary">
+          Change freshness!
+        </MyButton>
+        <Text testID="duplicateText">First Text</Text>
+        <Text testID="duplicateText">Second Text</Text>
+        <Text>{test}</Text>
+      </View>
+    );
+  }
+}
+
+const MyComponent = () => {
+  return <Text>My Component</Text>;
+};
+
+test('getByTestId returns only native elements', () => {
+  const { getByTestId, getAllByTestId } = render(
+    <View>
+      <Text testID="text">Text</Text>
+      <TextInput testID="textInput" />
+      <View testID="view" />
+      <Button testID="button" title="Button" onPress={jest.fn()} />
+      <MyComponent testID="myComponent" />
+    </View>
+  );
+
+  expect(getByTestId('text')).toBeTruthy();
+  expect(getByTestId('textInput')).toBeTruthy();
+  expect(getByTestId('view')).toBeTruthy();
+  expect(getByTestId('button')).toBeTruthy();
+
+  expect(getAllByTestId('text')).toHaveLength(1);
+  expect(getAllByTestId('textInput')).toHaveLength(1);
+  expect(getAllByTestId('view')).toHaveLength(1);
+  expect(getAllByTestId('button')).toHaveLength(1);
+
+  expect(() => getByTestId('myComponent')).toThrowError(
+    'No instances found with testID: myComponent'
+  );
+  expect(() => getAllByTestId('myComponent')).toThrowError(
+    'No instances found with testID: myComponent'
+  );
+});
+
+test('supports a regex matcher', () => {
+  const { getByTestId, getAllByTestId } = render(
+    <View>
+      <Text testID="text">Text</Text>
+      <TextInput testID="textInput" />
+      <View testID="view" />
+      <Button testID="button" title="Button" onPress={jest.fn()} />
+      <MyComponent testID="myComponent" />
+    </View>
+  );
+
+  expect(getByTestId(/view/)).toBeTruthy();
+  expect(getAllByTestId(/text/)).toHaveLength(2);
+});
+
+test('getByTestId, queryByTestId', () => {
+  const { getByTestId, queryByTestId } = render(<Banana />);
+  const component = getByTestId('bananaFresh');
+
+  expect(component.props.children).toBe('not fresh');
+  expect(() => getByTestId('InExistent')).toThrow('No instances found');
+
+  expect(getByTestId('bananaFresh')).toBe(component);
+  expect(queryByTestId('InExistent')).toBeNull();
+});
+
+test('getAllByTestId, queryAllByTestId', () => {
+  const { getAllByTestId, queryAllByTestId } = render(<Banana />);
+  const textElements = getAllByTestId('duplicateText');
+
+  expect(textElements.length).toBe(2);
+  expect(textElements[0].props.children).toBe('First Text');
+  expect(textElements[1].props.children).toBe('Second Text');
+  expect(() => getAllByTestId('nonExistentTestId')).toThrow(
+    'No instances found'
+  );
+
+  const queriedTextElements = queryAllByTestId('duplicateText');
+
+  expect(queriedTextElements.length).toBe(2);
+  expect(queriedTextElements[0]).toBe(textElements[0]);
+  expect(queriedTextElements[1]).toBe(textElements[1]);
+  expect(queryAllByTestId('nonExistentTestId')).toHaveLength(0);
+});
+
+test('findByTestId and findAllByTestId work asynchronously', async () => {
+  const options = { timeout: 10 }; // Short timeout so that this test runs quickly
+  const { rerender, findByTestId, findAllByTestId } = render(<View />);
+  await expect(findByTestId('aTestId', options)).rejects.toBeTruthy();
+  await expect(findAllByTestId('aTestId', options)).rejects.toBeTruthy();
+
+  setTimeout(
+    () =>
+      rerender(
+        <View testID="aTestId">
+          <Text>Some Text</Text>
+          <TextInput placeholder="Placeholder Text" />
+          <TextInput value="Display Value" />
+        </View>
+      ),
+    20
+  );
+
+  await expect(findByTestId('aTestId')).resolves.toBeTruthy();
+  await expect(findAllByTestId('aTestId')).resolves.toHaveLength(1);
+}, 20000);
diff --git a/src/__tests__/findByApi.test.js b/src/__tests__/findByApi.test.js
index 25cdffed2..e0020f9e1 100644
--- a/src/__tests__/findByApi.test.js
+++ b/src/__tests__/findByApi.test.js
@@ -7,8 +7,6 @@ test('findBy queries work asynchronously', async () => {
   const options = { timeout: 10 }; // Short timeout so that this test runs quickly
   const {
     rerender,
-    findByTestId,
-    findAllByTestId,
     findByText,
     findAllByText,
     findByPlaceholderText,
@@ -16,8 +14,6 @@ test('findBy queries work asynchronously', async () => {
     findByDisplayValue,
     findAllByDisplayValue,
   } = render(<View />);
-  await expect(findByTestId('aTestId', options)).rejects.toBeTruthy();
-  await expect(findAllByTestId('aTestId', options)).rejects.toBeTruthy();
   await expect(findByText('Some Text', options)).rejects.toBeTruthy();
   await expect(findAllByText('Some Text', options)).rejects.toBeTruthy();
   await expect(
@@ -45,8 +41,6 @@ test('findBy queries work asynchronously', async () => {
     20
   );
 
-  await expect(findByTestId('aTestId')).resolves.toBeTruthy();
-  await expect(findAllByTestId('aTestId')).resolves.toHaveLength(1);
   await expect(findByText('Some Text')).resolves.toBeTruthy();
   await expect(findAllByText('Some Text')).resolves.toHaveLength(1);
   await expect(findByPlaceholderText('Placeholder Text')).resolves.toBeTruthy();
diff --git a/src/__tests__/render.test.js b/src/__tests__/render.test.js
index 760eac5e7..f2f46ade4 100644
--- a/src/__tests__/render.test.js
+++ b/src/__tests__/render.test.js
@@ -79,36 +79,6 @@ class Banana extends React.Component<any, any> {
   }
 }
 
-test('getByTestId, queryByTestId', () => {
-  const { getByTestId, queryByTestId } = render(<Banana />);
-  const component = getByTestId('bananaFresh');
-
-  expect(component.props.children).toBe('not fresh');
-  expect(() => getByTestId('InExistent')).toThrow('No instances found');
-
-  expect(getByTestId('bananaFresh')).toBe(component);
-  expect(queryByTestId('InExistent')).toBeNull();
-});
-
-test('getAllByTestId, queryAllByTestId', () => {
-  const { getAllByTestId, queryAllByTestId } = render(<Banana />);
-  const textElements = getAllByTestId('duplicateText');
-
-  expect(textElements.length).toBe(2);
-  expect(textElements[0].props.children).toBe('First Text');
-  expect(textElements[1].props.children).toBe('Second Text');
-  expect(() => getAllByTestId('nonExistentTestId')).toThrow(
-    'No instances found'
-  );
-
-  const queriedTextElements = queryAllByTestId('duplicateText');
-
-  expect(queriedTextElements.length).toBe(2);
-  expect(queriedTextElements[0]).toBe(textElements[0]);
-  expect(queriedTextElements[1]).toBe(textElements[1]);
-  expect(queryAllByTestId('nonExistentTestId')).toHaveLength(0);
-});
-
 test('UNSAFE_getAllByType, UNSAFE_queryAllByType', () => {
   const { UNSAFE_getAllByType, UNSAFE_queryAllByType } = render(<Banana />);
   const [text, status, button] = UNSAFE_getAllByType(Text);
diff --git a/src/helpers/byTestId.js b/src/helpers/byTestId.js
new file mode 100644
index 000000000..aa619afd4
--- /dev/null
+++ b/src/helpers/byTestId.js
@@ -0,0 +1,58 @@
+// @flow
+import {
+  makeGetAllQuery,
+  makeSingleQuery,
+  makeGetQuery,
+  makeFindAllQuery,
+  makeFindQuery,
+} from './makeQueries';
+
+const getNodeByTestId = (node, testID) => {
+  return typeof testID === 'string'
+    ? testID === node.props.testID
+    : testID.test(node.props.testID);
+};
+
+export const queryAllByTestId = (instance: ReactTestInstance) =>
+  function getAllByTestIdFn(testID: string | RegExp): ReactTestInstance[] {
+    const results = instance
+      .findAll((node) => getNodeByTestId(node, testID))
+      .filter((element) => typeof element.type === 'string');
+
+    return results;
+  };
+
+export const getAllByTestId = (instance: ReactTestInstance) =>
+  makeGetAllQuery(
+    queryAllByTestId,
+    instance,
+    (testId) => `No instances found with testID: ${String(testId)}`
+  );
+
+export const queryByTestId = (instance: ReactTestInstance) =>
+  makeSingleQuery(
+    queryAllByTestId,
+    instance,
+    (testId: string, nbResults: number) =>
+      ` Expected 1 but found ${nbResults} instances with testID: ${String(
+        testId
+      )}`
+  );
+
+export const getByTestId = (instance: ReactTestInstance) =>
+  makeGetQuery(
+    queryAllByTestId,
+    instance,
+    (testId: string, nbResults: number) =>
+      nbResults > 1
+        ? ` Expected 1 but found ${nbResults} instances with testID: ${String(
+            testId
+          )}`
+        : `No instances found with testID: ${String(testId)}`
+  );
+
+export const findAllByTestId = (instance: ReactTestInstance) =>
+  makeFindAllQuery(getAllByTestId, instance);
+
+export const findByTestId = (instance: ReactTestInstance) =>
+  makeFindQuery(getByTestId, instance);
diff --git a/src/helpers/findByAPI.js b/src/helpers/findByAPI.js
index ea1e879dd..c5f4a13ea 100644
--- a/src/helpers/findByAPI.js
+++ b/src/helpers/findByAPI.js
@@ -2,8 +2,6 @@
 import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
 import {
-  getByTestId,
-  getAllByTestId,
   getByText,
   getAllByText,
   getByPlaceholderText,
@@ -11,6 +9,7 @@ import {
   getByDisplayValue,
   getAllByDisplayValue,
 } from './getByAPI';
+import { findAllByTestId, findByTestId } from './byTestId';
 import { throwRenamedFunctionError } from './errors';
 
 export type FindByAPI = {|
@@ -57,26 +56,6 @@ const makeFindQuery = <Text, Result>(
   waitForOptions: WaitForOptions
 ): Promise<Result> => waitFor(() => getQuery(instance)(text), waitForOptions);
 
-export const findByTestId = (
-  instance: ReactTestInstance
-): ((
-  testId: string | RegExp,
-  waitForOptions?: WaitForOptions
-) => Promise<ReactTestInstance>) => (
-  testId: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByTestId, testId, waitForOptions);
-
-export const findAllByTestId = (
-  instance: ReactTestInstance
-): ((
-  testId: string | RegExp,
-  waitForOptions?: WaitForOptions
-) => Promise<Array<ReactTestInstance>>) => (
-  testId: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByTestId, testId, waitForOptions);
-
 export const findByText = (
   instance: ReactTestInstance
 ): ((
diff --git a/src/helpers/getByAPI.js b/src/helpers/getByAPI.js
index d07745571..9f6a0d5c6 100644
--- a/src/helpers/getByAPI.js
+++ b/src/helpers/getByAPI.js
@@ -8,6 +8,7 @@ import {
   throwRemovedFunctionError,
   throwRenamedFunctionError,
 } from './errors';
+import { getAllByTestId, getByTestId } from './byTestId';
 
 export type GetByAPI = {|
   getByText: (text: string | RegExp) => ReactTestInstance,
@@ -117,12 +118,6 @@ const getTextInputNodeByDisplayValue = (node, value) => {
   }
 };
 
-const getNodeByTestId = (node, testID) => {
-  return typeof testID === 'string'
-    ? testID === node.props.testID
-    : testID.test(node.props.testID);
-};
-
 export const getByText = (
   instance: ReactTestInstance
 ): ((text: string | RegExp) => ReactTestInstance) =>
@@ -169,27 +164,6 @@ export const getByDisplayValue = (
     }
   };
 
-export const getByTestId = (
-  instance: ReactTestInstance
-): ((testID: string | RegExp) => ReactTestInstance) =>
-  function getByTestIdFn(testID: string | RegExp) {
-    try {
-      const results = getAllByTestId(instance)(testID);
-      if (results.length === 1) {
-        return results[0];
-      } else {
-        throw new ErrorWithStack(
-          ` Expected 1 but found ${
-            results.length
-          } instances with testID: ${String(testID)}`,
-          getByTestIdFn
-        );
-      }
-    } catch (error) {
-      throw new ErrorWithStack(prepareErrorMessage(error), getByTestIdFn);
-    }
-  };
-
 export const getAllByText = (
   instance: ReactTestInstance
 ): ((text: string | RegExp) => Array<ReactTestInstance>) =>
@@ -236,23 +210,6 @@ export const getAllByDisplayValue = (
     return results;
   };
 
-export const getAllByTestId = (
-  instance: ReactTestInstance
-): ((testID: string | RegExp) => Array<ReactTestInstance>) =>
-  function getAllByTestIdFn(testID: string | RegExp): ReactTestInstance[] {
-    const results = instance
-      .findAll((node) => getNodeByTestId(node, testID))
-      .filter((element) => typeof element.type === 'string');
-
-    if (results.length === 0) {
-      throw new ErrorWithStack(
-        `No instances found with testID: ${String(testID)}`,
-        getAllByTestIdFn
-      );
-    }
-    return results;
-  };
-
 export const UNSAFE_getByType = (
   instance: ReactTestInstance
 ): ((type: React.ComponentType<any>) => ReactTestInstance) =>
diff --git a/src/helpers/queryByAPI.js b/src/helpers/queryByAPI.js
index 0e7f4fc0f..a17c646cf 100644
--- a/src/helpers/queryByAPI.js
+++ b/src/helpers/queryByAPI.js
@@ -1,11 +1,9 @@
 // @flow
 import * as React from 'react';
 import {
-  getByTestId,
   getByText,
   getByPlaceholderText,
   getByDisplayValue,
-  getAllByTestId,
   getAllByText,
   getAllByPlaceholderText,
   getAllByDisplayValue,
@@ -14,6 +12,7 @@ import {
   UNSAFE_getAllByType,
   UNSAFE_getAllByProps,
 } from './getByAPI';
+import { queryByTestId, queryAllByTestId } from './byTestId';
 import {
   createQueryByError,
   throwRemovedFunctionError,
@@ -89,17 +88,6 @@ export const queryByDisplayValue = (
     }
   };
 
-export const queryByTestId = (
-  instance: ReactTestInstance
-): ((testID: string | RegExp) => ReactTestInstance | null) =>
-  function queryByTestIdFn(testID: string | RegExp) {
-    try {
-      return getByTestId(instance)(testID);
-    } catch (error) {
-      return createQueryByError(error, queryByTestIdFn);
-    }
-  };
-
 export const queryAllByText = (
   instance: ReactTestInstance
 ): ((text: string | RegExp) => Array<ReactTestInstance>) => (
@@ -136,18 +124,6 @@ export const queryAllByDisplayValue = (
   }
 };
 
-export const queryAllByTestId = (
-  instance: ReactTestInstance
-): ((testID: string | RegExp) => Array<ReactTestInstance>) => (
-  testID: string | RegExp
-) => {
-  try {
-    return getAllByTestId(instance)(testID);
-  } catch (error) {
-    return [];
-  }
-};
-
 export const UNSAFE_queryByType = (
   instance: ReactTestInstance
 ): ((type: React.ComponentType<any>) => ReactTestInstance | null) =>

From ee05201b39dded44c2db186261b8d799f7f70f35 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Wed, 9 Dec 2020 20:02:33 +0100
Subject: [PATCH 3/9] rebase and rearrange to a bit

---
 src/__tests__/byTestId.test.js | 10 +++--
 src/helpers/byTestId.js        | 65 +++++++++++++++----------------
 src/helpers/makeQueries.js     | 71 +++++++++++++++++++---------------
 3 files changed, 76 insertions(+), 70 deletions(-)

diff --git a/src/__tests__/byTestId.test.js b/src/__tests__/byTestId.test.js
index 7c95a97cd..ab195dbf7 100644
--- a/src/__tests__/byTestId.test.js
+++ b/src/__tests__/byTestId.test.js
@@ -96,10 +96,10 @@ test('getByTestId returns only native elements', () => {
   expect(getAllByTestId('button')).toHaveLength(1);
 
   expect(() => getByTestId('myComponent')).toThrowError(
-    'No instances found with testID: myComponent'
+    'Unable to find an element with testID: myComponent'
   );
   expect(() => getAllByTestId('myComponent')).toThrowError(
-    'No instances found with testID: myComponent'
+    'Unable to find an element with testID: myComponent'
   );
 });
 
@@ -123,7 +123,9 @@ test('getByTestId, queryByTestId', () => {
   const component = getByTestId('bananaFresh');
 
   expect(component.props.children).toBe('not fresh');
-  expect(() => getByTestId('InExistent')).toThrow('No instances found');
+  expect(() => getByTestId('InExistent')).toThrow(
+    'Unable to find an element with testID: InExistent'
+  );
 
   expect(getByTestId('bananaFresh')).toBe(component);
   expect(queryByTestId('InExistent')).toBeNull();
@@ -137,7 +139,7 @@ test('getAllByTestId, queryAllByTestId', () => {
   expect(textElements[0].props.children).toBe('First Text');
   expect(textElements[1].props.children).toBe('Second Text');
   expect(() => getAllByTestId('nonExistentTestId')).toThrow(
-    'No instances found'
+    'Unable to find an element with testID: nonExistentTestId'
   );
 
   const queriedTextElements = queryAllByTestId('duplicateText');
diff --git a/src/helpers/byTestId.js b/src/helpers/byTestId.js
index aa619afd4..30bc4497a 100644
--- a/src/helpers/byTestId.js
+++ b/src/helpers/byTestId.js
@@ -13,46 +13,43 @@ const getNodeByTestId = (node, testID) => {
     : testID.test(node.props.testID);
 };
 
-export const queryAllByTestId = (instance: ReactTestInstance) =>
-  function getAllByTestIdFn(testID: string | RegExp): ReactTestInstance[] {
+export const queryAllByTestId = (
+  instance: ReactTestInstance
+): ((testId: string | RegExp) => Array<ReactTestInstance>) =>
+  function getAllByTestIdFn(testId) {
     const results = instance
-      .findAll((node) => getNodeByTestId(node, testID))
+      .findAll((node) => getNodeByTestId(node, testId))
       .filter((element) => typeof element.type === 'string');
 
     return results;
   };
 
-export const getAllByTestId = (instance: ReactTestInstance) =>
-  makeGetAllQuery(
-    queryAllByTestId,
-    instance,
-    (testId) => `No instances found with testID: ${String(testId)}`
-  );
-
-export const queryByTestId = (instance: ReactTestInstance) =>
-  makeSingleQuery(
-    queryAllByTestId,
-    instance,
-    (testId: string, nbResults: number) =>
-      ` Expected 1 but found ${nbResults} instances with testID: ${String(
-        testId
-      )}`
-  );
-
-export const getByTestId = (instance: ReactTestInstance) =>
-  makeGetQuery(
-    queryAllByTestId,
-    instance,
-    (testId: string, nbResults: number) =>
-      nbResults > 1
-        ? ` Expected 1 but found ${nbResults} instances with testID: ${String(
-            testId
-          )}`
-        : `No instances found with testID: ${String(testId)}`
-  );
-
-export const findAllByTestId = (instance: ReactTestInstance) =>
+const getMultipleError = (testId) =>
+  `Found multiple elements with testID: ${String(testId)}`;
+const getMissingError = (testId) =>
+  `Unable to find an element with testID: ${String(testId)}`;
+
+export const getAllByTestId = (
+  instance: ReactTestInstance
+): ((testId: string | RegExp) => Array<ReactTestInstance>) =>
+  makeGetAllQuery(queryAllByTestId, instance, getMissingError);
+
+export const queryByTestId = (
+  instance: ReactTestInstance
+): ((testId: string | RegExp) => ReactTestInstance | null) =>
+  makeSingleQuery(queryAllByTestId, instance, getMultipleError);
+
+export const getByTestId = (
+  instance: ReactTestInstance
+): ((testId: string | RegExp) => ReactTestInstance) =>
+  makeGetQuery(queryAllByTestId, instance, getMultipleError, getMissingError);
+
+export const findAllByTestId = (
+  instance: ReactTestInstance
+): ((testId: string | RegExp) => Promise<Array<ReactTestInstance>>) =>
   makeFindAllQuery(getAllByTestId, instance);
 
-export const findByTestId = (instance: ReactTestInstance) =>
+export const findByTestId = (
+  instance: ReactTestInstance
+): ((testId: string | RegExp) => Promise<ReactTestInstance>) =>
   makeFindQuery(getByTestId, instance);
diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 11b94cbd0..ea790e983 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -3,37 +3,36 @@ import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
 import { ErrorWithStack } from './errors';
 
-type AllQuery = (
+type AllQuery = <T>(
   instance: ReactTestInstance
-) => (args: any) => Array<ReactTestInstance>;
+) => (...args: T) => Array<ReactTestInstance>;
 
-export const makeGetAllQuery = (
+export function makeGetAllQuery<T>(
   allQuery: AllQuery,
   instance: ReactTestInstance,
-  getMissingElementError: (args: any) => string
-) =>
-  function getAllFn(...args: Array<any>) {
+  getMissingError: (args: T) => string
+): (...args: Array<T>) => Array<ReactTestInstance> {
+  return function getAllFn(...args: Array<T>) {
     const results = allQuery(instance)(...args);
-    if (!results.length) {
-      throw new ErrorWithStack(getMissingElementError(...args), getAllFn);
+
+    if (results.length === 0) {
+      throw new ErrorWithStack(getMissingError(...args), getAllFn);
     }
 
     return results;
   };
+}
 
-export const makeSingleQuery = (
+export function makeSingleQuery<T>(
   allQuery: AllQuery,
   instance: ReactTestInstance,
-  getMissingElementError: (args: any, nbResults: number) => string
-) =>
-  function singleQueryFn(...args: Array<any>) {
+  getMultipleError: (args: T) => string
+): (...args: Array<T>) => null | ReactTestInstance {
+  return function singleQueryFn(...args: Array<T>) {
     const results = allQuery(instance)(...args);
 
     if (results.length > 1) {
-      throw new ErrorWithStack(
-        getMissingElementError(...args, results.length),
-        singleQueryFn
-      );
+      throw new ErrorWithStack(getMultipleError(...args), singleQueryFn);
     }
 
     if (results.length === 0) {
@@ -42,37 +41,45 @@ export const makeSingleQuery = (
 
     return results[0];
   };
+}
 
-export const makeGetQuery = (
+export function makeGetQuery<T>(
   allQuery: AllQuery,
   instance: ReactTestInstance,
-  getMissingElementError: (args: any, nbResults: number) => string
-) =>
-  function getFn(...args: Array<any>) {
+  getMultipleError: (args: T) => string,
+  getMissingError: (args: T) => string
+): (...args: Array<T>) => ReactTestInstance {
+  return function getFn(...args: Array<T>) {
     const results = allQuery(instance)(...args);
 
-    if (results.length !== 1) {
-      throw new ErrorWithStack(
-        getMissingElementError(...args, results.length),
-        getFn
-      );
+    if (results.length > 1) {
+      throw new ErrorWithStack(getMultipleError(...args), getFn);
+    }
+
+    if (results.length === 0) {
+      throw new ErrorWithStack(getMissingError(...args), getFn);
     }
 
     return results[0];
   };
+}
 
-export const makeFindAllQuery = (
+export function makeFindAllQuery<T>(
   getAllQuery: AllQuery,
   instance: ReactTestInstance
-) =>
-  function findAllFn(args: any, waitForOptions: WaitForOptions = {}) {
+): (
+  args: T,
+  waitForOptions?: WaitForOptions
+) => Promise<Array<ReactTestInstance>> {
+  return function findAllFn(args: T, waitForOptions: WaitForOptions = {}) {
     return waitFor(() => getAllQuery(instance)(args), waitForOptions);
   };
-
-export const makeFindQuery = (
+}
+export function makeFindQuery<T>(
   getQuery: (instance: ReactTestInstance) => (args: any) => ReactTestInstance,
   instance: ReactTestInstance
-) =>
-  function findFn(args: any, waitForOptions: WaitForOptions = {}) {
+): (args: T, waitForOptions?: WaitForOptions) => Promise<ReactTestInstance> {
+  return function findFn(args: T, waitForOptions: WaitForOptions = {}) {
     return waitFor(() => getQuery(instance)(args), waitForOptions);
   };
+}

From 59a8490a9ba6b12e011d154874c60d2c6b9c00e5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Wed, 9 Dec 2020 20:05:43 +0100
Subject: [PATCH 4/9] add fixme

---
 src/helpers/makeQueries.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index ea790e983..4b0888e87 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -5,6 +5,7 @@ import { ErrorWithStack } from './errors';
 
 type AllQuery = <T>(
   instance: ReactTestInstance
+  // $FlowFixMe - Property @@iterator is missing in T [1] but exists in $Iterable [2]
 ) => (...args: T) => Array<ReactTestInstance>;
 
 export function makeGetAllQuery<T>(

From cf5d3d344494d206e79fd4c328950f7c5555ebab Mon Sep 17 00:00:00 2001
From: MattAgn <matthieua@bam.tech>
Date: Sat, 12 Dec 2020 16:26:47 +0100
Subject: [PATCH 5/9] refactor: make single function makeQueries

---
 src/helpers/byTestId.js    |  50 +++++-------
 src/helpers/makeQueries.js | 159 +++++++++++++++++++++----------------
 2 files changed, 108 insertions(+), 101 deletions(-)

diff --git a/src/helpers/byTestId.js b/src/helpers/byTestId.js
index 30bc4497a..71ee61815 100644
--- a/src/helpers/byTestId.js
+++ b/src/helpers/byTestId.js
@@ -1,11 +1,5 @@
 // @flow
-import {
-  makeGetAllQuery,
-  makeSingleQuery,
-  makeGetQuery,
-  makeFindAllQuery,
-  makeFindQuery,
-} from './makeQueries';
+import { makeQueries } from './makeQueries';
 
 const getNodeByTestId = (node, testID) => {
   return typeof testID === 'string'
@@ -13,7 +7,7 @@ const getNodeByTestId = (node, testID) => {
     : testID.test(node.props.testID);
 };
 
-export const queryAllByTestId = (
+const queryAllByTestId = (
   instance: ReactTestInstance
 ): ((testId: string | RegExp) => Array<ReactTestInstance>) =>
   function getAllByTestIdFn(testId) {
@@ -29,27 +23,19 @@ const getMultipleError = (testId) =>
 const getMissingError = (testId) =>
   `Unable to find an element with testID: ${String(testId)}`;
 
-export const getAllByTestId = (
-  instance: ReactTestInstance
-): ((testId: string | RegExp) => Array<ReactTestInstance>) =>
-  makeGetAllQuery(queryAllByTestId, instance, getMissingError);
-
-export const queryByTestId = (
-  instance: ReactTestInstance
-): ((testId: string | RegExp) => ReactTestInstance | null) =>
-  makeSingleQuery(queryAllByTestId, instance, getMultipleError);
-
-export const getByTestId = (
-  instance: ReactTestInstance
-): ((testId: string | RegExp) => ReactTestInstance) =>
-  makeGetQuery(queryAllByTestId, instance, getMultipleError, getMissingError);
-
-export const findAllByTestId = (
-  instance: ReactTestInstance
-): ((testId: string | RegExp) => Promise<Array<ReactTestInstance>>) =>
-  makeFindAllQuery(getAllByTestId, instance);
-
-export const findByTestId = (
-  instance: ReactTestInstance
-): ((testId: string | RegExp) => Promise<ReactTestInstance>) =>
-  makeFindQuery(getByTestId, instance);
+const {
+  getBy: getByTestId,
+  getAllBy: getAllByTestId,
+  queryBy: queryByTestId,
+  findBy: findByTestId,
+  findAllBy: findAllByTestId,
+} = makeQueries(queryAllByTestId, getMissingError, getMultipleError);
+
+export {
+  getByTestId,
+  getAllByTestId,
+  queryByTestId,
+  findByTestId,
+  findAllByTestId,
+  queryAllByTestId,
+};
diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 4b0888e87..8e55280d7 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -3,84 +3,105 @@ import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
 import { ErrorWithStack } from './errors';
 
-type AllQuery = <T>(
+type QueryArg = string | RegExp;
+
+type QueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
-  // $FlowFixMe - Property @@iterator is missing in T [1] but exists in $Iterable [2]
-) => (...args: T) => Array<ReactTestInstance>;
-
-export function makeGetAllQuery<T>(
-  allQuery: AllQuery,
-  instance: ReactTestInstance,
-  getMissingError: (args: T) => string
-): (...args: Array<T>) => Array<ReactTestInstance> {
-  return function getAllFn(...args: Array<T>) {
-    const results = allQuery(instance)(...args);
-
-    if (results.length === 0) {
-      throw new ErrorWithStack(getMissingError(...args), getAllFn);
-    }
-
-    return results;
-  };
-}
+) => (args: ArgType) => ReturnType;
 
-export function makeSingleQuery<T>(
-  allQuery: AllQuery,
-  instance: ReactTestInstance,
-  getMultipleError: (args: T) => string
-): (...args: Array<T>) => null | ReactTestInstance {
-  return function singleQueryFn(...args: Array<T>) {
-    const results = allQuery(instance)(...args);
+type FindQueryFunction<ArgType, ReturnType> = (
+  instance: ReactTestInstance
+) => (args: ArgType, waitForOptions?: WaitForOptions) => Promise<ReturnType>;
 
-    if (results.length > 1) {
-      throw new ErrorWithStack(getMultipleError(...args), singleQueryFn);
-    }
+type QueryAllByQuery = QueryFunction<QueryArg, Array<ReactTestInstance>>;
+type QueryByQuery = QueryFunction<QueryArg, null | ReactTestInstance>;
 
-    if (results.length === 0) {
-      return null;
-    }
+type GetAllByQuery = QueryFunction<QueryArg, Array<ReactTestInstance>>;
+type GetByQuery = QueryFunction<QueryArg, ReactTestInstance>;
 
-    return results[0];
-  };
-}
+type FindAllByQuery = FindQueryFunction<QueryArg, Array<ReactTestInstance>>;
+type FindByQuery = FindQueryFunction<QueryArg, ReactTestInstance>;
 
-export function makeGetQuery<T>(
-  allQuery: AllQuery,
-  instance: ReactTestInstance,
-  getMultipleError: (args: T) => string,
-  getMissingError: (args: T) => string
-): (...args: Array<T>) => ReactTestInstance {
-  return function getFn(...args: Array<T>) {
-    const results = allQuery(instance)(...args);
+type Queries = {
+  getBy: GetByQuery,
+  getAllBy: GetAllByQuery,
+  queryBy: QueryByQuery,
+  findBy: FindByQuery,
+  findAllBy: FindAllByQuery,
+};
 
-    if (results.length > 1) {
-      throw new ErrorWithStack(getMultipleError(...args), getFn);
-    }
+export function makeQueries(
+  queryAllByQuery: QueryAllByQuery,
+  getMissingError: (args: QueryArg) => string,
+  getMultipleError: (args: QueryArg) => string
+): Queries {
+  function getAllByQuery(instance: ReactTestInstance) {
+    return function getAllFn(args: QueryArg) {
+      const results = queryAllByQuery(instance)(args);
 
-    if (results.length === 0) {
-      throw new ErrorWithStack(getMissingError(...args), getFn);
-    }
+      if (results.length === 0) {
+        throw new ErrorWithStack(getMissingError(args), getAllFn);
+      }
 
-    return results[0];
-  };
-}
+      return results;
+    };
+  }
 
-export function makeFindAllQuery<T>(
-  getAllQuery: AllQuery,
-  instance: ReactTestInstance
-): (
-  args: T,
-  waitForOptions?: WaitForOptions
-) => Promise<Array<ReactTestInstance>> {
-  return function findAllFn(args: T, waitForOptions: WaitForOptions = {}) {
-    return waitFor(() => getAllQuery(instance)(args), waitForOptions);
-  };
-}
-export function makeFindQuery<T>(
-  getQuery: (instance: ReactTestInstance) => (args: any) => ReactTestInstance,
-  instance: ReactTestInstance
-): (args: T, waitForOptions?: WaitForOptions) => Promise<ReactTestInstance> {
-  return function findFn(args: T, waitForOptions: WaitForOptions = {}) {
-    return waitFor(() => getQuery(instance)(args), waitForOptions);
+  function queryByQuery(instance: ReactTestInstance) {
+    return function singleQueryFn(args: QueryArg) {
+      const results = queryAllByQuery(instance)(args);
+
+      if (results.length > 1) {
+        throw new ErrorWithStack(getMultipleError(args), singleQueryFn);
+      }
+
+      if (results.length === 0) {
+        return null;
+      }
+
+      return results[0];
+    };
+  }
+
+  function getByQuery(instance: ReactTestInstance) {
+    return function getFn(args: QueryArg) {
+      const results = queryAllByQuery(instance)(args);
+
+      if (results.length > 1) {
+        throw new ErrorWithStack(getMultipleError(args), getFn);
+      }
+
+      if (results.length === 0) {
+        throw new ErrorWithStack(getMissingError(args), getFn);
+      }
+
+      return results[0];
+    };
+  }
+
+  function findAllByQuery(instance: ReactTestInstance) {
+    return function findAllFn(
+      args: QueryArg,
+      waitForOptions?: WaitForOptions = {}
+    ) {
+      return waitFor(() => getAllByQuery(instance)(args), waitForOptions);
+    };
+  }
+
+  function findByQuery(instance: ReactTestInstance) {
+    return function findFn(
+      args: QueryArg,
+      waitForOptions?: WaitForOptions = {}
+    ) {
+      return waitFor(() => getByQuery(instance)(args), waitForOptions);
+    };
+  }
+
+  return {
+    getBy: getByQuery,
+    getAllBy: getAllByQuery,
+    queryBy: queryByQuery,
+    findBy: findByQuery,
+    findAllBy: findAllByQuery,
   };
 }

From f822da0736fd71f72a4e1e1e797d2d23d646d451 Mon Sep 17 00:00:00 2001
From: MattAgn <matthieua@bam.tech>
Date: Sat, 12 Dec 2020 16:45:34 +0100
Subject: [PATCH 6/9] doc: add TODO to do before end of pr

---
 src/helpers/makeQueries.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 8e55280d7..4911d071f 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -3,6 +3,9 @@ import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
 import { ErrorWithStack } from './errors';
 
+// TODO: fix typing
+// is it always string | RegExp for every query?
+// what about options for each query?
 type QueryArg = string | RegExp;
 
 type QueryFunction<ArgType, ReturnType> = (

From 6f5b08d107a0d207cb2d34406a5ad17fe0c753be Mon Sep 17 00:00:00 2001
From: MattAgn <matthieua@bam.tech>
Date: Sat, 12 Dec 2020 16:49:11 +0100
Subject: [PATCH 7/9] fix: fix flow issue

---
 src/helpers/byTestId.js    | 3 ++-
 src/helpers/makeQueries.js | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/helpers/byTestId.js b/src/helpers/byTestId.js
index 71ee61815..7bc041e95 100644
--- a/src/helpers/byTestId.js
+++ b/src/helpers/byTestId.js
@@ -1,5 +1,6 @@
 // @flow
 import { makeQueries } from './makeQueries';
+import type { Queries } from './makeQueries';
 
 const getNodeByTestId = (node, testID) => {
   return typeof testID === 'string'
@@ -29,7 +30,7 @@ const {
   queryBy: queryByTestId,
   findBy: findByTestId,
   findAllBy: findAllByTestId,
-} = makeQueries(queryAllByTestId, getMissingError, getMultipleError);
+}: Queries = makeQueries(queryAllByTestId, getMissingError, getMultipleError);
 
 export {
   getByTestId,
diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 4911d071f..4d82fa983 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -25,7 +25,7 @@ type GetByQuery = QueryFunction<QueryArg, ReactTestInstance>;
 type FindAllByQuery = FindQueryFunction<QueryArg, Array<ReactTestInstance>>;
 type FindByQuery = FindQueryFunction<QueryArg, ReactTestInstance>;
 
-type Queries = {
+export type Queries = {
   getBy: GetByQuery,
   getAllBy: GetAllByQuery,
   queryBy: QueryByQuery,

From cc0582359a971f9d01967820db4853ded15a3d63 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pierzcha=C5=82a?= <thymikee@gmail.com>
Date: Sat, 12 Dec 2020 16:59:25 +0100
Subject: [PATCH 8/9] parametrize Queries

---
 src/helpers/byTestId.js    |  6 ++++-
 src/helpers/makeQueries.js | 50 ++++++++++++++++++++------------------
 2 files changed, 32 insertions(+), 24 deletions(-)

diff --git a/src/helpers/byTestId.js b/src/helpers/byTestId.js
index 7bc041e95..5c8efd63e 100644
--- a/src/helpers/byTestId.js
+++ b/src/helpers/byTestId.js
@@ -30,7 +30,11 @@ const {
   queryBy: queryByTestId,
   findBy: findByTestId,
   findAllBy: findAllByTestId,
-}: Queries = makeQueries(queryAllByTestId, getMissingError, getMultipleError);
+}: Queries<string | RegExp> = makeQueries(
+  queryAllByTestId,
+  getMissingError,
+  getMultipleError
+);
 
 export {
   getByTestId,
diff --git a/src/helpers/makeQueries.js b/src/helpers/makeQueries.js
index 4d82fa983..35aa7d4b7 100644
--- a/src/helpers/makeQueries.js
+++ b/src/helpers/makeQueries.js
@@ -3,11 +3,6 @@ import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
 import { ErrorWithStack } from './errors';
 
-// TODO: fix typing
-// is it always string | RegExp for every query?
-// what about options for each query?
-type QueryArg = string | RegExp;
-
 type QueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
 ) => (args: ArgType) => ReturnType;
@@ -16,28 +11,37 @@ type FindQueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
 ) => (args: ArgType, waitForOptions?: WaitForOptions) => Promise<ReturnType>;
 
-type QueryAllByQuery = QueryFunction<QueryArg, Array<ReactTestInstance>>;
-type QueryByQuery = QueryFunction<QueryArg, null | ReactTestInstance>;
-
-type GetAllByQuery = QueryFunction<QueryArg, Array<ReactTestInstance>>;
-type GetByQuery = QueryFunction<QueryArg, ReactTestInstance>;
-
-type FindAllByQuery = FindQueryFunction<QueryArg, Array<ReactTestInstance>>;
-type FindByQuery = FindQueryFunction<QueryArg, ReactTestInstance>;
-
-export type Queries = {
-  getBy: GetByQuery,
-  getAllBy: GetAllByQuery,
-  queryBy: QueryByQuery,
-  findBy: FindByQuery,
-  findAllBy: FindAllByQuery,
+type QueryAllByQuery<QueryArg> = QueryFunction<
+  QueryArg,
+  Array<ReactTestInstance>
+>;
+type QueryByQuery<QueryArg> = QueryFunction<QueryArg, null | ReactTestInstance>;
+
+type GetAllByQuery<QueryArg> = QueryFunction<
+  QueryArg,
+  Array<ReactTestInstance>
+>;
+type GetByQuery<QueryArg> = QueryFunction<QueryArg, ReactTestInstance>;
+
+type FindAllByQuery<QueryArg> = FindQueryFunction<
+  QueryArg,
+  Array<ReactTestInstance>
+>;
+type FindByQuery<QueryArg> = FindQueryFunction<QueryArg, ReactTestInstance>;
+
+export type Queries<QueryArg> = {
+  getBy: GetByQuery<QueryArg>,
+  getAllBy: GetAllByQuery<QueryArg>,
+  queryBy: QueryByQuery<QueryArg>,
+  findBy: FindByQuery<QueryArg>,
+  findAllBy: FindAllByQuery<QueryArg>,
 };
 
-export function makeQueries(
-  queryAllByQuery: QueryAllByQuery,
+export function makeQueries<QueryArg>(
+  queryAllByQuery: QueryAllByQuery<QueryArg>,
   getMissingError: (args: QueryArg) => string,
   getMultipleError: (args: QueryArg) => string
-): Queries {
+): Queries<QueryArg> {
   function getAllByQuery(instance: ReactTestInstance) {
     return function getAllFn(args: QueryArg) {
       const results = queryAllByQuery(instance)(args);

From 47c2fc4ccf6d05103bf59b0e09b25bae5800585b Mon Sep 17 00:00:00 2001
From: MattAgn <matthieua@bam.tech>
Date: Fri, 8 Jan 2021 21:46:22 +0100
Subject: [PATCH 9/9] chore: delete duplicated test

---
 src/__tests__/getByApi.test.js | 52 ----------------------------------
 1 file changed, 52 deletions(-)
 delete mode 100644 src/__tests__/getByApi.test.js

diff --git a/src/__tests__/getByApi.test.js b/src/__tests__/getByApi.test.js
deleted file mode 100644
index 177af8b05..000000000
--- a/src/__tests__/getByApi.test.js
+++ /dev/null
@@ -1,52 +0,0 @@
-// @flow
-import * as React from 'react';
-import { View, Text, TextInput, Button } from 'react-native';
-import { render } from '..';
-
-const MyComponent = () => {
-  return <Text>My Component</Text>;
-};
-
-test('getByTestId returns only native elements', () => {
-  const { getByTestId, getAllByTestId } = render(
-    <View>
-      <Text testID="text">Text</Text>
-      <TextInput testID="textInput" />
-      <View testID="view" />
-      <Button testID="button" title="Button" onPress={jest.fn()} />
-      <MyComponent testID="myComponent" />
-    </View>
-  );
-
-  expect(getByTestId('text')).toBeTruthy();
-  expect(getByTestId('textInput')).toBeTruthy();
-  expect(getByTestId('view')).toBeTruthy();
-  expect(getByTestId('button')).toBeTruthy();
-
-  expect(getAllByTestId('text')).toHaveLength(1);
-  expect(getAllByTestId('textInput')).toHaveLength(1);
-  expect(getAllByTestId('view')).toHaveLength(1);
-  expect(getAllByTestId('button')).toHaveLength(1);
-
-  expect(() => getByTestId('myComponent')).toThrowError(
-    'No instances found with testID: myComponent'
-  );
-  expect(() => getAllByTestId('myComponent')).toThrowError(
-    'No instances found with testID: myComponent'
-  );
-});
-
-test('supports a regex matcher', () => {
-  const { getByTestId, getAllByTestId } = render(
-    <View>
-      <Text testID="text">Text</Text>
-      <TextInput testID="textInput" />
-      <View testID="view" />
-      <Button testID="button" title="Button" onPress={jest.fn()} />
-      <MyComponent testID="myComponent" />
-    </View>
-  );
-
-  expect(getByTestId(/view/)).toBeTruthy();
-  expect(getAllByTestId(/text/)).toHaveLength(2);
-});