@testing-library/react-native 12.1.2 → 12.2.0

package/src/helpers/matchers/matchStringProp.ts

@@ -0,0 +1,23 @@
+import { TextMatch } from '../../matches';
+
+/**
+ * Matches the given string property again string or regex matcher.
+ *
+ * @param prop - The string prop to match.
+ * @param matcher - The string or regex to match.
+ * @returns - Whether the string prop matches the given string or regex.
+ */
+export function matchStringProp(
+  prop: string | undefined,
+  matcher: TextMatch
+): boolean {
+  if (!prop) {
+    return false;
+  }
+
+  if (typeof matcher === 'string') {
+    return prop === matcher;
+  }
+
+  return prop.match(matcher) != null;
+}

package/src/helpers/matchers/matchTextContent.ts

@@ -0,0 +1,20 @@
+import type { ReactTestInstance } from 'react-test-renderer';
+import { matches, TextMatch, TextMatchOptions } from '../../matches';
+import { getTextContent } from '../getTextContent';
+
+/**
+ * Matches the given node's text content against string or regex matcher.
+ *
+ * @param node - Node which text content will be matched
+ * @param text - The string or regex to match.
+ * @returns - Whether the node's text content matches the given string or regex.
+ */
+export function matchTextContent(
+  node: ReactTestInstance,
+  text: TextMatch,
+  options: TextMatchOptions = {}
+) {
+  const textContent = getTextContent(node);
+  const { exact, normalizer } = options;
+  return matches(text, textContent, normalizer, exact);
+}

package/src/helpers/pointer-events.ts

@@ -0,0 +1,27 @@
+import { ReactTestInstance } from 'react-test-renderer';
+import { getHostParent } from './component-tree';
+
+/**
+ * pointerEvents controls whether the View can be the target of touch events.
+ * 'auto': The View and its children can be the target of touch events.
+ * 'none': The View is never the target of touch events.
+ * 'box-none': The View is never the target of touch events but its subviews can be
+ * 'box-only': The view can be the target of touch events but its subviews cannot be
+ * see the official react native doc https://reactnative.dev/docs/view#pointerevents */
+export const isPointerEventEnabled = (
+  element: ReactTestInstance,
+  isParent?: boolean
+): boolean => {
+  const parentCondition = isParent
+    ? element?.props.pointerEvents === 'box-only'
+    : element?.props.pointerEvents === 'box-none';
+
+  if (element?.props.pointerEvents === 'none' || parentCondition) {
+    return false;
+  }
+
+  const hostParent = getHostParent(element);
+  if (!hostParent) return true;
+
+  return isPointerEventEnabled(hostParent, true);
+};

package/src/helpers/query-name.ts

@@ -0,0 +1,4 @@
+export function getQueryPrefix(queryName: string) {
+  const parts = queryName.split('By');
+  return parts[0];
+}

package/src/helpers/stringValidation.ts

@@ -0,0 +1,36 @@
+import { ReactTestRendererNode } from 'react-test-renderer';
+
+export const validateStringsRenderedWithinText = (
+  rendererJSON: ReactTestRendererNode | Array<ReactTestRendererNode> | null
+) => {
+  if (!rendererJSON) return;
+
+  if (Array.isArray(rendererJSON)) {
+    rendererJSON.forEach(validateStringsRenderedWithinTextForNode);
+    return;
+  }
+
+  return validateStringsRenderedWithinTextForNode(rendererJSON);
+};
+
+const validateStringsRenderedWithinTextForNode = (
+  node: ReactTestRendererNode
+) => {
+  if (typeof node === 'string') {
+    return;
+  }
+
+  if (node.type !== 'Text') {
+    node.children?.forEach((child) => {
+      if (typeof child === 'string') {
+        throw new Error(
+          `Invariant Violation: Text strings must be rendered within a <Text> component. Detected attempt to render "${child}" string within a <${node.type}> component.`
+        );
+      }
+    });
+  }
+
+  if (node.children) {
+    node.children.forEach(validateStringsRenderedWithinTextForNode);
+  }
+};

package/src/helpers/timers.ts

