@webex/contact-center 3.9.0-next.24 → 3.9.0-next.26

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/index.ts

@@ -217,7 +217,7 @@ describe('Task', () => {
   });
 
   describe('updateTaskData cases', () => {
-    it('test updating the task data by overwrite', async () => {
+    it('updates the task data by overwrite', async () => {
       const newData = {
         type: CC_EVENTS.AGENT_CONTACT_ASSIGNED,
         agentId: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
@@ -266,12 +266,12 @@ describe('Task', () => {
       expect(task.data).toEqual(newData);
     });
 
-    it('test updating the task data by merging', async () => {
+    it('updates the task data by merging with key removal', async () => {
       const newData = {
-        // ...taskDataMock, // Purposefully omit this to test scenario when other keys isn't present
+        // Purposefully omit other keys to test remove and merge behavior
         isConsulting: true, // Add a new custom key to test persistence
         interaction: {
-          // ...taskDataMock.interaction, // Purposefully omit this to test scenario when a nested key isn't present
+          // Purposefully omit other interaction keys to test removal
           media: {
             '58a45567-4e61-4f4b-a580-5bc86357bef0': {
               holdTimestamp: null,
@@ -298,11 +298,12 @@ describe('Task', () => {
         },
       };
 
+      // The reconcileData method removes keys from oldData that are not in newData
+      // This means only keys present in newData will remain in the final result
       const expectedData: TaskData = {
-        ...taskDataMock,
-        isConsulting: true,
+        isConsulting: true, // New key is added
         interaction: {
-          ...taskDataMock.interaction,
+          // Only the media key from newData.interaction remains
           media: {
             '58a45567-4e61-4f4b-a580-5bc86357bef0': {
               holdTimestamp: null,
@@ -335,6 +336,60 @@ describe('Task', () => {
 
       expect(task.data).toEqual(expectedData);
     });
+
+    it('updates the task data by merging and preserving existing keys', async () => {
+      const newData = {
+        ...taskDataMock, // Include all existing keys to test merge without removal
+        isConsulting: true, // Add a new custom key
+        interaction: {
+          ...taskDataMock.interaction, // Include existing interaction data
+          media: {
+            ...taskDataMock.interaction.media, // Include existing media
+            '58a45567-4e61-4f4b-a580-5bc86357bef0': {
+              holdTimestamp: null,
+              isHold: true,
+              mType: 'consult',
+              mediaMgr: 'callmm',
+              mediaResourceId: '58a45567-4e61-4f4b-a580-5bc86357bef0',
+              mediaType: 'telephony',
+              participants: [
+                'f520d6b5-28ad-4f2f-b83e-781bb64af617',
+                '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+              ],
+            },
+          },
+        },
+      };
+
+      const expectedData: TaskData = {
+        ...taskDataMock,
+        isConsulting: true,
+        interaction: {
+          ...taskDataMock.interaction,
+          media: {
+            ...taskDataMock.interaction.media,
+            '58a45567-4e61-4f4b-a580-5bc86357bef0': {
+              holdTimestamp: null,
+              isHold: true,
+              mType: 'consult',
+              mediaMgr: 'callmm',
+              mediaResourceId: '58a45567-4e61-4f4b-a580-5bc86357bef0',
+              mediaType: 'telephony',
+              participants: [
+                'f520d6b5-28ad-4f2f-b83e-781bb64af617',
+                '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+              ],
+            },
+          },
+        },
+      };
+
+      expect(task.data).toEqual(taskDataMock);
+      const shouldOverwrite = false;
+      task.updateTaskData(newData, shouldOverwrite);
+
+      expect(task.data).toEqual(expectedData);
+    });
   });
 
   it('should accept a task and answer call when using BROWSER login option', async () => {
@@ -1707,9 +1762,6 @@ describe('Task', () => {
       });
     });
 
-    // TODO: Uncomment this test section in future PR for Multi-Party Conference support (>3 participants)
-    // Conference transfer tests will be uncommented when implementing enhanced multi-party conference functionality
-    /*
     describe('transferConference', () => {
       it('should successfully transfer conference', async () => {
         const mockResponse = {
@@ -1756,6 +1808,5 @@ describe('Task', () => {
         });
       });
     });
-    */
   });
 });