Update getEventKey tests to use public API (#11299)

Author: mwilc0x

packages/react-dom/src/events/__tests__/getEventKey-test.js

@@ -9,70 +9,172 @@
 
 'use strict';
 
-// TODO: can we express this test with only public API?
-var getEventKey = require('../getEventKey');
-
 describe('getEventKey', () => {
+  var React;
+  var ReactTestUtils;
+
+  beforeEach(() => {
+    jest.resetModules();
+    React = require('react');
+    ReactTestUtils = require('react-dom/test-utils');
+  });
+
   describe('when key is implemented in a browser', () => {
     describe('when key is not normalized', () => {
       it('returns a normalized value', () => {
-        var nativeEvent = new KeyboardEvent('keypress', {key: 'Del'});
-
-        expect(getEventKey(nativeEvent)).toBe('Delete');
+        function cb(e) {
+          expect(e.key).toBe('Delete');
+        }
+
+        function Comp() {
+          return {
+            render() {
+              return <input ref="inputRef" onKeyPressCapture={cb} />;
+            },
+          };
+        }
+
+        var instance = ReactTestUtils.renderIntoDocument(<Comp />);
+        var node = instance.refs.inputRef;
+        ReactTestUtils.SimulateNative.keyPress(node, {key: 'Del'});
       });
     });
 
     describe('when key is normalized', () => {
       it('returns a key', () => {
-        var nativeEvent = new KeyboardEvent('keypress', {key: 'f'});
-
-        expect(getEventKey(nativeEvent)).toBe('f');
+        function cb(e) {
+          expect(e.key).toBe('f');
+        }
+
+        function Comp() {
+          return {
+            render() {
+              return <input ref="inputRef" onKeyPressCapture={cb} />;
+            },
+          };
+        }
+
+        var instance = ReactTestUtils.renderIntoDocument(<Comp />);
+        var node = instance.refs.inputRef;
+        ReactTestUtils.Simulate.keyPress(node, {key: 'f'});
       });
     });
   });
 
   describe('when key is not implemented in a browser', () => {
     describe('when event type is keypress', () => {
       describe('when charCode is 13', () => {
-        it("returns 'Enter'", () => {
-          var nativeEvent = new KeyboardEvent('keypress', {charCode: 13});
-
-          expect(getEventKey(nativeEvent)).toBe('Enter');
+        it('returns "Enter"', () => {
+          function cb(e) {
+            expect(e.key).toBe('Enter');
+          }
+
+          function Comp() {
+            return {
+              render() {
+                return <input ref="inputRef" onKeyPressCapture={cb} />;
+              },
+            };
+          }
+
+          var instance = ReactTestUtils.renderIntoDocument(<Comp />);
+          var node = instance.refs.inputRef;
+          ReactTestUtils.SimulateNative.keyPress(node, {
+            type: 'keypress',
+            charCode: 13,
+          });
         });
       });
 
       describe('when charCode is not 13', () => {
         it('returns a string from a charCode', () => {
-          var nativeEvent = new KeyboardEvent('keypress', {charCode: 65});
-
-          expect(getEventKey(nativeEvent)).toBe('A');
+          function cb(e) {
+            expect(e.key).toBe('A');
+          }
+
+          function Comp() {
+            return {
+              render() {
+                return <input ref="inputRef" onKeyPressCapture={cb} />;
+              },
+            };
+          }
+
+          var instance = ReactTestUtils.renderIntoDocument(<Comp />);
+          var node = instance.refs.inputRef;
+          ReactTestUtils.SimulateNative.keyPress(node, {
+            type: 'keypress',
+            charCode: 65,
+          });
         });
       });
     });
 
     describe('when event type is keydown or keyup', () => {
       describe('when keyCode is recognized', () => {
         it('returns a translated key', () => {
-          var nativeEvent = new KeyboardEvent('keydown', {keyCode: 45});
-
-          expect(getEventKey(nativeEvent)).toBe('Insert');
+          function cb(e) {
+            expect(e.key).toBe('Insert');
+          }
+
+          function Comp() {
+            return {
+              render() {
+                return <input ref="inputRef" onKeyDownCapture={cb} />;
+              },
+            };
+          }
+
+          var instance = ReactTestUtils.renderIntoDocument(<Comp />);
+          var node = instance.refs.inputRef;
+          ReactTestUtils.SimulateNative.keyDown(node, {
+            type: 'keydown',
+            keyCode: 45,
+          });
         });
       });
 
       describe('when keyCode is not recognized', () => {
         it('returns Unidentified', () => {
-          var nativeEvent = new KeyboardEvent('keydown', {keyCode: 1337});
-
-          expect(getEventKey(nativeEvent)).toBe('Unidentified');
+          function cb(e) {
+            expect(e.key).toBe('Unidentified');
+          }
+
+          function Comp() {
+            return {
+              render() {
+                return <input ref="inputRef" onKeyDownCapture={cb} />;
+              },
+            };
+          }
+
+          var instance = ReactTestUtils.renderIntoDocument(<Comp />);
+          var node = instance.refs.inputRef;
+          ReactTestUtils.SimulateNative.keyDown(node, {
+            type: 'keydown',
+            keyCode: 1337,
+          });
         });
       });
     });
 
     describe('when event type is unknown', () => {
       it('returns an empty string', () => {
-        var nativeEvent = new KeyboardEvent('keysmack');
-
-        expect(getEventKey(nativeEvent)).toBe('');
+        function cb(e) {
+          expect(e.key).toBe('');
+        }
+
+        function Comp() {
+          return {
+            render() {
+              return <input ref="inputRef" onKeyDownCapture={cb} />;
+            },
+          };
+        }
+
+        var instance = ReactTestUtils.renderIntoDocument(<Comp />);
+        var node = instance.refs.inputRef;
+        ReactTestUtils.SimulateNative.keyDown(node, {type: 'keysmack'});
       });
     });
   });