@webex/contact-center 3.9.0-next.9 → 3.10.0

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

@@ -1353,6 +1353,388 @@ describe('TaskManager', () => {
         expect(spy).toHaveBeenCalledWith(taskEvent, task);
       });
     });
+  });
+
+  describe('Conference event handling', () => {
+    let task;
+    const agentId = '723a8ffb-a26e-496d-b14a-ff44fb83b64f';
+    
+    beforeEach(() => {
+      // Set the agentId on taskManager before tests run
+      taskManager.setAgentId(agentId);
+      
+      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
+    });
+
+    describe('PARTICIPANT_LEFT_CONFERENCE event handling', () => {
+      it('should emit TASK_PARTICIPANT_LEFT event when participant leaves conference', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent is still in interaction', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist in collection
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent left but is in main interaction', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist - not removed
+        expect(removeTaskSpy).not.toHaveBeenCalled();
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should NOT remove task when agent left but is primary (owner)', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              owner: agentId,
+              media: {
+                [taskId]: {
+                  mType: 'consultCall',
+                  participants: ['other-agent'],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should still exist - not removed because agent is primary
+        expect(removeTaskSpy).not.toHaveBeenCalled();
+        expect(taskManager.getTask(taskId)).toBeDefined();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should remove task when agent left and is NOT in main interaction and is NOT primary', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: true,
+                },
+              },
+              owner: 'another-agent-id',
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: ['another-agent-id'],
+                },
+              },
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should be removed
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should remove task when agent is not in participants list', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                'other-agent-id': {
+                  hasLeft: false,
+                },
+              },
+              owner: 'another-agent-id',
+            },
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // Task should be removed because agent is not in participants
+        expect(removeTaskSpy).toHaveBeenCalled();
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should update isConferenceInProgress based on remaining active agents', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'agent-2': {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'customer-1': {
+                  hasLeft: false,
+                  pType: 'Customer',
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId, 'agent-2', 'customer-1'],
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // isConferenceInProgress should be true (2 active agents)
+        expect(task.data.isConferenceInProgress).toBe(true);
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should set isConferenceInProgress to false when only one agent remains', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {
+              participants: {
+                [agentId]: {
+                  hasLeft: false,
+                  pType: 'Agent',
+                },
+                'agent-2': {
+                  hasLeft: true,
+                  pType: 'Agent',
+                },
+                'customer-1': {
+                  hasLeft: false,
+                  pType: 'Customer',
+                },
+              },
+              media: {
+                [taskId]: {
+                  mType: 'mainCall',
+                  participants: [agentId, 'customer-1'],
+                },
+              },
+            },
+          },
+        };
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // isConferenceInProgress should be false (only 1 active agent)
+        expect(task.data.isConferenceInProgress).toBe(false);
+        expect(task.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_PARTICIPANT_LEFT, task);
+      });
+
+      it('should handle participant left when no participants data exists', () => {
+        const payload = {
+          data: {
+            type: CC_EVENTS.PARTICIPANT_LEFT_CONFERENCE,
+            interactionId: taskId,
+            interaction: {},
+          },
+        };
+
+        const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
+
+        webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+        // When no participants data exists, checkParticipantNotInInteraction returns true
+        // Since agent won't be in main interaction either, task should be removed
+        expect(removeTaskSpy).toHaveBeenCalled();
+        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/TaskUtils.ts

@@ -0,0 +1,131 @@
+import { checkParticipantNotInInteraction,
+  getIsConferenceInProgress,
+  isParticipantInMainInteraction,
+  isPrimary,} from '../../../../../src/services/task/TaskUtils';
+import {ITask} from '../../../../../src/services/task/types';
+
+describe('TaskUtils', () => {
+  let mockTask: ITask;
+  const mockAgentId = 'agent-123';
+  const mockOtherAgentId = 'agent-456';
+
+  beforeEach(() => {
+    mockTask = {
+      data: {
+        interactionId: 'interaction-123',
+        agentId: mockAgentId,
+        interaction: {
+          owner: mockAgentId,
+          participants: {
+            [mockAgentId]: { hasLeft: false },
+            [mockOtherAgentId]: { hasLeft: false },
+          },
+          media: {
+            'media-1': {
+              mType: 'mainCall',
+              participants: [mockAgentId, mockOtherAgentId],
+            },
+          },
+        },
+      },
+      emit: jest.fn(),
+      updateTaskData: jest.fn(),
+    } as any;
+  });
+
+  describe('isPrimary', () => {
+    it('should return true when agent is the owner', () => {
+      expect(isPrimary(mockTask, mockAgentId)).toBe(true);
+    });
+
+    it('should return false when agent is not the owner', () => {
+      expect(isPrimary(mockTask, mockOtherAgentId)).toBe(false);
+    });
+
+    it('should fallback to data.agentId when owner is not set', () => {
+      mockTask.data.interaction.owner = undefined;
+      expect(isPrimary(mockTask, mockAgentId)).toBe(true);
+      expect(isPrimary(mockTask, mockOtherAgentId)).toBe(false);
+    });
+  });
+
+  describe('isParticipantInMainInteraction', () => {
+    it('should return true when agent is in mainCall media', () => {
+      expect(isParticipantInMainInteraction(mockTask, mockAgentId)).toBe(true);
+    });
+
+    it('should return false when agent is not in mainCall media', () => {
+      mockTask.data.interaction.media['media-1'].participants = [mockOtherAgentId];
+      expect(isParticipantInMainInteraction(mockTask, mockAgentId)).toBe(false);
+    });
+
+    it('should return false when no mainCall media exists', () => {
+      mockTask.data.interaction.media['media-1'].mType = 'consult';
+      expect(isParticipantInMainInteraction(mockTask, mockAgentId)).toBe(false);
+    });
+  });
+
+  describe('checkParticipantNotInInteraction', () => {
+    it('should return false when agent is active participant', () => {
+      expect(checkParticipantNotInInteraction(mockTask, mockAgentId)).toBe(false);
+    });
+
+    it('should return true when agent is not in participants', () => {
+      delete mockTask.data.interaction.participants[mockAgentId];
+      expect(checkParticipantNotInInteraction(mockTask, mockAgentId)).toBe(true);
+    });
+
+    it('should return true when agent has left', () => {
+      mockTask.data.interaction.participants[mockAgentId].hasLeft = true;
+      expect(checkParticipantNotInInteraction(mockTask, mockAgentId)).toBe(true);
+    });
+  });
+
+  describe('getIsConferenceInProgress', () => {
+    beforeEach(() => {
+      // Set up mock task with proper media structure for conference detection
+      mockTask.data.interaction.media = {
+        [mockTask.data.interactionId]: {
+          mType: 'mainCall',
+          participants: [mockAgentId, mockOtherAgentId, 'customer-123'],
+        },
+      };
+      mockTask.data.interaction.participants = {
+        [mockAgentId]: { pType: 'Agent', hasLeft: false },
+        [mockOtherAgentId]: { pType: 'Agent', hasLeft: false },
+        'customer-123': { pType: 'Customer', hasLeft: false },
+      };
+    });
+
+    it('should return true when there are 2 or more active agents', () => {
+      expect(getIsConferenceInProgress(mockTask)).toBe(true);
+    });
+
+    it('should return false when there is only 1 active agent', () => {
+      mockTask.data.interaction.participants[mockOtherAgentId].hasLeft = true;
+      expect(getIsConferenceInProgress(mockTask)).toBe(false);
+    });
+
+    it('should exclude customers from agent count', () => {
+      // Remove one agent, should still be false with only 1 agent + customer
+      delete mockTask.data.interaction.participants[mockOtherAgentId];
+      mockTask.data.interaction.media[mockTask.data.interactionId].participants = [mockAgentId, 'customer-123'];
+      expect(getIsConferenceInProgress(mockTask)).toBe(false);
+    });
+
+    it('should exclude supervisors from agent count', () => {
+      mockTask.data.interaction.participants[mockOtherAgentId].pType = 'Supervisor';
+      expect(getIsConferenceInProgress(mockTask)).toBe(false);
+    });
+
+    it('should exclude VVA from agent count', () => {
+      mockTask.data.interaction.participants[mockOtherAgentId].pType = 'VVA';
+      expect(getIsConferenceInProgress(mockTask)).toBe(false);
+    });
+
+    it('should return false when no main call media exists', () => {
+      mockTask.data.interaction.media = {};
+      expect(getIsConferenceInProgress(mockTask)).toBe(false);
+    });
+  });
+});

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();
   });
 });