test: update the unit for contact center

Author: arun3528

packages/@webex/contact-center/src/services/task/TaskManager.ts

@@ -26,6 +26,10 @@ type WebSocketMessage = {
   keepalive?: 'true' | 'false' | boolean;
   data: WebSocketPayload;
 };
+
+const CC_EVENT_SET = new Set<CC_EVENTS>(Object.values(CC_EVENTS) as CC_EVENTS[]);
+
+const isCcEvent = (value: string): value is CC_EVENTS => CC_EVENT_SET.has(value as CC_EVENTS);
 /** @internal */
 export default class TaskManager extends EventEmitter {
   private call: ICall;
@@ -196,7 +200,7 @@ export default class TaskManager extends EventEmitter {
    * @param payload - The event payload
    * @param task - The task instance
    */
-  private sendEventToStateMachine(
+  private static sendEventToStateMachine(
     ccEvent: CC_EVENTS,
     payload: WebSocketPayload,
     task?: ITask
@@ -232,16 +236,17 @@ export default class TaskManager extends EventEmitter {
       }
       // Re-emit the task events to the task object
       let task: ITask;
-      if (payload.data?.type) {
-        if (Object.values(CC_TASK_EVENTS).includes(payload.data.type)) {
-          task = this.taskCollection[payload.data.interactionId];
-        }
-        LoggerProxy.info(`Handling task event ${payload.data?.type}`, {
+      const eventType = payload.data?.type;
+
+      if (eventType && isCcEvent(eventType)) {
+        task = this.taskCollection[payload.data.interactionId];
+
+        LoggerProxy.info(`Handling task event ${eventType}`, {
           module: TASK_MANAGER_FILE,
           method: METHODS.REGISTER_TASK_LISTENERS,
           interactionId: payload.data?.interactionId,
         });
-        switch (payload.data.type) {
+        switch (eventType) {
           case CC_EVENTS.AGENT_CONTACT:
             if (!task) {
               // Re-create task if it does not exist
@@ -452,10 +457,13 @@ export default class TaskManager extends EventEmitter {
         // Send all events to state machine after processing
         // Task may have been created in AGENT_CONTACT or AGENT_CONTACT_RESERVED cases
         if (task) {
-          task.emit(payload.data.type, payload.data);
+          // Only emit task-specific events to the task object
+          if (Object.values(CC_TASK_EVENTS).includes(eventType as any)) {
+            task.emit(eventType as any, payload.data);
+          }
 
           // Send event to state machine for all events
-          this.sendEventToStateMachine(payload.data.type as CC_EVENTS, payload.data, task);
+          TaskManager.sendEventToStateMachine(eventType, payload.data, task);
         }
       }
     });

packages/@webex/contact-center/src/services/task/state-machine/TaskStateMachine.ts

@@ -5,10 +5,26 @@
  * It orchestrates state transitions, guards, and actions for task lifecycle management.
  */
 
-import {createMachine} from 'xstate';
-import {TaskState, TaskEvent, UIControlConfig} from './types';
+import {setup} from 'xstate';
+import {TaskState, TaskEvent, TaskContext, TaskEventPayload, UIControlConfig} from './types';
 import {actions, createInitialContext} from './actions';
 
+type TaskActionConfigMap = {[K in keyof typeof actions]: undefined};
+
+const taskStateMachineSetup = setup<
+  TaskContext,
+  TaskEventPayload,
+  Record<string, never>,
+  Record<string, never>,
+  TaskActionConfigMap
+>({
+  types: {
+    context: {} as TaskContext,
+    events: {} as TaskEventPayload,
+  },
+  actors: {},
+});
+
 /**
  * Get task state machine configuration with UI control config
  * Defines all states, transitions, guards, and actions for task management
@@ -256,9 +272,9 @@ export function getTaskStateMachineConfig(uiControlConfig: UIControlConfig) {
  * @returns StateMachine instance for task management
  */
 export function createTaskStateMachine(uiControlConfig: UIControlConfig) {
-  return createMachine(getTaskStateMachineConfig(uiControlConfig), {
-    actions,
-  });
+  return taskStateMachineSetup
+    .createMachine(getTaskStateMachineConfig(uiControlConfig))
+    .provide({actions});
 }
 
 export type TaskStateMachine = ReturnType<typeof createTaskStateMachine>;

packages/@webex/contact-center/src/services/task/state-machine/actions.ts

@@ -12,10 +12,21 @@
  */
 
 import {assign} from 'xstate';
+import type {ActionFunctionMap, EventObject} from 'xstate';
 import {TaskContext, TaskEventPayload, TaskEvent, UIControlConfig, TaskState} from './types';
 import {TaskData} from '../types';
 import {computeUIControls, getDefaultUIControls} from './uiControlsComputer';
 
+type TaskActionsMap = ActionFunctionMap<
+  TaskContext,
+  TaskEventPayload,
+  never,
+  {type: string; params: undefined},
+  never,
+  never,
+  EventObject
+>;
+
 type RecordingStateUpdate = Partial<
   Pick<TaskContext, 'recordingControlsAvailable' | 'recordingInProgress'>
 >;
@@ -28,7 +39,11 @@ const deriveRecordingState = (taskData?: TaskData | null): RecordingStateUpdate
   }
 
   const update: RecordingStateUpdate = {};
-  const {recordingStarted, recordInProgress} = callProcessingDetails;
+  const {recordingStarted, recordInProgress, isPaused} = callProcessingDetails as {
+    recordingStarted?: boolean;
+    recordInProgress?: boolean;
+    isPaused?: boolean;
+  };
 
   if (recordingStarted !== undefined) {
     update.recordingControlsAvailable = recordingStarted;
@@ -51,6 +66,11 @@ const deriveRecordingState = (taskData?: TaskData | null): RecordingStateUpdate
     update.recordingInProgress = true;
   }
 
+  if (isPaused !== undefined) {
+    update.recordingControlsAvailable = true;
+    update.recordingInProgress = !isPaused;
+  }
+
   return update;
 };
 
@@ -64,10 +84,16 @@ const deriveRecordingState = (taskData?: TaskData | null): RecordingStateUpdate
  * single source of truth, while derived values (like recording flags)
  * are recalculated here via deriveRecordingState.
  */
-const deriveTaskDataUpdates = (_context: TaskContext, taskData: TaskData) => ({
-  taskData,
-  ...deriveRecordingState(taskData),
-});
+const deriveTaskDataUpdates = (_context: TaskContext, taskData: TaskData | undefined) =>
+  taskData
+    ? {
+        taskData,
+        ...deriveRecordingState(taskData),
+      }
+    : {};
+
+const getTaskDataFromEvent = (event?: TaskEventPayload): TaskData | undefined =>
+  event && typeof event === 'object' ? (event as any).taskData : undefined;
 
 /**
  * Create initial context for a new task.
@@ -116,7 +142,7 @@ export function createInitialContext(
  * @returns Assign action that updates UI controls
  */
 export function updateUIControls(currentState: TaskState) {
-  return assign((context: TaskContext) => ({
+  return assign(({context}: {context: TaskContext}) => ({
     uiControls: computeUIControls(currentState, context),
   }));
 }
@@ -125,25 +151,19 @@ export function updateUIControls(currentState: TaskState) {
  * Action implementations
  * These return XState assign actions that update the context
  */
-export const actions = {
+export const actions: TaskActionsMap = {
   /**
    * Initialize task with offer data
    */
-  initializeTask: assign((context: TaskContext, event: TaskEventPayload) => {
-    // Guard not needed in this action because the state machine only references
-    // initializeTask from OFFER/OFFER_CONSULT transitions, both of which carry taskData.
-    const {taskData} = event as Extract<TaskEventPayload, {taskData: TaskData}>;
-
-    return deriveTaskDataUpdates(context, taskData);
+  initializeTask: assign(({context, event}: {context: TaskContext; event: TaskEventPayload}) => {
+    return deriveTaskDataUpdates(context, getTaskDataFromEvent(event));
   }),
 
   /**
    * Update task data from ASSIGN event
    */
-  updateTaskData: assign((context: TaskContext, event: TaskEventPayload) => {
-    const {taskData} = event as Extract<TaskEventPayload, {taskData: TaskData}>;
-
-    return deriveTaskDataUpdates(context, taskData);
+  updateTaskData: assign(({context, event}: {context: TaskContext; event: TaskEventPayload}) => {
+    return deriveTaskDataUpdates(context, getTaskDataFromEvent(event));
   }),
 
   /**
@@ -156,35 +176,42 @@ export const actions = {
   /**
    * Set consult destination details
    */
-  setConsultDestination: assign((context: TaskContext, event: TaskEventPayload) => {
-    const consultEvent = event as Extract<
-      TaskEventPayload,
-      {type: TaskEvent.CONSULT; destination: string}
-    >;
+  setConsultDestination: assign(({event}: {event: TaskEventPayload}) => {
+    if (!event || event.type !== TaskEvent.CONSULT || !('destination' in event)) {
+      return {};
+    }
 
     return {
-      consultDestination: consultEvent.destination,
+      consultDestination: (event as {destination: string}).destination,
     };
   }),
 
   /**
    * Mark that consult destination agent has joined
    */
-  setConsultAgentJoined: assign((context: TaskContext, event: TaskEventPayload) => {
-    const consultingActive = event as Extract<
-      TaskEventPayload,
-      {type: TaskEvent.CONSULTING_ACTIVE; consultDestinationAgentJoined: boolean}
-    >;
+  setConsultAgentJoined: assign(({event}: {event: TaskEventPayload}) => {
+    if (
+      !event ||
+      event.type !== TaskEvent.CONSULTING_ACTIVE ||
+      !('consultDestinationAgentJoined' in event)
+    ) {
+      return {};
+    }
 
     return {
-      consultDestinationAgentJoined: consultingActive.consultDestinationAgentJoined,
+      consultDestinationAgentJoined: (event as {consultDestinationAgentJoined: boolean})
+        .consultDestinationAgentJoined,
     };
   }),
 
   /**
    * Set recording state
    */
-  setRecordingState: assign((context: TaskContext, event: TaskEventPayload) => {
+  setRecordingState: assign(({event}: {event: TaskEventPayload}) => {
+    if (!event || !('type' in event)) {
+      return {};
+    }
+
     if (event.type === TaskEvent.PAUSE_RECORDING) {
       return {
         recordingControlsAvailable: true,
@@ -212,13 +239,23 @@ export const actions = {
   /**
    * Track hold state updates (currently no-op placeholder)
    */
-  setHoldState: assign((context: TaskContext, event: TaskEventPayload) => {
-    const holdEvent = event as Extract<
-      TaskEventPayload,
-      | {type: TaskEvent.HOLD_SUCCESS; mediaResourceId: string}
-      | {type: TaskEvent.UNHOLD_SUCCESS; mediaResourceId: string}
-    >;
-    const mediaResourceId = holdEvent.mediaResourceId;
+  setHoldState: assign(({context, event}: {context: TaskContext; event: TaskEventPayload}) => {
+    if (
+      !event ||
+      (event.type !== TaskEvent.HOLD_SUCCESS && event.type !== TaskEvent.UNHOLD_SUCCESS)
+    ) {
+      return {};
+    }
+
+    const mediaResourceId =
+      'mediaResourceId' in event
+        ? (event as {mediaResourceId?: string}).mediaResourceId
+        : undefined;
+
+    if (!mediaResourceId) {
+      return {};
+    }
+
     const interaction = context.taskData?.interaction;
     const mediaEntry = interaction?.media?.[mediaResourceId];
 
@@ -230,7 +267,7 @@ export const actions = {
       ...interaction.media,
       [mediaResourceId]: {
         ...mediaEntry,
-        isHold: holdEvent.type === TaskEvent.HOLD_SUCCESS,
+        isHold: event.type === TaskEvent.HOLD_SUCCESS,
       },
     };