Add remote API to uninstall the global error handler in RN

Reviewed By: fromcelticpark

Differential Revision: D6426209

fbshipit-source-id: 804e73e0dc4e4b85b336e3627c00840d2ff3c9d6

Libraries/BatchedBridge/__tests__/MessageQueue-test.js

@@ -7,6 +7,7 @@
  * of patent rights can be found in the PATENTS file in the same directory.
  *
  * @emails oncall+react_native
+ * @format
  */
 'use strict';
 
@@ -38,10 +39,12 @@ describe('MessageQueue', function() {
     queue = new MessageQueue();
     queue.registerCallableModule(
       'MessageQueueTestModule',
-      MessageQueueTestModule
+      MessageQueueTestModule,
     );
-    queue.createDebugLookup(0, 'MessageQueueTestModule',
-      ['testHook1', 'testHook2']);
+    queue.createDebugLookup(0, 'MessageQueueTestModule', [
+      'testHook1',
+      'testHook2',
+    ]);
   });
 
   it('should enqueue native calls', () => {
@@ -65,7 +68,15 @@ describe('MessageQueue', function() {
 
   it('should call the stored callback', () => {
     let done = false;
-    queue.enqueueNativeCall(0, 1, [], () => {}, () => { done = true; });
+    queue.enqueueNativeCall(
+      0,
+      1,
+      [],
+      () => {},
+      () => {
+        done = true;
+      },
+    );
     queue.__invokeCallback(1, []);
     expect(done).toEqual(true);
   });
@@ -83,32 +94,92 @@ describe('MessageQueue', function() {
   });
 
   it('should throw when calling with unknown module', () => {
-    const unknownModule = 'UnknownModule', unknownMethod = 'UnknownMethod';
+    const unknownModule = 'UnknownModule',
+      unknownMethod = 'UnknownMethod';
     expect(() => queue.__callFunction(unknownModule, unknownMethod)).toThrow(
       `Module ${unknownModule} is not a registered callable module (calling ${unknownMethod})`,
     );
   });
 
   it('should return lazily registered module', () => {
-    const dummyModule = {}, name = 'modulesName';
+    const dummyModule = {},
+      name = 'modulesName';
     queue.registerLazyCallableModule(name, () => dummyModule);
 
     expect(queue.getCallableModule(name)).toEqual(dummyModule);
   });
 
   it('should not initialize lazily registered module before it was used for the first time', () => {
-    const dummyModule = {}, name = 'modulesName';
+    const dummyModule = {},
+      name = 'modulesName';
     const factory = jest.fn(() => dummyModule);
     queue.registerLazyCallableModule(name, factory);
     expect(factory).not.toHaveBeenCalled();
   });
 
   it('should initialize lazily registered module only once', () => {
-    const dummyModule = {}, name = 'modulesName';
+    const dummyModule = {},
+      name = 'modulesName';
     const factory = jest.fn(() => dummyModule);
     queue.registerLazyCallableModule(name, factory);
     queue.getCallableModule(name);
     queue.getCallableModule(name);
     expect(factory).toHaveBeenCalledTimes(1);
   });
+
+  it('should catch all exceptions if the global error handler is installed', () => {
+    const errorMessage = 'intentional error';
+    const errorModule = {
+      explode: function() {
+        throw new Error(errorMessage);
+      },
+    };
+    const name = 'errorModuleName';
+    const factory = jest.fn(() => errorModule);
+    queue.__guardSafe = jest.fn(() => {});
+    queue.__guardUnsafe = jest.fn(() => {});
+    queue.installGlobalErrorHandler();
+    queue.registerLazyCallableModule(name, factory);
+    queue.callFunctionReturnFlushedQueue(name, 'explode', []);
+    expect(queue.__guardUnsafe).toHaveBeenCalledTimes(0);
+    expect(queue.__guardSafe).toHaveBeenCalledTimes(2);
+  });
+
+  it('should propagate exceptions if the global error handler is uninstalled', () => {
+    queue.uninstallGlobalErrorHandler();
+    const errorMessage = 'intentional error';
+    const errorModule = {
+      explode: function() {
+        throw new Error(errorMessage);
+      },
+    };
+    const name = 'errorModuleName';
+    const factory = jest.fn(() => errorModule);
+    queue.__guardUnsafe = jest.fn(() => {});
+    queue.__guardSafe = jest.fn(() => {});
+    queue.registerLazyCallableModule(name, factory);
+    queue.uninstallGlobalErrorHandler();
+    queue.callFunctionReturnFlushedQueue(name, 'explode');
+    expect(queue.__guardUnsafe).toHaveBeenCalledTimes(2);
+    expect(queue.__guardSafe).toHaveBeenCalledTimes(0);
+  });
+
+  it('should catch all exceptions if the global error handler is re-installed', () => {
+    const errorMessage = 'intentional error';
+    const errorModule = {
+      explode: function() {
+        throw new Error(errorMessage);
+      },
+    };
+    const name = 'errorModuleName';
+    const factory = jest.fn(() => errorModule);
+    queue.__guardUnsafe = jest.fn(() => {});
+    queue.__guardSafe = jest.fn(() => {});
+    queue.registerLazyCallableModule(name, factory);
+    queue.uninstallGlobalErrorHandler();
+    queue.installGlobalErrorHandler();
+    queue.callFunctionReturnFlushedQueue(name, 'explode');
+    expect(queue.__guardUnsafe).toHaveBeenCalledTimes(0);
+    expect(queue.__guardSafe).toHaveBeenCalledTimes(2);
+  });
 });