@webex/contact-center 3.12.0-next.8 → 3.12.0-task-refactor.1

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

@@ -0,0 +1,288 @@
+import {guards, GuardParams} from '../../../../../../src/services/task/state-machine/guards';
+import {
+  TaskContext,
+  TaskEventPayload,
+} from '../../../../../../src/services/task/state-machine/types';
+import {TaskData, InteractionParticipant} from '../../../../../../src/services/task/types';
+
+describe('State Machine Guards', () => {
+  const createParticipant = (
+    id: string,
+    pType: string,
+    hasLeft = false
+  ): InteractionParticipant => ({
+    id,
+    pType,
+    type: pType,
+    hasJoined: true,
+    hasLeft,
+    isInPredial: false,
+  });
+  // Note: media key must match mainInteractionId for getIsConferenceInProgress to work
+  const INTERACTION_ID = 'interaction-123';
+
+  const createTaskData = (overrides: Partial<TaskData> = {}): TaskData =>
+    ({
+      mediaResourceId: INTERACTION_ID,
+      eventType: 'TEST_EVENT',
+      agentId: 'agent-123',
+      destAgentId: '',
+      trackingId: 'track-123',
+      consultMediaResourceId: '',
+      interactionId: INTERACTION_ID,
+      orgId: 'org-123',
+      owner: 'agent-123',
+      queueMgr: 'queue-mgr',
+      type: 'voice',
+      isConferencing: false,
+      interaction: {
+        mainInteractionId: INTERACTION_ID,
+        interactionId: INTERACTION_ID,
+        participants: {},
+        media: {
+          [INTERACTION_ID]: {
+            mediaResourceId: INTERACTION_ID,
+            mediaType: 'telephony',
+            mediaMgr: 'media-mgr',
+            participants: ['agent-123'],
+            mType: 'mainCall',
+            isHold: false,
+            holdTimestamp: null,
+          },
+        },
+        owner: 'agent-123',
+        mediaChannel: 'telephony',
+        contactDirection: {type: 'inbound'},
+      },
+      ...overrides,
+    } as TaskData);
+
+  const createContext = (overrides: Partial<TaskContext> = {}): TaskContext =>
+    ({
+      recordingControlsAvailable: false,
+      recordingInProgress: false,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      consultInitiator: false,
+      exitingConference: false,
+      consultDestinationType: null,
+      taskData: createTaskData(),
+      uiControlConfig: {agentId: 'agent-123'},
+      uiControls: {
+        main: {
+          accept: {isVisible: false, isEnabled: false},
+          decline: {isVisible: false, isEnabled: false},
+          hold: {isVisible: false, isEnabled: false},
+          end: {isVisible: false, isEnabled: false},
+          transfer: {isVisible: false, isEnabled: false},
+          consult: {isVisible: false, isEnabled: false},
+          consultTransfer: {isVisible: false, isEnabled: false},
+          endConsult: {isVisible: false, isEnabled: false},
+          recording: {isVisible: false, isEnabled: false},
+          conference: {isVisible: false, isEnabled: false},
+          wrapup: {isVisible: false, isEnabled: false},
+          exitConference: {isVisible: false, isEnabled: false},
+          transferConference: {isVisible: false, isEnabled: false},
+          mergeToConference: {isVisible: false, isEnabled: false},
+          switch: {isVisible: false, isEnabled: false},
+          mute: {isVisible: false, isEnabled: false},
+        },
+        consult: {
+          accept: {isVisible: false, isEnabled: false},
+          decline: {isVisible: false, isEnabled: false},
+          hold: {isVisible: false, isEnabled: false},
+          end: {isVisible: false, isEnabled: false},
+          transfer: {isVisible: false, isEnabled: false},
+          consult: {isVisible: false, isEnabled: false},
+          consultTransfer: {isVisible: false, isEnabled: false},
+          endConsult: {isVisible: false, isEnabled: false},
+          recording: {isVisible: false, isEnabled: false},
+          conference: {isVisible: false, isEnabled: false},
+          wrapup: {isVisible: false, isEnabled: false},
+          exitConference: {isVisible: false, isEnabled: false},
+          transferConference: {isVisible: false, isEnabled: false},
+          mergeToConference: {isVisible: false, isEnabled: false},
+          switch: {isVisible: false, isEnabled: false},
+          mute: {isVisible: false, isEnabled: false},
+        },
+        activeLeg: 'main',
+      },
+      ...overrides,
+    } as TaskContext);
+
+  const createParams = (context: TaskContext, event?: TaskEventPayload): GuardParams => ({
+    context,
+    event,
+  });
+
+  const createEventWithTaskData = (taskData: TaskData): TaskEventPayload =>
+    ({taskData} as TaskEventPayload);
+
+  describe('Conference Guards', () => {
+    it('conferenceInProgressFromEvent returns true with 2+ agents in event', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          participants: {
+            a1: createParticipant('a1', 'Agent'),
+            a2: createParticipant('a2', 'Agent'),
+          },
+          media: {
+            [INTERACTION_ID]: {
+              mediaResourceId: INTERACTION_ID,
+              mediaType: 'telephony',
+              mediaMgr: 'media-mgr',
+              participants: ['a1', 'a2'],
+              mType: 'mainCall',
+              isHold: false,
+              holdTimestamp: null,
+            },
+          },
+        },
+      });
+      expect(
+        guards.conferenceInProgressFromEvent(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(true);
+    });
+
+    it('conferenceInProgressFromEvent returns false with 1 agent', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          participants: {
+            a1: createParticipant('a1', 'Agent'),
+          },
+          media: {
+            [INTERACTION_ID]: {
+              mediaResourceId: INTERACTION_ID,
+              mediaType: 'telephony',
+              mediaMgr: 'media-mgr',
+              participants: ['a1'],
+              mType: 'mainCall',
+              isHold: false,
+              holdTimestamp: null,
+            },
+          },
+        },
+      });
+      expect(
+        guards.conferenceInProgressFromEvent(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(false);
+    });
+  });
+
+  describe('Consult Guards', () => {
+    it('didInitiateConsult returns true when consultingAgentId matches', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        consultingAgentId: 'agent-123',
+        isConsulted: false,
+      });
+      expect(guards.didInitiateConsult(createParams(ctx, createEventWithTaskData(taskData)))).toBe(
+        true
+      );
+    });
+
+    it('didInitiateConsult returns false when isConsulted is true', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({isConsulted: true});
+      expect(guards.didInitiateConsult(createParams(ctx, createEventWithTaskData(taskData)))).toBe(
+        false
+      );
+    });
+  });
+
+  describe('Wrap-up Guards', () => {
+    it('shouldWrapUp returns true for owner', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          owner: 'agent-123',
+        },
+      });
+      expect(guards.shouldWrapUp(createParams(ctx, createEventWithTaskData(taskData)))).toBe(true);
+    });
+
+    it('shouldWrapUp returns false for non-owner', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          owner: 'other-agent',
+        },
+      });
+      expect(guards.shouldWrapUp(createParams(ctx, createEventWithTaskData(taskData)))).toBe(false);
+    });
+
+    it('shouldWrapUp returns true when agentsPendingWrapUp includes agent', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        agentsPendingWrapUp: ['agent-123', 'other-agent'],
+      } as Partial<TaskData>);
+      expect(guards.shouldWrapUp(createParams(ctx, createEventWithTaskData(taskData)))).toBe(true);
+    });
+
+    it('shouldWrapUp uses isConsulted fallback when no owner', () => {
+      const taskData = createTaskData({
+        isConsulted: false,
+        interaction: {
+          ...createTaskData().interaction,
+          owner: undefined as unknown as string, // No owner
+        },
+      });
+      const ctx = createContext({taskData});
+      expect(guards.shouldWrapUp(createParams(ctx, createEventWithTaskData(taskData)))).toBe(true);
+    });
+  });
+
+  describe('Server State Guards', () => {
+    it('isPrimaryMediaOnHold returns true when media isHold is true', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          media: {
+            [INTERACTION_ID]: {
+              mediaResourceId: INTERACTION_ID,
+              mediaType: 'telephony',
+              mediaMgr: 'media-mgr',
+              participants: ['agent-123'],
+              mType: 'mainCall',
+              isHold: true,
+              holdTimestamp: Date.now(),
+            },
+          },
+        },
+      });
+      expect(
+        guards.isPrimaryMediaOnHold(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(true);
+    });
+
+    it('isPrimaryMediaOnHold returns false when media isHold is false', () => {
+      const ctx = createContext();
+      const taskData = createTaskData({
+        interaction: {
+          ...createTaskData().interaction,
+          media: {
+            [INTERACTION_ID]: {
+              mediaResourceId: INTERACTION_ID,
+              mediaType: 'telephony',
+              mediaMgr: 'media-mgr',
+              participants: ['agent-123'],
+              mType: 'mainCall',
+              isHold: false,
+              holdTimestamp: null,
+            },
+          },
+        },
+      });
+      expect(
+        guards.isPrimaryMediaOnHold(createParams(ctx, createEventWithTaskData(taskData)))
+      ).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,18 @@
+import {isEventOfType} from '../../../../../../src/services/task/state-machine/types';
+import {TaskEvent} from '../../../../../../src/services/task/state-machine';
+
+describe('state-machine types', () => {
+  describe('isEventOfType', () => {
+    it('returns true for matching type', () => {
+      const event = {type: TaskEvent.TASK_INCOMING, taskData: {interactionId: 'id'} as any};
+      expect(isEventOfType(event as any, TaskEvent.TASK_INCOMING)).toBe(true);
+    });
+
+    it('returns false for non-matching type or undefined', () => {
+      const event = {type: TaskEvent.TASK_INCOMING, taskData: {interactionId: 'id'} as any};
+      expect(isEventOfType(event as any, TaskEvent.ASSIGN)).toBe(false);
+      expect(isEventOfType(undefined, TaskEvent.ASSIGN)).toBe(false);
+    });
+  });
+});
+

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

@@ -0,0 +1,147 @@
+import {TASK_CHANNEL_TYPE} from '../../../../../../src/services/task/types';
+import {TaskState} from '../../../../../../src/services/task/state-machine/constants';
+import {
+  computeUIControls,
+  getDefaultUIControls,
+} from '../../../../../../src/services/task/state-machine/uiControlsComputer';
+import {TaskContext} from '../../../../../../src/services/task/state-machine/types';
+import {createTaskData} from '../taskTestUtils';
+
+function createConsultTaskData() {
+  return createTaskData({
+    agentId: 'agent-1',
+    mediaResourceId: 'interaction-1',
+    consultMediaResourceId: 'consult-media',
+    consultingAgentId: 'agent-1',
+    destAgentId: 'agent-2',
+    interaction: {
+      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,
+          consultState: 'consulting',
+          currentState: 'consulting',
+          isConsulted: true,
+        },
+        'customer-1': {id: 'customer-1', pType: 'CUSTOMER', hasLeft: false},
+      } as any,
+      media: {
+        'interaction-1': {
+          mediaResourceId: 'interaction-1',
+          isHold: false,
+          participants: ['agent-1', 'customer-1'],
+        },
+        'consult-media': {
+          mediaResourceId: 'consult-media',
+          isHold: false,
+          mType: 'consult',
+          participants: ['agent-2'],
+        },
+      } as any,
+    } as any,
+  });
+}
+
+function createVoiceContext(overrides: Partial<TaskContext> = {}): TaskContext {
+  return {
+    taskData: createConsultTaskData(),
+    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(),
+    ...overrides,
+  };
+}
+
+describe('uiControlsComputer consult initiator controls', () => {
+  it('returns separate main and consult controls when consult leg is active', () => {
+    const context = createVoiceContext();
+
+    const uiControls = computeUIControls(TaskState.CONSULTING, context, context.taskData);
+
+    expect(uiControls.activeLeg).toBe('consult');
+    expect(uiControls.consult).toBeDefined();
+
+    expect(uiControls.main.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+
+    expect(uiControls.consult.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.conference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.switch).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('switches top-level controls to main leg while keeping consult leg visible', () => {
+    const context = createVoiceContext({
+      consultCallHeld: true,
+    });
+
+    const uiControls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+
+    expect(uiControls.activeLeg).toBe('main');
+    expect(uiControls.consult).toBeDefined();
+
+    expect(uiControls.main.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.main.switch).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.transfer).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.conference).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: false});
+
+    expect(uiControls.consult.hold).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.transfer).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.conference).toEqual({isVisible: true, isEnabled: false});
+    expect(uiControls.consult.endConsult).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult.end).toEqual({isVisible: false, isEnabled: false});
+    expect(uiControls.consult.switch).toEqual({isVisible: false, isEnabled: false});
+  });
+
+  it('hides transfer for the consulted agent during consult', () => {
+    const consultedTaskData = createConsultTaskData();
+    const consultedContext = createVoiceContext({
+      consultInitiator: false,
+      taskData: {
+        ...consultedTaskData,
+        isConsulted: true,
+      } as any,
+    });
+
+    const uiControls = computeUIControls(
+      TaskState.CONSULTING,
+      consultedContext,
+      consultedContext.taskData
+    );
+
+    expect(uiControls.consult.transfer).toEqual({isVisible: false, isEnabled: false});
+  });
+
+  it('collapses stale consult leg controls during wrapup', () => {
+    const context = createVoiceContext();
+
+    const uiControls = computeUIControls(TaskState.WRAPPING_UP, context, context.taskData);
+
+    expect(uiControls.activeLeg).toBe('main');
+    expect(uiControls.main.wrapup).toEqual({isVisible: true, isEnabled: true});
+    expect(uiControls.consult).toEqual(getDefaultUIControls().consult);
+  });
+});

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

