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

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/helpers/timers.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runWithRealTimers = runWithRealTimers;
+exports.setTimeout = exports.setImmediate = exports.clearTimeout = exports.jestFakeTimersAreEnabled = void 0;
+// Most content of this file sourced directly from https://github.com/testing-library/dom-testing-library/blob/main/src/helpers.js
+
+/* globals jest */
+const globalObj = typeof window === 'undefined' ? global : window; // Currently this fn only supports jest timers, but it could support other test runners in the future.
+
+function runWithRealTimers(callback) {
+  const fakeTimersType = getJestFakeTimersType();
+
+  if (fakeTimersType) {
+    jest.useRealTimers();
+  }
+
+  const callbackReturnValue = callback();
+
+  if (fakeTimersType) {
+    jest.useFakeTimers(fakeTimersType);
+  }
+
+  return callbackReturnValue;
+}
+
+function getJestFakeTimersType() {
+  // istanbul ignore if
+  if (typeof jest === 'undefined' || typeof globalObj.setTimeout === 'undefined') {
+    return null;
+  }
+
+  if (typeof globalObj.setTimeout._isMockFunction !== 'undefined' && globalObj.setTimeout._isMockFunction) {
+    return 'legacy';
+  }
+
+  if (typeof globalObj.setTimeout.clock !== 'undefined' && // $FlowIgnore[prop-missing]
+  typeof jest.getRealSystemTime !== 'undefined') {
+    try {
+      // jest.getRealSystemTime is only supported for Jest's `modern` fake timers and otherwise throws
+      // $FlowExpectedError
+      jest.getRealSystemTime();
+      return 'modern';
+    } catch {// not using Jest's modern fake timers
+    }
+  }
+
+  return null;
+}
+
+const jestFakeTimersAreEnabled = () => Boolean(getJestFakeTimersType()); // we only run our tests in node, and setImmediate is supported in node.
+
+
+exports.jestFakeTimersAreEnabled = jestFakeTimersAreEnabled;
+
+function setImmediatePolyfill(fn) {
+  return globalObj.setTimeout(fn, 0);
+}
+
+function bindTimeFunctions() {
+  return {
+    clearTimeoutFn: globalObj.clearTimeout,
+    setImmediateFn: globalObj.setImmediate || setImmediatePolyfill,
+    setTimeoutFn: globalObj.setTimeout
+  };
+}
+
+const {
+  clearTimeoutFn,
+  setImmediateFn,
+  setTimeoutFn
+} = runWithRealTimers(bindTimeFunctions);
+exports.setTimeout = setTimeoutFn;
+exports.setImmediate = setImmediateFn;
+exports.clearTimeout = clearTimeoutFn;

package/build/helpers/timers.js.flow

@@ -0,0 +1,88 @@
+// Most content of this file sourced directly from https://github.com/testing-library/dom-testing-library/blob/main/src/helpers.js
+// @flow
+/* globals jest */
+
+const globalObj = typeof window === 'undefined' ? global : window;
+
+// Currently this fn only supports jest timers, but it could support other test runners in the future.
+function runWithRealTimers<T>(callback: () => T): T {
+  const fakeTimersType = getJestFakeTimersType();
+  if (fakeTimersType) {
+    jest.useRealTimers();
+  }
+
+  const callbackReturnValue = callback();
+
+  if (fakeTimersType) {
+    jest.useFakeTimers(fakeTimersType);
+  }
+
+  return callbackReturnValue;
+}
+
+function getJestFakeTimersType() {
+  // istanbul ignore if
+  if (
+    typeof jest === 'undefined' ||
+    typeof globalObj.setTimeout === 'undefined'
+  ) {
+    return null;
+  }
+
+  if (
+    typeof globalObj.setTimeout._isMockFunction !== 'undefined' &&
+    globalObj.setTimeout._isMockFunction
+  ) {
+    return 'legacy';
+  }
+
+  if (
+    typeof globalObj.setTimeout.clock !== 'undefined' &&
+    // $FlowIgnore[prop-missing]
+    typeof jest.getRealSystemTime !== 'undefined'
+  ) {
+    try {
+      // jest.getRealSystemTime is only supported for Jest's `modern` fake timers and otherwise throws
+      // $FlowExpectedError
+      jest.getRealSystemTime();
+      return 'modern';
+    } catch {
+      // not using Jest's modern fake timers
+    }
+  }
+  return null;
+}
+
+const jestFakeTimersAreEnabled = (): boolean =>
+  Boolean(getJestFakeTimersType());
+
+// we only run our tests in node, and setImmediate is supported in node.
+function setImmediatePolyfill(fn) {
+  return globalObj.setTimeout(fn, 0);
+}
+
+type BindTimeFunctions = {
+  clearTimeoutFn: typeof clearTimeout,
+  setImmediateFn: typeof setImmediate,
+  setTimeoutFn: typeof setTimeout,
+};
+
+function bindTimeFunctions(): BindTimeFunctions {
+  return {
+    clearTimeoutFn: globalObj.clearTimeout,
+    setImmediateFn: globalObj.setImmediate || setImmediatePolyfill,
+    setTimeoutFn: globalObj.setTimeout,
+  };
+}
+
+const { clearTimeoutFn, setImmediateFn, setTimeoutFn } = (runWithRealTimers(
+  bindTimeFunctions
+): BindTimeFunctions);
+
+export {
+  runWithRealTimers,
+  jestFakeTimersAreEnabled,
+  clearTimeoutFn as clearTimeout,
+  setImmediateFn as setImmediate,
+  setTimeoutFn as setTimeout,
+};

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/build/render.js

@@ -48,16 +48,23 @@ function render(component, {
   } : undefined);
   const update = updateWithAct(renderer, wrap);
   const instance = renderer.root;
-  (0, _cleanup.addToCleanupQueue)(renderer.unmount);
+
+  const unmount = () => {
+    (0, _act.default)(() => {
+      renderer.unmount();
+    });
+  };
+
+  (0, _cleanup.addToCleanupQueue)(unmount);
   return { ...(0, _getByAPI.getByAPI)(instance),
     ...(0, _queryByAPI.queryByAPI)(instance),
     ...(0, _findByAPI.findByAPI)(instance),
     ...(0, _a11yAPI.a11yAPI)(instance),
     update,
+    unmount,
     container: instance,
     rerender: update,
     // alias for `update`
-    unmount: renderer.unmount,
     toJSON: renderer.toJSON,
     debug: debug(instance, renderer)
   };

package/build/render.js.flow

@@ -46,8 +46,13 @@ export default function render<T>(
   );
   const update = updateWithAct(renderer, wrap);
   const instance = renderer.root;
+  const unmount = () => {
+    act(() => {
+      renderer.unmount();
+    });
+  };
 
-  addToCleanupQueue(renderer.unmount);
+  addToCleanupQueue(unmount);
 
   return {
     ...getByAPI(instance),
@@ -55,9 +60,9 @@ export default function render<T>(
     ...findByAPI(instance),
     ...a11yAPI(instance),
     update,
+    unmount,
     container: instance,
     rerender: update, // alias for `update`
-    unmount: renderer.unmount,
     toJSON: renderer.toJSON,
     debug: debug(instance, renderer),
   };