@webex/contact-center 3.12.0-next.13 → 3.12.0-next.130

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,233 @@ 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);
+    });
+
+    it('returns true when EP-DN participant is on consult leg but not main call (CAI-8329)', () => {
+      const interaction = {
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false, consultState: 'conferencing'},
+          '+13159998087': {
+            id: '+13159998087',
+            pType: 'EP-DN',
+            type: 'EpDn',
+            hasLeft: false,
+          },
+          'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false, hasJoined: true},
+        },
+        media: {
+          'interaction-1': {
+            mType: 'mainCall',
+            participants: ['customer-1', 'agent-1'],
+          },
+          'consult-media-1': {
+            mType: 'consult',
+            participants: ['+13159998087', 'agent-1'],
+          },
+        },
+      } as any;
+
+      expect(
+        getIsConsultInProgressForConferenceControls(interaction, 'interaction-1', 'agent-1')
+      ).toBe(true);
+    });
+  });
 });

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

@@ -0,0 +1,153 @@
+import {expect} from '@jest/globals';
+import {
+  getWebexCallingDeviceDetailsForAgent,
+  isWebexCallingCallForAgent,
+  isWxAppEngagedForControls,
+  decodedLineOwnerId,
+} from '../../../../../src/services/task/WebexCallingUtils';
+import {TaskState} from '../../../../../src/services/task/state-machine/constants';
+
+const WX_APP_PARTICIPANT = {
+  id: 'agent-1',
+  deviceType: 'wxApp',
+  deviceId: 'device-id-1',
+  deviceCallId: 'call-id-1',
+};
+
+const participantsById = {
+  'agent-1': WX_APP_PARTICIPANT,
+  'customer-1': {id: 'customer-1', pType: 'Customer'},
+};
+
+describe('getWebexCallingDeviceDetailsForAgent', () => {
+  it('returns device details when agent participant has wxApp deviceType', () => {
+    const result = getWebexCallingDeviceDetailsForAgent('agent-1', participantsById);
+
+    expect(result).toEqual({
+      deviceType: 'wxApp',
+      deviceId: 'device-id-1',
+      deviceCallId: 'call-id-1',
+    });
+  });
+
+  it('returns undefined when agentId is undefined', () => {
+    expect(getWebexCallingDeviceDetailsForAgent(undefined, participantsById)).toBeUndefined();
+  });
+
+  it('returns undefined when agentId is empty string', () => {
+    expect(getWebexCallingDeviceDetailsForAgent('', participantsById)).toBeUndefined();
+  });
+
+  it('returns undefined when participants is null', () => {
+    expect(getWebexCallingDeviceDetailsForAgent('agent-1', null)).toBeUndefined();
+  });
+
+  it('returns undefined when participants is an array (not object-by-id)', () => {
+    expect(getWebexCallingDeviceDetailsForAgent('agent-1', [WX_APP_PARTICIPANT])).toBeUndefined();
+  });
+
+  it('returns undefined when agent participant lacks deviceCallId', () => {
+    const participants = {
+      'agent-1': {id: 'agent-1', deviceType: 'wxApp', deviceId: 'device-id-1'},
+    };
+
+    expect(getWebexCallingDeviceDetailsForAgent('agent-1', participants)).toBeUndefined();
+  });
+
+  it('returns undefined when agent participant lacks deviceId', () => {
+    const participants = {
+      'agent-1': {id: 'agent-1', deviceType: 'wxApp', deviceCallId: 'call-id-1'},
+    };
+
+    expect(getWebexCallingDeviceDetailsForAgent('agent-1', participants)).toBeUndefined();
+  });
+
+  it('finds participant by id field when keyed differently', () => {
+    const participants = {
+      'some-other-key': WX_APP_PARTICIPANT,
+    };
+    const result = getWebexCallingDeviceDetailsForAgent('agent-1', participants);
+
+    expect(result?.deviceCallId).toBe('call-id-1');
+  });
+
+  it('defaults deviceType to empty string when missing', () => {
+    const participants = {
+      'agent-1': {id: 'agent-1', deviceId: 'device-id-1', deviceCallId: 'call-id-1'},
+    };
+    const result = getWebexCallingDeviceDetailsForAgent('agent-1', participants);
+
+    expect(result?.deviceType).toBe('');
+  });
+});
+
+describe('isWebexCallingCallForAgent', () => {
+  it('returns true when device details are found', () => {
+    expect(isWebexCallingCallForAgent('agent-1', participantsById)).toBe(true);
+  });
+
+  it('returns false when no device details are found', () => {
+    expect(isWebexCallingCallForAgent('unknown-agent', participantsById)).toBe(false);
+  });
+
+  it('returns false when agentId is undefined', () => {
+    expect(isWebexCallingCallForAgent(undefined, participantsById)).toBe(false);
+  });
+});
+
+describe('isWxAppEngagedForControls', () => {
+  it('returns true when flag is on, wxApp participant exists, and state is CONNECTED', () => {
+    expect(
+      isWxAppEngagedForControls(true, 'agent-1', participantsById, TaskState.CONNECTED)
+    ).toBe(true);
+  });
+
+  it('returns false in OFFERED state', () => {
+    expect(isWxAppEngagedForControls(true, 'agent-1', participantsById, TaskState.OFFERED)).toBe(
+      false
+    );
+  });
+
+  it('returns false when enableWxBetterTogether is false', () => {
+    expect(
+      isWxAppEngagedForControls(false, 'agent-1', participantsById, TaskState.CONNECTED)
+    ).toBe(false);
+  });
+
+  it('returns false in TERMINATED state', () => {
+    expect(
+      isWxAppEngagedForControls(true, 'agent-1', participantsById, TaskState.TERMINATED)
+    ).toBe(false);
+  });
+
+  it('returns false in COMPLETED state', () => {
+    expect(
+      isWxAppEngagedForControls(true, 'agent-1', participantsById, TaskState.COMPLETED)
+    ).toBe(false);
+  });
+
+  it('returns false in WRAPPING_UP state', () => {
+    expect(
+      isWxAppEngagedForControls(true, 'agent-1', participantsById, TaskState.WRAPPING_UP)
+    ).toBe(false);
+  });
+});
+
+describe('decodedLineOwnerId', () => {
+  it('returns undefined when lineOwnerId is not provided', () => {
+    expect(decodedLineOwnerId(undefined)).toBeUndefined();
+    expect(decodedLineOwnerId('')).toBeUndefined();
+  });
+
+  it('decodes base64 encoded ID and returns last path segment', () => {
+    const orgId = 'ciscospark://us/ORGANIZATION/org-abc';
+    const encoded = btoa(orgId);
+    const result = decodedLineOwnerId(encoded);
+
+    expect(result).toBe('org-abc');
+  });
+
+  it('returns undefined when base64 decoding fails', () => {
+    expect(decodedLineOwnerId('not-valid-base64!!')).toBeUndefined();
+  });
+});

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

