refactor: change component filtering logic

Author: bcarroll22

src/__tests__/query-helpers.js

@@ -1,57 +1,15 @@
 import { defaultFilter, filterNodeByType } from '../query-helpers';
 
-test('filterNodeByType returns true when node.type is a match', () => {
-  expect(filterNodeByType({ type: 'test' }, 'test')).toEqual(true);
+test('filterNodeByType returns `true` when node.type matches the provided type', () => {
+  expect(filterNodeByType({ type: 'Text' }, 'Text')).toEqual(true);
 });
-test('filterNodeByType returns false when node.type is not a match', () => {
-  expect(filterNodeByType({ type: 'test' }, 'tst')).toEqual(false);
+test('filterNodeByType returns `false` when node.type does not match the provided type', () => {
+  expect(filterNodeByType({ type: 'Text' }, 'Test')).toEqual(false);
 });
 
-test('filterNodeByType returns true when node.type.name is a match', () => {
-  expect(filterNodeByType({ type: { name: 'test' } }, 'test')).toEqual(true);
+test('defaultFilter returns `true` when node.type is in the mocked type list', () => {
+  expect(defaultFilter({ type: 'Text' })).toEqual(true);
 });
-test('filterNodeByType returns false when node.type.name is not a match', () => {
-  expect(filterNodeByType({ type: { name: 'test' } }, 'tst')).toEqual(false);
-});
-
-test('filterNodeByType returns true when node.type.displayName is a match', () => {
-  expect(filterNodeByType({ type: { displayName: 'test' } }, 'test')).toEqual(true);
-});
-test('filterNodeByType returns false when node.type.displayName is not a match', () => {
-  expect(filterNodeByType({ type: { displayName: 'test' } }, 'tst')).toEqual(false);
-});
-
-test('filterNodeByType returns false when no node is given', () => {
-  expect(filterNodeByType(null, 'test')).toEqual(false);
-});
-
-test('filterNodeByType returns false when undefined is given', () => {
-  expect(filterNodeByType(undefined, 'test')).toEqual(false);
-});
-
-//function defaultFilter(node) {
-//  const name =
-//    node.type.displayName ||
-//    node.type.name ||
-//    (node.type.render // handle React.forwardRef
-//     ? node.type.render.displayName || node.type.render.name
-//     : 'Unknown');
-//
-//  return name !== 'Unknown';
-//}
-
-test('defaultFilter returns `false` when node.type.displayName is provided', () => {
-  expect(defaultFilter({ type: { displayName: 'test' } })).toEqual(true);
-});
-test('defaultFilter returns `false` when node.type.name is provided', () => {
-  expect(defaultFilter({ type: { name: 'test' } })).toEqual(true);
-});
-test('defaultFilter returns `false` when node.type.render.displayName is provided', () => {
-  expect(defaultFilter({ type: { render: { displayName: 'test' } } })).toEqual(true);
-});
-test('defaultFilter returns `false` when node.type.render.name is provided', () => {
-  expect(defaultFilter({ type: { render: { name: 'test' } } })).toEqual(true);
-});
-test('defaultFilter returns `true` when when it cannot find a type name on the node', () => {
-  expect(defaultFilter({ type: {} })).toEqual(false);
+test('defaultFilter returns `false` when node.type is not in the mocked type list', () => {
+  expect(defaultFilter({ type: 'Test' })).toEqual(false);
 });

src/get-node-text.js

@@ -1,15 +1,11 @@
-import { Text, TextInput } from 'react-native';
 import { filterNodeByType } from './query-helpers';
 
 function getNodeText(node) {
-  if (filterNodeByType(node, TextInput)) {
+  if (filterNodeByType(node, 'TextInput')) {
     return node.props.value;
   }
 
-  return Array.from(node.children)
-    .filter(node => filterNodeByType(node, 'Text') && Boolean(node.props.children))
-    .map(({ props }) => props.children)
-    .join('');
+  return Array.from(node.children).join('');
 }
 
 export { getNodeText };

src/queries.js

@@ -20,7 +20,7 @@ const queryAllByA11yRole = queryAllByProp.bind(null, 'accessibilityRole');
 function queryAllByText(
   container,
   text,
-  { types = [Text, TextInput], exact = true, collapseWhitespace, trim, normalizer } = {},
+  { types = ['Text', 'TextInput'], exact = true, collapseWhitespace, trim, normalizer } = {},
 ) {
   const rootInstance = container.root;
   const matcher = exact ? matches : fuzzyMatches;

src/query-helpers.js

@@ -11,19 +11,8 @@ function getElementError(message, container) {
   return new Error([message, debugDOM(container)].filter(Boolean).join('\n\n'));
 }
 
-function filterNodeByType(node = {}, type) {
-  if (!node) {
-    return false;
-  }
-
-  return (
-    node.type === type ||
-    (node.type && node.type.name === type) ||
-    (node.type && node.type.displayName === type) ||
-    (node.type && node.type.render && node.type.render.name === type) ||
-    (node.type && node.type.render && node.type.render.displayName === type) ||
-    false
-  );
+function filterNodeByType(node, type) {
+  return node.type === type;
 }
 
 function firstResultOrNull(queryFunction, ...args) {
@@ -54,14 +43,20 @@ function firstResultOrNull(queryFunction, ...args) {
 // native components of only returning odd results. In the example above, that would be the inner-most
 // <Text /> component, which is the one you'll actually want (it's the mocked native <Text />).
 function defaultFilter(node) {
-  const name =
-    node.type.displayName ||
-    node.type.name ||
-    (node.type.render // handle React.forwardRef
-      ? node.type.render.displayName || node.type.render.name
-      : 'Unknown');
+  const mockedTypes = [
+    'Image',
+    'Text',
+    'TextInput',
+    'Modal',
+    'View',
+    'RefreshControl',
+    'ScrollView',
+    'ActivityIndicator',
+    'ListView',
+    'ListViewDataSource',
+  ];
 
-  return name !== 'Unknown';
+  return mockedTypes.includes(node.type);
 }
 
 function queryAllByProp(