@testing-library/react-native 8.0.0 → 9.0.0-alpha.0

package/build/helpers/byDisplayValue.js

@@ -5,27 +5,33 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.queryByDisplayValue = exports.queryAllByDisplayValue = exports.getByDisplayValue = exports.getAllByDisplayValue = exports.findByDisplayValue = exports.findAllByDisplayValue = void 0;
 
+var _matches = require("../matches");
+
 var _makeQueries = require("./makeQueries");
 
 var _filterNodeByType = require("./filterNodeByType");
 
 var _errors = require("./errors");
 
-const getTextInputNodeByDisplayValue = (node, value) => {
+const getTextInputNodeByDisplayValue = (node, value, options = {}) => {
   try {
     const {
       TextInput
     } = require('react-native');
 
+    const {
+      exact,
+      normalizer
+    } = options;
     const nodeValue = node.props.value !== undefined ? node.props.value : node.props.defaultValue;
-    return (0, _filterNodeByType.filterNodeByType)(node, TextInput) && (typeof value === 'string' ? value === nodeValue : value.test(nodeValue));
+    return (0, _filterNodeByType.filterNodeByType)(node, TextInput) && (0, _matches.matches)(value, nodeValue, normalizer, exact);
   } catch (error) {
     throw (0, _errors.createLibraryNotSupportedError)(error);
   }
 };
 
-const queryAllByDisplayValue = instance => function queryAllByDisplayValueFn(displayValue) {
-  return instance.findAll(node => getTextInputNodeByDisplayValue(node, displayValue));
+const queryAllByDisplayValue = instance => function queryAllByDisplayValueFn(displayValue, queryOptions) {
+  return instance.findAll(node => getTextInputNodeByDisplayValue(node, displayValue, queryOptions));
 };
 
 exports.queryAllByDisplayValue = queryAllByDisplayValue;

package/build/helpers/byDisplayValue.js.flow

@@ -1,19 +1,26 @@
 // @flow
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
 import { createLibraryNotSupportedError } from './errors';
+import type { TextMatchOptions } from './byText';
 
-const getTextInputNodeByDisplayValue = (node, value) => {
+const getTextInputNodeByDisplayValue = (
+  node,
+  value,
+  options?: TextMatchOptions = {}
+) => {
   try {
     const { TextInput } = require('react-native');
+    const { exact, normalizer } = options;
     const nodeValue =
       node.props.value !== undefined
         ? node.props.value
         : node.props.defaultValue;
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof value === 'string' ? value === nodeValue : value.test(nodeValue))
+      matches(value, nodeValue, normalizer, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -22,10 +29,13 @@ const getTextInputNodeByDisplayValue = (node, value) => {
 
 const queryAllByDisplayValue = (
   instance: ReactTestInstance
-): ((displayValue: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByDisplayValueFn(displayValue) {
+): ((
+  displayValue: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByDisplayValueFn(displayValue, queryOptions) {
     return instance.findAll((node) =>
-      getTextInputNodeByDisplayValue(node, displayValue)
+      getTextInputNodeByDisplayValue(node, displayValue, queryOptions)
     );
   };
 

package/build/helpers/byPlaceholderText.js

@@ -5,26 +5,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.queryByPlaceholderText = exports.queryAllByPlaceholderText = exports.getByPlaceholderText = exports.getAllByPlaceholderText = exports.findByPlaceholderText = exports.findAllByPlaceholderText = void 0;
 
+var _matches = require("../matches");
+
 var _makeQueries = require("./makeQueries");
 
 var _filterNodeByType = require("./filterNodeByType");
 
 var _errors = require("./errors");
 
-const getTextInputNodeByPlaceholderText = (node, placeholder) => {
+const getTextInputNodeByPlaceholderText = (node, placeholder, options = {}) => {
   try {
     const {
       TextInput
     } = require('react-native');
 
-    return (0, _filterNodeByType.filterNodeByType)(node, TextInput) && (typeof placeholder === 'string' ? placeholder === node.props.placeholder : placeholder.test(node.props.placeholder));
+    const {
+      exact,
+      normalizer
+    } = options;
+    return (0, _filterNodeByType.filterNodeByType)(node, TextInput) && (0, _matches.matches)(placeholder, node.props.placeholder, normalizer, exact);
   } catch (error) {
     throw (0, _errors.createLibraryNotSupportedError)(error);
   }
 };
 
-const queryAllByPlaceholderText = instance => function queryAllByPlaceholderFn(placeholder) {
-  return instance.findAll(node => getTextInputNodeByPlaceholderText(node, placeholder));
+const queryAllByPlaceholderText = instance => function queryAllByPlaceholderFn(placeholder, queryOptions) {
+  return instance.findAll(node => getTextInputNodeByPlaceholderText(node, placeholder, queryOptions));
 };
 
 exports.queryAllByPlaceholderText = queryAllByPlaceholderText;

package/build/helpers/byPlaceholderText.js.flow

@@ -1,17 +1,22 @@
 // @flow
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
 import { createLibraryNotSupportedError } from './errors';
+import type { TextMatchOptions } from './byText';
 
-const getTextInputNodeByPlaceholderText = (node, placeholder) => {
+const getTextInputNodeByPlaceholderText = (
+  node,
+  placeholder,
+  options?: TextMatchOptions = {}
+) => {
   try {
     const { TextInput } = require('react-native');
+    const { exact, normalizer } = options;
     return (
       filterNodeByType(node, TextInput) &&
-      (typeof placeholder === 'string'
-        ? placeholder === node.props.placeholder
-        : placeholder.test(node.props.placeholder))
+      matches(placeholder, node.props.placeholder, normalizer, exact)
     );
   } catch (error) {
     throw createLibraryNotSupportedError(error);
@@ -20,10 +25,13 @@ const getTextInputNodeByPlaceholderText = (node, placeholder) => {
 
 const queryAllByPlaceholderText = (
   instance: ReactTestInstance
-): ((placeholder: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByPlaceholderFn(placeholder) {
+): ((
+  placeholder: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByPlaceholderFn(placeholder, queryOptions) {
     return instance.findAll((node) =>
-      getTextInputNodeByPlaceholderText(node, placeholder)
+      getTextInputNodeByPlaceholderText(node, placeholder, queryOptions)
     );
   };
 

package/build/helpers/byTestId.js

@@ -5,14 +5,20 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.queryByTestId = exports.queryAllByTestId = exports.getByTestId = exports.getAllByTestId = exports.findByTestId = exports.findAllByTestId = void 0;
 
+var _matches = require("../matches");
+
 var _makeQueries = require("./makeQueries");
 
-const getNodeByTestId = (node, testID) => {
-  return typeof testID === 'string' ? testID === node.props.testID : testID.test(node.props.testID);
+const getNodeByTestId = (node, testID, options = {}) => {
+  const {
+    exact,
+    normalizer
+  } = options;
+  return (0, _matches.matches)(testID, node.props.testID, normalizer, exact);
 };
 
-const queryAllByTestId = instance => function queryAllByTestIdFn(testId) {
-  const results = instance.findAll(node => getNodeByTestId(node, testId)).filter(element => typeof element.type === 'string');
+const queryAllByTestId = instance => function queryAllByTestIdFn(testId, queryOptions) {
+  const results = instance.findAll(node => getNodeByTestId(node, testId, queryOptions)).filter(element => typeof element.type === 'string');
   return results;
 };
 

package/build/helpers/byTestId.js.flow

@@ -1,19 +1,23 @@
 // @flow
+import { matches } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
+import type { TextMatchOptions } from './byText';
 
-const getNodeByTestId = (node, testID) => {
-  return typeof testID === 'string'
-    ? testID === node.props.testID
-    : testID.test(node.props.testID);
+const getNodeByTestId = (node, testID, options?: TextMatchOptions = {}) => {
+  const { exact, normalizer } = options;
+  return matches(testID, node.props.testID, normalizer, exact);
 };
 
 const queryAllByTestId = (
   instance: ReactTestInstance
-): ((testId: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByTestIdFn(testId) {
+): ((
+  testId: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByTestIdFn(testId, queryOptions) {
     const results = instance
-      .findAll((node) => getNodeByTestId(node, testId))
+      .findAll((node) => getNodeByTestId(node, testId, queryOptions))
       .filter((element) => typeof element.type === 'string');
 
     return results;

package/build/helpers/byText.js

@@ -7,6 +7,8 @@ exports.queryByText = exports.queryAllByText = exports.getByText = exports.getAl
 
 var React = _interopRequireWildcard(require("react"));
 
+var _matches = require("../matches");
+
 var _makeQueries = require("./makeQueries");
 
 var _filterNodeByType = require("./filterNodeByType");
@@ -17,7 +19,8 @@ function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const getChildrenAsText = (children, TextComponent, textContent = []) => {
+const getChildrenAsText = (children, TextComponent) => {
+  const textContent = [];
   React.Children.forEach(children, child => {
     var _child$props;
 
@@ -40,13 +43,13 @@ const getChildrenAsText = (children, TextComponent, textContent = []) => {
         return;
       }
 
-      getChildrenAsText(child.props.children, TextComponent, textContent);
+      getChildrenAsText(child.props.children, TextComponent);
     }
   });
   return textContent;
 };
 
-const getNodeByText = (node, text) => {
+const getNodeByText = (node, text, options = {}) => {
   try {
     const {
       Text
@@ -59,7 +62,11 @@ const getNodeByText = (node, text) => {
 
       if (textChildren) {
         const textToTest = textChildren.join('');
-        return typeof text === 'string' ? text === textToTest : text.test(textToTest);
+        const {
+          exact,
+          normalizer
+        } = options;
+        return (0, _matches.matches)(text, textToTest, normalizer, exact);
       }
     }
 
@@ -69,8 +76,8 @@ const getNodeByText = (node, text) => {
   }
 };
 
-const queryAllByText = instance => function queryAllByTextFn(text) {
-  const results = instance.findAll(node => getNodeByText(node, text));
+const queryAllByText = instance => function queryAllByTextFn(text, queryOptions) {
+  const results = instance.findAll(node => getNodeByText(node, text, queryOptions));
   return results;
 };
 

package/build/helpers/byText.js.flow

@@ -1,11 +1,19 @@
 // @flow
 import * as React from 'react';
+import { matches } from '../matches';
+import type { NormalizerFn } from '../matches';
 import { makeQueries } from './makeQueries';
 import type { Queries } from './makeQueries';
 import { filterNodeByType } from './filterNodeByType';
 import { createLibraryNotSupportedError } from './errors';
 
-const getChildrenAsText = (children, TextComponent, textContent = []) => {
+export type TextMatchOptions = {
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+};
+
+const getChildrenAsText = (children, TextComponent) => {
+  const textContent = [];
   React.Children.forEach(children, (child) => {
     if (typeof child === 'string') {
       textContent.push(child);
@@ -26,14 +34,18 @@ const getChildrenAsText = (children, TextComponent, textContent = []) => {
         return;
       }
 
-      getChildrenAsText(child.props.children, TextComponent, textContent);
+      getChildrenAsText(child.props.children, TextComponent);
     }
   });
 
   return textContent;
 };
 
-const getNodeByText = (node, text: string | RegExp) => {
+const getNodeByText = (
+  node,
+  text: string | RegExp,
+  options?: TextMatchOptions = {}
+) => {
   try {
     const { Text } = require('react-native');
     const isTextComponent = filterNodeByType(node, Text);
@@ -41,9 +53,8 @@ const getNodeByText = (node, text: string | RegExp) => {
       const textChildren = getChildrenAsText(node.props.children, Text);
       if (textChildren) {
         const textToTest = textChildren.join('');
-        return typeof text === 'string'
-          ? text === textToTest
-          : text.test(textToTest);
+        const { exact, normalizer } = options;
+        return matches(text, textToTest, normalizer, exact);
       }
     }
     return false;
@@ -54,9 +65,14 @@ const getNodeByText = (node, text: string | RegExp) => {
 
 const queryAllByText = (
   instance: ReactTestInstance
-): ((text: string | RegExp) => Array<ReactTestInstance>) =>
-  function queryAllByTextFn(text) {
-    const results = instance.findAll((node) => getNodeByText(node, text));
+): ((
+  text: string | RegExp,
+  queryOptions?: TextMatchOptions
+) => Array<ReactTestInstance>) =>
+  function queryAllByTextFn(text, queryOptions) {
+    const results = instance.findAll((node) =>
+      getNodeByText(node, text, queryOptions)
+    );
 
     return results;
   };

package/build/helpers/errors.js

@@ -64,7 +64,8 @@ const warned = {};
 function printDeprecationWarning(functionName) {
   if (warned[functionName]) {
     return;
-  }
+  } // eslint-disable-next-line no-console
+
 
   console.warn(`
   Deprecation Warning:

package/build/helpers/errors.js.flow

@@ -53,6 +53,7 @@ export function printDeprecationWarning(functionName: string) {
     return;
   }
 
+  // eslint-disable-next-line no-console
   console.warn(`
   Deprecation Warning:
   Use of ${functionName} is not recommended and will be deleted in future versions of @testing-library/react-native.

package/build/helpers/findByAPI.js.flow

@@ -1,5 +1,6 @@
 // @flow
 import type { WaitForOptions } from '../waitFor';
+import type { TextMatchOptions } from './byText';
 import { findAllByTestId, findByTestId } from './byTestId';
 import { findAllByText, findByText } from './byText';
 import {
@@ -12,36 +13,44 @@ import { throwRenamedFunctionError } from './errors';
 export type FindByAPI = {|
   findAllByDisplayValue: (
     value: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByPlaceholder: () => void,
   findAllByPlaceholderText: (
     placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByTestId: (
     testId: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findAllByText: (
     text: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<Array<ReactTestInstance>>,
   findByDisplayValue: (
     value: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByPlaceholder: () => void,
   findByPlaceholderText: (
     placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByTestId: (
     testId: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
   findByText: (
     text: string | RegExp,
+    queryOptions?: TextMatchOptions & WaitForOptions,
     waitForOptions?: WaitForOptions
   ) => Promise<ReactTestInstance>,
 |};

package/build/helpers/getByAPI.js.flow

@@ -14,18 +14,41 @@ import {
   getByPlaceholderText,
 } from './byPlaceholderText';
 import { getAllByDisplayValue, getByDisplayValue } from './byDisplayValue';
+import type { TextMatchOptions } from './byText';
 
 export type GetByAPI = {|
-  getByText: (text: string | RegExp) => ReactTestInstance,
-  getByPlaceholderText: (placeholder: string | RegExp) => ReactTestInstance,
-  getByDisplayValue: (value: string | RegExp) => ReactTestInstance,
-  getByTestId: (testID: string | RegExp) => ReactTestInstance,
-  getAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>,
-  getAllByText: (text: string | RegExp) => Array<ReactTestInstance>,
+  getByText: (
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getByPlaceholderText: (
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getByTestId: (
+    testID: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance,
+  getAllByTestId: (
+    testID: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
+  getAllByText: (
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
   getAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
+  getAllByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
   ) => Array<ReactTestInstance>,
-  getAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>,
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance,

package/build/helpers/makeQueries.js

@@ -11,10 +11,34 @@ var _errors = require("./errors");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
+// The WaitForOptions has been moved to the second option param of findBy* methods with the adding of TextMatchOptions
+// To make the migration easier and avoid a breaking change, keep reading this options from the first param but warn
+const deprecatedKeys = ['timeout', 'interval', 'stackTraceError'];
+
+const extractDeprecatedWaitForOptionUsage = queryOptions => {
+  if (queryOptions) {
+    const waitForOptions = {
+      timeout: queryOptions.timeout,
+      interval: queryOptions.interval,
+      stackTraceError: queryOptions.stackTraceError
+    };
+    deprecatedKeys.forEach(key => {
+      if (queryOptions[key]) {
+        // eslint-disable-next-line no-console
+        console.warn(`Use of option "${key}" in a findBy* query's second parameter, TextMatchOptions, is deprecated. Please pass this option in the third, WaitForOptions, parameter. 
+Example: 
+
+  findByText(text, {}, { ${key}: ${queryOptions[key].toString()} })`);
+      }
+    });
+    return waitForOptions;
+  }
+};
+
 function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   function getAllByQuery(instance) {
-    return function getAllFn(args) {
-      const results = queryAllByQuery(instance)(args);
+    return function getAllFn(args, queryOptions) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length === 0) {
         throw new _errors.ErrorWithStack(getMissingError(args), getAllFn);
@@ -25,8 +49,8 @@ function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   }
 
   function queryByQuery(instance) {
-    return function singleQueryFn(args) {
-      const results = queryAllByQuery(instance)(args);
+    return function singleQueryFn(args, queryOptions) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length > 1) {
         throw new _errors.ErrorWithStack(getMultipleError(args), singleQueryFn);
@@ -41,8 +65,8 @@ function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   }
 
   function getByQuery(instance) {
-    return function getFn(args) {
-      const results = queryAllByQuery(instance)(args);
+    return function getFn(args, queryOptions) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length > 1) {
         throw new _errors.ErrorWithStack(getMultipleError(args), getFn);
@@ -57,14 +81,20 @@ function makeQueries(queryAllByQuery, getMissingError, getMultipleError) {
   }
 
   function findAllByQuery(instance) {
-    return function findAllFn(args, waitForOptions = {}) {
-      return (0, _waitFor.default)(() => getAllByQuery(instance)(args), waitForOptions);
+    return function findAllFn(args, queryOptions, waitForOptions = {}) {
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(queryOptions);
+      return (0, _waitFor.default)(() => getAllByQuery(instance)(args, queryOptions), { ...deprecatedWaitForOptions,
+        ...waitForOptions
+      });
     };
   }
 
   function findByQuery(instance) {
-    return function findFn(args, waitForOptions = {}) {
-      return (0, _waitFor.default)(() => getByQuery(instance)(args), waitForOptions);
+    return function findFn(args, queryOptions, waitForOptions = {}) {
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(queryOptions);
+      return (0, _waitFor.default)(() => getByQuery(instance)(args, queryOptions), { ...deprecatedWaitForOptions,
+        ...waitForOptions
+      });
     };
   }
 

package/build/helpers/makeQueries.js.flow

@@ -2,14 +2,19 @@
 import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
 import { ErrorWithStack } from './errors';
+import type { TextMatchOptions } from './byText';
 
 type QueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
-) => (args: ArgType) => ReturnType;
+) => (args: ArgType, queryOptions?: TextMatchOptions) => ReturnType;
 
 type FindQueryFunction<ArgType, ReturnType> = (
   instance: ReactTestInstance
-) => (args: ArgType, waitForOptions?: WaitForOptions) => Promise<ReturnType>;
+) => (
+  args: ArgType,
+  queryOptions?: TextMatchOptions & WaitForOptions,
+  waitForOptions?: WaitForOptions
+) => Promise<ReturnType>;
 
 type QueryAllByQuery<QueryArg> = QueryFunction<
   QueryArg,
@@ -37,14 +42,43 @@ export type Queries<QueryArg> = {
   findAllBy: FindAllByQuery<QueryArg>,
 };
 
+// The WaitForOptions has been moved to the second option param of findBy* methods with the adding of TextMatchOptions
+// To make the migration easier and avoid a breaking change, keep reading this options from the first param but warn
+const deprecatedKeys: $Keys<WaitForOptions>[] = [
+  'timeout',
+  'interval',
+  'stackTraceError',
+];
+const extractDeprecatedWaitForOptionUsage = (queryOptions?: WaitForOptions) => {
+  if (queryOptions) {
+    const waitForOptions: WaitForOptions = {
+      timeout: queryOptions.timeout,
+      interval: queryOptions.interval,
+      stackTraceError: queryOptions.stackTraceError,
+    };
+    deprecatedKeys.forEach((key) => {
+      if (queryOptions[key]) {
+        // eslint-disable-next-line no-console
+        console.warn(
+          `Use of option "${key}" in a findBy* query's second parameter, TextMatchOptions, is deprecated. Please pass this option in the third, WaitForOptions, parameter. 
+Example: 
+
+  findByText(text, {}, { ${key}: ${queryOptions[key].toString()} })`
+        );
+      }
+    });
+    return waitForOptions;
+  }
+};
+
 export function makeQueries<QueryArg>(
   queryAllByQuery: QueryAllByQuery<QueryArg>,
   getMissingError: (args: QueryArg) => string,
   getMultipleError: (args: QueryArg) => string
 ): Queries<QueryArg> {
   function getAllByQuery(instance: ReactTestInstance) {
-    return function getAllFn(args: QueryArg) {
-      const results = queryAllByQuery(instance)(args);
+    return function getAllFn(args: QueryArg, queryOptions?: TextMatchOptions) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length === 0) {
         throw new ErrorWithStack(getMissingError(args), getAllFn);
@@ -55,8 +89,11 @@ export function makeQueries<QueryArg>(
   }
 
   function queryByQuery(instance: ReactTestInstance) {
-    return function singleQueryFn(args: QueryArg) {
-      const results = queryAllByQuery(instance)(args);
+    return function singleQueryFn(
+      args: QueryArg,
+      queryOptions?: TextMatchOptions
+    ) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length > 1) {
         throw new ErrorWithStack(getMultipleError(args), singleQueryFn);
@@ -71,8 +108,8 @@ export function makeQueries<QueryArg>(
   }
 
   function getByQuery(instance: ReactTestInstance) {
-    return function getFn(args: QueryArg) {
-      const results = queryAllByQuery(instance)(args);
+    return function getFn(args: QueryArg, queryOptions?: TextMatchOptions) {
+      const results = queryAllByQuery(instance)(args, queryOptions);
 
       if (results.length > 1) {
         throw new ErrorWithStack(getMultipleError(args), getFn);
@@ -89,18 +126,32 @@ export function makeQueries<QueryArg>(
   function findAllByQuery(instance: ReactTestInstance) {
     return function findAllFn(
       args: QueryArg,
+      queryOptions?: TextMatchOptions & WaitForOptions,
       waitForOptions?: WaitForOptions = {}
     ) {
-      return waitFor(() => getAllByQuery(instance)(args), waitForOptions);
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(
+        queryOptions
+      );
+      return waitFor(() => getAllByQuery(instance)(args, queryOptions), {
+        ...deprecatedWaitForOptions,
+        ...waitForOptions,
+      });
     };
   }
 
   function findByQuery(instance: ReactTestInstance) {
     return function findFn(
       args: QueryArg,
+      queryOptions?: TextMatchOptions & WaitForOptions,
       waitForOptions?: WaitForOptions = {}
     ) {
-      return waitFor(() => getByQuery(instance)(args), waitForOptions);
+      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(
+        queryOptions
+      );
+      return waitFor(() => getByQuery(instance)(args, queryOptions), {
+        ...deprecatedWaitForOptions,
+        ...waitForOptions,
+      });
     };
   }
 

package/build/helpers/queryByAPI.js.flow

@@ -1,5 +1,6 @@
 // @flow
 import * as React from 'react';
+import type { TextMatchOptions } from './byText';
 import {
   UNSAFE_getByType,
   UNSAFE_getByProps,
@@ -20,18 +21,32 @@ import {
 } from './errors';
 
 export type QueryByAPI = {|
-  queryByText: (name: string | RegExp) => ReactTestInstance | null,
+  queryByText: (
+    name: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance | null,
+  queryAllByText: (
+    text: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
   queryByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
   ) => ReactTestInstance | null,
-  queryByDisplayValue: (value: string | RegExp) => ReactTestInstance | null,
-  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null,
-  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>,
-  queryAllByText: (text: string | RegExp) => Array<ReactTestInstance>,
   queryAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: string | RegExp,
+    queryOptions?: TextMatchOptions
   ) => Array<ReactTestInstance>,
-  queryAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>,
+  queryByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => ReactTestInstance | null,
+  queryAllByDisplayValue: (
+    value: string | RegExp,
+    queryOptions?: TextMatchOptions
+  ) => Array<ReactTestInstance>,
+  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null,
+  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>,
 
   // Unsafe aliases
   UNSAFE_queryByType: <P>(

package/build/matches.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.matches = matches;
+exports.getDefaultNormalizer = getDefaultNormalizer;
+
+function matches(matcher, text, normalizer = getDefaultNormalizer(), exact = true) {
+  if (typeof text !== 'string') {
+    return false;
+  }
+
+  const normalizedText = normalizer(text);
+
+  if (typeof matcher === 'string') {
+    return exact ? normalizedText === matcher : normalizedText.toLowerCase().includes(matcher.toLowerCase());
+  } else {
+    return matcher.test(normalizedText);
+  }
+}
+
+function getDefaultNormalizer({
+  trim = true,
+  collapseWhitespace = true
+} = {}) {
+  return text => {
+    let normalizedText = text;
+    normalizedText = trim ? normalizedText.trim() : normalizedText;
+    normalizedText = collapseWhitespace ? normalizedText.replace(/\s+/g, ' ') : normalizedText;
+    return normalizedText;
+  };
+}

package/build/matches.js.flow

@@ -0,0 +1,41 @@
+// @flow
+export type NormalizerFn = (textToNormalize: string) => string;
+
+export function matches(
+  matcher: string | RegExp,
+  text: string,
+  normalizer?: NormalizerFn = getDefaultNormalizer(),
+  exact?: boolean = true
+): boolean {
+  if (typeof text !== 'string') {
+    return false;
+  }
+
+  const normalizedText = normalizer(text);
+  if (typeof matcher === 'string') {
+    return exact
+      ? normalizedText === matcher
+      : normalizedText.toLowerCase().includes(matcher.toLowerCase());
+  } else {
+    return matcher.test(normalizedText);
+  }
+}
+
+type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+
+export function getDefaultNormalizer({
+  trim = true,
+  collapseWhitespace = true,
+}: NormalizerConfig = {}): NormalizerFn {
+  return (text: string) => {
+    let normalizedText = text;
+    normalizedText = trim ? normalizedText.trim() : normalizedText;
+    normalizedText = collapseWhitespace
+      ? normalizedText.replace(/\s+/g, ' ')
+      : normalizedText;
+    return normalizedText;
+  };
+}

package/build/pure.js

@@ -69,6 +69,12 @@ Object.defineProperty(exports, "getQueriesForElement", {
     return _within.getQueriesForElement;
   }
 });
+Object.defineProperty(exports, "getDefaultNormalizer", {
+  enumerable: true,
+  get: function () {
+    return _matches.getDefaultNormalizer;
+  }
+});
 
 var _act = _interopRequireDefault(require("./act"));
 
@@ -88,6 +94,8 @@ var _waitForElementToBeRemoved = _interopRequireDefault(require("./waitForElemen
 
 var _within = require("./within");
 
+var _matches = require("./matches");
+
 function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
 
 function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

package/build/pure.js.flow

@@ -8,6 +8,7 @@ import shallow from './shallow';
 import waitFor, { waitForElement } from './waitFor';
 import waitForElementToBeRemoved from './waitForElementToBeRemoved';
 import { within, getQueriesForElement } from './within';
+import { getDefaultNormalizer } from './matches';
 
 export { act };
 export { cleanup };
@@ -18,3 +19,4 @@ export { shallow };
 export { waitFor, waitForElement };
 export { waitForElementToBeRemoved };
 export { within, getQueriesForElement };
+export { getDefaultNormalizer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testing-library/react-native",
-  "version": "8.0.0",
+  "version": "9.0.0-alpha.0",
   "description": "Simple and complete React Native testing utilities that encourage good testing practices.",
   "main": "build/index.js",
   "typings": "./typings/index.d.ts",

package/typings/index.d.ts

@@ -14,17 +14,38 @@ type QueryAllReturn = Array<ReactTestInstance> | [];
 type FindReturn = Promise<ReactTestInstance>;
 type FindAllReturn = Promise<ReactTestInstance[]>;
 
+type TextMatch = string | RegExp;
+
 interface GetByAPI {
-  getByText: (text: string | RegExp) => ReactTestInstance;
-  getByPlaceholderText: (placeholder: string | RegExp) => ReactTestInstance;
-  getByDisplayValue: (value: string | RegExp) => ReactTestInstance;
-  getByTestId: (testID: string | RegExp) => ReactTestInstance;
-  getAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance>;
-  getAllByText: (text: string | RegExp) => Array<ReactTestInstance>;
+  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
   getAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  getAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance>;
-  getAllByDisplayValue: (value: string | RegExp) => Array<ReactTestInstance>;
 
   // Unsafe aliases
   UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
@@ -64,19 +85,31 @@ interface GetByAPI {
 }
 
 interface QueryByAPI {
-  queryByText: (name: string | RegExp) => ReactTestInstance | null;
+  queryByText: (
+    name: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
   queryByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
   ) => ReactTestInstance | null;
-  queryByDisplayValue: (value: string | RegExp) => ReactTestInstance | null;
-  queryByTestId: (testID: string | RegExp) => ReactTestInstance | null;
-  queryAllByTestId: (testID: string | RegExp) => Array<ReactTestInstance> | [];
-  queryAllByText: (text: string | RegExp) => Array<ReactTestInstance> | [];
+  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
+  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
+  queryAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
   queryAllByPlaceholderText: (
-    placeholder: string | RegExp
+    placeholder: TextMatch,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance> | [];
   queryAllByDisplayValue: (
-    value: string | RegExp
+    value: TextMatch,
+    options?: TextMatchOptions
   ) => Array<ReactTestInstance> | [];
 
   // Unsafe aliases
@@ -126,35 +159,43 @@ interface QueryByAPI {
 
 interface FindByAPI {
   findByText: (
-    text: string | RegExp,
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByDisplayValue: (
-    value: string | RegExp,
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByTestId: (
-    testID: string | RegExp,
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByText: (
-    text: string | RegExp,
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByPlaceholderText: (
-    placeholder: string | RegExp,
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByDisplayValue: (
-    value: string | RegExp,
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByTestId: (
-    testID: string | RegExp,
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 }
@@ -169,54 +210,54 @@ export type A11yValue = {
 
 type A11yAPI = {
   // Label
-  getByA11yLabel: (matcher: string | RegExp) => GetReturn;
-  getByLabelText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yLabel: (matcher: string | RegExp) => GetAllReturn;
-  getAllByLabelText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yLabel: (matcher: string | RegExp) => QueryReturn;
-  queryByLabelText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yLabel: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByLabelText: (matcher: string | RegExp) => QueryAllReturn;
+  getByA11yLabel: (matcher: TextMatch) => GetReturn;
+  getByLabelText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yLabel: (matcher: TextMatch) => GetAllReturn;
+  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yLabel: (matcher: TextMatch) => QueryReturn;
+  queryByLabelText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yLabel: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
   findByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yLabel: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByLabelText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
   // Hint
-  getByA11yHint: (matcher: string | RegExp) => GetReturn;
-  getByHintText: (matcher: string | RegExp) => GetReturn;
-  getAllByA11yHint: (matcher: string | RegExp) => GetAllReturn;
-  getAllByHintText: (matcher: string | RegExp) => GetAllReturn;
-  queryByA11yHint: (matcher: string | RegExp) => QueryReturn;
-  queryByHintText: (matcher: string | RegExp) => QueryReturn;
-  queryAllByA11yHint: (matcher: string | RegExp) => QueryAllReturn;
-  queryAllByHintText: (matcher: string | RegExp) => QueryAllReturn;
+  getByA11yHint: (matcher: TextMatch) => GetReturn;
+  getByHintText: (matcher: TextMatch) => GetReturn;
+  getAllByA11yHint: (matcher: TextMatch) => GetAllReturn;
+  getAllByHintText: (matcher: TextMatch) => GetAllReturn;
+  queryByA11yHint: (matcher: TextMatch) => QueryReturn;
+  queryByHintText: (matcher: TextMatch) => QueryReturn;
+  queryAllByA11yHint: (matcher: TextMatch) => QueryAllReturn;
+  queryAllByHintText: (matcher: TextMatch) => QueryAllReturn;
   findByA11yHint: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindReturn;
   findAllByA11yHint: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
   findAllByHintText: (
-    matcher: string | RegExp,
+    matcher: TextMatch,
     waitForOptions?: WaitForOptions
   ) => FindAllReturn;
 
@@ -334,6 +375,16 @@ export declare const render: (
 export declare const cleanup: () => void;
 export declare const fireEvent: FireEventAPI;
 
+type NormalizerFn = (textToNormalize: string) => string;
+type NormalizerConfig = {
+  trim?: boolean;
+  collapseWhitespace?: boolean;
+};
+type TextMatchOptions = {
+  exact?: boolean;
+  normalizer?: NormalizerFn;
+};
+
 type WaitForOptions = {
   timeout?: number;
   interval?: number;
@@ -359,6 +410,10 @@ export declare const getQueriesForElement: (
   instance: ReactTestInstance
 ) => Queries;
 
+export declare const getDefaultNormalizer: (
+  normalizerConfig?: NormalizerConfig
+) => NormalizerFn;
+
 /**
  * @deprecated This function has been removed. Please use `waitFor` function.
  */