@webex/contact-center 3.12.0-next.73 → 3.12.0-next.74

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

@@ -8,6 +8,12 @@ import {
   isDigitalOutbound,
   hasAgentInitiatedOutdial,
   shouldAutoAnswerTask,
+  getIsCustomerInCall,
+  getConferenceParticipantsCount,
+  isSecondaryAgent,
+  isSecondaryEpDnAgent,
+  getConsultMediaResourceId,
+  getIsConsultInProgressForConferenceControls,
 } from '../../../../../src/services/task/TaskUtils';
 import {ITask, Interaction, TaskData} from '../../../../../src/services/task/types';
 import {LoginOption} from '../../../../../src/types';
@@ -430,4 +436,204 @@ describe('TaskUtils', () => {
       });
     });
   });
+
+  // Additional coverage for conference/consult utility functions
+  describe('Conference Utility Functions', () => {
+    const interactionId = 'interaction-123';
+    const createInteraction = (media: any = {}, participants: any = {}) =>
+      ({interactionId, mainInteractionId: interactionId, media, participants}) as any;
+
+    it('getIsCustomerInCall returns true when customer active', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['c1']}},
+        {'c1': {pType: 'Customer', hasLeft: false}}
+      );
+      expect(getIsCustomerInCall(interaction, interactionId)).toBe(true);
+    });
+
+    it('getIsCustomerInCall returns false when participants map is missing', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['c1']}},
+        undefined
+      );
+      expect(getIsCustomerInCall(interaction, interactionId)).toBe(false);
+    });
+
+    it('getConferenceParticipantsCount counts active agents only', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['a1', 'a2', 'c1']}},
+        {'a1': {pType: 'Agent', hasLeft: false}, 'a2': {pType: 'Agent', hasLeft: false}, 'c1': {pType: 'Customer', hasLeft: false}}
+      );
+      expect(getConferenceParticipantsCount(interaction, interactionId)).toBe(2);
+    });
+
+    it('getConferenceParticipantsCount returns 0 when participants map is missing', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['a1', 'a2', 'c1']}},
+        undefined
+      );
+      expect(getConferenceParticipantsCount(interaction, interactionId)).toBe(0);
+    });
+
+    it('isSecondaryAgent returns true for consult with parentInteractionId', () => {
+      const interaction = createInteraction();
+      interaction.callProcessingDetails = {relationshipType: 'consult', parentInteractionId: 'parent-456'};
+      expect(isSecondaryAgent(interaction)).toBe(true);
+    });
+
+    it('isSecondaryEpDnAgent returns true for telephony secondary agent', () => {
+      const interaction = createInteraction();
+      interaction.mediaType = 'telephony';
+      interaction.callProcessingDetails = {relationshipType: 'consult', parentInteractionId: 'parent-456'};
+      expect(isSecondaryEpDnAgent(interaction)).toBe(true);
+    });
+  });
+
+  describe('getConsultMediaResourceId', () => {
+    it('returns consultMediaResourceId directly when provided', () => {
+      const result = getConsultMediaResourceId(undefined, 'consult-media-1', 'agent1');
+      expect(result).toBe('consult-media-1');
+    });
+
+    it('returns undefined when no interaction and no consultMediaResourceId', () => {
+      const result = getConsultMediaResourceId(undefined, undefined, 'agent1');
+      expect(result).toBeUndefined();
+    });
+
+    it('returns undefined when no agentId and no consultMediaResourceId', () => {
+      const interaction = {media: {}} as any;
+      const result = getConsultMediaResourceId(interaction, undefined, undefined);
+      expect(result).toBeUndefined();
+    });
+
+    it('finds consult media leg by mType and agent participation', () => {
+      const interaction = {
+        media: {
+          'main-media': {
+            mediaResourceId: 'main-media',
+            mType: 'mainCall',
+            participants: ['agent1', 'customer1'],
+          },
+          'consult-media': {
+            mediaResourceId: 'consult-media',
+            mType: 'consult',
+            participants: ['agent1', 'agent2'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, undefined, 'agent1');
+      expect(result).toBe('consult-media');
+    });
+
+    it('returns undefined when no consult media leg matches the agent', () => {
+      const interaction = {
+        media: {
+          'main-media': {
+            mediaResourceId: 'main-media',
+            mType: 'mainCall',
+            participants: ['agent1', 'customer1'],
+          },
+          'consult-media': {
+            mediaResourceId: 'consult-media',
+            mType: 'consult',
+            participants: ['agent2', 'agent3'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, undefined, 'agent1');
+      expect(result).toBeUndefined();
+    });
+
+    it('returns undefined when media has no consult type entries', () => {
+      const interaction = {
+        media: {
+          'main-media': {
+            mediaResourceId: 'main-media',
+            mType: 'mainCall',
+            participants: ['agent1', 'customer1'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, undefined, 'agent1');
+      expect(result).toBeUndefined();
+    });
+
+    it('prioritizes direct consultMediaResourceId over interaction search', () => {
+      const interaction = {
+        media: {
+          'consult-media': {
+            mediaResourceId: 'consult-media',
+            mType: 'consult',
+            participants: ['agent1', 'agent2'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, 'direct-id', 'agent1');
+      expect(result).toBe('direct-id');
+    });
+  });
+
+  describe('getIsConsultInProgressForConferenceControls', () => {
+    it('returns false when consultee is reserved but has not joined (RONA)', () => {
+      const interaction = {
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false, isConsulted: false},
+          'agent-2': {
+            id: 'agent-2',
+            pType: 'Agent',
+            hasLeft: false,
+            hasJoined: false,
+            isConsulted: true,
+            consultState: 'consultReserved',
+          },
+          'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            mType: 'mainCall',
+            participants: ['customer-1', 'agent-1'],
+          },
+          'consult-media': {
+            mType: 'consult',
+            participants: ['agent-2', 'agent-1'],
+          },
+        },
+      } as any;
+
+      expect(
+        getIsConsultInProgressForConferenceControls(interaction, 'interaction-1', 'agent-1')
+      ).toBe(false);
+    });
+
+    it('returns true when consultee is actively consulting', () => {
+      const interaction = {
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false, isConsulted: false},
+          'agent-2': {
+            id: 'agent-2',
+            pType: 'Agent',
+            hasLeft: false,
+            hasJoined: true,
+            isConsulted: true,
+            consultState: 'consulting',
+          },
+          'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            mType: 'mainCall',
+            participants: ['customer-1', 'agent-1'],
+          },
+          'consult-media': {
+            mType: 'consult',
+            participants: ['agent-2', 'agent-1'],
+          },
+        },
+      } as any;
+
+      expect(
+        getIsConsultInProgressForConferenceControls(interaction, 'interaction-1', 'agent-1')
+      ).toBe(true);
+    });
+  });
 });

package/test/unit/spec/services/task/digital/Digital.ts

@@ -0,0 +1,105 @@
+import Digital from '../../../../../../src/services/task/digital/Digital';
+import {MEDIA_CHANNEL, TaskData, TaskResponse} from '../../../../../../src/services/task/types';
+import {TaskEvent, TaskEventPayload} from '../../../../../../src/services/task/state-machine';
+
+jest.mock('../../../../../../src/services/core/WebexRequest', () => ({
+  __esModule: true,
+  default: {
+    getInstance: () => ({ uploadLogs: jest.fn() }),
+  },
+}));
+
+const sendStateEvents = (task: Digital, events: TaskEventPayload[]) => {
+  events.forEach((event) => {
+    if (!event) {
+      throw new Error('Task event payload is required');
+    }
+    task.stateMachineService?.send(event);
+  });
+};
+
+describe('Digital Task', () => {
+  const dummyData = {
+    interactionId: 'dig1',
+    interaction: {isTerminated: false, mediaType: MEDIA_CHANNEL.CHAT},
+  } as TaskData;
+  let dummyContact: { accept: jest.Mock<Promise<TaskResponse>> };
+
+  beforeEach(() => {
+    dummyContact = {
+      accept: jest.fn().mockResolvedValue({ status: 'ok' }),
+    };
+  });
+
+  it('accept() calls contact.accept with interactionId', async () => {
+    const task = new Digital(dummyContact, dummyData);
+    const res = await task.accept();
+    expect(dummyContact.accept).toHaveBeenCalledWith({ interactionId: 'dig1' });
+    expect(res).toEqual({ status: 'ok' });
+  });
+
+  it('accept() throws an error when contact.accept rejects', async () => {
+    const error = new Error('Error while performing accept');
+    (dummyContact.accept as jest.Mock).mockRejectedValue(error);
+    const task = new Digital(dummyContact, dummyData);
+    await expect(task.accept()).rejects.toThrow('Error while performing accept');
+  });
+
+  it('constructor shows accept when offered', () => {
+    const task = new Digital(dummyContact, dummyData);
+    sendStateEvents(task, [{type: TaskEvent.TASK_INCOMING, taskData: dummyData}]);
+    expect(task.uiControls.main.accept.isVisible).toBe(true);
+    expect(task.uiControls.main.accept.isEnabled).toBe(true);
+  });
+
+  describe('UI controls derived from state machine events', () => {
+    it('connected state shows transfer and end', () => {
+      const task = new Digital(dummyContact, dummyData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.ASSIGN, taskData: dummyData},
+      ]);
+      expect(task.uiControls.main.accept.isVisible).toBe(false);
+      expect(task.uiControls.main.transfer.isVisible).toBe(true);
+      expect(task.uiControls.main.end.isVisible).toBe(true);
+      expect(task.uiControls.main.wrapup.isVisible).toBe(false);
+    });
+
+    it('wrapup state hides transfer/end and shows wrapup button', () => {
+      const task = new Digital(dummyContact, dummyData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.ASSIGN, taskData: dummyData},
+        {type: TaskEvent.TASK_WRAPUP},
+      ]);
+      expect(task.uiControls.main.transfer.isVisible).toBe(false);
+      expect(task.uiControls.main.end.isVisible).toBe(false);
+      expect(task.uiControls.main.wrapup.isVisible).toBe(true);
+    });
+
+    it('terminated interaction toggles wrapup visibility even before END event', () => {
+      const task = new Digital(dummyContact, dummyData);
+      const terminatedData = {
+        ...dummyData,
+        interaction: {...(dummyData.interaction as any), isTerminated: true},
+      } as TaskData;
+      task.updateTaskData(terminatedData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.ASSIGN, taskData: terminatedData},
+      ]);
+      expect(task.uiControls.main.wrapup.isVisible).toBe(true);
+    });
+
+    it('rona hides accept controls', () => {
+      const task = new Digital(dummyContact, dummyData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.RONA},
+      ]);
+      expect(task.uiControls.main.accept.isVisible).toBe(false);
+      expect(task.uiControls.main.transfer.isVisible).toBe(false);
+      expect(task.uiControls.main.end.isVisible).toBe(false);
+    });
+  });
+});