@webex/contact-center 3.8.1 → 3.9.0-next.10

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

@@ -0,0 +1,323 @@
+import Queue from '../../../../src/services/Queue';
+import {HTTP_METHODS, WebexSDK, IHttpResponse} from '../../../../src/types';
+import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
+import WebexRequest from '../../../../src/services/core/WebexRequest';
+import MetricsManager from '../../../../src/metrics/MetricsManager';
+import LoggerProxy from '../../../../src/logger-proxy';
+
+jest.mock('../../../../src/metrics/MetricsManager');
+jest.mock('../../../../src/logger-proxy');
+
+describe('Queue', () => {
+  let queueAPI: Queue;
+  let mockWebex: WebexSDK;
+  let mockMetricsManager: jest.Mocked<MetricsManager>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (WebexRequest as any).instance = undefined;
+    mockWebex = {
+      credentials: {
+        getOrgId: jest.fn().mockReturnValue('test-org-id'),
+      },
+      request: jest.fn(),
+      internal: {
+        newMetrics: {
+          submitBehavioralEvent: jest.fn(),
+          submitOperationalEvent: jest.fn(),
+          submitBusinessEvent: jest.fn(),
+        },
+      },
+      ready: true,
+      once: jest.fn(),
+    } as unknown as WebexSDK;
+
+    mockMetricsManager = {
+      trackEvent: jest.fn(),
+      timeEvent: jest.fn(),
+    } as unknown as jest.Mocked<MetricsManager>;
+    (MetricsManager.getInstance as jest.Mock).mockReturnValue(mockMetricsManager);
+
+    queueAPI = new Queue(mockWebex);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with all required dependencies', () => {
+      expect(WebexRequest.getInstance({webex: mockWebex})).toBeDefined();
+      expect(MetricsManager.getInstance).toHaveBeenCalledWith({webex: mockWebex});
+    });
+  });
+
+  describe('getQueues', () => {
+    const mockQueues = [
+      {
+        id: 'queue1',
+        name: 'Support Queue',
+        queueType: 'INBOUND' as const,
+        channelType: 'TELEPHONY' as const,
+        active: true,
+        organizationId: 'test-org-id',
+        checkAgentAvailability: true,
+        serviceLevelThreshold: 300,
+        maxActiveContacts: 10,
+        maxTimeInQueue: 3600,
+        defaultMusicInQueueMediaFileId: 'media123',
+        monitoringPermitted: true,
+        parkingPermitted: true,
+        recordingPermitted: true,
+        recordingAllCallsPermitted: false,
+        pauseRecordingPermitted: true,
+        controlFlowScriptUrl: 'https://example.com/script',
+        ivrRequeueUrl: 'https://example.com/requeue',
+        routingType: 'LONGEST_AVAILABLE_AGENT' as const,
+        queueRoutingType: 'TEAM_BASED' as const,
+        callDistributionGroups: [
+          {
+            agentGroups: [{teamId: 'team1'}],
+            order: 1,
+            duration: 30
+          }
+        ],
+      },
+      {
+        id: 'queue2',
+        name: 'Sales Queue',
+        queueType: 'INBOUND' as const,
+        channelType: 'CHAT' as const,
+        active: true,
+        organizationId: 'test-org-id',
+        checkAgentAvailability: true,
+        serviceLevelThreshold: 300,
+        maxActiveContacts: 5,
+        maxTimeInQueue: 1800,
+        defaultMusicInQueueMediaFileId: 'media456',
+        monitoringPermitted: true,
+        parkingPermitted: false,
+        recordingPermitted: false,
+        recordingAllCallsPermitted: false,
+        pauseRecordingPermitted: false,
+        controlFlowScriptUrl: 'https://example.com/script2',
+        ivrRequeueUrl: 'https://example.com/requeue2',
+        routingType: 'SKILLS_BASED' as const,
+        queueRoutingType: 'SKILL_BASED' as const,
+        callDistributionGroups: [
+          {
+            agentGroups: [{teamId: 'team2'}],
+            order: 1,
+            duration: 60
+          }
+        ],
+      },
+    ];
+
+    const mockResponse: IHttpResponse = {
+      statusCode: 200,
+      method: 'GET',
+      url: '/organization/test-org-id/v2/contact-service-queue',
+      headers: {} as any,
+      body: {
+        data: mockQueues,
+        meta: {
+          page: 0,
+          pageSize: 100,
+          totalPages: 1,
+          totalRecords: 2,
+          orgid: 'test-org-id',
+        },
+      },
+    };
+
+    beforeEach(() => {
+      jest.spyOn(Date, 'now').mockReturnValue(1000);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should fetch contact service queues successfully with default parameters', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await queueAPI.getQueues();
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100',
+        method: HTTP_METHODS.GET,
+      });
+
+      expect(result).toEqual(mockResponse.body);
+      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(METRIC_EVENT_NAMES.QUEUE_FETCH_SUCCESS);
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.QUEUE_FETCH_SUCCESS,
+        {
+          orgId: 'test-org-id',
+          statusCode: 200,
+          recordCount: 2,
+          totalRecords: 2,
+          isSearchRequest: false,
+          isFirstPage: true,
+        },
+        ['behavioral', 'operational']
+      );
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching contact service queues', {
+        module: 'Queue',
+        method: 'getQueues',
+        data: expect.objectContaining({
+          orgId: 'test-org-id',
+          page: 0,
+          pageSize: 100,
+          isSearchRequest: false,
+        }),
+      });
+      expect(LoggerProxy.log).toHaveBeenCalledWith('Making API request to fetch contact service queues', {
+        module: 'Queue',
+        method: 'getQueues',
+        data: expect.objectContaining({
+          resource: '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100',
+          service: 'wcc-api-gateway',
+        }),
+      });
+    });
+
+    it('should fetch queues with custom parameters', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const params = {
+        page: 1,
+        pageSize: 25,
+        search: 'support',
+        filter: 'queueType=="INBOUND"',
+        attributes: 'id,name,queueType',
+        sortBy: 'name',
+        sortOrder: 'desc' as const,
+        desktopProfileFilter: true,
+        provisioningView: false,
+        singleObjectResponse: true,
+      };
+
+      await queueAPI.getQueues(params);
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=25&filter=queueType%3D%3D%22INBOUND%22&attributes=id%2Cname%2CqueueType&search=support&sortBy=name&sortOrder=desc&desktopProfileFilter=true&provisioningView=false&singleObjectResponse=true',
+        method: HTTP_METHODS.GET,
+      });
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.QUEUE_FETCH_SUCCESS,
+        expect.objectContaining({
+          isSearchRequest: true,
+          isFirstPage: false,
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should handle API errors and track metrics', async () => {
+      (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Internal Server Error'));
+
+      await expect(queueAPI.getQueues()).rejects.toThrow('Internal Server Error');
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100',
+        method: HTTP_METHODS.GET,
+      });
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.QUEUE_FETCH_FAILED,
+        {
+          orgId: 'test-org-id',
+          error: 'Internal Server Error',
+          isSearchRequest: false,
+          page: 0,
+          pageSize: 100,
+        },
+        ['behavioral', 'operational']
+      );
+      expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to fetch contact service queues', {
+        module: 'Queue',
+        method: 'getQueues',
+        data: expect.objectContaining({
+          orgId: 'test-org-id',
+          error: 'Internal Server Error',
+          isSearchRequest: false,
+          page: 0,
+          pageSize: 100,
+        }),
+        error: expect.any(Error),
+      });
+    });
+
+
+
+    it('should not track metrics for subsequent pages in simple pagination', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await queueAPI.getQueues({page: 2});
+      expect(result).toEqual(mockResponse.body);
+
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should track metrics for search requests on any page', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result2 = await queueAPI.getQueues({page: 2, search: 'test'});
+      expect(result2).toEqual(mockResponse.body);
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.QUEUE_FETCH_SUCCESS,
+        expect.objectContaining({
+          isSearchRequest: true,
+          isFirstPage: false,
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should call API when requested page is not cached (cache miss)', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      await queueAPI.getQueues({page: 0});
+
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce({
+        ...mockResponse,
+        body: {
+          data: mockQueues,
+          meta: {
+            page: 1,
+            pageSize: 100,
+            totalPages: 2,
+            totalRecords: 2,
+            orgid: 'test-org-id',
+          },
+        },
+      });
+
+      const callsBefore = (mockWebex.request as jest.Mock).mock.calls.length;
+      (LoggerProxy.log as jest.Mock).mockClear();
+
+      const result = await queueAPI.getQueues({page: 1});
+      const callsAfter = (mockWebex.request as jest.Mock).mock.calls.length;
+
+      expect(callsAfter).toBe(callsBefore + 1);
+      expect(result.meta.page).toBe(1);
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=100',
+        method: HTTP_METHODS.GET,
+      });
+      expect(LoggerProxy.log).toHaveBeenCalledWith('Making API request to fetch contact service queues', {
+        module: 'Queue',
+        method: 'getQueues',
+        data: expect.objectContaining({
+          resource: '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=100',
+          service: 'wcc-api-gateway',
+        }),
+      });
+    });
+  });
+});

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

