@webex/contact-center 3.12.0-llmrefactor.1 → 3.12.0-llmrefactor.11

package/test/unit/spec/services/core/aqm-reqs.ts

@@ -334,6 +334,28 @@ describe('AqmReqs', () => {
   });
 
   describe('Event tests', () => {
+    const participantDropConfig = (participantId: string, timeout?: number | 'disabled') => ({
+      host: 'fake-host',
+      url: `/v1/tasks/interaction/conference/participants/${participantId}/drop`,
+      data: {},
+      timeout,
+      redactSensitiveLogs: true,
+      err: (error: any) => error,
+      notifSuccess: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantLeftConference', interactionId: 'interaction'},
+        },
+      },
+      notifFail: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantDropConferenceFailed'},
+        },
+        errId: 'Service.aqm.task.dropConferenceParticipant' as const,
+      },
+    });
+
     it('should handle onMessage events', async () => {
       webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
     
@@ -564,5 +586,95 @@ describe('AqmReqs', () => {
       const result = await promise;
       expect(result).toEqual(eventData);
     });
+
+    it('redacts sensitive routing failure payloads from logs', async () => {
+      const participantId = '+1/failure-secret';
+      webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
+      const promise = aqm['createPromise'](participantDropConfig(participantId, 'disabled'));
+
+      webSocketManagerInstance.emit(
+        'message',
+        JSON.stringify({
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantDropConferenceFailed', participantId},
+        })
+      );
+
+      await expect(promise).rejects.toBeDefined();
+      expect(LoggerProxy.log).toHaveBeenCalledTimes(1);
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        'Routing request failed (sensitive details redacted)',
+        expect.objectContaining({module: AQM_REQS_FILE})
+      );
+      expect(JSON.stringify((LoggerProxy.log as jest.Mock).mock.calls)).not.toContain(participantId);
+      expect(aqm['pendingRequests']).toEqual({});
+    });
+
+    it('resolves a correlated participant-left event and clears its binds', async () => {
+      jest.useFakeTimers();
+      (global.window as any).setTimeout = global.setTimeout;
+
+      try {
+        const participantId = '+1/success-secret';
+        webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
+        const promise = aqm['createPromise'](participantDropConfig(participantId));
+        const eventData = {
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantLeftConference', interactionId: 'interaction'},
+        };
+
+        webSocketManagerInstance.emit('message', JSON.stringify(eventData));
+
+        await expect(promise).resolves.toEqual(eventData);
+        expect(aqm['pendingRequests']).toEqual({});
+      } finally {
+        jest.useRealTimers();
+        (global.window as any).setTimeout = global.setTimeout;
+      }
+    });
+
+    it('clears participant Drop binds after an HTTP failure without logging sensitive data', async () => {
+      jest.useFakeTimers();
+      (global.window as any).setTimeout = global.setTimeout;
+
+      try {
+        const participantId = '+1/http-secret';
+        const httpFailure = {headers: {Authorization: 'Bearer secret'}};
+        webexRequestInstance.request.mockRejectedValueOnce(httpFailure);
+        const promise = aqm['createPromise'](participantDropConfig(participantId));
+
+        await expect(promise).rejects.toBe(httpFailure);
+        expect(aqm['pendingRequests']).toEqual({});
+        expect(JSON.stringify([
+          (LoggerProxy.log as jest.Mock).mock.calls,
+          (LoggerProxy.error as jest.Mock).mock.calls,
+        ])).not.toContain(participantId);
+        expect(httpFailure.headers.Authorization).toBe('*');
+      } finally {
+        jest.useRealTimers();
+        (global.window as any).setTimeout = global.setTimeout;
+      }
+    });
+
+    it('uses the default timeout without logging a sensitive request URL', async () => {
+      jest.useFakeTimers();
+      (global.window as any).setTimeout = global.setTimeout;
+
+      try {
+        const participantId = '+1/timeout-secret';
+        webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
+        const promise = aqm['createPromise'](participantDropConfig(participantId));
+        const rejection = expect(promise).rejects.toBeDefined();
+
+        jest.advanceTimersByTime(20000);
+
+        await rejection;
+        expect(JSON.stringify((LoggerProxy.error as jest.Mock).mock.calls)).not.toContain(participantId);
+        expect(aqm['pendingRequests']).toEqual({});
+      } finally {
+        jest.useRealTimers();
+        (global.window as any).setTimeout = global.setTimeout;
+      }
+    });
   });
