chore: split the SDKConnect class into smaller chunks and add unit tests

app/core/SDKConnect/AndroidSDK/addAndroidConnection.test.ts

@@ -0,0 +1,65 @@
+import DefaultPreference from 'react-native-default-preference';
+import AppConstants from '../../../core/AppConstants';
+import { ConnectionProps } from '../Connection';
+import SDKConnect from '../SDKConnect';
+import addAndroidConnection from './addAndroidConnection';
+
+jest.mock('../Connection');
+jest.mock('../SDKConnect');
+jest.mock('../utils/DevLogger');
+jest.mock('react-native-default-preference', () => ({
+  set: jest.fn().mockResolvedValue(''),
+}));
+jest.mock('../../../core/AppConstants');
+
+describe('addAndroidConnection', () => {
+  let mockInstance = {} as unknown as SDKConnect;
+  const mockEmit = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockInstance = {
+      state: {
+        connections: {},
+      },
+      emit: mockEmit,
+    } as unknown as SDKConnect;
+  });
+
+  it('should add the connection to the instance state', async () => {
+    const mockConnection = {
+      id: 'test-id',
+    } as unknown as ConnectionProps;
+
+    await addAndroidConnection(mockConnection, mockInstance);
+
+    expect(mockInstance.state.connections[mockConnection.id]).toBe(
+      mockConnection,
+    );
+  });
+
+  it('should save the updated connections to DefaultPreference', async () => {
+    const mockConnection = {
+      id: 'test-id',
+    } as unknown as ConnectionProps;
+
+    await addAndroidConnection(mockConnection, mockInstance);
+
+    expect(DefaultPreference.set).toHaveBeenCalledWith(
+      AppConstants.MM_SDK.ANDROID_CONNECTIONS,
+      JSON.stringify(mockInstance.state.connections),
+    );
+  });
+
+  it('should emit a refresh event', async () => {
+    const mockConnection = {
+      id: 'test-id',
+    } as unknown as ConnectionProps;
+
+    await addAndroidConnection(mockConnection, mockInstance);
+
+    expect(mockEmit).toHaveBeenCalledTimes(1);
+    expect(mockEmit).toHaveBeenCalledWith('refresh');
+  });
+});

app/core/SDKConnect/AndroidSDK/addAndroidConnection.ts

@@ -0,0 +1,25 @@
+import { ConnectionProps } from '../Connection';
+import SDKConnect from '../SDKConnect';
+import DevLogger from '../utils/DevLogger';
+import DefaultPreference from 'react-native-default-preference';
+import AppConstants from '../../../core/AppConstants';
+
+async function addAndroidConnection(
+  connection: ConnectionProps,
+  instance: SDKConnect,
+) {
+  instance.state.connections[connection.id] = connection;
+
+  DevLogger.log(`SDKConnect::addAndroidConnection`, connection);
+
+  await DefaultPreference.set(
+    AppConstants.MM_SDK.ANDROID_CONNECTIONS,
+    JSON.stringify(instance.state.connections),
+  ).catch((err) => {
+    throw err;
+  });
+
+  instance.emit('refresh');
+}
+
+export default addAndroidConnection;

app/core/SDKConnect/AndroidSDK/bindAndroidSDK.test.ts

@@ -0,0 +1,44 @@
+import { NativeModules, Platform } from 'react-native';
+import SDKConnect from '../SDKConnect';
+import bindAndroidSDK from './bindAndroidSDK';
+
+jest.mock('../SDKConnect');
+jest.mock('../../../util/Logger');
+
+describe('bindAndroidSDK', () => {
+  let mockInstance = {} as unknown as SDKConnect;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    NativeModules.CommunicationClient = {
+      bindService: jest.fn(),
+    };
+
+    mockInstance = {
+      state: {
+        androidSDKBound: false,
+      },
+    } as unknown as SDKConnect;
+  });
+
+  it('should return early if the platform is not android', async () => {
+    (Platform as any).OS = 'ios';
+
+    await bindAndroidSDK(mockInstance);
+
+    expect(
+      NativeModules.CommunicationClient.bindService,
+    ).not.toHaveBeenCalled();
+  });
+
+  it('should return early if the Android SDK is already bound', async () => {
+    mockInstance.state.androidSDKBound = true;
+
+    await bindAndroidSDK(mockInstance);
+
+    expect(
+      NativeModules.CommunicationClient.bindService,
+    ).not.toHaveBeenCalled();
+  });
+});

app/core/SDKConnect/AndroidSDK/bindAndroidSDK.ts

@@ -0,0 +1,21 @@
+import Logger from '../../../util/Logger';
+import { NativeModules, Platform } from 'react-native';
+import SDKConnect from '../SDKConnect';
+
+async function bindAndroidSDK(instance: SDKConnect) {
+  if (Platform.OS !== 'android') {
+    return;
+  }
+
+  if (instance.state.androidSDKBound) return;
+
+  try {
+    // Always bind native module to client as early as possible otherwise connection may have an invalid status
+    await NativeModules.CommunicationClient.bindService();
+    instance.state.androidSDKBound = true;
+  } catch (err) {
+    Logger.log(err, `SDKConnect::bindAndroiSDK failed`);
+  }
+}
+
+export default bindAndroidSDK;