@@ -961,75 +961,4 @@ describe('AgentConfigService', () => {
       );
     });
   });
-
-  describe('getQueues', () => {
-    const mockQueues = [
-      {id: 'queue1', name: 'Queue 1'},
-      {id: 'queue2', name: 'Queue 2'},
-    ];
-
-    const mockError = new Error('API call failed');
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('should return a list of queues successfully', async () => {
-      const mockResponse = {statusCode: 200, body: {data: mockQueues}};
-      mockWebexRequest.request.mockResolvedValue(mockResponse);
-
-      const result = await agentConfigService.getQueues(mockOrgId, 0, 100, 'queue', 'id==someid');
-
-      expect(mockWebexRequest.request).toHaveBeenCalledWith({
-        service: mockWccAPIURL,
-        resource: `organization/${mockOrgId}/v2/contact-service-queue?page=0&pageSize=100&desktopProfileFilter=true&search=queue&filter=id==someid`,
-        method: 'GET',
-      });
-      expect(result).toEqual(mockQueues);
-      
-      expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching queue list', {
-        module: CONFIG_FILE_NAME,
-        method: 'getQueues',
-      });
-      expect(LoggerProxy.log).toHaveBeenCalledWith('getQueues API success.', {
-        module: CONFIG_FILE_NAME,
-        method: 'getQueues',
-      });
-    });
-
-    it('should throw an error if the API call fails', async () => {
-      mockWebexRequest.request.mockRejectedValue(mockError);
-
-      await expect(agentConfigService.getQueues(mockOrgId, 0, 100)).rejects.toThrow(
-        'API call failed'
-      );
-      expect(LoggerProxy.error).toHaveBeenCalledWith(
-        'getQueues API call failed with Error: API call failed',
-        {module: CONFIG_FILE_NAME, method: 'getQueues'}
-      );
-      expect(mockWebexRequest.request).toHaveBeenCalledWith({
-        service: mockWccAPIURL,
-        resource: `organization/${mockOrgId}/v2/contact-service-queue?page=0&pageSize=100&desktopProfileFilter=true`,
-        method: 'GET',
-      });
-    });
-
-    it('should throw an error if the API call returns a non-200 status code', async () => {
-      const mockResponse = {statusCode: 500};
-      mockWebexRequest.request.mockResolvedValue(mockResponse);
-
-      await expect(agentConfigService.getQueues(mockOrgId, 0, 100)).rejects.toThrow(
-        'API call failed with 500'
-      );
-      expect(LoggerProxy.error).toHaveBeenCalledWith(
-        'getQueues API call failed with Error: API call failed with 500',
-        {module: CONFIG_FILE_NAME, method: 'getQueues'}
-      );
-      expect(mockWebexRequest.request).toHaveBeenCalledWith({
-        service: mockWccAPIURL,
-        resource: `organization/${mockOrgId}/v2/contact-service-queue?page=0&pageSize=100&desktopProfileFilter=true`,
-        method: 'GET',
-      });
-    });
-  });
 });

