@webex/contact-center 3.12.0-llmrefactor.7 → 3.12.0-llmrefactor.9

package/test/unit/spec/services/WebexCrossClientService.ts

@@ -1,13 +1,30 @@
 import WebexCrossClientService from '../../../../src/services/WebexCrossClientService';
+import MetricsManager from '../../../../src/metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
+
+jest.mock('../../../../src/metrics/MetricsManager', () => ({
+  __esModule: true,
+  default: {
+    getInstance: jest.fn(),
+  },
+}));
 
 describe('WebexCrossClientService', () => {
   const userId = 'user-123';
   const deviceUrl = 'https://wdm.example.com/devices/device-abc';
+  const trackEvent = jest.fn();
+  const timeEvent = jest.fn();
+  const cancelTimedEvent = jest.fn();
 
   let webex: {request: jest.Mock; internal: {device: {userId: string; url: string}}};
   let service: WebexCrossClientService;
 
   beforeEach(() => {
+    trackEvent.mockClear();
+    timeEvent.mockClear();
+    cancelTimedEvent.mockClear();
+    (MetricsManager.getInstance as jest.Mock).mockReturnValue({trackEvent, timeEvent, cancelTimedEvent});
+
     webex = {
       request: jest.fn().mockResolvedValue({body: {}}),
       internal: {
@@ -82,6 +99,26 @@ describe('WebexCrossClientService', () => {
       'User ID is unavailable for cross-client publish'
     );
     expect(webex.request).not.toHaveBeenCalled();
+    expect(trackEvent).not.toHaveBeenCalled();
+  });
+
+  it('emits usersub publish failed when user ID is unavailable and trackPublishMetrics is true', async () => {
+    webex.internal.device.userId = undefined as unknown as string;
+
+    await expect(
+      service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true})
+    ).rejects.toThrow('User ID is unavailable for cross-client publish');
+
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+      expect.objectContaining({
+        enableWxBetterTogether: true,
+        skipReason: 'user_id_unavailable',
+      }),
+      ['operational', 'behavioral']
+    );
+    expect(timeEvent).not.toHaveBeenCalled();
+    expect(webex.request).not.toHaveBeenCalled();
   });
 
   it('throws when device URL is unavailable', async () => {
@@ -91,13 +128,182 @@ describe('WebexCrossClientService', () => {
       'Device URL is unavailable for cross-client publish'
     );
     expect(webex.request).not.toHaveBeenCalled();
+    expect(trackEvent).not.toHaveBeenCalled();
+  });
+
+  it('emits usersub publish failed when device URL is unavailable and trackPublishMetrics is true', async () => {
+    webex.internal.device.url = undefined as unknown as string;
+
+    await expect(
+      service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true})
+    ).rejects.toThrow('Device URL is unavailable for cross-client publish');
+
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+      expect.objectContaining({
+        enableWxBetterTogether: true,
+        skipReason: 'device_url_unavailable',
+      }),
+      ['operational', 'behavioral']
+    );
+    expect(timeEvent).not.toHaveBeenCalled();
+    expect(webex.request).not.toHaveBeenCalled();
   });
 
   it('rejects when usersub publish fails', async () => {
     const err = new Error('usersub failed');
     webex.request = jest.fn().mockRejectedValue(err);
 
-    await expect(service.setManageWebexCallingInWxcc(true)).rejects.toThrow('usersub failed');
+    await expect(
+      service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true})
+    ).rejects.toThrow('usersub failed');
+
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+      expect.objectContaining({enableWxBetterTogether: true}),
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('tracks usersub publish success when trackPublishMetrics is enabled', async () => {
+    await service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true});
+
+    expect(timeEvent).toHaveBeenCalledWith([
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+    ]);
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
+      {enableWxBetterTogether: true},
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('cancels usersub publish timer when publish completes after teardown bumps generation', async () => {
+    let resolvePublish: (value: {body: Record<string, never>}) => void;
+    const publishPromise = new Promise<{body: Record<string, never>}>((resolve) => {
+      resolvePublish = resolve;
+    });
+    webex.request = jest.fn().mockReturnValue(publishPromise);
+
+    const publishCall = service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true});
+    service.teardown();
+    resolvePublish!({body: {}});
+    await publishCall;
+
+    expect(cancelTimedEvent).toHaveBeenCalledWith([
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+    ]);
+    expect(trackEvent).not.toHaveBeenCalled();
+  });
+
+  it('cancels usersub publish timer when publish fails after teardown bumps generation', async () => {
+    let rejectPublish: (error: Error) => void;
+    const publishPromise = new Promise((_, reject) => {
+      rejectPublish = reject;
+    });
+    webex.request = jest.fn().mockReturnValue(publishPromise);
+
+    const publishCall = service.setManageWebexCallingInWxcc(true, {trackPublishMetrics: true});
+    service.teardown();
+    rejectPublish!(new Error('usersub failed'));
+    await expect(publishCall).rejects.toThrow('usersub failed');
+
+    expect(cancelTimedEvent).toHaveBeenCalledWith([
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_FAILED,
+    ]);
+    expect(trackEvent).not.toHaveBeenCalled();
+  });
+
+  it('does not cancel newer publish timer when stale publish completes', async () => {
+    let resolveFirstPublish: (value: {body: Record<string, never>}) => void;
+    const firstPublishPromise = new Promise<{body: Record<string, never>}>((resolve) => {
+      resolveFirstPublish = resolve;
+    });
+    webex.request = jest
+      .fn()
+      .mockReturnValueOnce(firstPublishPromise)
+      .mockResolvedValueOnce({body: {}});
+
+    const firstPublishCall = service.setManageWebexCallingInWxcc(true, {
+      trackPublishMetrics: true,
+    });
+    const secondPublishCall = service.setManageWebexCallingInWxcc(false, {
+      trackPublishMetrics: true,
+    });
+
+    await secondPublishCall;
+
+    service.teardown();
+    resolveFirstPublish!({body: {}});
+    await firstPublishCall;
+
+    expect(cancelTimedEvent).not.toHaveBeenCalled();
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS,
+      {enableWxBetterTogether: false},
+      ['operational', 'behavioral']
+    );
+  });
+
+  it('preserves duration_ms on newer publish when stale publish completes', async () => {
+    const {default: RealMetricsManager} = jest.requireActual(
+      '../../../../src/metrics/MetricsManager'
+    );
+    RealMetricsManager.resetInstance();
+    const realManager = RealMetricsManager.getInstance();
+    jest.spyOn(realManager as any, 'isMetricsDisabled').mockReturnValue(false);
+    const trackEventSpy = jest.spyOn(realManager, 'trackEvent');
+    (MetricsManager.getInstance as jest.Mock).mockReturnValue(realManager);
+
+    let resolveFirstPublish: (value: {body: Record<string, never>}) => void;
+    const firstPublishPromise = new Promise<{body: Record<string, never>}>((resolve) => {
+      resolveFirstPublish = resolve;
+    });
+    webex.request = jest
+      .fn()
+      .mockReturnValueOnce(firstPublishPromise)
+      .mockResolvedValueOnce({body: {}});
+
+    const firstPublishCall = service.setManageWebexCallingInWxcc(true, {
+      trackPublishMetrics: true,
+    });
+    const secondPublishCall = service.setManageWebexCallingInWxcc(false, {
+      trackPublishMetrics: true,
+    });
+
+    await secondPublishCall;
+    service.teardown();
+    resolveFirstPublish!({body: {}});
+    await firstPublishCall;
+
+    const successCall = trackEventSpy.mock.calls.find(
+      ([eventName, payload]) =>
+        eventName === METRIC_EVENT_NAMES.WXAPP_USERSUB_PUBLISH_SUCCESS &&
+        (payload as {enableWxBetterTogether?: boolean}).enableWxBetterTogether === false
+    );
+    expect(successCall?.[1]).toEqual(
+      expect.objectContaining({
+        enableWxBetterTogether: false,
+        duration_ms: expect.any(Number),
+      })
+    );
+
+    RealMetricsManager.resetInstance();
+    (MetricsManager.getInstance as jest.Mock).mockReturnValue({
+      trackEvent,
+      timeEvent,
+      cancelTimedEvent,
+    });
+  });
+
+  it('does not track usersub metrics by default', async () => {
+    await service.setManageWebexCallingInWxcc(true);
+
+    expect(trackEvent).not.toHaveBeenCalled();
+    expect(timeEvent).not.toHaveBeenCalled();
   });
 
   it('uses custom ttl from options', async () => {

package/test/unit/spec/services/WxAppTelephonyMercurySync.ts

@@ -2,15 +2,28 @@ import WxAppTelephonyMercurySync, {
   TELEPHONY_CALL_MUTED,
   TELEPHONY_CALL_UNMUTED,
 } from '../../../../src/services/WxAppTelephonyMercurySync';
+import MetricsManager from '../../../../src/metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
+
+jest.mock('../../../../src/metrics/MetricsManager', () => ({
+  __esModule: true,
+  default: {
+    getInstance: jest.fn(),
+  },
+}));
 
 describe('WxAppTelephonyMercurySync', () => {
   const agentId = 'agent-123';
+  const trackEvent = jest.fn();
   let mercury: {on: jest.Mock; off: jest.Mock};
   let webex: {internal: {mercury?: typeof mercury}};
   let sync: WxAppTelephonyMercurySync;
   let onMuteChange: jest.Mock;
 
   beforeEach(() => {
+    trackEvent.mockClear();
+    (MetricsManager.getInstance as jest.Mock).mockReturnValue({trackEvent});
+
     mercury = {on: jest.fn(), off: jest.fn()};
     webex = {internal: {mercury}};
     sync = new WxAppTelephonyMercurySync(webex as never);
@@ -27,6 +40,11 @@ describe('WxAppTelephonyMercurySync', () => {
     expect(mercury.on).toHaveBeenCalledWith(TELEPHONY_CALL_MUTED, expect.any(Function));
     expect(mercury.on).toHaveBeenCalledWith(TELEPHONY_CALL_UNMUTED, expect.any(Function));
     expect(sync.isSubscribed()).toBe(true);
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_SUCCESS,
+      {},
+      ['operational', 'behavioral']
+    );
   });
 
   it('invokes callback with decoded callId and muted when actorId matches agent', () => {
@@ -77,6 +95,11 @@ describe('WxAppTelephonyMercurySync', () => {
 
     expect(sync.isSubscribed()).toBe(false);
     expect(onMuteChange).not.toHaveBeenCalled();
+    expect(trackEvent).toHaveBeenCalledWith(
+      METRIC_EVENT_NAMES.WXAPP_MERCURY_SUBSCRIBE_FAILED,
+      expect.objectContaining({error: expect.stringContaining('Mercury is unavailable')}),
+      ['operational', 'behavioral']
+    );
   });
 
   it('invokes callback with muted false on unmuted Mercury event', () => {

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

@@ -199,7 +199,7 @@ describe('Task state machine', () => {
       expect(emitTaskEnd).not.toHaveBeenCalled();
     });
 
-    it('terminates CONNECTED when an out-of-order participant leave identifies the current agent', () => {
+    it('ignores PARTICIPANT_LEAVE in CONNECTED even when it identifies the current agent', () => {
       const {service, emitTaskEnd} = startMachineWithEndSpy();
       const taskData = createActiveMainCallTaskData();
 
@@ -213,53 +213,71 @@ describe('Task state machine', () => {
         taskData: createPartialMainCallTaskData(false, true),
       });
 
+      expect(service.getSnapshot().value).toBe(TaskState.CONNECTED);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('ignores PARTICIPANT_LEAVE in HOLD_INITIATING when a remote Drop identifies the current agent', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData();
+
+      enterTransientHoldState(service, TaskState.HOLD_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: createPartialMainCallTaskData(false, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.HOLD_INITIATING);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('terminates RESUME_INITIATING when a remote Drop identifies the current agent', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData(true);
+
+      enterTransientHoldState(service, TaskState.RESUME_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-1',
+        taskData: createPartialMainCallTaskData(true, true),
+      });
+
       expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
       expect(emitTaskEnd).toHaveBeenCalledTimes(1);
     });
 
-    it.each([TaskState.HOLD_INITIATING, TaskState.RESUME_INITIATING])(
-      'terminates %s when a remote Drop identifies the current agent',
-      (state) => {
-        const {service, emitTaskEnd} = startMachineWithEndSpy();
-        const taskData = createActiveMainCallTaskData(state === TaskState.RESUME_INITIATING);
-
-        enterTransientHoldState(service, state, taskData);
-        service.send({
-          type: TaskEvent.PARTICIPANT_LEAVE,
-          participantId: 'agent-1',
-          taskData: createPartialMainCallTaskData(
-            state === TaskState.RESUME_INITIATING,
-            true
-          ),
-        });
-
-        expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
-        expect(emitTaskEnd).toHaveBeenCalledTimes(1);
-      }
-    );
-
-    it.each([TaskState.HOLD_INITIATING, TaskState.RESUME_INITIATING])(
-      'keeps %s when ParticipantLeftConference identifies another participant',
-      (state) => {
-        const {service, emitTaskEnd} = startMachineWithEndSpy();
-        const taskData = createActiveMainCallTaskData(state === TaskState.RESUME_INITIATING);
-
-        enterTransientHoldState(service, state, taskData);
-        service.send({
-          type: TaskEvent.PARTICIPANT_LEAVE,
-          participantId: 'agent-2',
-          taskData: createPartialMainCallTaskData(
-            state === TaskState.RESUME_INITIATING,
-            true
-          ),
-        });
-
-        expect(service.getSnapshot().value).toBe(state);
-        expect(emitTaskEnd).not.toHaveBeenCalled();
-      }
-    );
+    it('keeps HOLD_INITIATING when ParticipantLeftConference identifies another participant', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData();
 
-    it('keeps HELD when another participant leave event omits self from its roster', () => {
+      enterTransientHoldState(service, TaskState.HOLD_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: createPartialMainCallTaskData(false, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.HOLD_INITIATING);
+      expect(emitTaskEnd).not.toHaveBeenCalled();
+    });
+
+    it('terminates RESUME_INITIATING when another participant leave omits self from the roster', () => {
+      const {service, emitTaskEnd} = startMachineWithEndSpy();
+      const taskData = createActiveMainCallTaskData(true);
+
+      enterTransientHoldState(service, TaskState.RESUME_INITIATING, taskData);
+      service.send({
+        type: TaskEvent.PARTICIPANT_LEAVE,
+        participantId: 'agent-2',
+        taskData: createPartialMainCallTaskData(true, true),
+      });
+
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(emitTaskEnd).toHaveBeenCalledTimes(1);
+    });
+
+    it('terminates HELD when another participant leave event omits self from its roster', () => {
       const {service, emitTaskEnd} = startMachineWithEndSpy();
       const taskData = createActiveMainCallTaskData(true);
 
@@ -275,8 +293,8 @@ describe('Task state machine', () => {
         taskData: createPartialMainCallTaskData(true, true),
       });
 
-      expect(service.getSnapshot().value).toBe(TaskState.HELD);
-      expect(emitTaskEnd).not.toHaveBeenCalled();
+      expect(service.getSnapshot().value).toBe(TaskState.TERMINATED);
+      expect(emitTaskEnd).toHaveBeenCalledTimes(1);
     });
 
     it('keeps HELD when CONSULT_END has a partial mainCall', () => {
@@ -2064,7 +2082,15 @@ describe('Task state machine', () => {
 
     it('transitions to CONNECTED on CONSULT_END without isTerminated during CONF_INITIATING', () => {
       const service = startMachine();
-      const taskData = createTaskData({consultingAgentId: 'agent-1'});
+      const taskData = createTaskData({
+        consultingAgentId: 'agent-1',
+        interaction: {
+          participants: {
+            'agent-1': {id: 'agent-1', pType: 'Agent', hasLeft: false},
+            'customer-1': {id: 'customer-1', pType: 'Customer', hasLeft: false},
+          },
+        } as any,
+      });
 
       service.send({type: TaskEvent.TASK_INCOMING, taskData});
       service.send({type: TaskEvent.ASSIGN, taskData});

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

@@ -636,7 +636,7 @@ describe('State Machine Guards', () => {
       expect(guards.didCurrentAgentLeaveMainInteraction(createParams(context, event))).toBe(true);
     });
 
-    it('returns true when the current participant is marked as departed', () => {
+    it('returns false when the current participant is marked hasLeft but remains in the map', () => {
       const context = createContext({taskData: activeTaskData});
       const updatedTaskData = createTaskData({
         interaction: {
@@ -652,10 +652,10 @@ describe('State Machine Guards', () => {
         guards.didCurrentAgentLeaveMainInteraction(
           createParams(context, createEventWithTaskData(updatedTaskData))
         )
-      ).toBe(true);
+      ).toBe(false);
     });
 
-    it('uses mainCall membership for nested CONSULT_END cleanup', () => {
+    it('does not infer departure from CONSULT_END mainCall membership', () => {
       const context = createContext({taskData: activeTaskData, consultFromConference: true});
       const updatedTaskData = createTaskData({
         interaction: {
@@ -690,10 +690,10 @@ describe('State Machine Guards', () => {
 
       expect(
         guards.didCurrentAgentLeaveMainInteraction(createParams(context, event))
-      ).toBe(true);
+      ).toBe(false);
     });
 
-    it('does not infer self departure when another participant leaves and the map omits self', () => {
+    it('returns true when another participant leaves and the map omits self', () => {
       const context = createContext({taskData: activeTaskData});
       const partialTaskData = createTaskData({
         interaction: {
@@ -718,7 +718,7 @@ describe('State Machine Guards', () => {
         taskData: partialTaskData,
       } as TaskEventPayload;
 
-      expect(guards.didCurrentAgentLeaveMainInteraction(createParams(context, event))).toBe(false);
+      expect(guards.didCurrentAgentLeaveMainInteraction(createParams(context, event))).toBe(true);
     });
 
     it.each(['connected', 'held'])(