@testing-library/react-native 9.0.0 → 10.0.0

package/build/helpers/a11yAPI.js.flow

@@ -1,241 +0,0 @@
-// @flow
-import type { A11yRole, A11yStates, A11yState, A11yValue } from '../types.flow';
-import type { WaitForOptions } from '../waitFor';
-import makeA11yQuery from './makeA11yQuery';
-
-type GetReturn = ReactTestInstance;
-type GetAllReturn = Array<ReactTestInstance>;
-type QueryReturn = ReactTestInstance | null;
-type QueryAllReturn = Array<ReactTestInstance>;
-type FindReturn = Promise<GetReturn>;
-type FindAllReturn = Promise<GetAllReturn>;
-
-export type A11yAPI = {|
-  // Label
-  getByA11yLabel: (string | RegExp) => GetReturn,
-  getByLabelText: (string | RegExp) => GetReturn,
-  getAllByA11yLabel: (string | RegExp) => GetAllReturn,
-  getAllByLabelText: (string | RegExp) => GetAllReturn,
-  queryByA11yLabel: (string | RegExp) => QueryReturn,
-  queryByLabelText: (string | RegExp) => QueryReturn,
-  queryAllByA11yLabel: (string | RegExp) => QueryAllReturn,
-  queryAllByLabelText: (string | RegExp) => QueryAllReturn,
-  findByA11yLabel: (string | RegExp, ?WaitForOptions) => FindReturn,
-  findByLabelText: (string | RegExp, ?WaitForOptions) => FindReturn,
-  findAllByA11yLabel: (string | RegExp, ?WaitForOptions) => FindAllReturn,
-  findAllByLabelText: (string | RegExp, ?WaitForOptions) => FindAllReturn,
-
-  // Hint
-  getByA11yHint: (string | RegExp) => GetReturn,
-  getByHintText: (string | RegExp) => GetReturn,
-  getAllByA11yHint: (string | RegExp) => GetAllReturn,
-  getAllByHintText: (string | RegExp) => GetAllReturn,
-  queryByA11yHint: (string | RegExp) => QueryReturn,
-  queryByHintText: (string | RegExp) => QueryReturn,
-  queryAllByA11yHint: (string | RegExp) => QueryAllReturn,
-  queryAllByHintText: (string | RegExp) => QueryAllReturn,
-  findByA11yHint: (string | RegExp, ?WaitForOptions) => FindReturn,
-  findByHintText: (string | RegExp, ?WaitForOptions) => FindReturn,
-  findAllByA11yHint: (string | RegExp, ?WaitForOptions) => FindAllReturn,
-  findAllByHintText: (string | RegExp, ?WaitForOptions) => FindAllReturn,
-
-  // Role
-  getByA11yRole: (A11yRole | RegExp) => GetReturn,
-  getByRole: (A11yRole | RegExp) => GetReturn,
-  getAllByA11yRole: (A11yRole | RegExp) => GetAllReturn,
-  getAllByRole: (A11yRole | RegExp) => GetAllReturn,
-  queryByA11yRole: (A11yRole | RegExp) => QueryReturn,
-  queryByRole: (A11yRole | RegExp) => QueryReturn,
-  queryAllByA11yRole: (A11yRole | RegExp) => QueryAllReturn,
-  queryAllByRole: (A11yRole | RegExp) => QueryAllReturn,
-  findByA11yRole: (A11yRole, ?WaitForOptions) => FindReturn,
-  findByRole: (A11yRole, ?WaitForOptions) => FindReturn,
-  findAllByA11yRole: (A11yRole, ?WaitForOptions) => FindAllReturn,
-  findAllByRole: (A11yRole, ?WaitForOptions) => FindAllReturn,
-
-  // States
-  getByA11yStates: (A11yStates | Array<A11yStates>) => GetReturn,
-  getAllByA11yStates: (A11yStates | Array<A11yStates>) => GetAllReturn,
-  queryByA11yStates: (A11yStates | Array<A11yStates>) => QueryReturn,
-  queryAllByA11yStates: (A11yStates | Array<A11yStates>) => QueryAllReturn,
-  findByA11yStates: (A11yStates, ?WaitForOptions) => FindReturn,
-  findAllByA11yStates: (A11yStates, ?WaitForOptions) => FindAllReturn,
-
-  // State
-  getByA11yState: (A11yState) => GetReturn,
-  getAllByA11yState: (A11yState) => GetAllReturn,
-  queryByA11yState: (A11yState) => QueryReturn,
-  queryAllByA11yState: (A11yState) => QueryAllReturn,
-  findByA11yState: (A11yState, ?WaitForOptions) => FindReturn,
-  findAllByA11yState: (A11yState, ?WaitForOptions) => FindAllReturn,
-
-  // Value
-  getByA11yValue: (A11yValue) => GetReturn,
-  getAllByA11yValue: (A11yValue) => GetAllReturn,
-  queryByA11yValue: (A11yValue) => QueryReturn,
-  queryAllByA11yValue: (A11yValue) => QueryAllReturn,
-  findByA11yValue: (A11yValue, ?WaitForOptions) => FindReturn,
-  findAllByA11yValue: (A11yValue, ?WaitForOptions) => FindAllReturn,
-|};
-
-export function matchStringValue(
-  prop?: string,
-  matcher: string | RegExp
-): boolean {
-  if (!prop) {
-    return false;
-  }
-
-  if (typeof matcher === 'string') {
-    return prop === matcher;
-  }
-
-  return Boolean(prop.match(matcher));
-}
-
-export function matchArrayValue(
-  prop?: Array<string>,
-  matcher: string | Array<string>
-): boolean {
-  if (!prop || matcher.length === 0) {
-    return false;
-  }
-
-  if (typeof matcher === 'string') {
-    return prop.includes(matcher);
-  }
-
-  return !matcher.some((e) => !prop.includes(e));
-}
-
-export function matchObject<T: {}>(prop?: T, matcher: T): boolean {
-  return prop
-    ? Object.keys(matcher).length !== 0 &&
-        Object.keys(prop).length !== 0 &&
-        !Object.keys(matcher).some((key) => prop[key] !== matcher[key])
-    : false;
-}
-
-export const a11yAPI = (instance: ReactTestInstance): A11yAPI =>
-  ({
-    ...makeA11yQuery(
-      'accessibilityLabel',
-      {
-        getBy: ['getByA11yLabel', 'getByAccessibilityLabel', 'getByLabelText'],
-        getAllBy: [
-          'getAllByA11yLabel',
-          'getAllByAccessibilityLabel',
-          'getAllByLabelText',
-        ],
-        queryBy: [
-          'queryByA11yLabel',
-          'queryByAccessibilityLabel',
-          'queryByLabelText',
-        ],
-        queryAllBy: [
-          'queryAllByA11yLabel',
-          'queryAllByAccessibilityLabel',
-          'queryAllByLabelText',
-        ],
-        findBy: [
-          'findByA11yLabel',
-          'findByAccessibilityLabel',
-          'findByLabelText',
-        ],
-        findAllBy: [
-          'findAllByA11yLabel',
-          'findAllByAccessibilityLabel',
-          'findAllByLabelText',
-        ],
-      },
-      matchStringValue
-    )(instance),
-    ...makeA11yQuery(
-      'accessibilityHint',
-      {
-        getBy: ['getByA11yHint', 'getByAccessibilityHint', 'getByHintText'],
-        getAllBy: [
-          'getAllByA11yHint',
-          'getAllByAccessibilityHint',
-          'getAllByHintText',
-        ],
-        queryBy: [
-          'queryByA11yHint',
-          'queryByAccessibilityHint',
-          'queryByHintText',
-        ],
-        queryAllBy: [
-          'queryAllByA11yHint',
-          'queryAllByAccessibilityHint',
-          'queryAllByHintText',
-        ],
-        findBy: ['findByA11yHint', 'findByAccessibilityHint', 'findByHintText'],
-        findAllBy: [
-          'findAllByA11yHint',
-          'findAllByAccessibilityHint',
-          'findAllByHintText',
-        ],
-      },
-      matchStringValue
-    )(instance),
-    ...makeA11yQuery(
-      'accessibilityRole',
-      {
-        getBy: ['getByA11yRole', 'getByAccessibilityRole', 'getByRole'],
-        getAllBy: [
-          'getAllByA11yRole',
-          'getAllByAccessibilityRole',
-          'getAllByRole',
-        ],
-        queryBy: ['queryByA11yRole', 'queryByAccessibilityRole', 'queryByRole'],
-        queryAllBy: [
-          'queryAllByA11yRole',
-          'queryAllByAccessibilityRole',
-          'queryAllByRole',
-        ],
-        findBy: ['findByA11yRole', 'findByAccessibilityRole', 'findByRole'],
-        findAllBy: [
-          'findAllByA11yRole',
-          'findAllByAccessibilityRole',
-          'findAllByRole',
-        ],
-      },
-      matchStringValue
-    )(instance),
-    ...makeA11yQuery(
-      'accessibilityStates',
-      {
-        getBy: ['getByA11yStates', 'getByAccessibilityStates'],
-        getAllBy: ['getAllByA11yStates', 'getAllByAccessibilityStates'],
-        queryBy: ['queryByA11yStates', 'queryByAccessibilityStates'],
-        queryAllBy: ['queryAllByA11yStates', 'queryAllByAccessibilityStates'],
-        findBy: ['findByA11yStates', 'findByAccessibilityStates'],
-        findAllBy: ['findAllByA11yStates', 'findAllByAccessibilityStates'],
-      },
-      matchArrayValue
-    )(instance),
-    ...makeA11yQuery(
-      'accessibilityState',
-      {
-        getBy: ['getByA11yState', 'getByAccessibilityState'],
-        getAllBy: ['getAllByA11yState', 'getAllByAccessibilityState'],
-        queryBy: ['queryByA11yState', 'queryByAccessibilityState'],
-        queryAllBy: ['queryAllByA11yState', 'queryAllByAccessibilityState'],
-        findBy: ['findByA11yState', 'findByAccessibilityState'],
-        findAllBy: ['findAllByA11yState', 'findAllByAccessibilityState'],
-      },
-      matchObject
-    )(instance),
-    ...makeA11yQuery(
-      'accessibilityValue',
-      {
-        getBy: ['getByA11yValue', 'getByAccessibilityValue'],
-        getAllBy: ['getAllByA11yValue', 'getAllByAccessibilityValue'],
-        queryBy: ['queryByA11yValue', 'queryByAccessibilityValue'],
-        queryAllBy: ['queryAllByA11yValue', 'queryAllByAccessibilityValue'],
-        findBy: ['findByA11yValue', 'findByAccessibilityValue'],
-        findAllBy: ['findAllByA11yValue', 'findAllByAccessibilityValue'],
-      },
-      matchObject
-    )(instance),
-  }: any);

