@testing-library/react-native 9.0.0 → 10.0.0

package/typings/index.flow.js

@@ -0,0 +1,394 @@
+// @flow
+import * as React from 'react';
+
+type GetReturn = ReactTestInstance;
+type GetAllReturn = Array<ReactTestInstance>;
+type QueryReturn = ReactTestInstance | null;
+type QueryAllReturn = Array<ReactTestInstance> | [];
+type FindReturn = Promise<ReactTestInstance>;
+type FindAllReturn = Promise<ReactTestInstance[]>;
+
+type TextMatch = string | RegExp;
+
+declare type NormalizerFn = (textToNormalize: string) => string;
+declare type NormalizerConfig = {
+  trim?: boolean,
+  collapseWhitespace?: boolean,
+};
+declare type TextMatchOptions = {
+  exact?: boolean,
+  normalizer?: NormalizerFn,
+};
+declare type A11yRole =
+  | 'none'
+  | 'button'
+  | 'link'
+  | 'search'
+  | 'image'
+  | 'keyboardkey'
+  | 'text'
+  | 'adjustable'
+  | 'imagebutton'
+  | 'header'
+  | 'summary'
+  | 'alert'
+  | 'checkbox'
+  | 'combobox'
+  | 'menu'
+  | 'menubar'
+  | 'menuitem'
+  | 'progressbar'
+  | 'radio'
+  | 'radiogroup'
+  | 'scrollbar'
+  | 'spinbutton'
+  | 'switch'
+  | 'tab'
+  | 'tablist'
+  | 'timer'
+  | 'toolbar';
+
+declare type A11yState = {|
+  disabled?: boolean,
+  selected?: boolean,
+  checked?: boolean | 'mixed',
+  busy?: boolean,
+  expanded?: boolean,
+|};
+
+declare type A11yStates =
+  | 'disabled'
+  | 'selected'
+  | 'checked'
+  | 'unchecked'
+  | 'busy'
+  | 'expanded'
+  | 'collapsed'
+  | 'hasPopup';
+
+declare type A11yValue = {
+  min?: number,
+  max?: number,
+  now?: number,
+  text?: string,
+};
+
+type WaitForOptions = {
+  timeout?: number,
+  interval?: number,
+  onTimeout?: (error: mixed) => Error,
+};
+type WaitForFunction = <T = any>(
+  expectation: () => T,
+  options?: WaitForOptions
+) => Promise<T>;
+
+interface ByTextQueries {
+  getByText: (text: TextMatch, options?: TextMatchOptions) => ReactTestInstance;
+  getAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByText: (
+    name: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByText: (
+    text: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByText: (
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByText: (
+    text: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface ByTestIdQueries {
+  getByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByTestId: (
+    testID: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByTestId: (testID: TextMatch) => ReactTestInstance | null;
+  queryAllByTestId: (testID: TextMatch) => Array<ReactTestInstance> | [];
+  findByTestId: (
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByTestId: (
+    testID: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface ByDisplayValueQueries {
+  getByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByDisplayValue: (
+    value: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByDisplayValue: (
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByDisplayValue: (
+    value: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface ByPlaceholderTextQueries {
+  getByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance;
+  getAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance>;
+  queryByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => ReactTestInstance | null;
+  queryAllByPlaceholderText: (
+    placeholder: TextMatch,
+    options?: TextMatchOptions
+  ) => Array<ReactTestInstance> | [];
+  findByPlaceholderText: (
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByPlaceholderText: (
+    placeholder: TextMatch,
+    queryOptions?: TextMatchOptions,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface UnsafeByTypeQueries {
+  UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance;
+  UNSAFE_getAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance>;
+  UNSAFE_queryByType: <P>(
+    type: React.ComponentType<P>
+  ) => ReactTestInstance | null;
+  UNSAFE_queryAllByType: <P>(
+    type: React.ComponentType<P>
+  ) => Array<ReactTestInstance> | [];
+}
+
+interface UnsafeByPropsQueries {
+  UNSAFE_getByProps: (props: { [string]: any }) => ReactTestInstance;
+  UNSAFE_getAllByProps: (props: { [string]: any }) => Array<ReactTestInstance>;
+  UNSAFE_queryByProps: (props: { [string]: any }) => ReactTestInstance | null;
+  UNSAFE_queryAllByProps: (props: { [string]: any }) =>
+    | Array<ReactTestInstance>
+    | [];
+}
+interface A11yAPI {
+  // Label
+  getByLabelText: (matcher: TextMatch) => GetReturn;
+  getAllByLabelText: (matcher: TextMatch) => GetAllReturn;
+  queryByLabelText: (matcher: TextMatch) => QueryReturn;
+  queryAllByLabelText: (matcher: TextMatch) => QueryAllReturn;
+  findByLabelText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByLabelText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Hint
+  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: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findByHintText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yHint: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+  findAllByHintText: (
+    matcher: TextMatch,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Role
+  getByRole: (matcher: A11yRole | RegExp) => GetReturn;
+  getAllByRole: (matcher: A11yRole | RegExp) => GetAllReturn;
+  queryByRole: (matcher: A11yRole | RegExp) => QueryReturn;
+  queryAllByRole: (matcher: A11yRole | RegExp) => QueryAllReturn;
+  findByRole: (
+    matcher: A11yRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByRole: (
+    matcher: A11yRole | RegExp,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // States
+  getByA11yStates: (matcher: A11yStates | Array<A11yStates>) => GetReturn;
+  getAllByA11yStates: (matcher: A11yStates | Array<A11yStates>) => GetAllReturn;
+  queryByA11yStates: (matcher: A11yStates | Array<A11yStates>) => QueryReturn;
+  queryAllByA11yStates: (
+    matcher: A11yStates | Array<A11yStates>
+  ) => QueryAllReturn;
+
+  // State
+  getByA11yState: (matcher: A11yStates) => GetReturn;
+  getAllByA11yState: (matcher: A11yStates) => GetAllReturn;
+  queryByA11yState: (matcher: A11yStates) => QueryReturn;
+  queryAllByA11yState: (matcher: A11yStates) => QueryAllReturn;
+  findByA11yState: (
+    matcher: A11yStates,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yState: (
+    matcher: A11yStates,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+
+  // Value
+  getByA11yValue: (matcher: A11yValue) => GetReturn;
+  getAllByA11yValue: (matcher: A11yValue) => GetAllReturn;
+  queryByA11yValue: (matcher: A11yValue) => QueryReturn;
+  queryAllByA11yValue: (matcher: A11yValue) => QueryAllReturn;
+  findByA11yValue: (
+    matcher: A11yValue,
+    waitForOptions?: WaitForOptions
+  ) => FindReturn;
+  findAllByA11yValue: (
+    matcher: A11yValue,
+    waitForOptions?: WaitForOptions
+  ) => FindAllReturn;
+}
+
+interface Thenable {
+  then: (resolve: () => any, reject?: () => any) => any;
+}
+
+interface RenderOptions {
+  wrapper?: React.ComponentType<any>;
+  createNodeMock?: (element: React.Element<any>) => any;
+}
+
+type Debug = {
+  (message?: string): void,
+  shallow: (message?: string) => void,
+};
+
+type Queries = ByTextQueries &
+  ByTestIdQueries &
+  ByDisplayValueQueries &
+  ByPlaceholderTextQueries &
+  UnsafeByTypeQueries &
+  UnsafeByPropsQueries &
+  A11yAPI;
+
+interface RenderAPI extends Queries {
+  update(nextElement: React.Element<any>): void;
+  rerender(nextElement: React.Element<any>): void;
+  unmount(nextElement?: React.Element<any>): void;
+  toJSON(): ReactTestRendererJSON[] | ReactTestRendererJSON | null;
+  debug: Debug;
+  container: ReactTestInstance;
+}
+
+type FireEventFunction = (
+  element: ReactTestInstance,
+  eventName: string,
+  ...data: Array<any>
+) => any;
+
+type FireEventAPI = FireEventFunction & {
+  press: (element: ReactTestInstance, ...data: Array<any>) => any,
+  changeText: (element: ReactTestInstance, ...data: Array<any>) => any,
+  scroll: (element: ReactTestInstance, ...data: Array<any>) => any,
+};
+
+type RenderHookResult<Result, Props> = {
+  rerender: (props: Props) => void,
+  result: { current: Result },
+  unmount: () => void,
+};
+
+type RenderHookOptions<Props> = {
+  initialProps?: Props,
+  wrapper?: React.ComponentType<any>,
+};
+
+declare module '@testing-library/react-native' {
+  declare export var render: (
+    component: React.Element<any>,
+    options?: RenderOptions
+  ) => RenderAPI;
+
+  declare export var cleanup: () => void;
+  declare export var fireEvent: FireEventAPI;
+
+  declare export var waitFor: WaitForFunction;
+
+  declare type WaitForElementToBeRemovedFunction = <T = any>(
+    expectation: () => T,
+    options?: WaitForOptions
+  ) => Promise<T>;
+
+  declare export var waitForElementToBeRemoved: WaitForElementToBeRemovedFunction;
+
+  declare export var act: (callback: () => void) => Thenable;
+  declare export var within: (instance: ReactTestInstance) => Queries;
+  declare export var getQueriesForElement: (
+    instance: ReactTestInstance
+  ) => Queries;
+
+  declare export var getDefaultNormalizer: (
+    normalizerConfig?: NormalizerConfig
+  ) => NormalizerFn;
+
+  declare type RenderHookFunction = <Result, Props>(
+    renderCallback: (props: Props) => Result,
+    options?: RenderHookOptions<Props>
+  ) => RenderHookResult<Result, Props>;
+
+  declare export var renderHook: RenderHookFunction;
+}

package/build/act.js.flow

@@ -1,9 +0,0 @@
-// @flow
-import { act } from 'react-test-renderer';
-import type { Thenable } from './types.flow';
-
-const actMock = (callback: () => void) => {
-  callback();
-};
-
-export default (act || actMock: (callback: () => void) => Thenable);

package/build/cleanup.js.flow

@@ -1,13 +0,0 @@
-// @flow
-let cleanupQueue = new Set();
-
-export default function cleanup() {
-  cleanupQueue.forEach((fn) => fn());
-  cleanupQueue.clear();
-}
-
-export function addToCleanupQueue(
-  fn: (nextElement?: React$Element<any>) => void
-) {
-  cleanupQueue.add(fn);
-}

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