@@ -215,6 +215,39 @@ describe("Routing contacts", () => {
     expect(req).toBeDefined();
   });
 
+  it('dropConferenceParticipant', () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.dropConferenceParticipant({
+      interactionId: 'test-interaction-drop-123',
+      participantId: '+1/participant 42',
+    }) as any;
+
+    expect(req).toEqual({
+      url: '/v1/tasks/test-interaction-drop-123/conference/participants/%2B1%2Fparticipant%2042/drop',
+      data: {},
+      host: 'wcc-api-gateway',
+      err: expect.any(Function),
+      redactSensitiveLogs: true,
+      notifSuccess: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {
+            type: 'ParticipantLeftConference',
+            interactionId: 'test-interaction-drop-123',
+          },
+        },
+        msg: {},
+      },
+      notifFail: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantDropConferenceFailed'},
+        },
+        errId: 'Service.aqm.task.dropConferenceParticipant',
+      },
+    });
+  });
+
   it("exitConference", () => {
     fakeAqm.pendingRequests = {};
     const req = contact.exitConference({

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

@@ -239,5 +239,195 @@ describe('AQM routing dialer', () => {
         ).rejects.toThrow('Request Timeout');
       });
     });
+
+    describe('skipPreviewContact', () => {
+      it('should construct the correct URL with campaignId and interactionId', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const config = dialer.skipPreviewContact({data: previewPayload}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/skip`
+        );
+      });
+
+      it('should URL-encode campaignId when it contains reserved characters', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const payloadWithSpecialChars = {
+          interactionId: 'interaction-456',
+          campaignId: 'My Campaign/Test #1',
+        };
+        const config = dialer.skipPreviewContact({data: payloadWithSpecialChars}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${encodeURIComponent(
+            payloadWithSpecialChars.campaignId
+          )}/preview-task/${payloadWithSpecialChars.interactionId}/skip`
+        );
+        expect(config.url).toContain('My%20Campaign%2FTest%20%231');
+      });
+
+      it('should call the skipPreviewContact api', () => {
+        const fakeAqm = {
+          req: () =>
+            jest.fn().mockResolvedValue(() => {
+              Promise.resolve({data: 'skip preview success'});
+            }),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        dialer
+          .skipPreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('skip preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
+
+        expect(dialer.skipPreviewContact).toHaveBeenCalled();
+      });
+
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
+
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
+
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
+
+    describe('removePreviewContact', () => {
+      it('should construct the correct URL with campaignId and interactionId', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const config = dialer.removePreviewContact({data: previewPayload}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/remove`
+        );
+      });
+
+      it('should URL-encode campaignId when it contains reserved characters', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const payloadWithSpecialChars = {
+          interactionId: 'interaction-456',
+          campaignId: 'My Campaign/Test #1',
+        };
+        const config = dialer.removePreviewContact({data: payloadWithSpecialChars}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${encodeURIComponent(
+            payloadWithSpecialChars.campaignId
+          )}/preview-task/${payloadWithSpecialChars.interactionId}/remove`
+        );
+        expect(config.url).toContain('My%20Campaign%2FTest%20%231');
+      });
+
+      it('should call the removePreviewContact api', () => {
+        const fakeAqm = {
+          req: () =>
+            jest.fn().mockResolvedValue(() => {
+              Promise.resolve({data: 'remove preview success'});
+            }),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        dialer
+          .removePreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('remove preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
+
+        expect(dialer.removePreviewContact).toHaveBeenCalled();
+      });
+
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
+
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
+
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
   });
 });