@testing-library/react-native 7.1.0 → 8.0.0

package/build/helpers/byTestId.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.queryByTestId = exports.queryAllByTestId = exports.getByTestId = exports.getAllByTestId = exports.findByTestId = exports.findAllByTestId = void 0;
+
+var _makeQueries = require("./makeQueries");
+
+const getNodeByTestId = (node, testID) => {
+  return typeof testID === 'string' ? testID === node.props.testID : testID.test(node.props.testID);
+};
+
+const queryAllByTestId = instance => function queryAllByTestIdFn(testId) {
+  const results = instance.findAll(node => getNodeByTestId(node, testId)).filter(element => typeof element.type === 'string');
+  return results;
+};
+
+exports.queryAllByTestId = queryAllByTestId;
+
+const getMultipleError = testId => `Found multiple elements with testID: ${String(testId)}`;
+
+const getMissingError = testId => `Unable to find an element with testID: ${String(testId)}`;
+
+const {
+  getBy: getByTestId,
+  getAllBy: getAllByTestId,
+  queryBy: queryByTestId,
+  findBy: findByTestId,
+  findAllBy: findAllByTestId
+} = (0, _makeQueries.makeQueries)(queryAllByTestId, getMissingError, getMultipleError);
+exports.findAllByTestId = findAllByTestId;
+exports.findByTestId = findByTestId;
+exports.queryByTestId = queryByTestId;
+exports.getAllByTestId = getAllByTestId;
+exports.getByTestId = getByTestId;

package/build/helpers/byTestId.js.flow

@@ -0,0 +1,46 @@
+// @flow
+import { makeQueries } from './makeQueries';
+import type { Queries } from './makeQueries';
+
+const getNodeByTestId = (node, testID) => {
+  return typeof testID === 'string'
+    ? testID === node.props.testID
+    : testID.test(node.props.testID);
+};
+
+const queryAllByTestId = (
+  instance: ReactTestInstance
+): ((testId: string | RegExp) => Array<ReactTestInstance>) =>
+  function queryAllByTestIdFn(testId) {
+    const results = instance
+      .findAll((node) => getNodeByTestId(node, testId))
+      .filter((element) => typeof element.type === 'string');
+
+    return results;
+  };
+
+const getMultipleError = (testId) =>
+  `Found multiple elements with testID: ${String(testId)}`;
+const getMissingError = (testId) =>
+  `Unable to find an element with testID: ${String(testId)}`;
+
+const {
+  getBy: getByTestId,
+  getAllBy: getAllByTestId,
+  queryBy: queryByTestId,
+  findBy: findByTestId,
+  findAllBy: findAllByTestId,
+}: Queries<string | RegExp> = makeQueries(
+  queryAllByTestId,
+  getMissingError,
+  getMultipleError
+);
+
+export {
+  findAllByTestId,
+  findByTestId,
+  getAllByTestId,
+  getByTestId,
+  queryAllByTestId,
+  queryByTestId,
+};

package/build/helpers/byText.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.queryByText = exports.queryAllByText = exports.getByText = exports.getAllByText = exports.findByText = exports.findAllByText = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _makeQueries = require("./makeQueries");
+
+var _filterNodeByType = require("./filterNodeByType");
+
+var _errors = require("./errors");
+
+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; }
+
+const getChildrenAsText = (children, TextComponent, textContent = []) => {
+  React.Children.forEach(children, child => {
+    var _child$props;
+
+    if (typeof child === 'string') {
+      textContent.push(child);
+      return;
+    }
+
+    if (typeof child === 'number') {
+      textContent.push(child.toString());
+      return;
+    }
+
+    if (child !== null && child !== void 0 && (_child$props = child.props) !== null && _child$props !== void 0 && _child$props.children) {
+      // Bail on traversing text children down the tree if current node (child)
+      // has no text. In such situations, react-test-renderer will traverse down
+      // this tree in a separate call and run this query again. As a result, the
+      // query will match the deepest text node that matches requested text.
+      if ((0, _filterNodeByType.filterNodeByType)(child, TextComponent) && textContent.length === 0) {
+        return;
+      }
+
+      getChildrenAsText(child.props.children, TextComponent, textContent);
+    }
+  });
+  return textContent;
+};
+
+const getNodeByText = (node, text) => {
+  try {
+    const {
+      Text
+    } = require('react-native');
+
+    const isTextComponent = (0, _filterNodeByType.filterNodeByType)(node, Text);
+
+    if (isTextComponent) {
+      const textChildren = getChildrenAsText(node.props.children, Text);
+
+      if (textChildren) {
+        const textToTest = textChildren.join('');
+        return typeof text === 'string' ? text === textToTest : text.test(textToTest);
+      }
+    }
+
+    return false;
+  } catch (error) {
+    throw (0, _errors.createLibraryNotSupportedError)(error);
+  }
+};
+
+const queryAllByText = instance => function queryAllByTextFn(text) {
+  const results = instance.findAll(node => getNodeByText(node, text));
+  return results;
+};
+
+exports.queryAllByText = queryAllByText;
+
+const getMultipleError = text => `Found multiple elements with text: ${String(text)}`;
+
+const getMissingError = text => `Unable to find an element with text: ${String(text)}`;
+
+const {
+  getBy: getByText,
+  getAllBy: getAllByText,
+  queryBy: queryByText,
+  findBy: findByText,
+  findAllBy: findAllByText
+} = (0, _makeQueries.makeQueries)(queryAllByText, getMissingError, getMultipleError);
+exports.findAllByText = findAllByText;
+exports.findByText = findByText;
+exports.queryByText = queryByText;
+exports.getAllByText = getAllByText;
+exports.getByText = getByText;