package/test/unit/spec/services/core/Utils.ts

@@ -276,4 +276,54 @@ describe('Utils', () => {
       });
     });
   });
+
+  describe('getDestinationAgentId', () => {
+    const currentAgentId = 'agent-current-123';
+
+    it('returns another Agent id when present and not in wrap-up', () => {
+      const participants: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        agent1: {type: 'Agent', id: 'agent-1', isWrapUp: false},
+        customer1: {type: 'Customer', id: 'cust-1', isWrapUp: false},
+      };
+
+      const result = Utils.getDestinationAgentId(participants, currentAgentId);
+      expect(result).toBe('agent-1');
+    });
+
+    it('ignores self and wrap-up participants', () => {
+      const participants: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        agentWrap: {type: 'Agent', id: 'agent-wrap', isWrapUp: true},
+      };
+
+      const result = Utils.getDestinationAgentId(participants, currentAgentId);
+      expect(result).toBe('');
+    });
+
+    it('supports DN, EpDn and entryPoint types', () => {
+      const participantsDN: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        dn1: {type: 'DN', id: 'dn-1', isWrapUp: false},
+      };
+      expect(Utils.getDestinationAgentId(participantsDN, currentAgentId)).toBe('dn-1');
+
+      const participantsEpDn: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        epdn1: {type: 'EpDn', id: 'epdn-1', isWrapUp: false},
+      };
+      expect(Utils.getDestinationAgentId(participantsEpDn, currentAgentId)).toBe('epdn-1');
+
+      const participantsEntry: any = {
+        [currentAgentId]: {type: 'Agent', id: currentAgentId, isWrapUp: false},
+        entry1: {type: 'entryPoint', id: 'entry-1', isWrapUp: false},
+      };
+      expect(Utils.getDestinationAgentId(participantsEntry, currentAgentId)).toBe('entry-1');
+    });
+
+    it('returns empty string when participants is missing or empty', () => {
+      expect(Utils.getDestinationAgentId(undefined as any, currentAgentId)).toBe('');
+      expect(Utils.getDestinationAgentId({} as any, currentAgentId)).toBe('');
+    });
+  });
 });

