chore: fix remaining tests, disable not relevant ones

mdjastrzebski · mdjastrzebski · commit 50ad609a94e0 · 2024-10-15T12:58:30.000+02:00
diff --git a/src/__tests__/render.test.tsx b/src/__tests__/render.test.tsx
@@ -74,41 +74,41 @@ class Banana extends React.Component<any, { fresh: boolean }> {
   }
 }
 
-test('UNSAFE_getAllByType, UNSAFE_queryAllByType', () => {
-  render(<Banana />);
-  const [text, status, button] = screen.UNSAFE_getAllByType(Text);
-  const InExistent = () => null;
-
-  expect(text.props.children).toBe('Is the banana fresh?');
-  expect(status.props.children).toBe('not fresh');
-  expect(button.props.children).toBe('Change freshness!');
-  expect(() => screen.UNSAFE_getAllByType(InExistent)).toThrow('No instances found');
-
-  expect(screen.UNSAFE_queryAllByType(Text)[1]).toBe(status);
-  expect(screen.UNSAFE_queryAllByType(InExistent)).toHaveLength(0);
-});
+// test('UNSAFE_getAllByType, UNSAFE_queryAllByType', () => {
+//   render(<Banana />);
+//   const [text, status, button] = screen.UNSAFE_getAllByType(Text);
+//   const InExistent = () => null;
 
-test('UNSAFE_getByProps, UNSAFE_queryByProps', () => {
-  render(<Banana />);
-  const primaryType = screen.UNSAFE_getByProps({ type: 'primary' });
+//   expect(text.props.children).toBe('Is the banana fresh?');
+//   expect(status.props.children).toBe('not fresh');
+//   expect(button.props.children).toBe('Change freshness!');
+//   expect(() => screen.UNSAFE_getAllByType(InExistent)).toThrow('No instances found');
 
-  expect(primaryType.props.children).toBe('Change freshness!');
-  expect(() => screen.UNSAFE_getByProps({ type: 'inexistent' })).toThrow('No instances found');
+//   expect(screen.UNSAFE_queryAllByType(Text)[1]).toBe(status);
+//   expect(screen.UNSAFE_queryAllByType(InExistent)).toHaveLength(0);
+// });
 
-  expect(screen.UNSAFE_queryByProps({ type: 'primary' })).toBe(primaryType);
-  expect(screen.UNSAFE_queryByProps({ type: 'inexistent' })).toBeNull();
-});
+// test('UNSAFE_getByProps, UNSAFE_queryByProps', () => {
+//   render(<Banana />);
+//   const primaryType = screen.UNSAFE_getByProps({ type: 'primary' });
 
