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

package/build/fireEvent.js.flow

@@ -1,127 +0,0 @@
-// @flow
-import act from './act';
-
-const isHostElement = (element?: ReactTestInstance) => {
-  return typeof element?.type === 'string';
-};
-
-const isTextInput = (element?: ReactTestInstance) => {
-  const { TextInput } = require('react-native');
-  return element?.type === TextInput;
-};
-
-const isTouchResponder = (element?: ReactTestInstance) => {
-  if (!isHostElement(element)) return false;
-
-  return !!element?.props.onStartShouldSetResponder || isTextInput(element);
-};
-
-const isPointerEventEnabled = (
-  element?: ReactTestInstance,
-  isParent?: boolean
-) => {
-  const parentCondition = isParent
-    ? element?.props.pointerEvents === 'box-only'
-    : element?.props.pointerEvents === 'box-none';
-
-  if (element?.props.pointerEvents === 'none' || parentCondition) {
-    return false;
-  }
-
-  if (!element?.parent) return true;
-
-  return isPointerEventEnabled(element.parent, true);
-};
-
-const isEventEnabled = (
-  element?: ReactTestInstance,
-  touchResponder?: ReactTestInstance
-) => {
-  if (isTextInput(element)) return element?.props.editable !== false;
-  if (!isPointerEventEnabled(element)) return false;
-
-  const touchStart = touchResponder?.props.onStartShouldSetResponder?.();
-  const touchMove = touchResponder?.props.onMoveShouldSetResponder?.();
-
-  if (touchStart || touchMove) return true;
-
-  return touchStart === undefined && touchMove === undefined;
-};
-
-const findEventHandler = (
-  element: ReactTestInstance,
-  eventName: string,
-  callsite?: any,
-  nearestTouchResponder?: ReactTestInstance
-) => {
-  const touchResponder = isTouchResponder(element)
-    ? element
-    : nearestTouchResponder;
-
-  const handler = getEventHandler(element, eventName);
-  if (handler && isEventEnabled(element, touchResponder)) return handler;
-
-  if (element.parent === null || element.parent.parent === null) {
-    return null;
-  }
-
-  return findEventHandler(element.parent, eventName, callsite, touchResponder);
-};
-
-const getEventHandler = (element: ReactTestInstance, eventName: string) => {
-  const eventHandlerName = toEventHandlerName(eventName);
-  if (typeof element.props[eventHandlerName] === 'function') {
-    return element.props[eventHandlerName];
-  }
-
-  if (typeof element.props[eventName] === 'function') {
-    return element.props[eventName];
-  }
-
-  return undefined;
-};
-
-const invokeEvent = (
-  element: ReactTestInstance,
-  eventName: string,
-  callsite?: any,
-  ...data: Array<any>
-) => {
-  const handler = findEventHandler(element, eventName, callsite);
-
-  if (!handler) {
-    return;
-  }
-
-  let returnValue;
-
-  act(() => {
-    returnValue = handler(...data);
-  });
-
-  return returnValue;
-};
-
-const toEventHandlerName = (eventName: string) =>
-  `on${eventName.charAt(0).toUpperCase()}${eventName.slice(1)}`;
-
-const pressHandler = (element: ReactTestInstance, ...data: Array<any>): void =>
-  invokeEvent(element, 'press', pressHandler, ...data);
-const changeTextHandler = (
-  element: ReactTestInstance,
-  ...data: Array<any>
-): void => invokeEvent(element, 'changeText', changeTextHandler, ...data);
-const scrollHandler = (element: ReactTestInstance, ...data: Array<any>): void =>
-  invokeEvent(element, 'scroll', scrollHandler, ...data);
-
-const fireEvent = (
-  element: ReactTestInstance,
-  eventName: string,
-  ...data: Array<any>
-): void => invokeEvent(element, eventName, fireEvent, ...data);
-
-fireEvent.press = pressHandler;
-fireEvent.changeText = changeTextHandler;
-fireEvent.scroll = scrollHandler;
-
-export default fireEvent;

package/build/flushMicroTasks.js.flow

@@ -1,23 +0,0 @@
-// @flow
-import { printDeprecationWarning } from './helpers/errors';
-import { setImmediate } from './helpers/timers';
-
-type Thenable<T> = { then: (() => T) => mixed };
-
-/**
- * Wait for microtasks queue to flush
- */
-export default function flushMicrotasksQueue<T>(): Thenable<T> {
-  printDeprecationWarning('flushMicrotasksQueue');
-  return flushMicroTasks();
-}
-
-export function flushMicroTasks<T>(): Thenable<T> {
-  return {
-    // using "thenable" instead of a Promise, because otherwise it breaks when
-    // using "modern" fake timers
-    then(resolve) {
-      setImmediate(resolve);
-    },
-  };
-}

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