@@ -0,0 +1,87 @@
+import {MEDIA_CHANNEL, TaskData} from '../../../../../src/services/task/types';
+
+type TaskDataOverrides = Partial<TaskData> & {
+  interaction?: Partial<TaskData['interaction']> & {
+    media?: Record<string, {mediaResourceId: string; isHold: boolean}>;
+    callProcessingDetails?: Record<string, any>;
+  };
+};
+
+/**
+ * Utility to create task data for tests with sensible defaults while allowing overrides.
+ */
+export function createTaskData(overrides: TaskDataOverrides = {}): TaskData {
+  const base: TaskData = {
+    interactionId: 'interaction-1',
+    mediaResourceId: 'media-1',
+    eventType: 'OFFER',
+    agentId: 'agent-1',
+    destAgentId: 'agent-2',
+    trackingId: 'tracking-1',
+    consultMediaResourceId: 'media-1',
+    interaction: {
+      isFcManaged: false,
+      isTerminated: false,
+      mediaType: MEDIA_CHANNEL.TELEPHONY,
+      previousVTeams: [],
+      state: 'new',
+      currentVTeam: 'team-1',
+      participants: [],
+      interactionId: 'interaction-1',
+      orgId: 'org-1',
+      callProcessingDetails: {
+        recordingStarted: true,
+        recordInProgress: true,
+      },
+      media: {
+        'media-1': {
+          mediaResourceId: 'media-1',
+          isHold: false,
+        },
+      },
+    } as any,
+  } as TaskData;
+
+  const mergedInteraction = {
+    ...(base.interaction as any),
+    ...(overrides.interaction || {}),
+    media: {
+      ...((base.interaction as any).media || {}),
+      ...((overrides.interaction as any)?.media || {}),
+    },
+    callProcessingDetails: {
+      ...((base.interaction as any).callProcessingDetails || {}),
+      ...((overrides.interaction as any)?.callProcessingDetails || {}),
+    },
+  };
+
+  return {
+    ...base,
+    ...overrides,
+    interaction: mergedInteraction,
+  } as TaskData;
+}
+
+describe('taskTestUtils', () => {
+  it('creates sensible defaults when no overrides are provided', () => {
+    const task = createTaskData();
+
+    expect(task.interactionId).toBe('interaction-1');
+    expect(task.interaction?.state).toBe('new');
+    expect(task.interaction?.media?.['media-1']?.isHold).toBe(false);
+  });
+
+  it('merges nested interaction overrides', () => {
+    const task = createTaskData({
+      interaction: {
+        state: 'connected',
+        media: {
+          'media-1': {mediaResourceId: 'media-1', isHold: true},
+        },
+      },
+    });
+
+    expect(task.interaction?.state).toBe('connected');
+    expect(task.interaction?.media?.['media-1']?.isHold).toBe(true);
+  });
+});