@webex/contact-center 3.12.0-task-refactor.3 → 3.12.0-task-refactor.5

package/test/unit/spec/services/task/state-machine/TaskStateMachine.ts

@@ -444,6 +444,109 @@ describe('Task state machine', () => {
     });
   });
 
+  describe('CONF_INITIATING state event handlers', () => {
+    it('transitions to CONFERENCING on CONFERENCE_START', () => {
+      const service = startMachine();
+      const taskData = createTaskData({consultingAgentId: 'agent-1'});
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({
+        type: TaskEvent.CONSULT,
+        destination: 'agent-42',
+        destinationType: 'agent',
+      });
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      expect(service.getSnapshot().value).toBe(TaskState.CONF_INITIATING);
+
+      service.send({type: TaskEvent.CONFERENCE_START, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+    });
+
+    it('transitions to WRAPPING_UP on CONSULT_END with isTerminated during CONF_INITIATING', () => {
+      const service = startMachine();
+      const taskData = createTaskData({consultingAgentId: 'agent-1'});
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({
+        type: TaskEvent.CONSULT,
+        destination: 'agent-42',
+        destinationType: 'agent',
+      });
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      expect(service.getSnapshot().value).toBe(TaskState.CONF_INITIATING);
+
+      const terminatedTaskData = createTaskData({
+        consultingAgentId: 'agent-1',
+        interaction: {
+          isTerminated: true,
+          owner: 'agent-1',
+        } as any,
+      });
+      service.send({type: TaskEvent.CONSULT_END, taskData: terminatedTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+
+    it('transitions to CONNECTED on CONSULT_END without isTerminated during CONF_INITIATING', () => {
+      const service = startMachine();
+      const taskData = createTaskData({consultingAgentId: 'agent-1'});
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({
+        type: TaskEvent.CONSULT,
+        destination: 'agent-42',
+        destinationType: 'agent',
+      });
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      expect(service.getSnapshot().value).toBe(TaskState.CONF_INITIATING);
+
+      service.send({type: TaskEvent.CONSULT_END, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+    });
+
+  });
+
+  describe('CONFERENCING state CONSULT_END with terminated interaction', () => {
+    it('transitions to WRAPPING_UP when CONSULT_END arrives with isTerminated in CONFERENCING', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        consultingAgentId: 'agent-1',
+        interaction: {
+          owner: 'agent-1',
+          state: 'conference',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({
+        type: TaskEvent.CONSULT,
+        destination: 'agent-42',
+        destinationType: 'agent',
+      });
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData});
+      service.send({type: TaskEvent.MERGE_TO_CONFERENCE});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      const terminatedTaskData = createTaskData({
+        consultingAgentId: 'agent-1',
+        interaction: {
+          isTerminated: true,
+          owner: 'agent-1',
+          state: 'conference',
+        } as any,
+      });
+      service.send({type: TaskEvent.CONSULT_END, taskData: terminatedTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+  });
+
   describe('OFFERED state event handlers', () => {
     it('transitions to TERMINATED when customer disconnects before agent answers', () => {
       const service = startMachine();
@@ -470,4 +573,65 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
     });
   });
+
+  describe('OUTBOUND_FAILED handling', () => {
+    it('transitions from IDLE to TERMINATED on OUTBOUND_FAILED (race condition)', () => {
+      const service = startMachine();
+      expect(service.getSnapshot().value).toBe(TaskState.IDLE);
+
+      const taskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData, reason: 'CUSTOMER_BUSY'});
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('transitions from OFFERED to TERMINATED on OUTBOUND_FAILED without wrapup', () => {
+      const service = startMachine();
+      const offerTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const failedTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'CUSTOMER_BUSY'});
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+    });
+
+    it('transitions from OFFERED to WRAPPING_UP on OUTBOUND_FAILED when wrapup is required', () => {
+      const service = startMachine();
+      const offerTaskData = createTaskData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: offerTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.OFFERED);
+
+      const failedTaskData = createTaskData({
+        agentId: 'agent-1',
+        agentsPendingWrapUp: ['agent-1'],
+        interaction: {
+          outboundType: 'OUTDIAL',
+          isTerminated: true,
+        } as any,
+      });
+      service.send({type: TaskEvent.OUTBOUND_FAILED, taskData: failedTaskData, reason: 'CUSTOMER_BUSY'});
+      expect(service.getSnapshot().value).toBe(TaskState.WRAPPING_UP);
+    });
+  });
 });

package/test/unit/spec/services/task/state-machine/guards.ts

@@ -238,6 +238,109 @@ describe('State Machine Guards', () => {
     });
   });
 
+  describe('Hydration Guards - isInteractionConsulting', () => {
+    it('returns true when interaction state is consulting', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          state: 'consulting',
+        },
+      });
+      expect(
+        guards.isInteractionConsulting(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(true);
+    });
+
+    it('returns true for EP_DN consulted agent (state=connected, CPD relationshipType=consult)', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          state: 'connected',
+          callProcessingDetails: {
+            ...createTaskData().interaction!.callProcessingDetails,
+            relationshipType: 'consult',
+          },
+        },
+      });
+      expect(
+        guards.isInteractionConsulting(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(true);
+    });
+
+    it('returns true when post_call with active consult (consultState=consulting + consult media)', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          state: 'post_call',
+          participants: {
+            'agent-123': {
+              ...createParticipant('agent-123', 'Agent'),
+              consultState: 'consulting',
+            },
+          },
+          media: {
+            [INTERACTION_ID]: {
+              mediaResourceId: INTERACTION_ID,
+              mediaType: 'telephony',
+              mediaMgr: 'media-mgr',
+              participants: ['agent-123'],
+              mType: 'mainCall',
+              isHold: false,
+              holdTimestamp: null,
+            },
+            'consult-media': {
+              mediaResourceId: 'consult-media',
+              mediaType: 'telephony',
+              mediaMgr: 'media-mgr',
+              participants: ['agent-123', 'agent-2'],
+              mType: 'consult',
+              isHold: false,
+              holdTimestamp: null,
+            },
+          },
+        },
+      });
+      expect(
+        guards.isInteractionConsulting(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(true);
+    });
+
+    it('returns false for post_call without consult media', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          state: 'post_call',
+          participants: {
+            'agent-123': {
+              ...createParticipant('agent-123', 'Agent'),
+              consultState: undefined,
+            },
+          },
+        },
+      });
+      expect(
+        guards.isInteractionConsulting(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(false);
+    });
+
+    it('returns false for plain connected state without consult CPD', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          state: 'connected',
+        },
+      });
+      expect(
+        guards.isInteractionConsulting(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(false);
+    });
+  });
+
   describe('Server State Guards', () => {
     it('isPrimaryMediaOnHold returns true when media isHold is true', () => {
       const ctx = createContext();

package/test/unit/spec/services/task/state-machine/uiControlsComputer.ts

@@ -27,7 +27,7 @@ function createConsultTaskData() {
           currentState: 'consulting',
           isConsulted: true,
         },
-        'customer-1': {id: 'customer-1', pType: 'CUSTOMER', hasLeft: false},
+        'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
       } as any,
       media: {
         'interaction-1': {
@@ -145,3 +145,239 @@ describe('uiControlsComputer consult initiator controls', () => {
     expect(uiControls.consult).toEqual(getDefaultUIControls().consult);
   });
 });
+
+describe('uiControlsComputer outdial accept/decline controls', () => {
+  function createOutdialContext(voiceVariant: 'webrtc' | 'pstn' = 'webrtc'): TaskContext {
+    const taskData = createTaskData({
+      interaction: {
+        outboundType: 'OUTDIAL',
+        state: 'new',
+        isTerminated: false,
+      } as any,
+    });
+    return {
+      taskData,
+      consultInitiator: false,
+      exitingConference: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      recordingControlsAvailable: false,
+      recordingInProgress: false,
+      uiControlConfig: {
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isRecordingEnabled: false,
+        agentId: 'agent-1',
+        voiceVariant,
+      },
+      uiControls: getDefaultUIControls(),
+    };
+  }
+
+  it('accept is visible but disabled for WebRTC outdial in OFFERED state', () => {
+    const context = createOutdialContext('webrtc');
+    const uiControls = computeUIControls(TaskState.OFFERED, context, context.taskData);
+
+    expect(uiControls.main.accept).toEqual({isVisible: true, isEnabled: false});
+  });
+
+  it('decline is visible but disabled for WebRTC outdial in OFFERED state', () => {
+    const context = createOutdialContext('webrtc');
+    const uiControls = computeUIControls(TaskState.OFFERED, context, context.taskData);
+
+    expect(uiControls.main.decline).toEqual({isVisible: true, isEnabled: false});
+  });
+});
+
+describe('uiControlsComputer conference controls', () => {
+  function createConferenceTaskData(participantCount: number) {
+    const participants: Record<string, any> = {
+      'customer-1': {id: 'customer-1', pType: 'Customer', hasJoined: true, hasLeft: false},
+      'agent-1': {
+        id: 'agent-1',
+        pType: 'Agent',
+        hasJoined: true,
+        hasLeft: false,
+        consultState: 'conferencing',
+      },
+    };
+    const mainCallParticipants = ['customer-1', 'agent-1'];
+
+    if (participantCount > 1) {
+      participants['agent-2'] = {
+        id: 'agent-2',
+        pType: 'Agent',
+        hasJoined: true,
+        hasLeft: false,
+        consultState: 'conferencing',
+      };
+      mainCallParticipants.push('agent-2');
+    }
+
+    return createTaskData({
+      agentId: 'agent-1',
+      mediaResourceId: 'interaction-1',
+      consultMediaResourceId: '' as any,
+      interaction: {
+        interactionId: 'interaction-1',
+        mainInteractionId: 'interaction-1',
+        state: 'conference',
+        participants,
+        media: {
+          'interaction-1': {
+            mediaResourceId: 'interaction-1',
+            mType: 'mainCall',
+            isHold: false,
+            participants: mainCallParticipants,
+          },
+        },
+      } as any,
+    });
+  }
+
+  function createConferenceContext(participantCount: number, overrides: Partial<TaskContext> = {}): TaskContext {
+    return {
+      taskData: createConferenceTaskData(participantCount),
+      consultInitiator: true,
+      exitingConference: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      recordingControlsAvailable: true,
+      recordingInProgress: true,
+      uiControlConfig: {
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isRecordingEnabled: true,
+        agentId: 'agent-1',
+      },
+      uiControls: getDefaultUIControls(),
+      ...overrides,
+    };
+  }
+
+  it('pending conference (participantCount <= 1): transfer/recording enabled, consult disabled, exitConference hidden', () => {
+    const context = createConferenceContext(1);
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, context.taskData);
+
+    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.recording).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.consult).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.exitConference).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('real conference (participantCount > 1): transfer/recording hidden, consult enabled, exitConference visible', () => {
+    const context = createConferenceContext(2);
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, context.taskData);
+
+    expect(uiControls.main.transfer).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.recording).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.consult).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.exitConference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('hold button shows visible but disabled in conference', () => {
+    const context = createConferenceContext(2);
+
+    const uiControls = computeUIControls(TaskState.CONFERENCING, context, context.taskData);
+
+    expect(uiControls.main.hold).toEqual({isVisible: true, isEnabled: false});
+  });
+});
+
+describe('uiControlsComputer post-call consult controls (customer left)', () => {
+  function createPostCallConsultTaskData() {
+    return createTaskData({
+      agentId: 'agent-1',
+      mediaResourceId: 'interaction-1',
+      consultMediaResourceId: 'consult-media',
+      consultingAgentId: 'agent-1',
+      destAgentId: 'agent-2',
+      interaction: {
+        interactionId: 'interaction-1',
+        mainInteractionId: 'interaction-1',
+        state: 'post_call',
+        isTerminated: false,
+        participants: {
+          'agent-1': {
+            id: 'agent-1',
+            pType: 'Agent',
+            hasJoined: true,
+            hasLeft: false,
+            consultState: 'consulting',
+          },
+          'agent-2': {
+            id: 'agent-2',
+            pType: 'Agent',
+            hasLeft: false,
+            consultState: 'consulting',
+            isConsulted: true,
+          },
+          'customer-1': {id: 'customer-1', pType: 'Customer', hasJoined: true, hasLeft: true},
+        } as any,
+        media: {
+          'interaction-1': {
+            mediaResourceId: 'interaction-1',
+            mType: 'mainCall',
+            isHold: false,
+            participants: ['agent-1'],
+          },
+          'consult-media': {
+            mediaResourceId: 'consult-media',
+            mType: 'consult',
+            isHold: false,
+            participants: ['agent-1', 'agent-2'],
+          },
+        } as any,
+      } as any,
+    });
+  }
+
+  it('consult controls are visible but disabled when customer has left', () => {
+    const taskData = createPostCallConsultTaskData();
+    const context: TaskContext = {
+      taskData,
+      consultInitiator: true,
+      exitingConference: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: true,
+      consultCallHeld: false,
+      recordingControlsAvailable: true,
+      recordingInProgress: true,
+      uiControlConfig: {
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isRecordingEnabled: true,
+        agentId: 'agent-1',
+      },
+      uiControls: getDefaultUIControls(),
+    };
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, context.taskData);
+
+    // Consult leg: transfer/conference/merge/switch should be visible but disabled
+    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.conference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.switch).toEqual({isVisible: true, isEnabled: false});
+
+    // Main leg end should be visible but disabled
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+  });
+});

package/test/unit/spec/services/task/voice/Voice.ts

@@ -72,6 +72,30 @@ describe('Voice Task', () => {
     jest.clearAllMocks();
   });
 
+  describe('emitTaskOutdialFailed', () => {
+    it('emits the failure reason string instead of the Task object', () => {
+      const taskData = createBaseData({
+        interaction: {
+          outboundType: 'OUTDIAL',
+        } as any,
+      });
+      const voice = new Voice(dummyContact, taskData, {});
+      const emitSpy = jest.spyOn(voice, 'emit');
+
+      voice.sendStateMachineEvent({
+        type: TaskEvent.OUTBOUND_FAILED,
+        taskData,
+        reason: 'CUSTOMER_BUSY',
+      });
+
+      const outdialFailedCall = emitSpy.mock.calls.find(
+        (call) => call[0] === 'task:outdialFailed'
+      );
+      expect(outdialFailedCall).toBeDefined();
+      expect(outdialFailedCall![1]).toBe('CUSTOMER_BUSY');
+    });
+  });
+
   it('hides end and endConsult when disabled', () => {
     const voice = new Voice(dummyContact, createBaseData(), {
       isEndTaskEnabled: false,