-});
+});

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

@@ -4,19 +4,27 @@ import {
   DESTINATION_TYPE,
   TASK_EVENTS,
   TASK_CHANNEL_TYPE,
+  TransferPayLoad,
   VOICE_VARIANT,
 } from '../../../../../src/services/task/types';
 import {TaskEvent} from '../../../../../src/services/task/state-machine';
+import {ENTRY_POINT_TRANSFER_DESTINATION_TYPE} from '../../../../../src/services/task/constants';
 import LoggerProxy from '../../../../../src/logger-proxy';
 import {createTaskData} from './taskTestUtils';
 
 class DummyTask extends Task {
-  constructor(contact: any, data: TaskData) {
-    super(contact, data, {
-      channelType: 'voice',
-      isEndTaskEnabled: true,
-      isEndConsultEnabled: true,
-    });
+  constructor(contact: any, data: TaskData, wrapupData?: any, agentId?: string) {
+    super(
+      contact,
+      data,
+      {
+        channelType: 'voice',
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+      },
+      wrapupData,
+      agentId
+    );
   }
 
   public accept() {
@@ -24,6 +32,20 @@ class DummyTask extends Task {
   }
 }
 
+class ConferenceTask extends DummyTask {
+  protected override getChannelSpecificActionOverrides() {
+    return {
+      ...super.getChannelSpecificActionOverrides(),
+      emitTaskParticipantLeft: this.createEmitSelfAction(TASK_EVENTS.TASK_PARTICIPANT_LEFT, {
+        updateTaskData: true,
+      }),
+      emitTaskConferenceEnded: this.createEmitSelfAction(TASK_EVENTS.TASK_CONFERENCE_ENDED, {
+        updateTaskData: true,
+      }),
+    };
+  }
+}
+
 class SpyAcceptTask extends Task {
   public acceptMock: jest.Mock;
 
@@ -234,6 +256,68 @@ describe('Task (base class)', () => {
     expect(emitSpy).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_WRAPUP, task);
   });
 
+  it('starts auto wrap-up only when wrapUpRequired is true and profile autoWrapup is enabled', () => {
+    const wrapUpProps = {
+      autoWrapup: true,
+      autoWrapupInterval: 25000,
+      wrapUpReasonList: [{id: 'code-1', name: 'Default', isDefault: true, isSystem: false}],
+    };
+    const enabled = new DummyTask(
+      dummyContact,
+      createTaskData({wrapUpRequired: false}) as TaskData,
+      {wrapUpProps},
+      'agent-1'
+    );
+
+    expect(enabled.autoWrapup).toBeUndefined();
+    try {
+      enabled.updateTaskData(createTaskData({wrapUpRequired: true}) as TaskData);
+      expect(enabled.autoWrapup).toBeDefined();
+
+      const disabled = new DummyTask(
+        dummyContact,
+        createTaskData({wrapUpRequired: false}) as TaskData,
+        {wrapUpProps: {...wrapUpProps, autoWrapup: false}},
+        'agent-1'
+      );
+      disabled.updateTaskData(createTaskData({wrapUpRequired: true}) as TaskData);
+      expect(disabled.autoWrapup).toBeUndefined();
+    } finally {
+      enabled.cancelAutoWrapupTimer();
+    }
+  });
+
+  it('calls contact.wrapup when the auto wrap-up timer elapses after wrapUpRequired is stamped', async () => {
+    const wrapUpProps = {
+      autoWrapup: true,
+      autoWrapupInterval: 1000,
+      wrapUpReasonList: [{id: 'code-1', name: 'Default', isDefault: true, isSystem: false}],
+    };
+    const contact = {wrapup: jest.fn().mockResolvedValue({result: 'wrap'})};
+    const wrappingTask = new DummyTask(
+      contact,
+      createTaskData({wrapUpRequired: false}) as TaskData,
+      {wrapUpProps},
+      'agent-1'
+    );
+
+    jest.useFakeTimers();
+    try {
+      wrappingTask.updateTaskData(createTaskData({wrapUpRequired: true}) as TaskData);
+      expect(wrappingTask.autoWrapup).toBeDefined();
+
+      jest.advanceTimersByTime(1000);
+
+      expect(contact.wrapup).toHaveBeenCalledWith({
+        interactionId: 'interaction-1',
+        data: {wrapUpReason: 'Default', auxCodeId: 'code-1'},
+      });
+    } finally {
+      wrappingTask.cancelAutoWrapupTimer();
+      jest.useRealTimers();
+    }
+  });
+
   it('throws for unsupported voice operations in the base class', async () => {
     const fullData = createTaskData();
     const voiceTask = new DummyTask(dummyContact, fullData);
@@ -246,6 +330,7 @@ describe('Task (base class)', () => {
       () => voiceTask.endConsult({} as any),
       () => voiceTask.consultTransfer({} as any),
       () => voiceTask.consultConference(),
+      () => voiceTask.dropConferenceParticipant({participantId: 'participant-id'}),
       () => voiceTask.exitConference(),
       () => voiceTask.transferConference(),
       () => voiceTask.toggleMute(),
@@ -273,6 +358,171 @@ describe('Task (base class)', () => {
     expect((voiceTask.data as any).foo).toBe('new');
   });
 
+  it('syncs owner changes and emits task:hydrate without changing task state', () => {
+    const originalData = createTaskData({
+      interaction: {owner: 'agent-1'} as any,
+    });
+    const voiceTask = new DummyTask(dummyContact, originalData);
+    const hydrateHandler = jest.fn();
+
+    voiceTask.stateMachineService?.send({
+      type: TaskEvent.TASK_INCOMING,
+      taskData: originalData,
+    });
+    voiceTask.stateMachineService?.send({type: TaskEvent.ASSIGN, taskData: originalData});
+    const stateBeforeOwnerChange = voiceTask.stateMachineService?.getSnapshot().value;
+    voiceTask.on(TASK_EVENTS.TASK_HYDRATE, hydrateHandler);
+
+    const updatedData = createTaskData({
+      interaction: {owner: 'agent-2'} as any,
+    });
+    voiceTask.sendStateMachineEvent({
+      type: TaskEvent.CONTACT_OWNER_CHANGED,
+      taskData: updatedData,
+    });
+
+    expect(voiceTask.data.interaction.owner).toBe('agent-2');
+    expect(hydrateHandler).toHaveBeenCalledWith(voiceTask);
+    expect(voiceTask.stateMachineService?.getSnapshot().value).toBe(stateBeforeOwnerChange);
+  });
+
+  it('synchronizes the roster from PARTICIPANT_LEAVE without an unrelated state transition', () => {
+    const conferenceData = createTaskData({
+      agentId: 'agent-1',
+      interactionId: 'interaction-1',
+      interaction: {
+        state: 'conference',
+        owner: 'agent-1',
+        interactionId: 'interaction-1',
+        mainInteractionId: 'interaction-1',
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+          'agent-2': {id: 'agent-2', pType: 'Agent', hasLeft: false},
+          'agent-3': {id: 'agent-3', pType: 'Agent', hasLeft: false},
+          customer: {id: 'customer', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            mediaResourceId: 'interaction-1',
+            mType: 'mainCall',
+            participants: ['agent-1', 'agent-2', 'agent-3', 'customer'],
+            isHold: false,
+          },
+        },
+      } as any,
+    });
+    const voiceTask = new ConferenceTask(dummyContact, conferenceData);
+    const participantLeftHandler = jest.fn();
+
+    voiceTask.sendStateMachineEvent({type: TaskEvent.TASK_INCOMING, taskData: conferenceData});
+    voiceTask.sendStateMachineEvent({type: TaskEvent.ASSIGN, taskData: conferenceData});
+    voiceTask.sendStateMachineEvent({type: TaskEvent.CONFERENCE_START, taskData: conferenceData});
+    const conferenceState = voiceTask.stateMachineService?.getSnapshot().value;
+    voiceTask.on(TASK_EVENTS.TASK_PARTICIPANT_LEFT, participantLeftHandler);
+
+    const updatedData = createTaskData({
+      ...conferenceData,
+      participantId: 'agent-2',
+      interaction: {
+        ...conferenceData.interaction,
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+          'agent-3': {id: 'agent-3', pType: 'Agent', hasLeft: false},
+          customer: {id: 'customer', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            ...conferenceData.interaction.media['interaction-1'],
+            participants: ['agent-1', 'agent-3', 'customer'],
+          },
+        },
+      } as any,
+    });
+
+    voiceTask.sendStateMachineEvent({
+      type: TaskEvent.PARTICIPANT_LEAVE,
+      taskData: updatedData,
+      participantId: 'agent-2',
+    });
+
+    expect(voiceTask.data.interaction.participants['agent-2']).toBeUndefined();
+    expect(participantLeftHandler).toHaveBeenCalledWith(voiceTask);
+    expect(voiceTask.stateMachineService?.getSnapshot().value).toBe(conferenceState);
+  });
+
+  it('keeps the conference participant controls after the customer leaves', () => {
+    const conferenceData = createTaskData({
+      agentId: 'agent-1',
+      interactionId: 'interaction-1',
+      isConferenceInProgress: true,
+      isConferencing: true,
+      interaction: {
+        state: 'conference',
+        mediaType: 'telephony',
+        owner: 'agent-1',
+        interactionId: 'interaction-1',
+        mainInteractionId: 'interaction-1',
+        callProcessingDetails: {isConferencing: true},
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+          'agent-2': {id: 'agent-2', pType: 'Agent', hasLeft: false},
+          customer: {id: 'customer', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            mediaResourceId: 'interaction-1',
+            mType: 'mainCall',
+            participants: ['agent-1', 'agent-2', 'customer'],
+            isHold: false,
+          },
+        },
+      } as any,
+    });
+    const voiceTask = new ConferenceTask(dummyContact, conferenceData);
+    const participantLeftHandler = jest.fn();
+    const conferenceEndedHandler = jest.fn();
+
+    voiceTask.sendStateMachineEvent({type: TaskEvent.TASK_INCOMING, taskData: conferenceData});
+    voiceTask.sendStateMachineEvent({type: TaskEvent.ASSIGN, taskData: conferenceData});
+    voiceTask.sendStateMachineEvent({type: TaskEvent.CONFERENCE_START, taskData: conferenceData});
+    voiceTask.on(TASK_EVENTS.TASK_PARTICIPANT_LEFT, participantLeftHandler);
+    voiceTask.on(TASK_EVENTS.TASK_CONFERENCE_ENDED, conferenceEndedHandler);
+
+    const customerLeftData = createTaskData({
+      ...conferenceData,
+      participantId: 'customer',
+      interaction: {
+        ...conferenceData.interaction,
+        participants: {
+          'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+          'agent-2': {id: 'agent-2', pType: 'Agent', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            ...conferenceData.interaction.media['interaction-1'],
+            participants: ['agent-1', 'agent-2'],
+          },
+        },
+      } as any,
+    });
+
+    voiceTask.sendStateMachineEvent({
+      type: TaskEvent.PARTICIPANT_LEAVE,
+      taskData: customerLeftData,
+      participantId: 'customer',
+    });
+
+    expect(voiceTask.data.interaction.participants.customer).toBeUndefined();
+    expect(voiceTask.data.interaction.participants['agent-2']).toBeDefined();
+    expect(voiceTask.stateMachineService?.getSnapshot().value).toBe('CONFERENCING');
+    expect(voiceTask.uiControls.main.exitConference).toEqual({
+      isVisible: true,
+      isEnabled: true,
+    });
+    expect(participantLeftHandler).toHaveBeenCalledWith(voiceTask);
+    expect(conferenceEndedHandler).not.toHaveBeenCalled();
+  });
+
   it('stopStateMachine clears state snapshot access', () => {
     const fullData = createTaskData();
     const voiceTask = new DummyTask(dummyContact, fullData);
@@ -398,6 +648,24 @@ describe('Task common methods', () => {
     expect(result).toEqual({result: 'vt'});
   });
 
+  it('transfer uses vteamTransfer with the backend destination type for entry-point destinations', async () => {
+    const payload: TransferPayLoad = {
+      to: 'entry-point-1',
+      destinationType: DESTINATION_TYPE.ENTRYPOINT,
+    };
+    const result = await task.transfer(payload);
+
+    expect(contact.vteamTransfer).toHaveBeenCalledWith({
+      interactionId: taskData.interactionId,
+      data: {
+        to: payload.to,
+        destinationType: ENTRY_POINT_TRANSFER_DESTINATION_TYPE,
+      },
+    });
+    expect(contact.blindTransfer).not.toHaveBeenCalled();
+    expect(result).toEqual({result: 'vt'});
+  });
+
   it('end invokes contact.end and returns its response', async () => {
     const result = await task.end();
     expect(contact.end).toHaveBeenCalledWith({

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

@@ -1,6 +1,10 @@
 import 'jsdom-global/register';
 import TaskFactory from '../../../../../src/services/task/TaskFactory';
-import {MEDIA_CHANNEL, TaskData} from '../../../../../src/services/task/types';
+import {
+  CONSULT_TRANSFER_DESTINATION_TYPE,
+  MEDIA_CHANNEL,
+  TaskData,
+} from '../../../../../src/services/task/types';
 import {LoginOption} from '../../../../../src/types';
 import WebCallingService from '../../../../../src/services/WebCallingService';
 import {ConfigFlags} from '../../../../../src/types';
@@ -18,7 +22,7 @@ describe('TaskFactory', () => {
       loginOption,
       on: jest.fn(),
       off: jest.fn?.(),
-    } as unknown) as WebCallingService;
+    } as unknown as WebCallingService);
 
   const configFlags: ConfigFlags = {
     isEndTaskEnabled: true,
@@ -59,4 +63,37 @@ describe('TaskFactory', () => {
     const t2 = TaskFactory.createTask(dummyContact, svcExt, data, configFlags);
     expect(t2.constructor.name).toBe('Voice');
   });
+
+  it('passes consult/transfer destination policy into created tasks', () => {
+    const svc = makeSvc(LoginOption.EXTENSION);
+    const data = {
+      ...baseData,
+      interaction: {
+        mediaType: MEDIA_CHANNEL.TELEPHONY,
+        contactDirection: {type: 'INBOUND'},
+      },
+    } as TaskData;
+    const task = TaskFactory.createTask(dummyContact, svc, data, {
+      ...configFlags,
+      consultTransfer: {
+        allowConsultToQueue: true,
+        accessQueue: 'ALL',
+        accessEntryPoint: 'NONE',
+        accessBuddyTeam: 'ALL',
+      },
+    });
+
+    expect(task.uiControls.consultTransferDestinations).toEqual({
+      consult: [
+        CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
+        CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE,
+        CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER,
+      ],
+      transfer: [
+        CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
+        CONSULT_TRANSFER_DESTINATION_TYPE.QUEUE,
+        CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER,
+      ],
+    });
+  });
 });