@webex/contact-center 3.8.1 → 3.9.0-multipleLLM.1

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,
@@ -1346,6 +1353,143 @@ describe('TaskManager', () => {
         expect(spy).toHaveBeenCalledWith(taskEvent, task);
       });
     });
+  });
+
+  describe('Conference event handling', () => {
+    let task;
+    
+    beforeEach(() => {
+      task = {
+        data: { interactionId: taskId },
+        emit: jest.fn(),
+        updateTaskData: jest.fn().mockImplementation((updatedData) => {
+          // Mock the updateTaskData method to actually update task.data
+          task.data = { ...task.data, ...updatedData };
+          return task;
+        }),
+      };
+      taskManager.taskCollection[taskId] = task;
+    });
+
+    it('should handle AGENT_CONSULT_CONFERENCED event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCED,
+          interactionId: taskId,
+          isConferencing: true,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.isConferencing).toBe(true);
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+    });
+
+    it('should handle AGENT_CONSULT_CONFERENCING event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCING,
+          interactionId: taskId,
+          isConferencing: true,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.isConferencing).toBe(true);
+      // No task event emission for conferencing - only for conferenced (completed)
+      expect(task.emit).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+    });
+
+    it('should handle AGENT_CONSULT_CONFERENCE_FAILED event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCE_FAILED,
+          interactionId: taskId,
+          reason: 'Network error',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.reason).toBe('Network error');
+      // No event emission expected for failure - handled by contact method promise rejection
+    });
+
+    it('should handle PARTICIPANT_JOINED_CONFERENCE event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.PARTICIPANT_JOINED_CONFERENCE,
+          interactionId: taskId,
+          participantId: 'new-participant-123',
+          participantType: 'agent',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.participantId).toBe('new-participant-123');
+      expect(task.data.participantType).toBe('agent');
+      // No specific task event emission for participant joined - just data update
+    });
+
+    it('should handle PARTICIPANT_LEFT_CONFERENCE event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+          interactionId: taskId,
+          isConferencing: false,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.isConferencing).toBe(false);
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+    });
+
+    it('should handle PARTICIPANT_LEFT_CONFERENCE_FAILED event', () => {
+      const payload = {
+        data: {
+          type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE_FAILED,
+          interactionId: taskId,
+          reason: 'Exit failed',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.data.reason).toBe('Exit failed');
+      // No event emission expected for failure - handled by contact method promise rejection
+    });
+
+    it('should only update task for matching interactionId', () => {
+      const otherTaskId = 'other-task-id';
+      const otherTask = {
+        data: { interactionId: otherTaskId },
+        emit: jest.fn(),
+      };
+      taskManager.taskCollection[otherTaskId] = otherTask;
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.AGENT_CONSULT_CONFERENCED,
+          interactionId: taskId,
+          isConferencing: true,
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      // Only the matching task should be updated
+      expect(task.data.isConferencing).toBe(true);
+      expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_CONFERENCE_STARTED, task);
+      
+      // Other task should not be affected
+      expect(otherTask.data.isConferencing).toBeUndefined();
+      expect(otherTask.emit).not.toHaveBeenCalled();
+    });
   });  
 });
 

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

@@ -197,7 +197,37 @@ describe("Routing contacts", () => {
     const req = contact.wrapup({
       interactionId: "interactionId",
       data: { wrapUpReason: "testWrapUpReason", auxCodeId: "auxCodeID1234", isAutoWrapup: "on" }
-    } as any);
+  } as any);
+  expect(req).toBeDefined();
+});
+
+  it("consultConference", () => {
+    fakeAqm.pendingRequests = {};
+    const consultData = {
+      agentId: "current-agent-id",
+      to: "destination-agent-id",
+      destinationType: "agent"
+    };
+    const req = contact.consultConference({
+      interactionId: "test-interaction-123",
+      data: consultData
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("exitConference", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.exitConference({
+      interactionId: "test-interaction-456"
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("conferenceTransfer", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.conferenceTransfer({
+      interactionId: "test-interaction-transfer-123"
+    });
     expect(req).toBeDefined();
   });
 });