package/build/helpers/byText.js.flow

@@ -0,0 +1,88 @@
+// @flow
+import * as React from 'react';
+import { makeQueries } from './makeQueries';
+import type { Queries } from './makeQueries';
+import { filterNodeByType } from './filterNodeByType';
+import { createLibraryNotSupportedError } from './errors';
+
+const getChildrenAsText = (children, TextComponent, textContent = []) => {
+  React.Children.forEach(children, (child) => {
+    if (typeof child === 'string') {
+      textContent.push(child);
+      return;
+    }
+
+    if (typeof child === 'number') {
+      textContent.push(child.toString());
+      return;
+    }
+
+    if (child?.props?.children) {
+      // Bail on traversing text children down the tree if current node (child)
+      // has no text. In such situations, react-test-renderer will traverse down
+      // this tree in a separate call and run this query again. As a result, the
+      // query will match the deepest text node that matches requested text.
+      if (filterNodeByType(child, TextComponent) && textContent.length === 0) {
+        return;
+      }
+
+      getChildrenAsText(child.props.children, TextComponent, textContent);
+    }
+  });
+
+  return textContent;
+};
+
+const getNodeByText = (node, text: string | RegExp) => {
+  try {
+    const { Text } = require('react-native');
+    const isTextComponent = filterNodeByType(node, Text);
+    if (isTextComponent) {
+      const textChildren = getChildrenAsText(node.props.children, Text);
+      if (textChildren) {
+        const textToTest = textChildren.join('');
+        return typeof text === 'string'
+          ? text === textToTest
+          : text.test(textToTest);
+      }
+    }
+    return false;
+  } catch (error) {
+    throw createLibraryNotSupportedError(error);
+  }
+};
+
+const queryAllByText = (
+  instance: ReactTestInstance
+): ((text: string | RegExp) => Array<ReactTestInstance>) =>
+  function queryAllByTextFn(text) {
+    const results = instance.findAll((node) => getNodeByText(node, text));
+
+    return results;
+  };
+
+const getMultipleError = (text: string | RegExp) =>
+  `Found multiple elements with text: ${String(text)}`;
+const getMissingError = (text: string | RegExp) =>
+  `Unable to find an element with text: ${String(text)}`;
+
+const {
+  getBy: getByText,
+  getAllBy: getAllByText,
+  queryBy: queryByText,
+  findBy: findByText,
+  findAllBy: findAllByText,
+}: Queries<string | RegExp> = makeQueries(
+  queryAllByText,
+  getMissingError,
+  getMultipleError
+);
+
+export {
+  findAllByText,
+  findByText,
+  getAllByText,
+  getByText,
+  queryAllByText,
+  queryByText,
+};

package/build/helpers/debugDeep.js

@@ -12,7 +12,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 /**
  * Log pretty-printed deep test component instance
  */
