[MOB-11900] Remove Unneeded Crash Reporting Events (#916)

a7medev · ymabdallah · commit 7e5645266bc0 · 2023-02-20T16:52:57.000+02:00
diff --git a/src/modules/CrashReporting.ts b/src/modules/CrashReporting.ts
@@ -2,8 +2,6 @@ import { Platform } from 'react-native';
 import type { ExtendedError } from 'react-native/Libraries/Core/Devtools/parseErrorStack';
 
 import { NativeCrashReporting } from '../native';
-import IBGEventEmitter from '../utils/IBGEventEmitter';
-import InstabugConstants from '../utils/InstabugConstants';
 import InstabugUtils from '../utils/InstabugUtils';
 
 /**
@@ -42,13 +40,9 @@ export const reportError = (error: ExtendedError) => {
     exception: jsStackTrace,
   };
 
-  if (InstabugUtils.isOnReportHandlerSet() && Platform.OS === 'android') {
-    IBGEventEmitter.emit(InstabugConstants.SEND_HANDLED_CRASH, jsonObject);
+  if (Platform.OS === 'android') {
+    NativeCrashReporting.sendHandledJSCrash(JSON.stringify(jsonObject));
   } else {
-    if (Platform.OS === 'android') {
-      NativeCrashReporting.sendHandledJSCrash(JSON.stringify(jsonObject));
-    } else {
-      NativeCrashReporting.sendHandledJSCrash(jsonObject);
-    }
+    NativeCrashReporting.sendHandledJSCrash(jsonObject);
   }
 };
diff --git a/src/modules/Instabug.ts b/src/modules/Instabug.ts
@@ -7,7 +7,7 @@ import type { NavigationAction, NavigationState as NavigationStateV4 } from 'rea
 
 import type { InstabugConfig } from '../models/InstabugConfig';
 import Report from '../models/Report';
-import { NativeCrashReporting, NativeInstabug } from '../native';
+import { NativeInstabug } from '../native';
 import {
   IBGPosition,
   actionTypes,
@@ -533,64 +533,12 @@ export const show = () => {
 };
 
 export const onReportSubmitHandler = (handler?: (report: Report) => void) => {
-  if (handler) {
-    InstabugUtils.setOnReportHandler(true);
-  } else {
-    InstabugUtils.setOnReportHandler(false);
-  }
-
-  // send bug report
   IBGEventEmitter.addListener(NativeInstabug, InstabugConstants.PRESENDING_HANDLER, (report) => {
     const { tags, consoleLogs, instabugLogs, userAttributes, fileAttachments } = report;
     const reportObj = new Report(tags, consoleLogs, instabugLogs, userAttributes, fileAttachments);
     handler && handler(reportObj);
   });
 
-  // handled js crash
-  if (Platform.OS === 'android') {
-    IBGEventEmitter.addListener(
-      NativeInstabug,
-      InstabugConstants.SEND_HANDLED_CRASH,
-      async (jsonObject) => {
-        try {
-          const report = await NativeInstabug.getReport();
-          const { tags, consoleLogs, instabugLogs, userAttributes, fileAttachments } = report;
-          const reportObj = new Report(
-            tags,
-            consoleLogs,
-            instabugLogs,
-            userAttributes,
-            fileAttachments,
-          );
-          handler && handler(reportObj);
-          NativeCrashReporting.sendHandledJSCrash(JSON.stringify(jsonObject));
-        } catch (e) {
-          console.error(e);
-        }
-      },
-    );
-  }
-
-  if (Platform.OS === 'android') {
-    IBGEventEmitter.addListener(
-      NativeInstabug,
-      InstabugConstants.SEND_UNHANDLED_CRASH,
-      async (jsonObject) => {
-        const report = await NativeInstabug.getReport();
-        const { tags, consoleLogs, instabugLogs, userAttributes, fileAttachments } = report;
-        const reportObj = new Report(
-          tags,
-          consoleLogs,
-          instabugLogs,
-          userAttributes,
-          fileAttachments,
-        );
-        handler && handler(reportObj);
-        NativeCrashReporting.sendJSCrash(JSON.stringify(jsonObject));
-      },
-    );
-  }
-
   NativeInstabug.setPreSendingHandler(handler);
 };
 
diff --git a/src/utils/InstabugConstants.ts b/src/utils/InstabugConstants.ts
@@ -1,8 +1,6 @@
 enum InstabugConstants {
   NETWORK_DATA_OBFUSCATION_HANDLER_EVENT = 'IBGSetNetworkDataObfuscationHandler',
   PRESENDING_HANDLER = 'IBGpreSendingHandler',
-  SEND_HANDLED_CRASH = 'IBGSendHandledJSCrash',
-  SEND_UNHANDLED_CRASH = 'IBGSendUnhandledJSCrash',
   ON_INVOKE_HANDLER = 'IBGpreInvocationHandler',
   ON_SDK_DISMISSED_HANDLER = 'IBGpostInvocationHandler',
   ON_REPLY_RECEIVED_HANDLER = 'IBGOnNewReplyReceivedCallback',
diff --git a/src/utils/InstabugUtils.ts b/src/utils/InstabugUtils.ts
@@ -8,21 +8,11 @@ import type { NavigationState as NavigationStateV5, PartialState } from '@react-
 import type { NavigationState as NavigationStateV4 } from 'react-navigation';
 
 import { NativeCrashReporting } from '../native';
-import IBGEventEmitter from './IBGEventEmitter';
-import InstabugConstants from './InstabugConstants';
 
 export const parseErrorStack = (error: ExtendedError): StackFrame[] => {
   return parseErrorStackLib(error);
 };
 
-let _isOnReportHandlerSet = false;
-
-export const isOnReportHandlerSet = (): boolean => _isOnReportHandlerSet;
-
-export const setOnReportHandler = (flag: boolean) => {
-  _isOnReportHandlerSet = flag;
-};
-
 export const getActiveRouteName = (navigationState: NavigationStateV4): string | null => {
   if (!navigationState) {
     return null;
@@ -90,11 +80,7 @@ export const captureJsErrors = () => {
     };
 
     if (Platform.OS === 'android') {
-      if (_isOnReportHandlerSet) {
-        IBGEventEmitter.emit(InstabugConstants.SEND_UNHANDLED_CRASH, jsonObject);
-      } else {
-        NativeCrashReporting.sendJSCrash(JSON.stringify(jsonObject));
-      }
+      NativeCrashReporting.sendJSCrash(JSON.stringify(jsonObject));
     } else {
       NativeCrashReporting.sendJSCrash(jsonObject);
     }
@@ -115,8 +101,6 @@ export const stringifyIfNotString = (input: unknown) => {
 export default {
   parseErrorStack,
   captureJsErrors,
-  setOnReportHandler,
-  isOnReportHandlerSet,
   getActiveRouteName,
   getFullRoute,
   getStackTrace,
diff --git a/test/mocks/mockInstabugUtils.ts b/test/mocks/mockInstabugUtils.ts
@@ -2,8 +2,6 @@ jest.mock('../../src/utils/InstabugUtils', () => {
   return {
     parseErrorStack: jest.fn(),
     captureJsErrors: jest.fn(),
-    setOnReportHandler: jest.fn(),
-    isOnReportHandlerSet: jest.fn(),
     getActiveRouteName: jest.fn(),
     stringifyIfNotString: jest.fn(),
     getStackTrace: jest.fn().mockReturnValue('javascriptStackTrace'),
diff --git a/test/modules/CrashReporting.spec.ts b/test/modules/CrashReporting.spec.ts
@@ -1,12 +1,9 @@
 import '../mocks/mockInstabugUtils';
 
-import { NativeModules, Platform } from 'react-native';
+import { Platform } from 'react-native';
 
 import * as CrashReporting from '../../src/modules/CrashReporting';
 import { NativeCrashReporting } from '../../src/native';
-import IBGEventEmitter from '../../src/utils/IBGEventEmitter';
-import IBGConstants from '../../src/utils/InstabugConstants';
-import InstabugUtils from '../../src/utils/InstabugUtils';
 
 describe('CrashReporting Module', () => {
   it('should call the native method setEnabled', () => {
@@ -16,12 +13,12 @@ describe('CrashReporting Module', () => {
     expect(NativeCrashReporting.setEnabled).toBeCalledWith(true);
   });
 
-  it('should call the native method sendHandledJSCrash when platform is ios', () => {
+  it('should call the native method sendHandledJSCrash with JSON object when platform is iOS', () => {
     Platform.OS = 'ios';
-    const errorObject = { name: 'TypeError', message: 'Invalid type' };
-    CrashReporting.reportError(errorObject);
+    const error = { name: 'TypeError', message: 'Invalid type' };
+    CrashReporting.reportError(error);
 
-    const expectedObject = {
+    const expected = {
       message: 'TypeError - Invalid type',
       e_message: 'Invalid type',
       e_name: 'TypeError',
@@ -31,51 +28,24 @@ describe('CrashReporting Module', () => {
     };
 
     expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledTimes(1);
-    expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledWith(expectedObject);
+    expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledWith(expected);
   });
 
-  it('should call the native method sendHandledJSCrash when platform is android', () => {
+  it('should call the native method sendHandledJSCrash with stringified JSON object when platform is Android', () => {
     Platform.OS = 'android';
-    const errorObject = { name: 'TypeError', message: 'Invalid type' };
-    CrashReporting.reportError(errorObject);
+    const error = { name: 'TypeError', message: 'Invalid type' };
+    CrashReporting.reportError(error);
 
-    const expectedObject = {
+    const expected = JSON.stringify({
       message: 'TypeError - Invalid type',
       e_message: 'Invalid type',
       e_name: 'TypeError',
       os: 'android',
       platform: 'react_native',
       exception: 'javascriptStackTrace',
-    };
+    });
 
     expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledTimes(1);
-    expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledWith(JSON.stringify(expectedObject));
-  });
-
-  //TODO: finish this
-  it('should emit event IBGSendHandledJSCrash with the error object when platform is android', () => {
-    Platform.OS = 'android';
-    InstabugUtils.isOnReportHandlerSet = jest.fn().mockReturnValue(true);
-
-    const errorObject = { name: 'TypeError', message: 'Invalid type' };
-    const expectedObject = {
-      message: 'TypeError - Invalid type',
-      e_message: 'Invalid type',
-      e_name: 'TypeError',
-      os: 'android',
-      platform: 'react_native',
-      exception: 'javascriptStackTrace',
-    };
-
-    const crashHandler = jest.fn();
-    IBGEventEmitter.addListener(
-      NativeModules.Instabug,
-      IBGConstants.SEND_HANDLED_CRASH,
-      crashHandler,
-    );
-
-    CrashReporting.reportError(errorObject);
-    expect(crashHandler).toBeCalledTimes(1);
-    expect(crashHandler).toBeCalledWith(expectedObject);
+    expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledWith(expected);
   });
 });
diff --git a/test/modules/Instabug.spec.ts b/test/modules/Instabug.spec.ts
@@ -1,12 +1,12 @@
 import '../mocks/mockInstabugUtils';
 
-import { NativeModules, Platform, findNodeHandle, processColor } from 'react-native';
+import { Platform, findNodeHandle, processColor } from 'react-native';
 
 import waitForExpect from 'wait-for-expect';
 
 import Report from '../../src/models/Report';
 import * as Instabug from '../../src/modules/Instabug';
-import { NativeCrashReporting, NativeInstabug } from '../../src/native';
+import { NativeInstabug } from '../../src/native';
 import {
   ColorTheme,
   InvocationEvent,
@@ -610,16 +610,6 @@ describe('Instabug Module', () => {
     expect(NativeInstabug.show).toBeCalledTimes(1);
   });
 
-  it('should set _isOnReportHandlerSet to true on calling onReportSubmitHandler', () => {
-    Instabug.onReportSubmitHandler(jest.fn());
-    expect(InstabugUtils.setOnReportHandler).toBeCalledWith(true);
-  });
-
-  it('should set _isOnReportHandlerSet to false on calling onReportSubmitHandler without a handler', () => {
-    Instabug.onReportSubmitHandler();
-    expect(InstabugUtils.setOnReportHandler).toBeCalledWith(false);
-  });
-
   it('should call the native method setPreSendingHandler with a function', () => {
     const callback = jest.fn();
     Instabug.onReportSubmitHandler(callback);
@@ -651,97 +641,6 @@ describe('Instabug Module', () => {
     expect(IBGEventEmitter.getListeners(IBGConstants.PRESENDING_HANDLER).length).toEqual(1);
   });
 
-  it('should invoke callback on emitting the event IBGSendHandledJSCrash', async (done) => {
-    Platform.OS = 'android';
-    const report = {
-      tags: ['tag1', 'tag2'],
-      consoleLogs: ['consoleLog'],
-      instabugLogs: ['instabugLog'],
-      userAttributes: [{ age: '24' }],
-      fileAttachments: ['path'],
-    };
-    NativeModules.Instabug.getReport.mockResolvedValue(report);
-    const jsonObject = { stack: 'error' };
-    const callback = (rep: Report) => {
-      expect(rep).toBeInstanceOf(Report);
-      expect(rep.tags).toBe(report.tags);
-      expect(rep.consoleLogs).toBe(report.consoleLogs);
-      expect(rep.instabugLogs).toBe(report.instabugLogs);
-      expect(rep.userAttributes).toBe(report.userAttributes);
-      expect(rep.fileAttachments).toBe(report.fileAttachments);
-      done();
-    };
-    Instabug.onReportSubmitHandler(callback);
-    IBGEventEmitter.emit(IBGConstants.SEND_HANDLED_CRASH, jsonObject);
-
-    expect(IBGEventEmitter.getListeners(IBGConstants.SEND_HANDLED_CRASH).length).toEqual(1);
-    await waitForExpect(() => expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledTimes(1));
-    await waitForExpect(() =>
-      expect(NativeCrashReporting.sendHandledJSCrash).toBeCalledWith(jsonObject),
-    );
-  });
-
-  it('should not break if pre-sending callback fails on emitting the event IBGSendHandledJSCrash', async () => {
-    const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
-
-    Platform.OS = 'android';
-    NativeModules.Instabug.getReport.mockResolvedValue({});
-    const callback = jest.fn(() => {
-      throw new Error('Pre-sending callback failed.');
-    });
-
-    Instabug.onReportSubmitHandler(callback);
-    IBGEventEmitter.emit(IBGConstants.SEND_HANDLED_CRASH, {});
-
-    // We don't care if console.error is called but we use it as a sign that the function finished running
-    await waitForExpect(() => expect(callback).toBeCalled());
-    expect(NativeCrashReporting.sendHandledJSCrash).not.toBeCalled();
-
-    consoleSpy.mockRestore();
-  });
-
-  it('should not invoke callback on emitting the event IBGSendHandledJSCrash when Platform is iOS', () => {
-    Platform.OS = 'ios';
-    Instabug.onReportSubmitHandler(jest.fn());
-    IBGEventEmitter.emit(IBGConstants.SEND_HANDLED_CRASH, {});
-    expect(IBGEventEmitter.getListeners(IBGConstants.SEND_HANDLED_CRASH).length).toEqual(0);
-  });
-
-  it('should invoke callback on emitting the event IBGSendUnhandledJSCrash', async (done) => {
-    Platform.OS = 'android';
-    const report = {
-      tags: ['tag1', 'tag2'],
-      consoleLogs: ['consoleLog'],
-      instabugLogs: ['instabugLog'],
-      userAttributes: [{ age: '24' }],
-      fileAttachments: ['path'],
-    };
-    NativeModules.Instabug.getReport.mockResolvedValue(report);
-    const jsonObject = { stack: 'error' };
-    const callback = (rep: Report) => {
-      expect(rep).toBeInstanceOf(Report);
-      expect(rep.tags).toBe(report.tags);
-      expect(rep.consoleLogs).toBe(report.consoleLogs);
-      expect(rep.instabugLogs).toBe(report.instabugLogs);
-      expect(rep.userAttributes).toBe(report.userAttributes);
-      expect(rep.fileAttachments).toBe(report.fileAttachments);
-      done();
-    };
-    Instabug.onReportSubmitHandler(callback);
-    IBGEventEmitter.emit(IBGConstants.SEND_UNHANDLED_CRASH, jsonObject);
-
-    expect(IBGEventEmitter.getListeners(IBGConstants.SEND_UNHANDLED_CRASH).length).toEqual(1);
-    await waitForExpect(() => expect(NativeCrashReporting.sendJSCrash).toBeCalledTimes(1));
-    await waitForExpect(() => expect(NativeCrashReporting.sendJSCrash).toBeCalledWith(jsonObject));
-  });
-
-  it('should not invoke callback on emitting the event IBGSendUnhandledJSCrash when Platform is iOS', () => {
-    Platform.OS = 'ios';
-    Instabug.onReportSubmitHandler(jest.fn());
-    IBGEventEmitter.emit(IBGConstants.SEND_UNHANDLED_CRASH, {});
-    expect(IBGEventEmitter.getListeners(IBGConstants.SEND_UNHANDLED_CRASH).length).toEqual(0);
-  });
-
   it('should invoke the native method callPrivateApi', () => {
     const apiName = 'name';
     const param = 'param';
diff --git a/test/utils/InstabugUtils.spec.ts b/test/utils/InstabugUtils.spec.ts