package/build/helpers/byDisplayValue.js.flow

@@ -1,66 +0,0 @@
-// @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,
-  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) &&
-      matches(value, nodeValue, normalizer, exact)
-    );
-  } catch (error) {
-    throw createLibraryNotSupportedError(error);
-  }
-};
-
-const queryAllByDisplayValue = (
-  instance: ReactTestInstance
-): ((
-  displayValue: string | RegExp,
-  queryOptions?: TextMatchOptions
-) => Array<ReactTestInstance>) =>
-  function queryAllByDisplayValueFn(displayValue, queryOptions) {
-    return instance.findAll((node) =>
-      getTextInputNodeByDisplayValue(node, displayValue, queryOptions)
-    );
-  };
-
-const getMultipleError = (displayValue: string | RegExp) =>
-  `Found multiple elements with display value: ${String(displayValue)} `;
-const getMissingError = (displayValue: string | RegExp) =>
-  `Unable to find an element with displayValue: ${String(displayValue)}`;
-
-const {
-  getBy: getByDisplayValue,
-  getAllBy: getAllByDisplayValue,
-  queryBy: queryByDisplayValue,
-  findBy: findByDisplayValue,
-  findAllBy: findAllByDisplayValue,
-}: Queries<string | RegExp> = makeQueries(
-  queryAllByDisplayValue,
-  getMissingError,
-  getMultipleError
-);
-
-export {
-  findAllByDisplayValue,
-  findByDisplayValue,
-  getAllByDisplayValue,
-  getByDisplayValue,
-  queryAllByDisplayValue,
-  queryByDisplayValue,
-};