-test('UNSAFE_getAllByProp, UNSAFE_queryAllByProps', () => {
-  render(<Banana />);
-  const primaryTypes = screen.UNSAFE_getAllByProps({ type: 'primary' });
+//   expect(primaryType.props.children).toBe('Change freshness!');
+//   expect(() => screen.UNSAFE_getByProps({ type: 'inexistent' })).toThrow('No instances found');
 
-  expect(primaryTypes).toHaveLength(1);
-  expect(() => screen.UNSAFE_getAllByProps({ type: 'inexistent' })).toThrow('No instances found');
+//   expect(screen.UNSAFE_queryByProps({ type: 'primary' })).toBe(primaryType);
+//   expect(screen.UNSAFE_queryByProps({ type: 'inexistent' })).toBeNull();
+// });
 
-  expect(screen.UNSAFE_queryAllByProps({ type: 'primary' })).toEqual(primaryTypes);
-  expect(screen.UNSAFE_queryAllByProps({ type: 'inexistent' })).toHaveLength(0);
-});
+// test('UNSAFE_getAllByProp, UNSAFE_queryAllByProps', () => {
+//   render(<Banana />);
+//   const primaryTypes = screen.UNSAFE_getAllByProps({ type: 'primary' });
+
+//   expect(primaryTypes).toHaveLength(1);
+//   expect(() => screen.UNSAFE_getAllByProps({ type: 'inexistent' })).toThrow('No instances found');
+
+//   expect(screen.UNSAFE_queryAllByProps({ type: 'primary' })).toEqual(primaryTypes);
+//   expect(screen.UNSAFE_queryAllByProps({ type: 'inexistent' })).toHaveLength(0);
+// });
 
 test('update', () => {
   const fn = jest.fn();
@@ -204,13 +204,13 @@ test('returns host root', () => {
   expect(screen.root.props.testID).toBe('inner');
 });
 
-test('returns composite UNSAFE_root', () => {
-  render(<View testID="inner" />);
+// test('returns composite UNSAFE_root', () => {
+//   render(<View testID="inner" />);
 
-  expect(screen.UNSAFE_root).toBeDefined();
-  expect(screen.UNSAFE_root.type).toBe(View);
-  expect(screen.UNSAFE_root.props.testID).toBe('inner');
-});
+//   expect(screen.UNSAFE_root).toBeDefined();
+//   expect(screen.UNSAFE_root.type).toBe(View);
+//   expect(screen.UNSAFE_root.props.testID).toBe('inner');
+// });
 
 test('container displays deprecation', () => {
   render(<View testID="inner" />);
diff --git a/src/helpers/accessibility.ts b/src/helpers/accessibility.ts
@@ -16,6 +16,7 @@ import {
 } from './host-component-names';
 import { getTextContent } from './text-content';
 import { isTextInputEditable } from './text-input';
+import { findAllByProps } from './find-all';
 
 type IsInaccessibleOptions = {
   cache?: WeakMap<ReactTestInstance, boolean>;
@@ -253,9 +254,9 @@ export function computeAccessibleName(element: ReactTestInstance): string | unde
   const labelElementId = computeAriaLabelledBy(element);
   if (labelElementId) {
     const rootElement = getUnsafeRootElement(element);
-    const labelElement = rootElement?.findByProps({ nativeID: labelElementId });
-    if (labelElement) {
-      return getTextContent(labelElement);
+    const labelElement = findAllByProps(rootElement, { nativeID: labelElementId });
+    if (labelElement.length > 0) {
+      return getTextContent(labelElement[0]);
     }
   }
 
diff --git a/src/helpers/component-tree.ts b/src/helpers/component-tree.ts
@@ -88,13 +88,9 @@ export function getHostSiblings(element: ReactTestInstance | null): HostTestInst
  * @param element The element start traversing from.
  * @returns The root element of the tree (host or composite).
  */
-export function getUnsafeRootElement(element: ReactTestInstance | null) {
-  if (element == null) {
-    return null;
-  }
-
-  let current = element;
-  while (current.parent) {
+export function getUnsafeRootElement(element: ReactTestInstance) {
+  let current: ReactTestInstance | null = element;
+  while (current?.parent) {
     current = current.parent;
   }
 
diff --git a/src/helpers/find-all.ts b/src/helpers/find-all.ts
@@ -67,3 +67,20 @@ function findAllInternal(
 
   return results;
 }
+
+export function findAllByProps(
+  root: ReactTestInstance,
+  props: { [propName: string]: any },
+  options?: FindAllOptions,
+): HostTestInstance[] {
+  return findAll(root, (element) => matchProps(element, props), options);
+}
+
+function matchProps(element: ReactTestInstance, props: { [propName: string]: any }): boolean {
+  for (const key in props) {
+    if (props[key] !== element.props[key]) {
+      return false;
+    }
+  }
+  return true;
+}
diff --git a/src/queries/unsafe-props.ts b/src/queries/unsafe-props.ts
@@ -2,13 +2,27 @@ import type { ReactTestInstance } from 'react-test-renderer';
 import prettyFormat from 'pretty-format';
 import { ErrorWithStack, prepareErrorMessage } from '../helpers/errors';
 import { createQueryByError } from '../helpers/errors';
+import { findAllByProps } from '../helpers/find-all';
 
 const UNSAFE_getByProps = (
   instance: ReactTestInstance,
 ): ((props: { [propName: string]: any }) => ReactTestInstance) =>
   function getByPropsFn(props: { [propName: string]: any }) {
     try {
-      return instance.findByProps(props);
+      const results = findAllByProps(instance, props);
+      if (results.length === 0) {
+        throw new ErrorWithStack(
+          `No instances found with props:\n${prettyFormat(props)}`,
+          getByPropsFn,
+        );
+      }
+      if (results.length > 1) {
+        throw new ErrorWithStack(
+          `Found multiple instances with props:\n${prettyFormat(props)}`,
+          getByPropsFn,
+        );
+      }
+      return results[0];
     } catch (error) {
       throw new ErrorWithStack(prepareErrorMessage(error), getByPropsFn);
     }
@@ -18,7 +32,7 @@ const UNSAFE_getAllByProps = (
   instance: ReactTestInstance,
 ): ((props: { [propName: string]: any }) => Array<ReactTestInstance>) =>
   function getAllByPropsFn(props: { [propName: string]: any }) {
-    const results = instance.findAllByProps(props);
+    const results = findAllByProps(instance, props);
     if (results.length === 0) {
       throw new ErrorWithStack(
         `No instances found with props:\n${prettyFormat(props)}`,
diff --git a/src/queries/unsafe-type.ts b/src/queries/unsafe-type.ts
@@ -1,26 +1,30 @@
 import type { ReactTestInstance } from 'react-test-renderer';
 import * as React from 'react';
-import { ErrorWithStack, prepareErrorMessage } from '../helpers/errors';
+import { ErrorWithStack } from '../helpers/errors';
 import { createQueryByError } from '../helpers/errors';
+import { findAll } from '../helpers/find-all';
 
 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);
+    const results = findAllByType(instance, type);
+    if (results.length === 0) {
+      throw new ErrorWithStack(`No instances found with type:\n${type}`, getByTypeFn);
     }
+    if (results.length > 1) {
+      throw new ErrorWithStack(`Found multiple instances with type:\n${type}`, getByTypeFn);
+    }
+    return results[0];
   };
 
 const UNSAFE_getAllByType = (
   instance: ReactTestInstance,
 ): ((type: React.ComponentType<any>) => Array<ReactTestInstance>) =>
   function getAllByTypeFn(type: React.ComponentType<any>) {
-    const results = instance.findAllByType(type);
+    const results = findAllByType(instance, type);
     if (results.length === 0) {
-      throw new ErrorWithStack('No instances found', getAllByTypeFn);
+      throw new ErrorWithStack(`No instances found with type:\n${type}`, getAllByTypeFn);
     }
     return results;
   };
@@ -61,3 +65,7 @@ export const bindUnsafeByTypeQueries = (instance: ReactTestInstance): UnsafeByTy
   UNSAFE_queryByType: UNSAFE_queryByType(instance),
   UNSAFE_queryAllByType: UNSAFE_queryAllByType(instance),
 });
+
+function findAllByType(instance: ReactTestInstance, type: React.ComponentType<any>) {
+  return findAll(instance, (element) => element.type === type);
+}