package/test/unit/spec/services/core/aqm-reqs.ts

@@ -381,9 +381,7 @@ describe('AqmReqs', () => {
           data: { type: 'KeepaliveEvent' },
         })
       );
-    
-      expect(LoggerProxy.info).toHaveBeenCalledWith('Keepalive from web socket', {"method": "onMessage", "module": AQM_REQS_FILE});
-    
+        
       // Unhandled event
       webSocketManagerInstance.emit(
         'message',

package/test/unit/spec/services/core/websocket/WebSocketManager.ts

@@ -200,10 +200,6 @@ describe('WebSocketManager', () => {
     await new Promise((resolve) => setTimeout(resolve, 10));
 
     expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
-    expect(LoggerProxy.info).toHaveBeenCalledWith(
-      '[WebSocketStatus] | desktop online status is false',
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler' }
-    );
     expect(LoggerProxy.error).toHaveBeenCalledWith(
       '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: network issue',
       { module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler' }

package/test/unit/spec/services/task/TaskManager.ts

@@ -658,6 +658,13 @@ describe('TaskManager', () => {
   });
 
   it('should emit TASK_CONSULT_ACCEPTED event on AGENT_CONSULTING event', () => {
+    const initialConsultingPayload = {
+      data: {
+        ...initalPayload.data,
+        type: CC_EVENTS.AGENT_OFFER_CONSULT,
+      },
+    };
+
     const consultingPayload = {
       data: {
         ...initalPayload.data,
@@ -672,8 +679,8 @@ describe('TaskManager', () => {
     });
 
     const taskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+    webSocketManagerMock.emit('message', JSON.stringify(initialConsultingPayload));
     webSocketManagerMock.emit('message', JSON.stringify(consultingPayload));
-    expect(taskManager.getTask(taskId).updateTaskData).toHaveBeenCalledWith(consultingPayload.data);
     expect(taskManager.getTask(taskId).data.isConsulted).toBe(true);
     expect(taskEmitSpy).toHaveBeenCalledWith(
       TASK_EVENTS.TASK_CONSULT_ACCEPTED,