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

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.flow

@@ -1,76 +0,0 @@
-// @flow
-import type { WaitForOptions } from '../waitFor';
-import type { TextMatchOptions } from './byText';
-import { findAllByTestId, findByTestId } from './byTestId';
-import { findAllByText, findByText } from './byText';
-import {
-  findAllByPlaceholderText,
-  findByPlaceholderText,
-} from './byPlaceholderText';
-import { findAllByDisplayValue, findByDisplayValue } from './byDisplayValue';
-import { throwRenamedFunctionError } from './errors';
-
-export type FindByAPI = {|
-  findAllByDisplayValue: (
-    value: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<Array<ReactTestInstance>>,
-  findAllByPlaceholder: () => void,
-  findAllByPlaceholderText: (
-    placeholder: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<Array<ReactTestInstance>>,
-  findAllByTestId: (
-    testId: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<Array<ReactTestInstance>>,
-  findAllByText: (
-    text: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<Array<ReactTestInstance>>,
-  findByDisplayValue: (
-    value: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<ReactTestInstance>,
-  findByPlaceholder: () => void,
-  findByPlaceholderText: (
-    placeholder: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<ReactTestInstance>,
-  findByTestId: (
-    testId: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<ReactTestInstance>,
-  findByText: (
-    text: string | RegExp,
-    queryOptions?: TextMatchOptions & WaitForOptions,
-    waitForOptions?: WaitForOptions
-  ) => Promise<ReactTestInstance>,
-|};
-
-export const findByAPI = (instance: ReactTestInstance): FindByAPI => ({
-  findByTestId: findByTestId(instance),
-  findByText: findByText(instance),
-  findByPlaceholderText: findByPlaceholderText(instance),
-  findByDisplayValue: findByDisplayValue(instance),
-  findAllByTestId: findAllByTestId(instance),
-  findAllByText: findAllByText(instance),
-  findAllByPlaceholderText: findAllByPlaceholderText(instance),
-  findAllByDisplayValue: findAllByDisplayValue(instance),
-
-  // Renamed
-  findByPlaceholder: () =>
-    throwRenamedFunctionError('findByPlaceholder', 'findByPlaceholderText'),
-  findAllByPlaceholder: () =>
-    throwRenamedFunctionError(
-      'findAllByPlaceholder',
-      'findAllByPlaceholderText'
-    ),
-});

package/build/helpers/format.js.flow

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

package/build/helpers/getByAPI.js.flow

@@ -1,157 +0,0 @@
-// @flow
-import * as React from 'react';
-import prettyFormat from 'pretty-format';
-import {
-  ErrorWithStack,
-  prepareErrorMessage,
-  throwRemovedFunctionError,
-  throwRenamedFunctionError,
-} from './errors';
-import { getAllByTestId, getByTestId } from './byTestId';
-import { getAllByText, getByText } from './byText';
-import {
-  getAllByPlaceholderText,
-  getByPlaceholderText,
-} from './byPlaceholderText';
-import { getAllByDisplayValue, getByDisplayValue } from './byDisplayValue';
-import type { TextMatchOptions } from './byText';
-
-export type GetByAPI = {|
-  getByText: (
-    text: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => ReactTestInstance,
-  getByPlaceholderText: (
-    placeholder: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => ReactTestInstance,
-  getByDisplayValue: (
-    value: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => ReactTestInstance,
-  getByTestId: (
-    testID: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => ReactTestInstance,
-  getAllByTestId: (
-    testID: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => Array<ReactTestInstance>,
-  getAllByText: (
-    text: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => Array<ReactTestInstance>,
-  getAllByPlaceholderText: (
-    placeholder: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => Array<ReactTestInstance>,
-  getAllByDisplayValue: (
-    value: string | RegExp,
-    queryOptions?: TextMatchOptions
-  ) => Array<ReactTestInstance>,
-
-  // Unsafe aliases
-  UNSAFE_getByType: <P>(type: React.ComponentType<P>) => ReactTestInstance,
-  UNSAFE_getAllByType: <P>(
-    type: React.ComponentType<P>
-  ) => Array<ReactTestInstance>,
-  UNSAFE_getByProps: (props: { [string]: any }) => ReactTestInstance,
-  UNSAFE_getAllByProps: (props: { [string]: any }) => Array<ReactTestInstance>,
-
-  getByName: () => void,
-  getByType: () => void,
-  getByProps: () => void,
-  getAllByName: () => void,
-  getAllByType: () => void,
-  getAllByProps: () => void,
-
-  getByPlaceholder: () => void,
-  getAllByPlaceholder: () => void,
-|};
-
-export const UNSAFE_getByType = (
-  instance: ReactTestInstance
-): ((type: React.ComponentType<any>) => ReactTestInstance) =>
-  function getByTypeFn(type: React.ComponentType<any>) {
-    try {
-      return instance.findByType(type);
-    } catch (error) {
-      throw new ErrorWithStack(prepareErrorMessage(error), getByTypeFn);
-    }
-  };
-
-export const UNSAFE_getByProps = (
-  instance: ReactTestInstance
-): ((props: { [propName: string]: any }) => ReactTestInstance) =>
-  function getByPropsFn(props: { [propName: string]: any }) {
-    try {
-      return instance.findByProps(props);
-    } catch (error) {
-      throw new ErrorWithStack(prepareErrorMessage(error), getByPropsFn);
-    }
-  };
-
-export const UNSAFE_getAllByType = (
-  instance: ReactTestInstance
-): ((type: React.ComponentType<any>) => Array<ReactTestInstance>) =>
-  function getAllByTypeFn(type: React.ComponentType<any>) {
-    const results = instance.findAllByType(type);
-    if (results.length === 0) {
-      throw new ErrorWithStack('No instances found', getAllByTypeFn);
-    }
-    return results;
-  };
-
-export const UNSAFE_getAllByProps = (
-  instance: ReactTestInstance
-): ((props: { [propName: string]: any }) => Array<ReactTestInstance>) =>
-  function getAllByPropsFn(props: { [propName: string]: any }) {
-    const results = instance.findAllByProps(props);
-    if (results.length === 0) {
-      throw new ErrorWithStack(
-        `No instances found with props:\n${prettyFormat(props)}`,
-        getAllByPropsFn
-      );
-    }
-    return results;
-  };
-
-export const getByAPI = (instance: ReactTestInstance): GetByAPI => ({
-  getByText: getByText(instance),
-  getByPlaceholderText: getByPlaceholderText(instance),
-  getByDisplayValue: getByDisplayValue(instance),
-  getByTestId: getByTestId(instance),
-  getAllByText: getAllByText(instance),
-  getAllByPlaceholderText: getAllByPlaceholderText(instance),
-  getAllByDisplayValue: getAllByDisplayValue(instance),
-  getAllByTestId: getAllByTestId(instance),
-
-  // Unsafe
-  UNSAFE_getByType: UNSAFE_getByType(instance),
-  UNSAFE_getAllByType: UNSAFE_getAllByType(instance),
-  UNSAFE_getByProps: UNSAFE_getByProps(instance),
-  UNSAFE_getAllByProps: UNSAFE_getAllByProps(instance),
-
-  // Removed
-  getByName: () =>
-    throwRemovedFunctionError('getByName', 'migration-v2#removed-functions'),
-  getAllByName: () =>
-    throwRemovedFunctionError('getAllByName', 'migration-v2#removed-functions'),
-  getByType: () =>
-    throwRemovedFunctionError('getByType', 'migration-v2#removed-functions'),
-  getAllByType: () =>
-    throwRemovedFunctionError('getAllByType', 'migration-v2#removed-functions'),
-  getByProps: () =>
-    throwRemovedFunctionError('getByProps', 'migration-v2#removed-functions'),
-  getAllByProps: () =>
-    throwRemovedFunctionError(
-      'getAllByProps',
-      'migration-v2#removed-functions'
-    ),
-
-  // Renamed
-  getByPlaceholder: () =>
-    throwRenamedFunctionError('getByPlaceholder', 'getByPlaceholderText'),
-  getAllByPlaceholder: () =>
-    throwRenamedFunctionError('getAllByPlaceholder', 'getByPlaceholderText'),
-});

package/build/helpers/makeA11yQuery.js.flow

@@ -1,98 +0,0 @@
-// @flow
-import waitFor from '../waitFor';
-import type { WaitForOptions } from '../waitFor';
-import {
-  ErrorWithStack,
-  prepareErrorMessage,
-  createQueryByError,
-} from './errors';
-
-function isNodeValid(node: ReactTestInstance) {
-  return typeof node.type === 'string';
-}
-
-function makeAliases(aliases: Array<string>, query: Function) {
-  return aliases
-    .map((alias) => ({ [alias]: query }))
-    .reduce((acc, query) => ({ ...acc, ...query }), {});
-}
-
-type QueryNames = {
-  getBy: Array<string>,
-  getAllBy: Array<string>,
-  queryBy: Array<string>,
-  queryAllBy: Array<string>,
-  findBy: Array<string>,
-  findAllBy: Array<string>,
-};
-
-const makeA11yQuery = <P: mixed, M: mixed>(
-  name: string,
-  queryNames: QueryNames,
-  matcherFn: (prop: P, value: M) => boolean
-): ((instance: ReactTestInstance) => { ... }) => (
-  instance: ReactTestInstance
-) => {
-  const getBy = (matcher: M) => {
-    try {
-      return instance.find(
-        (node) => isNodeValid(node) && matcherFn(node.props[name], matcher)
-      );
-    } catch (error) {
-      throw new ErrorWithStack(
-        prepareErrorMessage(error, name, matcher),
-        getBy
-      );
-    }
-  };
-
-  const getAllBy = (matcher: M) => {
-    const results = instance.findAll(
-      (node) => isNodeValid(node) && matcherFn(node.props[name], matcher)
-    );
-
-    if (results.length === 0) {
-      throw new ErrorWithStack(
-        prepareErrorMessage(new Error('No instances found'), name, matcher),
-        getAllBy
-      );
-    }
-
-    return results;
-  };
-
-  const queryBy = (matcher: M) => {
-    try {
-      return getBy(matcher);
-    } catch (error) {
-      return createQueryByError(error, queryBy);
-    }
-  };
-
-  const queryAllBy = (matcher: M) => {
-    try {
-      return getAllBy(matcher);
-    } catch (error) {
-      return [];
-    }
-  };
-
-  const findBy = (matcher: M, waitForOptions?: WaitForOptions) => {
-    return waitFor(() => getBy(matcher), waitForOptions);
-  };
-
-  const findAllBy = (matcher: M, waitForOptions?: WaitForOptions) => {
-    return waitFor(() => getAllBy(matcher), waitForOptions);
-  };
-
-  return {
-    ...makeAliases(queryNames.getBy, getBy),
-    ...makeAliases(queryNames.getAllBy, getAllBy),
-    ...makeAliases(queryNames.queryBy, queryBy),
-    ...makeAliases(queryNames.queryAllBy, queryAllBy),
-    ...makeAliases(queryNames.findBy, findBy),
-    ...makeAliases(queryNames.findAllBy, findAllBy),
-  };
-};
-
-export default makeA11yQuery;

package/build/helpers/makeQueries.js.flow

@@ -1,165 +0,0 @@
-// @flow
-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, queryOptions?: TextMatchOptions) => ReturnType;
-
-type FindQueryFunction<ArgType, ReturnType> = (
-  instance: ReactTestInstance
-) => (
-  args: ArgType,
-  queryOptions?: TextMatchOptions & WaitForOptions,
-  waitForOptions?: WaitForOptions
-) => Promise<ReturnType>;
-
-type QueryAllByQuery<QueryArg> = QueryFunction<
-  QueryArg,
-  Array<ReactTestInstance>
->;
-type QueryByQuery<QueryArg> = QueryFunction<QueryArg, null | ReactTestInstance>;
-
-type GetAllByQuery<QueryArg> = QueryFunction<
-  QueryArg,
-  Array<ReactTestInstance>
->;
-type GetByQuery<QueryArg> = QueryFunction<QueryArg, ReactTestInstance>;
-
-type FindAllByQuery<QueryArg> = FindQueryFunction<
-  QueryArg,
-  Array<ReactTestInstance>
->;
-type FindByQuery<QueryArg> = FindQueryFunction<QueryArg, ReactTestInstance>;
-
-export type Queries<QueryArg> = {
-  getBy: GetByQuery<QueryArg>,
-  getAllBy: GetAllByQuery<QueryArg>,
-  queryBy: QueryByQuery<QueryArg>,
-  findBy: FindByQuery<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, queryOptions?: TextMatchOptions) {
-      const results = queryAllByQuery(instance)(args, queryOptions);
-
-      if (results.length === 0) {
-        throw new ErrorWithStack(getMissingError(args), getAllFn);
-      }
-
-      return results;
-    };
-  }
-
-  function queryByQuery(instance: ReactTestInstance) {
-    return function singleQueryFn(
-      args: QueryArg,
-      queryOptions?: TextMatchOptions
-    ) {
-      const results = queryAllByQuery(instance)(args, queryOptions);
-
-      if (results.length > 1) {
-        throw new ErrorWithStack(getMultipleError(args), singleQueryFn);
-      }
-
-      if (results.length === 0) {
-        return null;
-      }
-
-      return results[0];
-    };
-  }
-
-  function getByQuery(instance: ReactTestInstance) {
-    return function getFn(args: QueryArg, queryOptions?: TextMatchOptions) {
-      const results = queryAllByQuery(instance)(args, queryOptions);
-
-      if (results.length > 1) {
-        throw new ErrorWithStack(getMultipleError(args), getFn);
-      }
-
-      if (results.length === 0) {
-        throw new ErrorWithStack(getMissingError(args), getFn);
-      }
-
-      return results[0];
-    };
-  }
-
-  function findAllByQuery(instance: ReactTestInstance) {
-    return function findAllFn(
-      args: QueryArg,
-      queryOptions?: TextMatchOptions & WaitForOptions,
-      waitForOptions?: 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 = {}
-    ) {
-      const deprecatedWaitForOptions = extractDeprecatedWaitForOptionUsage(
-        queryOptions
-      );
-      return waitFor(() => getByQuery(instance)(args, queryOptions), {
-        ...deprecatedWaitForOptions,
-        ...waitForOptions,
-      });
-    };
-  }
-
-  return {
-    getBy: getByQuery,
-    getAllBy: getAllByQuery,
-    queryBy: queryByQuery,
-    findBy: findByQuery,
-    findAllBy: findAllByQuery,
-  };
-}