package/build/helpers/byPlaceholderText.js.flow

@@ -1,62 +0,0 @@
-// @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,
-  options?: TextMatchOptions = {}
-) => {
-  try {
-    const { TextInput } = require('react-native');
-    const { exact, normalizer } = options;
-    return (
-      filterNodeByType(node, TextInput) &&
-      matches(placeholder, node.props.placeholder, normalizer, exact)
-    );
-  } catch (error) {
-    throw createLibraryNotSupportedError(error);
-  }
-};
-
-const queryAllByPlaceholderText = (
-  instance: ReactTestInstance
-): ((
-  placeholder: string | RegExp,
-  queryOptions?: TextMatchOptions
-) => Array<ReactTestInstance>) =>
-  function queryAllByPlaceholderFn(placeholder, queryOptions) {
-    return instance.findAll((node) =>
-      getTextInputNodeByPlaceholderText(node, placeholder, queryOptions)
-    );
-  };
-
-const getMultipleError = (placeholder) =>
-  `Found multiple elements with placeholder: ${String(placeholder)} `;
-const getMissingError = (placeholder) =>
-  `Unable to find an element with placeholder: ${String(placeholder)}`;
-
-const {
-  getBy: getByPlaceholderText,
-  getAllBy: getAllByPlaceholderText,
-  queryBy: queryByPlaceholderText,
-  findBy: findByPlaceholderText,
-  findAllBy: findAllByPlaceholderText,
-}: Queries<string | RegExp> = makeQueries(
-  queryAllByPlaceholderText,
-  getMissingError,
-  getMultipleError
-);
-
-export {
-  findAllByPlaceholderText,
-  findByPlaceholderText,
-  getAllByPlaceholderText,
-  getByPlaceholderText,
-  queryAllByPlaceholderText,
-  queryByPlaceholderText,
-};

