feat: ignore events on diabled targets

Previously, an event could still fire if its target was disabled. This is incorrect because that
wouldn't work in a real application. Additionally, undocumented APIs for querying React elements
were removed in the sprit of the testing-library guiding principles.

Author: bcarroll22

examples/__tests__/__snapshots__/docs.js.snap

@@ -0,0 +1,3 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`examples of some things 1`] = `undefined`;

src/__tests__/events.js

@@ -55,6 +55,13 @@ test('calling a handler when there is no valid target throws', () => {
   expect(handleEvent).toBeCalledTimes(0);
 });
 
+test('calling a handler the target is disabled throws', () => {
+  const handleEvent = jest.fn();
+  const { getByText } = render(<Button disabled onPress={handleEvent} title="button" />);
+  expect(() => fireEvent.press(getByText('button'))).toThrow();
+  expect(handleEvent).toBeCalledTimes(0);
+});
+
 test('calling an event that has no defined handler throws', () => {
   const { getByText } = render(<Text>test</Text>);
   expect(() => fireEvent.press(getByText('test'))).toThrow();

src/events.js

@@ -202,6 +202,15 @@ const eventMap = {
   },
 };
 
+const disableableElements = [
+  'Slider',
+  'Switch',
+  'TouchableHighlight',
+  'TouchableNativeFeedback',
+  'TouchableOpacity',
+  'TouchableWithoutFeedback',
+];
+
 class NativeEvent {
   constructor(typeArg, event = {}) {
     const config = eventMap[typeArg] || eventMap.custom;
@@ -225,25 +234,37 @@ function getEventHandlerName(key) {
   return `on${key.charAt(0).toUpperCase()}${key.slice(1)}`;
 }
 
+function validateElementType(list, element) {
+  return (
+    list.includes(element.type) ||
+    list.includes(element.type.name) ||
+    list.includes(element.type.displayName)
+  );
+}
+
 function isValidTarget(element, event) {
-  return event.validTargets.length
-    ? event.validTargets.includes(element.type) ||
-        event.validTargets.includes(element.type.name) ||
-        event.validTargets.includes(element.type.displayName)
-    : true;
+  return event.validTargets.length ? validateElementType(event.validTargets, element) : true;
+}
+
+function isDisabled(element) {
+  return element.props.disabled && validateElementType(disableableElements, element);
 }
 
 function findEventHandler(element, event) {
   const { typeArg } = event;
   const eventHandler = getEventHandlerName(typeArg);
-  const isValid = isValidTarget(element, event);
+  const valid = isValidTarget(element, event);
+  const disabled = isDisabled(element);
 
-  if (typeof element.props[eventHandler] === 'function' && isValid) {
+  if (typeof element.props[eventHandler] === 'function' && valid) {
+    if (disabled) {
+      throw new Error(`A target was found for event: "${typeArg}", but the target is disabled!`);
+    }
     return element.props[eventHandler];
   }
 
   if (element.parent === null || element.parent.parent === null) {
-    throw new Error(`No handler found for event: ${typeArg}`);
+    throw new Error(`No target found for event: "${typeArg}"`);
   }
 
   return findEventHandler(element.parent, event);

src/queries.js

@@ -31,7 +31,28 @@ function queryAllByText(
     [],
   );
 
-  return [...baseArray].filter(node => matcher(getNodeText(node), node, text, matchNormalizer));
+  return [...baseArray]
+    .filter(node => matcher(getNodeText(node), node, text, matchNormalizer))
+    .map(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
+      // testing-library. It's not that we don't trust you, in fact we do trust you! We've
+      // left `findAll` on the instance for you as an emergency escape hatch for when
+      // you're really in a bind. We do want you to test successfully, after all ☺️
+      //
+      // The main intent is to:
+      //   1) Make it hard to assert on implementation details
+      //   2) Force you to consider how to test from a user's perspective
+      //
+      // Of course if you can't figure that out, we still want you to be able to use this library,
+      // so use `findAll`, just use it sparingly! We really believe you can do everything you
+      // need using the query methods provided on the `render` API.
+      ['find', 'findAllByProps', 'findAllByType', 'findByProps', 'findByType', 'instance'].forEach(
+        op => Object.defineProperty(node, op, { get: undefined }),
+      );
+
+      return node;
+    });
 }
 
 function queryByText(...args) {