-function debugDeep(instance, message = '') {
+function debugDeep(instance, message) {
   if (message) {
     console.log(`${message}\n\n`, (0, _format.default)(instance));
   } else {

package/build/helpers/debugDeep.js.flow

@@ -6,7 +6,7 @@ import format from './format';
  */
 export default function debugDeep(
   instance: ?ReactTestRendererJSON,
-  message?: any = ''
+  message?: string
 ) {
   if (message) {
     console.log(`${message}\n\n`, format(instance));

package/build/helpers/debugShallow.js.flow

@@ -8,7 +8,7 @@ import format from './format';
  */
 export default function debugShallow(
   instance: ReactTestInstance | React.Element<any>,
-  message?: any
+  message?: string
 ) {
   const { output } = shallowInternal(instance);
 

package/build/helpers/errors.js

@@ -3,6 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.copyStackTrace = copyStackTrace;
 exports.printDeprecationWarning = printDeprecationWarning;
 exports.throwRemovedFunctionError = throwRemovedFunctionError;
 exports.throwRenamedFunctionError = throwRenamedFunctionError;
@@ -53,6 +54,11 @@ const createQueryByError = (error, callsite) => {
 };
 
 exports.createQueryByError = createQueryByError;
+
+function copyStackTrace(target, stackTraceSource) {
+  target.stack = stackTraceSource.stack.replace(stackTraceSource.message, target.message);
+}
+
 const warned = {};
 
 function printDeprecationWarning(functionName) {

package/build/helpers/errors.js.flow

@@ -10,7 +10,7 @@ export class ErrorWithStack extends Error {
   }
 }
 
-export const createLibraryNotSupportedError = (error: Error) =>
+export const createLibraryNotSupportedError = (error: Error): Error =>
   new Error(
     `Currently the only supported library to search by text is "react-native".\n\n${error.message}`
   );
@@ -19,7 +19,7 @@ export const prepareErrorMessage = (
   error: Error,
   name: ?string,
   value: ?mixed
-) => {
+): string => {
   // Strip info about custom predicate
   let errorMessage = error.message.replace(
     / matching custom predicate[^]*/gm,
@@ -32,13 +32,20 @@ export const prepareErrorMessage = (
   return errorMessage;
 };
 
-export const createQueryByError = (error: Error, callsite: Function) => {
+export const createQueryByError = (error: Error, callsite: Function): null => {
   if (error.message.includes('No instances found')) {
     return null;
   }
   throw new ErrorWithStack(error.message, callsite);
 };
 
+export function copyStackTrace(target: Error, stackTraceSource: Error) {
+  target.stack = stackTraceSource.stack.replace(
+    stackTraceSource.message,
+    target.message
+  );
+}
+
 const warned = {};
 
 export function printDeprecationWarning(functionName: string) {

package/build/helpers/filterNodeByType.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterNodeByType = void 0;
+
+const filterNodeByType = (node, type) => node.type === type;
+
+exports.filterNodeByType = filterNodeByType;

package/build/helpers/filterNodeByType.js.flow

@@ -0,0 +1 @@
+export const filterNodeByType = (node, type) => node.type === type;

package/build/helpers/findByAPI.js

@@ -3,59 +3,27 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.findByAPI = exports.findAllByDisplayValue = exports.findByDisplayValue = exports.findAllByPlaceholderText = exports.findByPlaceholderText = exports.findAllByText = exports.findByText = exports.findAllByTestId = exports.findByTestId = void 0;
+exports.findByAPI = void 0;
 
-var _waitFor = _interopRequireDefault(require("../waitFor"));
+var _byTestId = require("./byTestId");
 
-var _getByAPI = require("./getByAPI");
+var _byText = require("./byText");
 
-var _errors = require("./errors");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-const makeFindQuery = (instance, getQuery, text, waitForOptions) => (0, _waitFor.default)(() => getQuery(instance)(text), waitForOptions);
-
-const findByTestId = instance => (testId, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getByTestId, testId, waitForOptions);
-
-exports.findByTestId = findByTestId;
-
-const findAllByTestId = instance => (testId, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getAllByTestId, testId, waitForOptions);
-
-exports.findAllByTestId = findAllByTestId;
-
-const findByText = instance => (text, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getByText, text, waitForOptions);
-
-exports.findByText = findByText;
+var _byPlaceholderText = require("./byPlaceholderText");
 
-const findAllByText = instance => (text, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getAllByText, text, waitForOptions);
+var _byDisplayValue = require("./byDisplayValue");
 
-exports.findAllByText = findAllByText;
-
-const findByPlaceholderText = instance => (placeholder, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getByPlaceholderText, placeholder, waitForOptions);
-
-exports.findByPlaceholderText = findByPlaceholderText;
-
-const findAllByPlaceholderText = instance => (placeholder, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getAllByPlaceholderText, placeholder, waitForOptions);
-
-exports.findAllByPlaceholderText = findAllByPlaceholderText;
-
-const findByDisplayValue = instance => (value, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getByDisplayValue, value, waitForOptions);
-
-exports.findByDisplayValue = findByDisplayValue;
-
-const findAllByDisplayValue = instance => (value, waitForOptions = {}) => makeFindQuery(instance, _getByAPI.getAllByDisplayValue, value, waitForOptions);
-
-exports.findAllByDisplayValue = findAllByDisplayValue;
+var _errors = require("./errors");
 
 const findByAPI = instance => ({
-  findByTestId: findByTestId(instance),
-  findByText: findByText(instance),
-  findByPlaceholderText: findByPlaceholderText(instance),
-  findByDisplayValue: findByDisplayValue(instance),
-  findAllByTestId: findAllByTestId(instance),
-  findAllByText: findAllByText(instance),
-  findAllByPlaceholderText: findAllByPlaceholderText(instance),
-  findAllByDisplayValue: findAllByDisplayValue(instance),
+  findByTestId: (0, _byTestId.findByTestId)(instance),
+  findByText: (0, _byText.findByText)(instance),
+  findByPlaceholderText: (0, _byPlaceholderText.findByPlaceholderText)(instance),
+  findByDisplayValue: (0, _byDisplayValue.findByDisplayValue)(instance),
+  findAllByTestId: (0, _byTestId.findAllByTestId)(instance),
+  findAllByText: (0, _byText.findAllByText)(instance),
+  findAllByPlaceholderText: (0, _byPlaceholderText.findAllByPlaceholderText)(instance),
+  findAllByDisplayValue: (0, _byDisplayValue.findAllByDisplayValue)(instance),
   // Renamed
   findByPlaceholder: () => (0, _errors.throwRenamedFunctionError)('findByPlaceholder', 'findByPlaceholderText'),
   findAllByPlaceholder: () => (0, _errors.throwRenamedFunctionError)('findAllByPlaceholder', 'findAllByPlaceholderText')

package/build/helpers/findByAPI.js.flow

@@ -1,67 +1,52 @@
 // @flow
-import waitFor from '../waitFor';
 import type { WaitForOptions } from '../waitFor';
+import { findAllByTestId, findByTestId } from './byTestId';
+import { findAllByText, findByText } from './byText';
 import {
-  getByTestId,
-  getAllByTestId,
-  getByText,
-  getAllByText,
-  getByPlaceholderText,
-  getAllByPlaceholderText,
-  getByDisplayValue,
-  getAllByDisplayValue,
-} from './getByAPI';
+  findAllByPlaceholderText,
+  findByPlaceholderText,
+} from './byPlaceholderText';
+import { findAllByDisplayValue, findByDisplayValue } from './byDisplayValue';
 import { throwRenamedFunctionError } from './errors';
 
-const makeFindQuery = <Text, Result>(
-  instance: ReactTestInstance,
-  getQuery: (instance: ReactTestInstance) => (text: Text) => Result,
-  text: Text,
-  waitForOptions: WaitForOptions
-): Promise<Result> => waitFor(() => getQuery(instance)(text), waitForOptions);
+export type FindByAPI = {|
+  findAllByDisplayValue: (
+    value: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<Array<ReactTestInstance>>,
+  findAllByPlaceholder: () => void,
+  findAllByPlaceholderText: (
+    placeholder: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<Array<ReactTestInstance>>,
+  findAllByTestId: (
+    testId: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<Array<ReactTestInstance>>,
+  findAllByText: (
+    text: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<Array<ReactTestInstance>>,
+  findByDisplayValue: (
+    value: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<ReactTestInstance>,
+  findByPlaceholder: () => void,
+  findByPlaceholderText: (
+    placeholder: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<ReactTestInstance>,
+  findByTestId: (
+    testId: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<ReactTestInstance>,
+  findByText: (
+    text: string | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => Promise<ReactTestInstance>,
+|};
 
-export const findByTestId = (instance: ReactTestInstance) => (
-  testId: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByTestId, testId, waitForOptions);
-
-export const findAllByTestId = (instance: ReactTestInstance) => (
-  testId: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByTestId, testId, waitForOptions);
-
-export const findByText = (instance: ReactTestInstance) => (
-  text: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByText, text, waitForOptions);
-
-export const findAllByText = (instance: ReactTestInstance) => (
-  text: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByText, text, waitForOptions);
-
-export const findByPlaceholderText = (instance: ReactTestInstance) => (
-  placeholder: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByPlaceholderText, placeholder, waitForOptions);
-
-export const findAllByPlaceholderText = (instance: ReactTestInstance) => (
-  placeholder: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) =>
-  makeFindQuery(instance, getAllByPlaceholderText, placeholder, waitForOptions);
-
-export const findByDisplayValue = (instance: ReactTestInstance) => (
-  value: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getByDisplayValue, value, waitForOptions);
-
-export const findAllByDisplayValue = (instance: ReactTestInstance) => (
-  value: string | RegExp,
-  waitForOptions: WaitForOptions = {}
-) => makeFindQuery(instance, getAllByDisplayValue, value, waitForOptions);
-
-export const findByAPI = (instance: ReactTestInstance) => ({
+export const findByAPI = (instance: ReactTestInstance): FindByAPI => ({
   findByTestId: findByTestId(instance),
   findByText: findByText(instance),
   findByPlaceholderText: findByPlaceholderText(instance),

package/build/helpers/format.js.flow

@@ -1,7 +1,7 @@
 // @flow
 import prettyFormat, { plugins } from 'pretty-format';
 
-const format = (input: ?ReactTestRendererJSON) =>
+const format = (input: ?ReactTestRendererJSON): typeof prettyFormat =>
   prettyFormat(input, {
     plugins: [plugins.ReactTestComponent, plugins.ReactElement],
     highlight: true,