package/build/helpers/byTestId.js.flow

@@ -1,50 +0,0 @@
-// @flow
-import { matches } from '../matches';
-import { makeQueries } from './makeQueries';
-import type { Queries } from './makeQueries';
-import type { TextMatchOptions } from './byText';
-
-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,
-  queryOptions?: TextMatchOptions
-) => Array<ReactTestInstance>) =>
-  function queryAllByTestIdFn(testId, queryOptions) {
-    const results = instance
-      .findAll((node) => getNodeByTestId(node, testId, queryOptions))
-      .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.flow

@@ -1,104 +0,0 @@
-// @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';
-
-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);
-      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);
-    }
-  });
-
-  return textContent;
-};
-
-const getNodeByText = (
-  node,
-  text: string | RegExp,
-  options?: TextMatchOptions = {}
-) => {
-  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('');
-        const { exact, normalizer } = options;
-        return matches(text, textToTest, normalizer, exact);
-      }
-    }
-    return false;
-  } catch (error) {
-    throw createLibraryNotSupportedError(error);
-  }
-};
-
-const queryAllByText = (
-  instance: ReactTestInstance
-): ((
-  text: string | RegExp,
-  queryOptions?: TextMatchOptions
-) => Array<ReactTestInstance>) =>
-  function queryAllByTextFn(text, queryOptions) {
-    const results = instance.findAll((node) =>
-      getNodeByText(node, text, queryOptions)
-    );
-
-    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.flow

@@ -1,16 +0,0 @@
-// @flow
-import format from './format';
-
-/**
- * Log pretty-printed deep test component instance
- */
-export default function debugDeep(
-  instance: ?ReactTestRendererJSON,
-  message?: string
-) {
-  if (message) {
-    console.log(`${message}\n\n`, format(instance));
-  } else {
-    console.log(format(instance));
-  }
-}

package/build/helpers/debugShallow.js.flow

@@ -1,20 +0,0 @@
-// @flow
-import * as React from 'react';
-import { shallowInternal } from '../shallow';
-import format from './format';
-
-/**
- * Log pretty-printed shallow test component instance
- */
-export default function debugShallow(
-  instance: ReactTestInstance | React.Element<any>,
-  message?: string
-) {
-  const { output } = shallowInternal(instance);
-
-  if (message) {
-    console.log(`${message}\n\n`, format(output));
-  } else {
-    console.log(format(output));
-  }
-}

package/build/helpers/errors.js.flow

@@ -1,82 +0,0 @@
-// @flow
-import prettyFormat from 'pretty-format';
-
-export class ErrorWithStack extends Error {
-  constructor(message: ?string, callsite: Function) {
-    super(message);
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, callsite);
-    }
-  }
-}
-
-export const createLibraryNotSupportedError = (error: Error): Error =>
-  new Error(
-    `Currently the only supported library to search by text is "react-native".\n\n${error.message}`
-  );
-
-export const prepareErrorMessage = (
-  error: Error,
-  name: ?string,
-  value: ?mixed
-): string => {
-  // Strip info about custom predicate
-  let errorMessage = error.message.replace(
-    / matching custom predicate[^]*/gm,
-    ''
-  );
-
-  if (name && value) {
-    errorMessage += ` with ${name} ${prettyFormat(value, { min: true })}`;
-  }
-  return errorMessage;
-};
-
-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) {
-  if (warned[functionName]) {
-    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.
-  `);
-
-  warned[functionName] = true;
-}
-
-export function throwRemovedFunctionError(
-  functionName: string,
-  docsRef: string
-) {
-  throw new Error(
-    `"${functionName}" has been removed.\n\nPlease consult: https://callstack.github.io/react-native-testing-library/docs/${docsRef}`
-  );
-}
-
-export function throwRenamedFunctionError(
-  functionName: string,
-  newFunctionName: string
-) {
-  throw new ErrorWithStack(
-    `The "${functionName}" function has been renamed to "${newFunctionName}". Please replace all occurrences.`,
-    throwRenamedFunctionError
-  );
-}

package/build/helpers/filterNodeByType.js.flow

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

package/build/helpers/findByAPI.js

@@ -1,32 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.findByAPI = void 0;
-
-var _byTestId = require("./byTestId");
-
-var _byText = require("./byText");
-
-var _byPlaceholderText = require("./byPlaceholderText");
-
-var _byDisplayValue = require("./byDisplayValue");
-
-var _errors = require("./errors");
-
-const findByAPI = 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')
-});
-
-exports.findByAPI = findByAPI;