Add singleSync tests for shared client.

src/sync/__tests__/syncManagerOnline.spec.ts

@@ -1,27 +1,47 @@
 import { fullSettings } from '../../utils/settingsValidation/__tests__/settings.mocks';
 import { syncTaskFactory } from './syncTask.mock';
 import { syncManagerOnlineFactory } from '../syncManagerOnline';
-import { pushManagerFactory } from '../streaming/pushManager';
-import { IPushManager } from '../streaming/types';
-import { EventEmitter } from '../../utils/MinEvents';
+import { IReadinessManager } from '../../readiness/types';
 
 jest.mock('../submitters/submitterManager', () => {
   return {
     submitterManagerFactory: syncTaskFactory
   };
 });
 
-const paramsMock = {
-  platform: {
-    getEventSource: jest.fn(() => { return () => { }; }),
-    EventEmitter
-  },
-  settings: fullSettings,
-  storage: {},
-  readiness: {},
-  start: jest.fn()
+// Mocked storageManager
+const storageManagerMock = {
+  splits: {
+    usesSegments: () => false
+  }
 };
 
+// @ts-expect-error
+// Mocked readinessManager
+let readinessManagerMock = {
+  isReady: jest.fn(() => true) // Fake the signal for the non ready SDK
+} as IReadinessManager;
+
+
+// Mocked pollingManager
+const pollingManagerMock = {
+  syncAll: jest.fn(),
+  start: jest.fn(),
+  stop: jest.fn(),
+  isRunning: jest.fn(),
+  add: jest.fn(()=>{return {isrunning: () => true};}),
+  get: jest.fn()
+};
+
+const pushManagerMock = {
+  start: jest.fn(),
+  on: jest.fn(),
+  stop: jest.fn()
+};
+
+// Mocked pushManager
+const pushManagerFactoryMock = jest.fn(() => pushManagerMock);
+
 test('syncManagerOnline should start or not the submitter depending on user consent status', () => {
   const settings = { ...fullSettings };
 
@@ -57,41 +77,92 @@ test('syncManagerOnline should start or not the submitter depending on user cons
 test('syncManagerOnline should syncAll a single time in singleSync mode', () => {
   const settings = { ...fullSettings };
 
+  // Enable single sync
   settings.sync.singleSync = true;
 
-  const pollingManager = {
-    syncAll: jest.fn(),
-    start: jest.fn(),
-    stop: jest.fn(),
-    isRunning: jest.fn()
-  };
+  // @ts-ignore
+  // Test pushManager for main client
+  const syncManager = syncManagerOnlineFactory(() => pollingManagerMock, pushManagerFactoryMock)({ settings });
+
+  expect(pushManagerFactoryMock).not.toBeCalled();
+
+  // Test pollingManager for Main client
+  syncManager.start();
 
-  const fetchAuthMock = jest.fn();
+  expect(pollingManagerMock.start).not.toBeCalled();
+  expect(pollingManagerMock.syncAll).toBeCalledTimes(1);
+
+  syncManager.stop();
+  syncManager.start();
+
+  expect(pollingManagerMock.start).not.toBeCalled();
+  expect(pollingManagerMock.syncAll).toBeCalledTimes(1);
+
+  syncManager.stop();
+  syncManager.start();
+
+  expect(pollingManagerMock.start).not.toBeCalled();
+  expect(pollingManagerMock.syncAll).toBeCalledTimes(1);
+
+  syncManager.stop();
 
   // @ts-ignore
-  const pollingSyncManager = syncManagerOnlineFactory(() => pollingManager)({ settings });
+  // Test pollingManager for shared client
+  const pollingSyncManagerShared = syncManager.shared('sharedKey', readinessManagerMock, storageManagerMock);
 
-  pollingSyncManager.start();
+  if (!pollingSyncManagerShared) throw new Error('pollingSyncManagerShared should exist');
 
-  expect(pollingManager.start).not.toBeCalled();
-  expect(pollingManager.syncAll).toBeCalledTimes(1);
+  pollingSyncManagerShared.start();
 
-  pollingSyncManager.stop();
+  expect(pollingManagerMock.start).not.toBeCalled();
 
-  const pushManager = pushManagerFactory({ // @ts-ignore
-    ...paramsMock, splitApi: { fetchAuth: fetchAuthMock }
-  }, {}) as IPushManager;
+  pollingSyncManagerShared.stop();
+  pollingSyncManagerShared.start();
 
-  pushManager.start = jest.fn();
+  expect(pollingManagerMock.start).not.toBeCalled();
+
+  pollingSyncManagerShared.stop();
+
+  syncManager.start();
+
+  expect(pollingManagerMock.start).not.toBeCalled();
+
+  syncManager.stop();
+  syncManager.start();
+
+  expect(pollingManagerMock.start).not.toBeCalled();
+
+  syncManager.stop();
 
   // @ts-ignore
-  const pushingSyncManager = syncManagerOnlineFactory(() => pollingManager, () => pushManager)({ settings });
+  // Test pollingManager for shared client
+  const pushingSyncManagerShared = syncManager.shared('pushingSharedKey', readinessManagerMock, storageManagerMock);
+
+  if (!pushingSyncManagerShared) throw new Error('pushingSyncManagerShared should exist');
+
+  pushingSyncManagerShared.start();
+
+  expect(pollingManagerMock.start).not.toBeCalled();
+
+  pushingSyncManagerShared.stop();
+  pushingSyncManagerShared.start();
+
+  expect(pollingManagerMock.start).not.toBeCalled();
+
+  pushingSyncManagerShared.stop();
+
+  settings.sync.singleSync = false;
+  // @ts-ignore
+  // pushManager instantiation control test
+  const testSyncManager = syncManagerOnlineFactory(() => pollingManagerMock, pushManagerFactoryMock)({ settings });
+
+  expect(pushManagerFactoryMock).toBeCalled();
 
-  pushingSyncManager.start();
+  // Test pollingManager for Main client
+  testSyncManager.start();
 
-  expect(pushManager.start).not.toBeCalled();
-  expect(pollingManager.start).not.toBeCalled();
+  expect(pushManagerMock.start).toBeCalled();
 
-  pushingSyncManager.stop();
+  testSyncManager.stop();
 
 });

src/sync/syncManagerOnline.ts

@@ -28,13 +28,13 @@ export function syncManagerOnlineFactory(
    */
   return function (params: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const { settings, settings: { log, streamingEnabled }, telemetryTracker } = params;
+    const { settings, settings: { log, streamingEnabled, sync: { singleSync } },  telemetryTracker } = params;
 
     /** Polling Manager */
     const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
 
     /** Push Manager */
-    const pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+    const pushManager = !singleSync && streamingEnabled && pollingManager && pushManagerFactory ?
       pushManagerFactory(params, pollingManager) :
       undefined;
 
@@ -91,7 +91,7 @@ export function syncManagerOnlineFactory(
         if (pollingManager) {
 
           // If singleSync is enabled pushManager and pollingManager should not start
-          if (settings.sync.singleSync === true) {
+          if (singleSync === true) {
             if (startFirstTime) {
               pollingManager.syncAll();
               startFirstTime = false;
@@ -147,7 +147,7 @@ export function syncManagerOnlineFactory(
         return {
           isRunning: mySegmentsSyncTask.isRunning,
           start() {
-            if (settings.sync.singleSync === true) {
+            if (singleSync === true) {
               if (!readinessManager.isReady()) mySegmentsSyncTask.execute();
             } else {
               if (pushManager) {