rebase and rearrange to a bit

Author: thymikee

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');

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);

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);
   };
+}