app/core/SDKConnect/AndroidSDK/loadAndroidConnections.test.ts

@@ -0,0 +1,46 @@
+import DefaultPreference from 'react-native-default-preference';
+import AppConstants from '../../../core/AppConstants';
+import loadAndroidConnections from './loadAndroidConnections';
+
+jest.mock('../../../core/AppConstants');
+jest.mock('react-native-default-preference', () => ({
+  get: jest.fn().mockResolvedValue(''),
+  set: jest.fn().mockResolvedValue(''),
+}));
+jest.mock('../utils/DevLogger');
+
+describe('loadAndroidConnections', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should retrieve Android connections from DefaultPreference', async () => {
+    await loadAndroidConnections();
+
+    expect(DefaultPreference.get).toHaveBeenCalledWith(
+      AppConstants.MM_SDK.ANDROID_CONNECTIONS,
+    );
+  });
+
+  it('should return an empty object if no connections are found', async () => {
+    const result = await loadAndroidConnections();
+
+    expect(result).toStrictEqual({});
+  });
+
+  it('should parse the retrieved connections', async () => {
+    const mockConnections = {
+      'test-id': {
+        id: 'test-id',
+      },
+    };
+
+    (DefaultPreference.get as jest.Mock).mockResolvedValueOnce(
+      JSON.stringify(mockConnections),
+    );
+
+    const result = await loadAndroidConnections();
+
+    expect(result).toStrictEqual(mockConnections);
+  });
+});

app/core/SDKConnect/AndroidSDK/loadAndroidConnections.ts

@@ -0,0 +1,22 @@
+import AppConstants from '../../../core/AppConstants';
+import { ConnectionProps } from '../Connection';
+import DefaultPreference from 'react-native-default-preference';
+import DevLogger from '../utils/DevLogger';
+
+async function loadAndroidConnections(): Promise<{
+  [id: string]: ConnectionProps;
+}> {
+  const rawConnections = await DefaultPreference.get(
+    AppConstants.MM_SDK.ANDROID_CONNECTIONS,
+  );
+
+  if (!rawConnections) return {};
+
+  const parsed = JSON.parse(rawConnections);
+  DevLogger.log(
+    `SDKConnect::loadAndroidConnections found ${Object.keys(parsed).length}`,
+  );
+  return parsed;
+}
+
+export default loadAndroidConnections;

app/core/SDKConnect/AndroidSDK/removeAndroidConnection.test.ts

@@ -0,0 +1,69 @@
+import DefaultPreference from 'react-native-default-preference';
+import AppConstants from '../../../core/AppConstants';
+import { ConnectionProps } from '../Connection';
+import SDKConnect from '../SDKConnect';
+import removeAndroidConnection from './removeAndroidConnection';
+
+jest.mock('../../../core/AppConstants');
+jest.mock('../SDKConnect');
+jest.mock('react-native-default-preference', () => ({
+  set: jest.fn().mockResolvedValue(''),
+}));
+
+describe('removeAndroidConnection', () => {
+  let mockInstance = {} as unknown as SDKConnect;
+  const mockEmit = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockInstance = {
+      state: {
+        connections: {},
+      },
+      emit: mockEmit,
+    } as unknown as SDKConnect;
+  });
+
+  it('should remove the specified connection from the instance state', () => {
+    const mockConnection = {
+      id: 'test-id',
+    };
+
+    mockInstance.state.connections[mockConnection.id] =
+      mockConnection as unknown as ConnectionProps;
+
+    removeAndroidConnection(mockConnection.id, mockInstance);
+
+    expect(mockInstance.state.connections[mockConnection.id]).toBeUndefined();
+  });
+
+  it('should update the connections in DefaultPreference', () => {
+    const mockConnection = {
+      id: 'test-id',
+    };
+
+    mockInstance.state.connections[mockConnection.id] =
+      mockConnection as unknown as ConnectionProps;
+
+    removeAndroidConnection(mockConnection.id, mockInstance);
+
+    expect(DefaultPreference.set).toHaveBeenCalledWith(
+      AppConstants.MM_SDK.ANDROID_CONNECTIONS,
+      JSON.stringify(mockInstance.state.connections),
+    );
+  });
+
+  it('should emit a refresh event', () => {
+    const mockConnection = {
+      id: 'test-id',
+    };
+
+    mockInstance.state.connections[mockConnection.id] =
+      mockConnection as unknown as ConnectionProps;
+
+    removeAndroidConnection(mockConnection.id, mockInstance);
+
+    expect(mockEmit).toHaveBeenCalledWith('refresh');
+  });
+});

app/core/SDKConnect/AndroidSDK/removeAndroidConnection.ts

@@ -0,0 +1,16 @@
+import AppConstants from '../../../core/AppConstants';
+import SDKConnect from '../SDKConnect';
+import DefaultPreference from 'react-native-default-preference';
+
+function removeAndroidConnection(id: string, instance: SDKConnect) {
+  delete instance.state.connections[id];
+  DefaultPreference.set(
+    AppConstants.MM_SDK.ANDROID_CONNECTIONS,
+    JSON.stringify(instance.state.connections),
+  ).catch((err) => {
+    throw err;
+  });
+  instance.emit('refresh');
+}
+
+export default removeAndroidConnection;