@webex/contact-center 3.12.0-task-refactor.4 → 3.12.0-task-refactor.6

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

@@ -18,6 +18,7 @@ describe('Task state machine', () => {
   const startMachine = () => {
     const actor = createActor(createTaskStateMachine(createConfig()));
     actor.start();
+
     return actor;
   };
 
@@ -124,6 +125,28 @@ describe('Task state machine', () => {
       service.send({type: TaskEvent.RESUME_RECORDING});
       expect(service.getSnapshot().context.recordingInProgress).toBe(true);
     });
+
+    it('toggles recording state while task is held', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        interaction: {
+          callProcessingDetails: {recordInProgress: true},
+        } as any,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData});
+      service.send({type: TaskEvent.ASSIGN, taskData});
+      service.send({type: TaskEvent.HOLD_INITIATED, mediaResourceId: taskData.mediaResourceId});
+      service.send({type: TaskEvent.HOLD_SUCCESS, mediaResourceId: taskData.mediaResourceId});
+      expect(service.getSnapshot().value).toBe(TaskState.HELD);
+      expect(service.getSnapshot().context.recordingInProgress).toBe(true);
+
+      service.send({type: TaskEvent.PAUSE_RECORDING});
+      expect(service.getSnapshot().context.recordingInProgress).toBe(false);
+
+      service.send({type: TaskEvent.RESUME_RECORDING});
+      expect(service.getSnapshot().context.recordingInProgress).toBe(true);
+    });
   });
 
   describe('wrap-up and completion flow', () => {
@@ -160,6 +183,95 @@ describe('Task state machine', () => {
   });
 
   describe('consult and conference flows', () => {
+    const createSingleAgentConferenceTaskData = (interactionState: string, isHold = false) =>
+      createTaskData({
+        interactionId: 'interaction-1',
+        mediaResourceId: 'interaction-1',
+        interaction: {
+          state: interactionState,
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'customer-1'],
+              isHold,
+            },
+          },
+        } as any,
+      });
+
+    const createConferenceConsultTaskData = ({
+      interactionState,
+      includeSecondAgent,
+      conferenceHoldParticipant,
+      isMainHeld = false,
+    }: {
+      interactionState: string;
+      includeSecondAgent: boolean;
+      conferenceHoldParticipant: boolean | string;
+      isMainHeld?: boolean;
+    }) =>
+      createTaskData({
+        interactionId: 'interaction-1',
+        mediaResourceId: 'interaction-1',
+        consultMediaResourceId: 'consult-media-1',
+        interaction: {
+          state: interactionState,
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          callProcessingDetails: {
+            conferenceHoldParticipant,
+          },
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consulting',
+            },
+            ...(includeSecondAgent
+              ? {
+                  'agent-2': {
+                    id: 'agent-2',
+                    pType: 'Agent',
+                    hasLeft: false,
+                  },
+                }
+              : {}),
+            'agent-3': {
+              id: 'agent-3',
+              pType: 'Agent',
+              hasLeft: false,
+              isConsulted: true,
+              consultState: 'consulting',
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: includeSecondAgent
+                ? ['agent-1', 'agent-2', 'customer-1']
+                : ['agent-1', 'customer-1'],
+              isHold: isMainHeld,
+            },
+            'consult-media-1': {
+              mediaResourceId: 'consult-media-1',
+              mType: 'consult',
+              participants: ['agent-1', 'agent-3'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
     it('boots from IDLE to CONSULTING on CONSULTING_ACTIVE for split-leg ordering', () => {
       const service = startMachine();
       const taskData = createTaskData({
@@ -181,6 +293,154 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().context.consultDestinationAgentJoined).toBe(true);
     });
 
+    it('hydrates to CONSULTING when top-level state is conference but self consultState is consulting', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        isConsulted: false,
+        interaction: {
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consulting',
+              isConsulted: false,
+            },
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consulting',
+              isConsulted: true,
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'customer-1'],
+              isHold: true,
+            },
+            'consult-media-1': {
+              mediaResourceId: 'consult-media-1',
+              mType: 'consult',
+              participants: ['agent-1', 'agent-2'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.HYDRATE, taskData});
+
+      const snapshot = service.getSnapshot();
+      expect(snapshot.value).toBe(TaskState.CONSULTING);
+      expect(snapshot.context.consultInitiator).toBe(true);
+      expect(snapshot.context.consultFromConference).toBe(true);
+    });
+
+  it('hydrates consulted agent to CONSULTING when self consultState is consulting and main leg is held', () => {
+    const service = startMachine();
+    const taskData = createTaskData({
+      agentId: 'agent-2',
+      isConsulted: true,
+      interaction: {
+        state: 'conference',
+        mainInteractionId: 'interaction-1',
+        interactionId: 'interaction-1',
+        participants: {
+          'agent-1': {
+            id: 'agent-1',
+            pType: 'Agent',
+            hasLeft: false,
+            consultState: 'consulting',
+            isConsulted: false,
+          },
+          'agent-2': {
+            id: 'agent-2',
+            pType: 'Agent',
+            hasLeft: false,
+            consultState: 'consulting',
+            isConsulted: true,
+          },
+          'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+        },
+        media: {
+          'interaction-1': {
+            mediaResourceId: 'interaction-1',
+            mType: 'mainCall',
+            participants: ['agent-1', 'customer-1'],
+            isHold: true,
+          },
+          'consult-media-1': {
+            mediaResourceId: 'consult-media-1',
+            mType: 'consult',
+            participants: ['agent-1', 'agent-2'],
+            isHold: false,
+          },
+        },
+      } as any,
+    });
+
+    service.send({type: TaskEvent.HYDRATE, taskData});
+
+    expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+  });
+
+    it('hydrates to CONSULTING when consult is pending (self consultState is consultInitiated)', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        isConsulted: false,
+        interaction: {
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consultInitiated',
+              isConsulted: false,
+            },
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consultReserved',
+              isConsulted: true,
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'customer-1'],
+              isHold: true,
+            },
+            'consult-media-1': {
+              mediaResourceId: 'consult-media-1',
+              mType: 'consult',
+              participants: ['agent-1', 'agent-2'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.HYDRATE, taskData});
+
+      const snapshot = service.getSnapshot();
+      expect(snapshot.value).toBe(TaskState.CONSULTING);
+      expect(snapshot.context.consultInitiator).toBe(true);
+      expect(snapshot.context.consultFromConference).toBe(true);
+    });
+
     it('tracks consult destination, agent join, and clears on consult end', () => {
       const service = startMachine();
       const taskData = createTaskData();
@@ -211,6 +471,137 @@ describe('Task state machine', () => {
       expect(snapshotAfterEnd.context.consultDestinationAgentJoined).toBe(false);
     });
 
+    it('keeps consultDestinationAgentJoined false while consultee is only reserved, then sets true on actual join', () => {
+      const service = startMachine();
+      const pendingTaskData = createTaskData({
+        isConsulted: false,
+        interaction: {
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consultInitiated',
+              isConsulted: false,
+            },
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              hasLeft: false,
+              hasJoined: false,
+              consultState: 'consultReserved',
+              isConsulted: true,
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'customer-1'],
+              isHold: true,
+            },
+            'consult-media-1': {
+              mediaResourceId: 'consult-media-1',
+              mType: 'consult',
+              participants: ['agent-1', 'agent-2'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.HYDRATE, taskData: pendingTaskData});
+
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+      expect(service.getSnapshot().context.consultDestinationAgentJoined).toBe(false);
+
+      const joinedTaskData = {
+        ...pendingTaskData,
+        interaction: {
+          ...pendingTaskData.interaction,
+          participants: {
+            ...pendingTaskData.interaction?.participants,
+            'agent-2': {
+              ...pendingTaskData.interaction?.participants?.['agent-2'],
+              hasJoined: true,
+              consultState: 'consulting',
+            },
+          },
+        },
+      } as any;
+
+      service.send({type: TaskEvent.CONTACT_UPDATED, taskData: joinedTaskData});
+
+      expect(service.getSnapshot().context.consultDestinationAgentJoined).toBe(true);
+    });
+
+    it('hydrates conference consult context flags for active consult leg controls', () => {
+      const service = startMachine();
+      const taskData = createTaskData({
+        type: 'AgentContactUnheld' as any,
+        isConsulted: false,
+        consultingAgentId: 'agent-1',
+        consultMediaResourceId: 'consult-media-1',
+        interaction: {
+          state: 'conference',
+          mainInteractionId: 'interaction-1',
+          interactionId: 'interaction-1',
+          participants: {
+            'agent-1': {
+              id: 'agent-1',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'consulting',
+              isConsulted: false,
+            },
+            'agent-2': {
+              id: 'agent-2',
+              pType: 'Agent',
+              hasLeft: false,
+              hasJoined: true,
+              consultState: 'consulting',
+              isConsulted: true,
+            },
+            'agent-3': {
+              id: 'agent-3',
+              pType: 'Agent',
+              hasLeft: false,
+              consultState: 'conferencing',
+              isConsulted: false,
+            },
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+          media: {
+            'interaction-1': {
+              mediaResourceId: 'interaction-1',
+              mType: 'mainCall',
+              participants: ['agent-1', 'agent-3', 'customer-1'],
+              isHold: false,
+            },
+            'consult-media-1': {
+              mediaResourceId: 'consult-media-1',
+              mType: 'consult',
+              participants: ['agent-1', 'agent-2'],
+              isHold: false,
+            },
+          },
+        } as any,
+      });
+
+      service.send({type: TaskEvent.HYDRATE, taskData});
+
+      const snapshot = service.getSnapshot();
+      expect(snapshot.value).toBe(TaskState.CONSULTING);
+      expect(snapshot.context.consultInitiator).toBe(true);
+      expect(snapshot.context.consultFromConference).toBe(true);
+      expect(snapshot.context.consultDestinationAgentJoined).toBe(true);
+      expect(snapshot.context.consultCallHeld).toBe(false);
+    });
+
     it('returns to connected when consult ends after switching back to the main leg', () => {
       const service = startMachine();
       const taskData = createTaskData();
@@ -234,6 +625,89 @@ describe('Task state machine', () => {
       expect(snapshotAfterEnd.context.consultCallHeld).toBe(false);
     });
 
+    it('downgrades to HELD on CONSULT_END when conference has downgraded and conferenceHoldParticipant is true', () => {
+      const service = startMachine();
+      const conferenceTaskData = createConferenceConsultTaskData({
+        interactionState: 'conference',
+        includeSecondAgent: true,
+        conferenceHoldParticipant: false,
+      });
+      const downgradedHeldTaskData = createConferenceConsultTaskData({
+        interactionState: 'hold',
+        includeSecondAgent: false,
+        conferenceHoldParticipant: true,
+        isMainHeld: true,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-3', destinationType: 'agent'});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULT_INITIATING);
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+
+      service.send({type: TaskEvent.CONSULT_END, taskData: downgradedHeldTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.HELD);
+    });
+
+    it('downgrades to CONNECTED on CONSULT_END when conference has downgraded and conferenceHoldParticipant is false', () => {
+      const service = startMachine();
+      const conferenceTaskData = createConferenceConsultTaskData({
+        interactionState: 'conference',
+        includeSecondAgent: true,
+        conferenceHoldParticipant: false,
+      });
+      const downgradedConnectedTaskData = createConferenceConsultTaskData({
+        interactionState: 'connected',
+        includeSecondAgent: false,
+        conferenceHoldParticipant: false,
+        isMainHeld: false,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-3', destinationType: 'agent'});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULT_INITIATING);
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+
+      service.send({type: TaskEvent.CONSULT_END, taskData: downgradedConnectedTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+    });
+
+    it('returns to CONFERENCING on CONSULT_END when conference is still active', () => {
+      const service = startMachine();
+      const conferenceTaskData = createConferenceConsultTaskData({
+        interactionState: 'conference',
+        includeSecondAgent: true,
+        conferenceHoldParticipant: false,
+      });
+      const stillConferenceTaskData = createConferenceConsultTaskData({
+        interactionState: 'conference',
+        includeSecondAgent: true,
+        conferenceHoldParticipant: false,
+      });
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({type: TaskEvent.CONSULT, destination: 'agent-3', destinationType: 'agent'});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULT_INITIATING);
+      service.send({type: TaskEvent.CONSULT_SUCCESS, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONSULTING);
+
+      service.send({type: TaskEvent.CONSULT_END, taskData: stillConferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+    });
+
     it('transitions to conferencing when merge event is received', () => {
       const service = startMachine();
       const taskData = createTaskData({consultingAgentId: 'agent-1'});
@@ -372,6 +846,44 @@ describe('Task state machine', () => {
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
     });
 
+    it('downgrades to HELD on HOLD_SUCCESS when no other agents remain on task', () => {
+      const service = startMachine();
+      const conferenceTaskData = createSingleAgentConferenceTaskData('conference');
+      const heldTaskData = createSingleAgentConferenceTaskData('hold', true);
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({
+        type: TaskEvent.HOLD_SUCCESS,
+        mediaResourceId: heldTaskData.mediaResourceId,
+        taskData: heldTaskData,
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.HELD);
+    });
+
+    it('downgrades to CONNECTED on UNHOLD_SUCCESS when no other agents remain on task', () => {
+      const service = startMachine();
+      const conferenceTaskData = createSingleAgentConferenceTaskData('conference');
+      const connectedTaskData = createSingleAgentConferenceTaskData('connected', false);
+
+      service.send({type: TaskEvent.TASK_INCOMING, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.ASSIGN, taskData: conferenceTaskData});
+      service.send({type: TaskEvent.CONFERENCE_START, taskData: conferenceTaskData});
+      expect(service.getSnapshot().value).toBe(TaskState.CONFERENCING);
+
+      service.send({
+        type: TaskEvent.UNHOLD_SUCCESS,
+        mediaResourceId: connectedTaskData.mediaResourceId,
+        taskData: connectedTaskData,
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+    });
+
     it('returns to CONNECTED when CTQ cancel arrives before queue connects', () => {
       const service = startMachine();
       const taskData = createTaskData();
@@ -573,4 +1085,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);
+    });
+  });
 });