feat: only traverse valid parents and children

Author: Brandon Carroll

src/__tests__/misc.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { Button, Picker } from 'react-native';
+import { Button, Picker, Text, View } from 'react-native';
 import { toMatchDiffSnapshot } from 'snapshot-diff';
 
 import { fireEvent, render } from '../';
@@ -42,3 +42,42 @@ test('fragments can show diffs', () => {
   // See https://github.com/jest-community/snapshot-diff
   expect(firstRender).toMatchDiffSnapshot(asFragment());
 });
+
+test('finds only valid children', () => {
+  const Wrapper = ({ children }) => <View>{children}</View>;
+
+  const { container } = render(
+    <View>
+      <Wrapper>
+        <Text>hey</Text>
+        <Text>sup</Text>
+        <View />
+      </Wrapper>
+    </View>,
+  );
+
+  expect(
+    // AppContainer
+    // => node text
+    // => Text
+    // => View (from Wrapper)
+    // => View
+    container.children[0].children[0].children[0].children[0],
+  ).toBe('hey');
+});
+
+test('it finds only valid parents', () => {
+  const Wrapper = ({ children }) => <View>{children}</View>;
+
+  const { baseElement, getByText } = render(
+    <View testID="view">
+      <Wrapper>
+        <Text>hey</Text>
+        <Text>sup</Text>
+      </Wrapper>
+    </View>,
+  );
+
+  expect(getByText('hey').parentNode.parentNode.props.testID).toBe('view');
+  expect(baseElement.parentNode).toBeNull();
+});

src/lib/__tests__/misc.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { View } from 'react-native';
+import { Text, View } from 'react-native';
 
 import { render, queryByProp, queryByTestId } from '../../';
 

src/lib/query-helpers.js

@@ -24,6 +24,35 @@ function validComponentFilter(node, key) {
   return key ? getConfig(key).includes(node.type) : typeof node.type === 'string';
 }
 
+function flatten(arr) {
+  return arr.reduce(
+    (flat, toFlatten) => flat.concat(Array.isArray(toFlatten) ? flatten(toFlatten) : toFlatten),
+    [],
+  );
+}
+
+function getChildren(node) {
+  return node.children.map(child => {
+    if (typeof child === 'string') {
+      return child;
+    } else if (validComponentFilter(child)) {
+      return proxyUnsafeProperties(child);
+    }
+
+    return getChildren(child);
+  });
+}
+
+function getParent(node) {
+  if (node.parent) {
+    return validComponentFilter(node.parent)
+      ? proxyUnsafeProperties(node.parent)
+      : getParent(node.parent);
+  }
+
+  return null;
+}
+
 function proxyUnsafeProperties(node) {
   // We take the guiding principles seriously around these parts. These methods just let
   // you do too much unfortunately, and they make it hard to follow the rules of the
@@ -55,6 +84,10 @@ function proxyUnsafeProperties(node) {
             /* istanbul ignore next */
             return target.props[prop];
           };
+        case 'children':
+          return flatten(getChildren(target));
+        case 'parentNode':
+          return getParent(target);
         case '$$typeof':
           return Symbol.for('ntl.element');
         case 'findAllByProps':