chore: add network obfuscation and filtering unit tests

Author: AndrewAminInstabug

android/native.gradle

@@ -1,5 +1,5 @@
 project.ext.instabug = [
-    version: '13.4.1.6273165-SNAPSHOT'
+    version: '14.0.0.6273213-SNAPSHOT'
 ]
 
 dependencies {

examples/default/android/build.gradle

@@ -4,8 +4,8 @@ buildscript {
     ext {
         buildToolsVersion = "33.0.0"
         minSdkVersion = 21
-        compileSdkVersion = 33
-        targetSdkVersion = 33
+        compileSdkVersion = 34
+        targetSdkVersion = 34
         kotlinVersion = "1.7.10"
 
         // We use NDK 23 which has both M1 support and is the side-by-side NDK version from AGP.
@@ -26,7 +26,8 @@ buildscript {
         classpath("com.android.tools.build:gradle")
         classpath("com.facebook.react:react-native-gradle-plugin")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
-        classpath 'com.instabug.library:instabug-plugin:13.4.1.6273165-SNAPSHOT'
+        classpath 'com.instabug.library:instabug-plugin:14.0.0.6273213-SNAPSHOT'
+
     }
 }
 

examples/default/ios/Podfile.lock

@@ -758,6 +758,6 @@ SPEC CHECKSUMS:
   SocketRocket: f32cd54efbe0f095c4d7594881e52619cfe80b17
   Yoga: 8796b55dba14d7004f980b54bcc9833ee45b28ce
 
-PODFILE CHECKSUM: c4e288aeafe746a77427798d0e33069c948e4b76
+PODFILE CHECKSUM: 2859b36546d44408bcfd30e23db5e6bb05548a0c
 
 COCOAPODS: 1.15.2

src/modules/NetworkLogger.ts

@@ -146,6 +146,19 @@ export const apolloLinkRequestHandler: RequestHandler = (operation, forward) =>
   return forward(operation);
 };
 
+/**
+ * @internal
+ * Exported for internal/testing purposes only.
+ */
+export function registerNetworkLogsListener(
+  type: NetworkListenerType,
+  handler?: (networkSnapshot: NetworkData) => void,
+) {
+  if (process.env.NODE_ENV === 'test') {
+    _registerNetworkLogsListener(type, handler);
+  }
+}
+
 const _registerNetworkLogsListener = (
   type: NetworkListenerType,
   handler?: (networkSnapshot: NetworkData) => void,

test/mocks/mockNetworkLogger.ts

@@ -5,6 +5,11 @@ const mockNetworkLogger: NetworkLoggerNativeModule = {
   removeListeners: jest.fn(),
   hasAPMNetworkPlugin: jest.fn(),
   isNativeInterceptionEnabled: jest.fn(),
+  forceStartNetworkLoggingIOS: jest.fn(),
+  forceStopNetworkLoggingIOS: jest.fn(),
+  registerNetworkLogsListener: jest.fn(),
+  updateNetworkLogSnapshot: jest.fn(),
+  setNetworkLoggingRequestFilterPredicateIOS: jest.fn(),
 };
 
 export default mockNetworkLogger;

test/modules/Instabug.spec.ts

@@ -926,7 +926,7 @@ describe('Instabug iOS initialization tests', () => {
     await Instabug.init(config);
 
     expect(NativeNetworkLogger.isNativeInterceptionEnabled).toHaveBeenCalled();
-    expect(NetworkLogger.setEnabled).not.toHaveBeenCalled();
+    expect(NetworkLogger.setEnabled).toHaveBeenCalledWith(false);
     expect(NativeInstabug.init).toHaveBeenCalledWith(
       config.token,
       config.invocationEvents,

test/modules/NetworkLogger.spec.ts

@@ -8,14 +8,21 @@ import Interceptor from '../../src/utils/XhrNetworkInterceptor';
 import { isContentTypeNotAllowed, reportNetworkLog } from '../../src/utils/InstabugUtils';
 import InstabugConstants from '../../src/utils/InstabugConstants';
 import * as Instabug from '../../src/modules/Instabug';
-import { NativeNetworkLogger } from '../../src/native/NativeNetworkLogger';
+import {
+  NativeNetworkLogger,
+  NativeNetworkLoggerEvent,
+  NetworkListenerType,
+  NetworkLoggerEmitter,
+} from '../../src/native/NativeNetworkLogger';
 import { InvocationEvent, LogLevel, NetworkInterceptionMode } from '../../src';
 import { Platform } from 'react-native';
 
 const clone = <T>(obj: T): T => {
   return JSON.parse(JSON.stringify(obj));
 };
 
+jest.mock('../../src/native/NativeNetworkLogger');
+
 describe('NetworkLogger Module', () => {
   const network: NetworkLogger.NetworkData = {
     id: '',
@@ -312,3 +319,111 @@ describe('NetworkLogger Module', () => {
     expect(NativeNetworkLogger.hasAPMNetworkPlugin).toHaveBeenCalled();
   });
 });
+
+describe('_registerNetworkLogsListener', () => {
+  let handlerMock: jest.Mock;
+  let type: NetworkListenerType;
+
+  beforeEach(() => {
+    jest.resetModules(); // Clear cached modules and reload
+    jest.resetAllMocks(); // Reset mock implementation and calls
+    jest.clearAllMocks(); // Clear only calls, keeping implementation intact
+  });
+
+  afterEach(() => {
+    handlerMock = jest.fn();
+    type = NetworkListenerType.both;
+    // Make sure to clean up listeners to avoid side effects
+    NetworkLoggerEmitter.removeAllListeners(NativeNetworkLoggerEvent.NETWORK_LOGGER_HANDLER);
+  });
+
+  it('should ignore repetitive calls with the same type', () => {
+    // Simulate existing listener
+    jest.spyOn(NetworkLoggerEmitter, 'listenerCount').mockReturnValue(1);
+    NetworkLogger.registerNetworkLogsListener(type, handlerMock);
+
+    // Call again with the same type to ensure it does nothing
+    NetworkLogger.registerNetworkLogsListener(type, handlerMock);
+
+    expect(NetworkLoggerEmitter.removeAllListeners).toHaveBeenCalledTimes(1);
+    expect(NetworkLoggerEmitter.addListener).toHaveBeenCalledTimes(1);
+    expect(NativeNetworkLogger.registerNetworkLogsListener).toHaveBeenCalledTimes(1);
+  });
+
+  it('should remove old listeners if they exist', () => {
+    // Simulate that there are existing listeners
+    jest.spyOn(NetworkLoggerEmitter, 'listenerCount').mockReturnValue(2);
+
+    NetworkLogger.registerNetworkLogsListener(type, handlerMock);
+
+    expect(NetworkLoggerEmitter.removeAllListeners).toHaveBeenCalledWith(
+      NativeNetworkLoggerEvent.NETWORK_LOGGER_HANDLER,
+    );
+  });
+
+  it('should set the new listener if _networkListener is null', () => {
+    // No existing listener
+    jest.spyOn(NetworkLoggerEmitter, 'listenerCount').mockReturnValue(0);
+
+    NetworkLogger.registerNetworkLogsListener(type, handlerMock);
+
+    expect(NetworkLoggerEmitter.addListener).toHaveBeenCalled();
+    expect(NativeNetworkLogger.registerNetworkLogsListener).toHaveBeenCalledWith(type);
+  });
+
+  it('should attach a new listener to the existing one if _networkListener is set', () => {
+    type = NetworkListenerType.filtering;
+    const newType = NetworkListenerType.both;
+
+    // First call to set the listener
+    NetworkLogger.registerNetworkLogsListener(type, handlerMock);
+
+    // Second call with a different type to trigger setting to `both`
+    NetworkLogger.registerNetworkLogsListener(newType, handlerMock);
+
+    expect(NetworkLoggerEmitter.addListener).toHaveBeenCalledTimes(2);
+    expect(NativeNetworkLogger.registerNetworkLogsListener).toHaveBeenCalledWith(
+      NetworkListenerType.both,
+    );
+  });
+
+  it('should map networkSnapshot data correctly and call handler', () => {
+    const mockNetworkSnapshot = {
+      id: '123',
+      url: 'http://example.com',
+      requestHeader: {},
+      requestBody: 'test request body',
+      responseHeader: {},
+      response: 'test response',
+      responseCode: 200,
+    };
+
+    (NetworkLoggerEmitter.addListener as jest.Mock).mockImplementation((_, callback) => {
+      callback(mockNetworkSnapshot);
+    });
+
+    NetworkLogger.registerNetworkLogsListener(type, handlerMock);
+
+    const expectedNetworkData: NetworkLogger.NetworkData = {
+      id: '123',
+      url: 'http://example.com',
+      requestBody: 'test request body',
+      requestHeaders: {},
+      method: '',
+      responseBody: 'test response',
+      responseCode: 200,
+      responseHeaders: {},
+      contentType: '',
+      duration: 0,
+      requestBodySize: 0,
+      responseBodySize: 0,
+      errorDomain: '',
+      errorCode: 0,
+      startTime: 0,
+      serverErrorMessage: '',
+      requestContentType: '',
+    };
+
+    expect(handlerMock).toHaveBeenCalledWith(expectedNetworkData);
+  });
+});

test/utils/InstabugUtils.spec.ts

@@ -243,6 +243,7 @@ describe('Instabug Utils', () => {
 
 describe('reportNetworkLog', () => {
   const network: NetworkData = {
+    id: 'id',
     url: 'https://api.instabug.com',
     method: 'GET',
     requestBody: 'requestBody',