@@ -0,0 +1,98 @@
+// Most content of this file sourced directly from https://github.com/testing-library/dom-testing-library/blob/main/src/helpers.js
+/* globals jest */
+const globalObj = typeof window === 'undefined' ? global : window;
+
+type FakeTimersTypes = 'modern' | 'legacy';
+
+// Currently this fn only supports jest timers, but it could support other test runners in the future.
+function runWithRealTimers<T>(callback: () => T): T {
+  const fakeTimersType = getJestFakeTimersType();
+  if (fakeTimersType) {
+    jest.useRealTimers();
+  }
+
+  const callbackReturnValue = callback();
+
+  if (fakeTimersType) {
+    const fakeTimersConfig = getFakeTimersConfigFromType(fakeTimersType);
+    jest.useFakeTimers(fakeTimersConfig);
+  }
+
+  return callbackReturnValue;
+}
+
+function getJestFakeTimersType(): FakeTimersTypes | null {
+  // istanbul ignore if
+  if (
+    typeof jest === 'undefined' ||
+    typeof globalObj.setTimeout === 'undefined' ||
+    process.env.RNTL_SKIP_AUTO_DETECT_FAKE_TIMERS
+  ) {
+    return null;
+  }
+
+  if (
+    // @ts-expect-error jest mutates setTimeout
+    typeof globalObj.setTimeout._isMockFunction !== 'undefined' &&
+    // @ts-expect-error jest mutates setTimeout
+    globalObj.setTimeout._isMockFunction
+  ) {
+    return 'legacy';
+  }
+
+  if (
+    // @ts-expect-error jest mutates setTimeout
+    typeof globalObj.setTimeout.clock !== 'undefined' &&
+    typeof jest.getRealSystemTime !== 'undefined'
+  ) {
+    try {
+      // jest.getRealSystemTime is only supported for Jest's `modern` fake timers and otherwise throws
+      jest.getRealSystemTime();
+      return 'modern';
+    } catch {
+      // not using Jest's modern fake timers
+    }
+  }
+
+  return null;
+}
+
+function getFakeTimersConfigFromType(type: FakeTimersTypes) {
+  return type === 'legacy'
+    ? { legacyFakeTimers: true }
+    : { legacyFakeTimers: false };
+}
+
+const jestFakeTimersAreEnabled = (): boolean =>
+  Boolean(getJestFakeTimersType());
+
+// we only run our tests in node, and setImmediate is supported in node.
+function setImmediatePolyfill(fn: Function) {
+  return globalObj.setTimeout(fn, 0);
+}
+
+type BindTimeFunctions = {
+  clearTimeoutFn: typeof clearTimeout;
+  setImmediateFn: typeof setImmediate;
+  setTimeoutFn: typeof setTimeout;
+};
+
+function bindTimeFunctions(): BindTimeFunctions {
+  return {
+    clearTimeoutFn: globalObj.clearTimeout,
+    setImmediateFn: globalObj.setImmediate || setImmediatePolyfill,
+    setTimeoutFn: globalObj.setTimeout,
+  };
+}
+
+const { clearTimeoutFn, setImmediateFn, setTimeoutFn } = runWithRealTimers(
+  bindTimeFunctions
+) as BindTimeFunctions;
+
+export {
+  runWithRealTimers,
+  jestFakeTimersAreEnabled,
+  clearTimeoutFn as clearTimeout,
+  setImmediateFn as setImmediate,
+  setTimeoutFn as setTimeout,
+};

package/src/index.ts

@@ -0,0 +1,33 @@
+import { cleanup } from './pure';
+import { flushMicroTasksLegacy } from './flush-micro-tasks';
+import { getIsReactActEnvironment, setReactActEnvironment } from './act';
+
+if (typeof process === 'undefined' || !process.env?.RNTL_SKIP_AUTO_CLEANUP) {
+  // If we're running in a test runner that supports afterEach
+  // then we'll automatically run cleanup afterEach test
+  // this ensures that tests run in isolation from each other
+  // if you don't like this then either import the `pure` module
+  // or set the RNTL_SKIP_AUTO_CLEANUP env variable to 'true'.
+  if (typeof afterEach === 'function') {
+    // eslint-disable-next-line no-undef
+    afterEach(async () => {
+      await flushMicroTasksLegacy();
+      cleanup();
+    });
+  }
+
+  if (typeof beforeAll === 'function' && typeof afterAll === 'function') {
+    // This matches the behavior of React < 18.
+    let previousIsReactActEnvironment = getIsReactActEnvironment();
+    beforeAll(() => {
+      previousIsReactActEnvironment = getIsReactActEnvironment();
+      setReactActEnvironment(true);
+    });
+
+    afterAll(() => {
+      setReactActEnvironment(previousIsReactActEnvironment);
+    });
+  }
+}
+
+export * from './pure';

package/src/matches.ts

@@ -0,0 +1,49 @@
+export type NormalizerFn = (textToNormalize: string) => string;
+
+export type TextMatch = string | RegExp;
+export type TextMatchOptions = {
+  exact?: boolean;
+  normalizer?: NormalizerFn;
+};
+
+export function matches(
+  matcher: TextMatch,
+  text: string,
+  normalizer: NormalizerFn = getDefaultNormalizer(),
+  exact: boolean = true
+): boolean {
+  if (typeof text !== 'string') {
+    return false;
+  }
+
+  const normalizedText = normalizer(text);
+  if (typeof matcher === 'string') {
+    const normalizedMatcher = normalizer(matcher);
+    return exact
+      ? normalizedText === normalizedMatcher
+      : normalizedText.toLowerCase().includes(normalizedMatcher.toLowerCase());
+  } else {
+    // Reset state for global regexes: https://stackoverflow.com/a/1520839/484499
+    matcher.lastIndex = 0;
+    return matcher.test(normalizedText);
+  }
+}
+
+type NormalizerConfig = {
+  trim?: boolean;
+  collapseWhitespace?: boolean;
+};
+
+export function getDefaultNormalizer({
+  trim = true,
+  collapseWhitespace = true,
+}: NormalizerConfig = {}): NormalizerFn {
+  return (text: string) => {
+    let normalizedText = text;
+    normalizedText = trim ? normalizedText.trim() : normalizedText;
+    normalizedText = collapseWhitespace
+      ? normalizedText.replace(/\s+/g, ' ')
+      : normalizedText;
+    return normalizedText;
+  };
+}

package/src/pure.ts

@@ -0,0 +1,27 @@
+export { default as act } from './act';
+export { default as cleanup } from './cleanup';
+export { default as fireEvent } from './fireEvent';
+export { default as render } from './render';
+export { default as waitFor } from './waitFor';
+export { default as waitForElementToBeRemoved } from './waitForElementToBeRemoved';
+export { within, getQueriesForElement } from './within';
+
+export { configure, resetToDefaults } from './config';
+export {
+  isHiddenFromAccessibility,
+  isInaccessible,
+} from './helpers/accessiblity';
+export { getDefaultNormalizer } from './matches';
+export { renderHook } from './renderHook';
+export { screen } from './screen';
+export { userEvent } from './user-event';
+
+export type {
+  RenderOptions,
+  RenderResult,
+  RenderResult as RenderAPI,
+  DebugFunction,
+} from './render';
+export type { RenderHookOptions, RenderHookResult } from './renderHook';
+export type { Config } from './config';
+export type { UserEventConfig } from './user-event';