@webex/contact-center 3.12.0-next.9 → 3.12.0-task-refactor.2

package/test/unit/spec/cc.ts

@@ -15,7 +15,7 @@ import type {ContactServiceQueuesResponse} from '../../../src/types';
 import MockWebex from '@webex/test-helper-mock-webex';
 import {StationLoginSuccess, AGENT_EVENTS} from '../../../src/services/agent/types';
 import {SetStateResponse} from '../../../src/types';
-import {AGENT, SUBSCRIBE_API, WEB_RTC_PREFIX} from '../../../src/services/constants';
+import {AGENT, WEB_RTC_PREFIX} from '../../../src/services/constants';
 import Services from '../../../src/services';
 import config from '../../../src/config';
 import {CC_EVENTS} from '../../../src/services/config/types';
@@ -59,6 +59,7 @@ global.URL.createObjectURL = jest.fn(() => 'blob:http://localhost:3000/12345');
 
 describe('webex.cc', () => {
   let webex;
+  let mockApiAIAssistant;
   let mockContact;
   let mockTaskManager;
   let mockMetricsManager;
@@ -88,8 +89,6 @@ describe('webex.cc', () => {
       initWebSocket: jest.fn(),
       on: jest.fn(),
       off: jest.fn(),
-      close: jest.fn(),
-      isSocketClosed: false,
     };
 
     mockContact = {
@@ -109,6 +108,12 @@ describe('webex.cc', () => {
       cancelCtq: jest.fn(),
     };
 
+    mockApiAIAssistant = {
+      sendEvent: jest.fn(),
+      fetchHistoricTranscripts: jest.fn(),
+      setAIFeatureFlags: jest.fn(),
+    };
+
     // Mock Services instance
     const mockServicesInstance = {
       agent: {
@@ -123,13 +128,6 @@ describe('webex.cc', () => {
         getOutdialAniEntries: jest.fn(),
       },
       webSocketManager: mockWebSocketManager,
-      rtdWebSocketManager: {
-        initWebSocket: jest.fn().mockResolvedValue({}),
-        on: jest.fn(),
-        off: jest.fn(),
-        close: jest.fn(),
-        isSocketClosed: false,
-      },
       connectionService: {
         on: jest.fn(),
         off: jest.fn(),
@@ -138,26 +136,21 @@ describe('webex.cc', () => {
 
       dialer: {
         startOutdial: jest.fn(),
-        acceptPreviewContact: jest.fn(),
-      },
-      apiAIAssistant: {
-        sendEvent: jest.fn(),
-        fetchHistoricTranscripts: jest.fn(),
       },
     };
 
     mockTaskManager = {
+      apiAIAssistant: mockApiAIAssistant,
       contact: mockContact,
       call: undefined,
       taskCollection: {},
       webCallingService: undefined,
       webSocketManager: mockWebSocketManager,
       task: undefined,
+      setConfigFlags: jest.fn(),
       setWrapupData: jest.fn(),
       setAgentId: jest.fn(),
       setWebRtcEnabled: jest.fn(),
-      handleRealtimeTranscriptEvent: jest.fn(),
-      setApiAIAssistant: jest.fn(),
       registerIncomingCallEvent: jest.fn(),
       registerTaskListeners: jest.fn(),
       getTask: jest.fn(),
@@ -267,7 +260,7 @@ describe('webex.cc', () => {
       isAgentAvailableAfterOutdial: false,
       isCampaignManagementEnabled: false,
       outDialEp: '',
-      isEndCallEnabled: false,
+      isEndTaskEnabled: false,
       isEndConsultEnabled: false,
       agentDbId: '',
       allowConsultToQueue: false,
@@ -278,7 +271,6 @@ describe('webex.cc', () => {
     };
 
     it('should register successfully and return agent profile', async () => {
-      mockAgentProfile.aiFeature = {realtimeTranscripts: {enable: true}} as any;
       const mercuryConnect = jest.spyOn(webex.internal.mercury, 'connect').mockResolvedValue(true);
       const connectWebsocketSpy = jest.spyOn(webex.cc, 'connectWebsocket');
       const setupEventListenersSpy = jest.spyOn(webex.cc, 'setupEventListeners');
@@ -322,7 +314,7 @@ describe('webex.cc', () => {
           clientType: 'WebexCCSDK',
           allowMultiLogin: false,
         },
-        resource: SUBSCRIBE_API,
+        resource: 'v1/notification/subscribe',
       });
 
       // TODO: https://jira-eng-gpk2.cisco.com/jira/browse/SPARK-626777 Implement the de-register method and close the listener there
@@ -335,25 +327,24 @@ describe('webex.cc', () => {
         expect.any(Function)
       );
       expect(mockWebSocketManager.on).toHaveBeenCalledWith('message', expect.any(Function));
-      expect(webex.cc.services.rtdWebSocketManager.initWebSocket).toHaveBeenCalledWith({
-        body: {
-          force: true,
-          isKeepAliveEnabled: false,
-          clientType: 'WebexCCSDK',
-          allowMultiLogin: false,
-        },
-        resource: 'v1/realtime/subscribe',
-      });
-      expect(webex.cc.services.rtdWebSocketManager.on).toHaveBeenCalledWith(
-        'message',
-        expect.any(Function)
-      );
 
       expect(configSpy).toHaveBeenCalled();
       expect(LoggerProxy.log).toHaveBeenCalledWith('Agent config is fetched successfully', {
         module: CC_FILE,
         method: 'connectWebsocket',
       });
+      expect(mockTaskManager.setConfigFlags).toHaveBeenCalledWith({
+        isEndTaskEnabled: mockAgentProfile.isEndTaskEnabled,
+        isEndConsultEnabled: mockAgentProfile.isEndConsultEnabled,
+        webRtcEnabled: mockAgentProfile.webRtcEnabled,
+        autoWrapup: mockAgentProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
+      });
+      expect(mockTaskManager.setConfigFlags).toHaveBeenCalledWith({
+        isEndTaskEnabled: mockAgentProfile.isEndTaskEnabled,
+        isEndConsultEnabled: mockAgentProfile.isEndConsultEnabled,
+        webRtcEnabled: mockAgentProfile.webRtcEnabled,
+        autoWrapup: mockAgentProfile.wrapUpData.wrapUpProps.autoWrapup ?? false,
+      });
       expect(reloadSpy).toHaveBeenCalled();
       expect(result).toEqual(mockAgentProfile);
       expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith([
@@ -391,7 +382,7 @@ describe('webex.cc', () => {
           clientType: 'WebexCCSDK',
           allowMultiLogin: true,
         },
-        resource: SUBSCRIBE_API,
+        resource: 'v1/notification/subscribe',
       });
       expect(configSpy).toHaveBeenCalled();
       expect(LoggerProxy.log).toHaveBeenCalledWith('Agent config is fetched successfully', {
@@ -471,7 +462,7 @@ describe('webex.cc', () => {
           clientType: 'WebexCCSDK',
           allowMultiLogin: false,
         },
-        resource: SUBSCRIBE_API,
+        resource: 'v1/notification/subscribe',
       });
 
       expect(mockTaskManager.on).toHaveBeenCalledWith(
@@ -495,7 +486,6 @@ describe('webex.cc', () => {
 
     it('should not attempt for mercury connection when webrtc is disabled', async () => {
       mockAgentProfile.webRtcEnabled = false;
-      mockAgentProfile.aiFeature = {realtimeTranscripts: {enable: false}} as any;
       const mercurySpy = jest.spyOn(webex.internal.mercury, 'connect');
       const connectWebsocketSpy = jest.spyOn(webex.cc, 'connectWebsocket');
       const setupEventListenersSpy = jest.spyOn(webex.cc, 'setupEventListeners');
@@ -525,39 +515,13 @@ describe('webex.cc', () => {
           clientType: 'WebexCCSDK',
           allowMultiLogin: false,
         },
-        resource: SUBSCRIBE_API,
+        resource: 'v1/notification/subscribe',
       });
 
       expect(configSpy).toHaveBeenCalled();
       expect(mercurySpy).not.toHaveBeenCalled();
-      expect(webex.cc.services.rtdWebSocketManager.initWebSocket).not.toHaveBeenCalled();
       expect(result).toEqual(mockAgentProfile);
     });
-
-    it('should not connect RTD websocket when realtime transcripts feature is disabled', async () => {
-      mockAgentProfile.aiFeature = {realtimeTranscripts: {enable: false}} as any;
-      jest.spyOn(webex.internal.mercury, 'connect').mockResolvedValue(true);
-      jest.spyOn(webex.cc.services.agent, 'reload').mockResolvedValue({
-        data: {
-          auxCodeId: 'auxCodeId',
-          agentId: 'agentId',
-          deviceType: LoginOption.EXTENSION,
-          dn: '12345',
-        },
-      });
-      jest.spyOn(webex.cc.services.config, 'getAgentConfig').mockResolvedValue(mockAgentProfile);
-      mockWebSocketManager.initWebSocket.mockResolvedValue({
-        agentId: 'agent123',
-      });
-
-      await webex.cc.register();
-
-      expect(webex.cc.services.rtdWebSocketManager.initWebSocket).not.toHaveBeenCalled();
-      expect(webex.cc.services.rtdWebSocketManager.on).not.toHaveBeenCalledWith(
-        'message',
-        expect.any(Function)
-      );
-    });
   });
 
   describe('stationLogin', () => {
@@ -1500,6 +1464,27 @@ describe('webex.cc', () => {
     });
   });
 
+  describe('getQueues', () => {
+    it('delegates to the queue service when successful', async () => {
+      const mockQueuesResponse = [{queueId: 'queue1', queueName: 'Queue 1'}];
+      const queueSpy = jest
+        .spyOn(webex.cc.queue, 'getQueues')
+        .mockResolvedValue(mockQueuesResponse as any);
+
+      const result = await webex.cc.getQueues({page: 1});
+
+      expect(queueSpy).toHaveBeenCalledWith({page: 1});
+      expect(result).toBe(mockQueuesResponse);
+    });
+
+    it('propagates queue service errors', async () => {
+      const error = new Error('Test error.');
+      jest.spyOn(webex.cc.queue, 'getQueues').mockRejectedValue(error);
+
+      await expect(webex.cc.getQueues()).rejects.toThrow('Test error.');
+    });
+  });
+
   describe('uploadLogs', () => {
     it('should upload logs successfully', async () => {
       const uploadLogsMock = jest.spyOn(webex.cc.webexRequest, 'uploadLogs').mockResolvedValue({
@@ -1529,6 +1514,7 @@ describe('webex.cc', () => {
 
   describe('unregister', () => {
     let mockWebSocketManager;
+    let mockRTDWebSocketManager;
     let mercuryDisconnectSpy;
     let deviceUnregisterSpy;
 
@@ -1545,8 +1531,15 @@ describe('webex.cc', () => {
         off: jest.fn(),
         on: jest.fn(),
       };
+      mockRTDWebSocketManager = {
+        isSocketClosed: false,
+        close: jest.fn(),
+        off: jest.fn(),
+        on: jest.fn(),
+      };
 
       webex.cc.services.webSocketManager = mockWebSocketManager;
+      webex.cc.services.rtdWebSocketManager = mockRTDWebSocketManager;
 
       webex.internal = webex.internal || {};
       webex.internal.mercury = {
@@ -1563,13 +1556,6 @@ describe('webex.cc', () => {
     });
 
     it('should unregister successfully and clean up all resources when webrtc is enabled', async () => {
-      webex.cc.services.rtdWebSocketManager = {
-        isSocketClosed: false,
-        close: jest.fn(),
-        off: jest.fn(),
-        on: jest.fn(),
-      } as any;
-
       await webex.cc.deregister();
 
       expect(mockTaskManager.off).toHaveBeenCalledWith(
@@ -1581,20 +1567,13 @@ describe('webex.cc', () => {
         expect.any(Function)
       );
       expect(mockWebSocketManager.off).toHaveBeenCalledWith('message', expect.any(Function));
-      expect(webex.cc.services.rtdWebSocketManager.off).toHaveBeenCalledWith(
-        'message',
-        expect.any(Function)
-      );
       expect(webex.cc.services.connectionService.off).toHaveBeenCalledWith(
         'connectionLost',
         expect.any(Function)
       );
 
       expect(mockWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
-      expect(webex.cc.services.rtdWebSocketManager.close).toHaveBeenCalledWith(
-        false,
-        'Unregistering the RTD websocket'
-      );
+      expect(mockRTDWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
       expect(webex.cc.agentConfig).toBeNull();
 
       expect(webex.internal.mercury.off).toHaveBeenCalledWith('online');
@@ -1670,6 +1649,7 @@ describe('webex.cc', () => {
       expect(webex.internal.mercury.off).not.toHaveBeenCalled();
       expect(mercuryDisconnectSpy).not.toHaveBeenCalled();
       expect(deviceUnregisterSpy).not.toHaveBeenCalled();
+      expect(mockRTDWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
     });
 
     it('should skip internal mercury cleanup when loginVoiceOptions does not include BROWSER', async () => {
@@ -1687,6 +1667,7 @@ describe('webex.cc', () => {
       expect(deviceUnregisterSpy).not.toHaveBeenCalled();
 
       expect(mockWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
+      expect(mockRTDWebSocketManager.close).toHaveBeenCalledWith(false, 'Unregistering the SDK');
       expect(webex.cc.agentConfig).toBeNull();
     });
 
@@ -2256,68 +2237,4 @@ describe('webex.cc', () => {
       );
     });
   });
-
-  describe('acceptPreviewContact', () => {
-    const previewPayload = {
-      interactionId: 'interaction-123',
-      campaignId: 'campaign-456',
-    };
-
-    it('should accept preview contact successfully', async () => {
-      const mockResponse = {trackingId: 'track-123'} as AgentContact;
-
-      const acceptPreviewContactMock = jest
-        .spyOn(webex.cc.services.dialer, 'acceptPreviewContact')
-        .mockResolvedValue(mockResponse);
-
-      const result = await webex.cc.acceptPreviewContact(previewPayload);
-
-      expect(LoggerProxy.info).toHaveBeenCalledWith('Accepting campaign preview contact', {
-        module: CC_FILE,
-        method: 'acceptPreviewContact',
-      });
-      expect(LoggerProxy.log).toHaveBeenCalledWith(
-        'Campaign preview contact accepted successfully',
-        {
-          module: CC_FILE,
-          method: 'acceptPreviewContact',
-          trackingId: 'track-123',
-          interactionId: previewPayload.interactionId,
-        }
-      );
-
-      expect(acceptPreviewContactMock).toHaveBeenCalledWith({data: previewPayload});
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should handle error during acceptPreviewContact', async () => {
-      getErrorDetailsSpy.mockRestore();
-      getErrorDetailsSpy = jest.spyOn(Utils, 'getErrorDetails');
-
-      const error = {
-        details: {
-          trackingId: '1234',
-          data: {
-            reason: 'Error while performing acceptPreviewContact',
-          },
-        },
-      };
-
-      jest.spyOn(webex.cc.services.dialer, 'acceptPreviewContact').mockRejectedValue(error);
-
-      await expect(webex.cc.acceptPreviewContact(previewPayload)).rejects.toThrow(
-        error.details.data.reason
-      );
-
-      expect(LoggerProxy.info).toHaveBeenCalledWith('Accepting campaign preview contact', {
-        module: CC_FILE,
-        method: 'acceptPreviewContact',
-      });
-      expect(LoggerProxy.error).toHaveBeenCalledWith(
-        `acceptPreviewContact failed with reason: ${error.details.data.reason}`,
-        {module: CC_FILE, method: 'acceptPreviewContact', trackingId: error.details.trackingId}
-      );
-      expect(getErrorDetailsSpy).toHaveBeenCalledWith(error, 'acceptPreviewContact', CC_FILE);
-    });
-  });
 });

package/test/unit/spec/logger-proxy.ts

@@ -0,0 +1,70 @@
+import LoggerProxy from '../../../src/logger-proxy';
+
+describe('LoggerProxy', () => {
+  beforeEach(() => {
+    // Reset between tests
+    (LoggerProxy as any).logger = undefined;
+  });
+
+  it('no-ops when logger is not initialized', () => {
+    expect(() => {
+      LoggerProxy.log('msg');
+      LoggerProxy.info('msg');
+      LoggerProxy.warn('msg');
+      LoggerProxy.trace('msg');
+      LoggerProxy.error('msg');
+    }).not.toThrow();
+  });
+
+  it('routes calls to the injected logger with formatted context', () => {
+    const logger = {
+      log: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      trace: jest.fn(),
+      error: jest.fn(),
+    };
+
+    LoggerProxy.initialize(logger as any);
+
+    LoggerProxy.log('hello', {module: 'm', method: 'fn', interactionId: 'i', trackingId: 't'});
+    expect(logger.log).toHaveBeenCalled();
+    expect(String(logger.log.mock.calls[0][0])).toContain('module:m - method:fn');
+    expect(String(logger.log.mock.calls[0][0])).toContain('interactionId:i');
+    expect(String(logger.log.mock.calls[0][0])).toContain('trackingId:t');
+
+    LoggerProxy.info('hello', {module: 'm', method: 'fn'});
+    LoggerProxy.warn('hello', {module: 'm', method: 'fn'});
+    LoggerProxy.trace('hello', {module: 'm', method: 'fn'});
+    LoggerProxy.error('hello', {module: 'm', method: 'fn'});
+    expect(logger.info).toHaveBeenCalled();
+    expect(logger.warn).toHaveBeenCalled();
+    expect(logger.trace).toHaveBeenCalled();
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  it('handles unserializable data and different error shapes', () => {
+    const logger = {
+      log: jest.fn(),
+      info: jest.fn(),
+      warn: jest.fn(),
+      trace: jest.fn(),
+      error: jest.fn(),
+    };
+    LoggerProxy.initialize(logger as any);
+
+    const circular: any = {};
+    circular.self = circular;
+
+    LoggerProxy.info('msg', {module: 'm', method: 'fn', data: circular, error: 'oops'});
+    expect(String(logger.info.mock.calls[0][0])).toContain('data:[object]');
+    expect(String(logger.info.mock.calls[0][0])).toContain('error:oops');
+
+    const err = new Error('boom');
+    LoggerProxy.error('msg', {module: 'm', method: 'fn', error: err});
+    const errorLine = String(logger.error.mock.calls[0][0]);
+    expect(errorLine).toContain('error:Error:boom');
+    expect(errorLine).toContain('stack:');
+  });
+});
+

package/test/unit/spec/services/ApiAiAssistant.ts

@@ -1,6 +1,7 @@
 import ApiAIAssistant from '../../../../src/services/ApiAiAssistant';
 import MetricsManager from '../../../../src/metrics/MetricsManager';
 import LoggerProxy from '../../../../src/logger-proxy';
+import WebexRequest from '../../../../src/services/core/WebexRequest';
 import {HTTP_METHODS, WebexSDK} from '../../../../src/types';
 
 jest.mock('../../../../src/metrics/MetricsManager');
@@ -13,6 +14,9 @@ describe('ApiAIAssistant', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    jest.spyOn(WebexRequest, 'getInstance').mockReturnValue({
+      uploadLogs: jest.fn(),
+    } as any);
 
     mockWebex = {
       credentials: {
@@ -112,4 +116,17 @@ describe('ApiAIAssistant', () => {
     expect(failed).toBe(true);
     expect(LoggerProxy.error).toHaveBeenCalled();
   });
+
+  it('should fail when realtime transcripts feature is disabled', async () => {
+    apiAIAssistant.setAIFeatureFlags({realtimeTranscripts: {enable: false}} as any);
+    let errorMessage = '';
+
+    try {
+      await apiAIAssistant.fetchHistoricTranscripts('test-agent-id', 'interaction-1');
+    } catch (error) {
+      errorMessage = (error as Error)?.message || '';
+    }
+
+    expect(errorMessage).toBe('Error while performing fetchHistoricTranscripts');
+  });
 });

package/test/unit/spec/services/config/index.ts

@@ -66,7 +66,6 @@ describe('AgentConfigService', () => {
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching user data using CI', {
         module: CONFIG_FILE_NAME,
         method: 'getUserUsingCI',
@@ -124,7 +123,6 @@ describe('AgentConfigService', () => {
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching desktop profile', {
         module: CONFIG_FILE_NAME,
         method: 'getDesktopProfileById',
@@ -183,7 +181,6 @@ describe('AgentConfigService', () => {
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching list of teams', {
         module: CONFIG_FILE_NAME,
         method: 'getListOfTeams',
@@ -267,7 +264,6 @@ describe('AgentConfigService', () => {
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching list of aux codes', {
         module: CONFIG_FILE_NAME,
         method: 'getListOfAuxCodes',
@@ -495,7 +491,7 @@ describe('AgentConfigService', () => {
       const mockResponse = {
         statusCode: 200,
         body: {
-          realtimeTranscripts: {enable: true},
+          data: [{realtimeTranscripts: {enable: true}}],
         },
       };
       mockWebexRequest.request.mockResolvedValue(mockResponse);
@@ -710,6 +706,31 @@ describe('AgentConfigService', () => {
   });
 
   describe('getAgentConfig', () => {
+    const mockTeamData = [
+      {id: 'team1', name: 'Support Team'},
+      {id: 'team2', name: 'Sales Team'},
+    ];
+
+    const mockOrgInfo = {
+      tenantId: 'tenant123',
+      timezone: 'GMT',
+    };
+
+    const mockSiteInfo = {
+      id: 'c6a5451f-5ba7-49a1-aee8-fbef70c19ece',
+      name: 'Site-1',
+      multimediaProfileId: 'c5888e6f-5661-4871-9936-cbcec7658d41',
+    };
+
+    const mockURLMapping = [
+      {key: 'ACQUEON_API_URL', url: 'https://api.example.com'},
+      {key: 'ACQUEON_CONSOLE_URL', url: 'https://console.example.com'},
+    ];
+
+    const mockAIFeatureFlags = {
+      data: [{realtimeTranscripts: {enable: true}}],
+    };
+
     beforeEach(() => {
       jest.clearAllMocks();
     });
@@ -753,29 +774,12 @@ describe('AgentConfigService', () => {
 
       const mockDialPlanData = [];
 
-      const mockTeamData = [
-        {id: 'team1', name: 'Support Team'},
-        {id: 'team2', name: 'Sales Team'},
-      ];
-
-      const mockOrgInfo = {
-        tenantId: 'tenant123',
-        timezone: 'GMT',
-        environment: 'produs1',
-      };
-
       const mockOrgSettings = {
         campaignManagerEnabled: true,
         webRtcEnabled: true,
         maskSensitiveData: false,
       };
 
-      const mockSiteInfo = {
-        id: 'c6a5451f-5ba7-49a1-aee8-fbef70c19ece',
-        name: 'Site-1',
-        multimediaProfileId: 'c5888e6f-5661-4871-9936-cbcec7658d41',
-      };
-
       const mockTenantData = {
         timeoutDesktopInactivityEnabled: false,
         timeoutDesktopInactivityMins: 15,
@@ -789,18 +793,10 @@ describe('AgentConfigService', () => {
         callVariablesSuppressed: false,
       };
 
-      const mockURLMapping = [
-        {key: 'ACQUEON_API_URL', url: 'https://api.example.com'},
-        {key: 'ACQUEON_CONSOLE_URL', url: 'https://console.example.com'},
-      ];
-
       const mockAuxCodes = [
         {id: 'aux1', type: 'WRAP_UP_CODE', name: 'Wrap Up Code 1', isDefault: true},
         {id: 'aux2', type: 'IDLE_CODE', name: 'Idle Code 1', isDefault: true},
       ];
-      const mockAIFeatureFlags = {
-        data: [{realtimeTranscripts: {enable: true}}],
-      };
 
       const parseAgentConfigsSpy = jest.spyOn(util, 'parseAgentConfigs');
       agentConfigService.getUserUsingCI = jest.fn().mockResolvedValue(mockUserConfig);
@@ -898,29 +894,12 @@ describe('AgentConfigService', () => {
         {id: 'dialPlan2', name: 'Plan 2'},
       ];
 
-      const mockTeamData = [
-        {id: 'team1', name: 'Support Team'},
-        {id: 'team2', name: 'Sales Team'},
-      ];
-
-      const mockOrgInfo = {
-        tenantId: 'tenant123',
-        timezone: 'GMT',
-        environment: 'produs1',
-      };
-
       const mockOrgSettings = {
         campaignManagerEnabled: true,
         webRtcEnabled: true,
         maskSensitiveData: true,
       };
 
-      const mockSiteInfo = {
-        id: 'c6a5451f-5ba7-49a1-aee8-fbef70c19ece',
-        name: 'Site-1',
-        multimediaProfileId: 'c5888e6f-5661-4871-9936-cbcec7658d41',
-      };
-
       const mockTenantData = {
         timeoutDesktopInactivityEnabled: true,
         timeoutDesktopInactivityMins: 15,
@@ -935,18 +914,10 @@ describe('AgentConfigService', () => {
         lostConnectionRecoveryTimeout: 30,
       };
 
-      const mockURLMapping = [
-        {key: 'ACQUEON_API_URL', url: 'https://api.example.com'},
-        {key: 'ACQUEON_CONSOLE_URL', url: 'https://console.example.com'},
-      ];
-
       const mockAuxCodes = [
         {id: 'aux1', type: 'WRAP_UP_CODE', name: 'Wrap Up Code 1'},
         {id: 'aux2', type: 'IDLE_CODE', name: 'Idle Code 1'},
       ];
-      const mockAIFeatureFlags = {
-        data: [{realtimeTranscripts: {enable: true}}],
-      };
 
       const parseAgentConfigsSpy = jest.spyOn(util, 'parseAgentConfigs');
       agentConfigService.getUserUsingCI = jest.fn().mockResolvedValue(mockUserConfig);