@webex/contact-center 3.12.0-next.14 → 3.12.0-next.141

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

@@ -0,0 +1,235 @@
+import 'jsdom-global/register';
+import {LocalMicrophoneStream, CALL_EVENT_KEYS} from '@webex/calling';
+import WebRTC from '../../../../../../src/services/task/voice/WebRTC';
+import WebCallingService from '../../../../../../src/services/WebCallingService';
+import {TaskData, TASK_EVENTS} from '../../../../../../src/services/task/types';
+import type {WebexSDK} from '../../../../../../src/types';
+import {TaskEvent, TaskEventPayload} from '../../../../../../src/services/task/state-machine';
+import {createTaskData} from '../taskTestUtils';
+
+jest.mock('@webex/calling', () => ({
+  LocalMicrophoneStream: class {
+    constructor(stream) {
+      this.outputStream = stream;
+    }
+  },
+  CALL_EVENT_KEYS: {REMOTE_MEDIA: 'remoteMedia'},
+}));
+
+beforeAll(() => {
+  navigator.mediaDevices = {getUserMedia: jest.fn()};
+  // @ts-ignore
+  global.MediaStream = class {
+    constructor(private tracks: MediaStreamTrack[]) {}
+    getAudioTracks() {
+      return this.tracks;
+    }
+  } as typeof MediaStream;
+});
+
+jest.mock('../../../../../../src/services/core/WebexRequest', () => ({
+  __esModule: true,
+  default: {
+    getInstance: jest.fn().mockReturnValue({uploadLogs: jest.fn()}),
+  },
+}));
+
+const sendStateEvents = (task: WebRTC, events: TaskEventPayload[]) => {
+  events.forEach((event) => {
+    if (!event) {
+      throw new Error('Task event payload is required');
+    }
+    task.stateMachineService?.send(event);
+  });
+};
+
+describe('WebRTC Task', () => {
+  const dummyContact = {} as any;
+  let taskData: TaskData;
+  let webCallingService: WebCallingService;
+  let onSpy: jest.SpyInstance;
+  let offSpy: jest.SpyInstance;
+  let answerSpy: jest.SpyInstance;
+  let declineSpy: jest.SpyInstance;
+  let muteSpy: jest.SpyInstance;
+
+  let webRtc: WebRTC;
+
+  beforeAll(() => {
+    const webex = {
+      logger: {
+        log: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+      },
+    } as unknown as WebexSDK;
+
+    webCallingService = new WebCallingService(webex);
+    onSpy = jest.spyOn(webCallingService, 'on');
+    offSpy = jest.spyOn(webCallingService, 'off');
+    answerSpy = jest.spyOn(webCallingService, 'answerCall');
+    declineSpy = jest.spyOn(webCallingService, 'declineCall');
+    muteSpy = jest.spyOn(webCallingService, 'muteUnmuteCall');
+  });
+
+  beforeEach(() => {
+    taskData = createTaskData();
+    webRtc = new WebRTC(dummyContact, webCallingService, taskData, {
+      isEndTaskEnabled: true,
+      isEndConsultEnabled: true,
+    });
+  });
+
+  it('accept() obtains media and answers call', async () => {
+    const fakeTrack = {} as any;
+    const fakeStream = {getAudioTracks: () => [fakeTrack]} as any;
+    jest.spyOn(navigator.mediaDevices, 'getUserMedia').mockResolvedValue(fakeStream);
+    await webRtc.accept();
+    expect(answerSpy).toHaveBeenCalled();
+    const [[streamArg, interactionIdArg]] = webCallingService.answerCall.mock.calls;
+    expect(streamArg).toBeInstanceOf(LocalMicrophoneStream);
+    expect(interactionIdArg).toBe(taskData.interactionId);
+  });
+
+  it('decline() calls declineCall and unregisters listeners', async () => {
+    jest.spyOn(webRtc, 'unregisterWebCallListeners');
+    const res = await webRtc.decline();
+    expect(declineSpy).toHaveBeenCalledWith(taskData.interactionId);
+    expect(webRtc.unregisterWebCallListeners).toHaveBeenCalled();
+    expect(res).toBeUndefined();
+  });
+
+  it('toggleMute() calls muteUnmuteCall with stored localAudioStream', async () => {
+    const dummyStream = {} as any;
+    webRtc.localAudioStream = dummyStream;
+    await webRtc.toggleMute();
+    expect(muteSpy).toHaveBeenCalledWith(dummyStream);
+  });
+
+  describe('WebRTC internal methods', () => {
+    it('registerWebCallListeners binds remote media event', () => {
+      webRtc.registerWebCallListeners();
+      expect(onSpy).toHaveBeenCalledWith(CALL_EVENT_KEYS.REMOTE_MEDIA, webRtc.handleRemoteMedia);
+    });
+
+    it('handleRemoteMedia emits TASK_MEDIA event', () => {
+      const fakeTrack = {} as any;
+      jest.spyOn(webRtc, 'emit');
+      webRtc.handleRemoteMedia(fakeTrack);
+      expect(webRtc.emit).toHaveBeenCalledWith(TASK_EVENTS.TASK_MEDIA, fakeTrack);
+    });
+  });
+
+  describe('UI controls', () => {
+    beforeEach(() => {
+      taskData = createTaskData();
+      webRtc = new WebRTC(dummyContact, webCallingService, taskData, {
+        isEndTaskEnabled: true,
+        isEndConsultEnabled: true,
+      });
+    });
+
+    it('initialiseUIControls sets accept and decline visible', () => {
+      sendStateEvents(webRtc, [{type: TaskEvent.TASK_INCOMING, taskData}]);
+      expect(webRtc.uiControls.main.accept.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.decline.isVisible).toBe(true);
+    });
+
+    it('setUIControls for AGENT_CONTACT_ASSIGNED shows mute enabled', () => {
+      sendStateEvents(webRtc, [
+        {type: TaskEvent.TASK_INCOMING, taskData},
+        {type: TaskEvent.ASSIGN, taskData},
+      ]);
+      expect(webRtc.uiControls.main.mute.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.mute.isEnabled).toBe(true);
+    });
+
+    it('default setUIControls hides mute when wrapup visible', () => {
+      sendStateEvents(webRtc, [
+        {type: TaskEvent.TASK_INCOMING, taskData},
+        {type: TaskEvent.ASSIGN, taskData},
+        {type: TaskEvent.TASK_WRAPUP},
+      ]);
+      expect(webRtc.uiControls.main.wrapup.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.mute.isVisible).toBe(false);
+    });
+
+    it('setUIControls for AGENT_CONTACT_HELD disables mute', () => {
+      sendStateEvents(webRtc, [
+        {type: TaskEvent.TASK_INCOMING, taskData},
+        {type: TaskEvent.ASSIGN, taskData},
+        {type: TaskEvent.HOLD_INITIATED, mediaResourceId: taskData.mediaResourceId},
+        {type: TaskEvent.HOLD_SUCCESS, mediaResourceId: taskData.mediaResourceId},
+      ]);
+      expect(webRtc.uiControls.main.mute.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.mute.isEnabled).toBe(false);
+    });
+
+    it('setUIControls for AGENT_CONTACT_UNHELD re-enables mute', () => {
+      sendStateEvents(webRtc, [
+        {type: TaskEvent.TASK_INCOMING, taskData},
+        {type: TaskEvent.ASSIGN, taskData},
+        {type: TaskEvent.HOLD_INITIATED, mediaResourceId: taskData.mediaResourceId},
+        {type: TaskEvent.HOLD_SUCCESS, mediaResourceId: taskData.mediaResourceId},
+        {type: TaskEvent.UNHOLD_INITIATED, mediaResourceId: taskData.mediaResourceId},
+        {type: TaskEvent.UNHOLD_SUCCESS, mediaResourceId: taskData.mediaResourceId},
+      ]);
+      expect(webRtc.uiControls.main.mute.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.mute.isEnabled).toBe(true);
+    });
+
+    it('setUIControls for AGENT_OFFER_CONTACT shows accept and decline', () => {
+      sendStateEvents(webRtc, [{type: TaskEvent.TASK_INCOMING, taskData}]);
+      expect(webRtc.uiControls.main.accept.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.decline.isVisible).toBe(true);
+    });
+
+    it('setUIControls for AGENT_OFFER_CONSULT shows accept and decline', () => {
+      const consultedTaskData = {...taskData, isConsulted: true};
+      sendStateEvents(webRtc, [
+        {type: TaskEvent.TASK_INCOMING, taskData},
+        {type: TaskEvent.OFFER_CONSULT, taskData: consultedTaskData},
+      ]);
+      expect(webRtc.uiControls.main.accept.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.decline.isVisible).toBe(true);
+    });
+
+    it('setUIControls for AGENT_CONSULTING hides accept/decline and shows mute when consulted', () => {
+      const consultedTaskData = {...taskData, isConsulted: true};
+      sendStateEvents(webRtc, [
+        {type: TaskEvent.TASK_INCOMING, taskData},
+        {type: TaskEvent.OFFER_CONSULT, taskData: consultedTaskData},
+        {
+          type: TaskEvent.CONSULTING_ACTIVE,
+          consultDestinationAgentJoined: true,
+          taskData: consultedTaskData,
+        },
+      ]);
+      expect(webRtc.uiControls.main.accept.isVisible).toBe(false);
+      expect(webRtc.uiControls.main.decline.isVisible).toBe(false);
+      expect(webRtc.uiControls.main.mute.isVisible).toBe(true);
+      expect(webRtc.uiControls.main.mute.isEnabled).toBe(true);
+    });
+
+    it('setUIControls for AGENT_CONSULT_ENDED returns mute to connected state behavior', () => {
+      const consultedTaskData = {...taskData, isConsulted: true};
+      sendStateEvents(webRtc, [
+        {type: TaskEvent.TASK_INCOMING, taskData},
+        {type: TaskEvent.OFFER_CONSULT, taskData: consultedTaskData},
+        {
+          type: TaskEvent.CONSULTING_ACTIVE,
+          consultDestinationAgentJoined: true,
+          taskData: consultedTaskData,
+        },
+        {type: TaskEvent.CONSULT_END},
+      ]);
+      expect(webRtc.uiControls.main.mute.isVisible).toBe(false);
+    });
+
+    it('setUIControls for AGENT_CONTACT_OFFER_RONA hides accept and decline', () => {
+      sendStateEvents(webRtc, [{type: TaskEvent.TASK_INCOMING, taskData}, {type: TaskEvent.RONA}]);
+      expect(webRtc.uiControls.main.accept.isVisible).toBe(false);
+      expect(webRtc.uiControls.main.decline.isVisible).toBe(false);
+    });
+  });
+});

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

@@ -0,0 +1,361 @@
+import MetricsManager from '../../../../../../src/metrics/MetricsManager';
+import {METRIC_EVENT_NAMES} from '../../../../../../src/metrics/constants';
+import {TaskState} from '../../../../../../src/services/task/state-machine';
+import {TaskData, VOICE_VARIANT} from '../../../../../../src/services/task/types';
+import {
+  WxAppOfferObservability,
+  WxAppOfferObservabilityContext,
+  WXAPP_PARTICIPANT_MISMATCH_GRACE_MS,
+} from '../../../../../../src/services/task/voice/wxAppOfferObservability';
+import {WxAppVoiceDependencies} from '../../../../../../src/services/task/voice/wxAppVoiceMethods';
+import * as wxAppDiagnosticLogging from '../../../../../../src/services/wxAppDiagnosticLogging';
+import {createTaskData} from '../taskTestUtils';
+
+const wxAppParticipant = {
+  deviceType: 'wxApp',
+  deviceId: 'device-id-1',
+  deviceCallId: 'call-id-1',
+};
+
+function makeTaskDataWithoutWxAppFields(): TaskData {
+  return createTaskData({
+    agentId: 'agent-1',
+    interaction: {
+      participants: {
+        'agent-1': {id: 'agent-1'},
+      },
+    } as TaskData['interaction'],
+  });
+}
+
+function makeTaskDataWithWxAppFields(): TaskData {
+  return createTaskData({
+    agentId: 'agent-1',
+    interaction: {
+      participants: {
+        'agent-1': {id: 'agent-1', ...wxAppParticipant},
+      },
+    } as TaskData['interaction'],
+  });
+}
+
+function makeMockMetricsManager(): jest.Mocked<Pick<MetricsManager, 'trackEvent'>> {
+  return {trackEvent: jest.fn()};
+}
+
+function makeContext(
+  overrides: {
+    taskData?: TaskData;
+    taskState?: TaskState;
+    usersubPublished?: boolean;
+    wxAppAcceptInFlight?: boolean;
+    wxAppAnswerPending?: boolean;
+    voiceVariant?: typeof VOICE_VARIANT.PSTN;
+    acceptEnabled?: boolean;
+    isOutdial?: boolean;
+  } = {}
+): WxAppOfferObservabilityContext & {
+  setTaskData: (data: TaskData) => void;
+  setTaskState: (s: TaskState) => void;
+  setUsersubPublished: (value: boolean) => void;
+} {
+  let taskData = overrides.taskData ?? makeTaskDataWithoutWxAppFields();
+  let taskState = overrides.taskState ?? TaskState.OFFERED;
+  let usersubPublished = overrides.usersubPublished ?? true;
+  const metricsManager = makeMockMetricsManager() as unknown as MetricsManager;
+
+  const deps = (): WxAppVoiceDependencies => ({
+    enableWxBetterTogether: true,
+    agentId: 'agent-1',
+    metricsManager,
+    getTaskData: () => taskData,
+    getTaskState: () => taskState,
+    getWxAppMuted: () => false,
+    setWxAppMuted: jest.fn(),
+    getUsersubPublished: () => usersubPublished,
+  });
+
+  return {
+    getInteractionId: () => taskData.interactionId,
+    getTaskState: () => taskState,
+    getAcceptControl: () => ({
+      isVisible: true,
+      isEnabled: overrides.acceptEnabled ?? false,
+    }),
+    getVoiceVariant: () => overrides.voiceVariant ?? VOICE_VARIANT.PSTN,
+    isOutdial: () => overrides.isOutdial ?? false,
+    isWxAppInboundOffer: () => {
+      const p = taskData.interaction?.participants?.['agent-1'] as
+        | {deviceType?: string; deviceCallId?: string; deviceId?: string}
+        | undefined;
+      return (
+        p?.deviceType === 'wxApp' &&
+        typeof p.deviceCallId === 'string' &&
+        p.deviceCallId.trim() !== '' &&
+        typeof p.deviceId === 'string' &&
+        p.deviceId.trim() !== ''
+      );
+    },
+    isWxAppCallingOffer: () => {
+      const p = taskData.interaction?.participants?.['agent-1'] as
+        | {deviceType?: string; deviceCallId?: string; deviceId?: string}
+        | undefined;
+      return (
+        p?.deviceType === 'wxApp' &&
+        typeof p.deviceCallId === 'string' &&
+        p.deviceCallId.trim() !== '' &&
+        typeof p.deviceId === 'string' &&
+        p.deviceId.trim() !== ''
+      );
+    },
+    getWxAppAcceptInFlight: () => overrides.wxAppAcceptInFlight ?? false,
+    getWxAppAnswerPending: () => overrides.wxAppAnswerPending ?? false,
+    getEnableWxBetterTogether: () => true,
+    getUsersubPublished: () => usersubPublished,
+    getWxAppVoiceDependencies: deps,
+    getMetricsManager: () => metricsManager,
+    setTaskData: (data: TaskData) => {
+      taskData = data;
+    },
+    setTaskState: (state: TaskState) => {
+      taskState = state;
+    },
+    setUsersubPublished: (value: boolean) => {
+      usersubPublished = value;
+    },
+  };
+}
+
+describe('WxAppOfferObservability', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('offer decision logging', () => {
+    it('logs wxApp_offer_ready when participant fields are present', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({taskData: makeTaskDataWithWxAppFields(), acceptEnabled: true});
+
+      observability.handleUiControlsUpdate(ctx);
+
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.objectContaining({acceptReason: 'wxApp_offer_ready'})
+      );
+    });
+
+    it('logs accept reason transitions only once per reason', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({
+        taskData: makeTaskDataWithWxAppFields(),
+        wxAppAcceptInFlight: true,
+      });
+
+      observability.handleUiControlsUpdate(ctx);
+      observability.handleUiControlsUpdate(ctx);
+
+      expect(logSpy).toHaveBeenCalledTimes(1);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.objectContaining({acceptReason: 'wxApp_accept_in_flight'})
+      );
+    });
+
+    it('logs browser_webrtc_offer for WebRTC variant without wxApp participant', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({
+        taskData: createTaskData({
+          agentId: 'agent-1',
+          interaction: {
+            participants: {
+              'agent-1': {id: 'agent-1', deviceType: 'phone', deviceId: 'device-id-1'},
+            },
+          } as TaskData['interaction'],
+        }),
+        voiceVariant: VOICE_VARIANT.WEBRTC,
+      });
+
+      observability.handleUiControlsUpdate(ctx);
+
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.objectContaining({acceptReason: 'browser_webrtc_offer'})
+      );
+    });
+  });
+
+  describe('deferred participant mismatch', () => {
+    it('does not warn when wxApp fields arrive before grace period elapses', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      ctx.setTaskData(makeTaskDataWithWxAppFields());
+      observability.handleUiControlsUpdate(ctx);
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('warns and emits metric when fields remain missing after grace period', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          interactionId: 'interaction-1',
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+          acceptReason: 'extension_non_wxApp_offer',
+        })
+      );
+      expect(ctx.getMetricsManager().trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.objectContaining({
+          taskId: 'interaction-1',
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+          acceptReason: 'extension_non_wxApp_offer',
+        }),
+        ['operational', 'behavioral']
+      );
+    });
+
+    it('cancels pending mismatch when task leaves OFFERED before grace period', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      ctx.setTaskState(TaskState.TERMINATED);
+      observability.handleUiControlsUpdate(ctx);
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('clears grace timer on dispose', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.handleUiControlsUpdate(ctx);
+      observability.dispose();
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not reschedule diagnostics after dispose', () => {
+      const logSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferDecision');
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext();
+
+      observability.dispose();
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(logSpy).not.toHaveBeenCalled();
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('does not warn or emit metric for outdial offers with missing wxApp fields', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({isOutdial: true});
+
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+
+    it('does not schedule mismatch while usersub is unpublished, then emits after refresh when usersub becomes active', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({usersubPublished: false});
+
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      ctx.setUsersubPublished(true);
+      observability.handleUiControlsUpdate(ctx);
+      expect(warnSpy).not.toHaveBeenCalled();
+
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.objectContaining({
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+        })
+      );
+      expect(ctx.getMetricsManager().trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.objectContaining({
+          usersubPublished: true,
+          hasDeviceCallId: false,
+          hasDeviceId: false,
+        }),
+        ['operational', 'behavioral']
+      );
+    });
+
+    it('does not emit mismatch after usersub refresh when participant fields are already valid', () => {
+      const warnSpy = jest.spyOn(wxAppDiagnosticLogging, 'logWxAppOfferParticipantMismatch');
+      const observability = new WxAppOfferObservability();
+      const ctx = makeContext({
+        taskData: makeTaskDataWithWxAppFields(),
+        usersubPublished: false,
+      });
+
+      observability.handleUiControlsUpdate(ctx);
+      ctx.setUsersubPublished(true);
+      observability.handleUiControlsUpdate(ctx);
+      jest.advanceTimersByTime(WXAPP_PARTICIPANT_MISMATCH_GRACE_MS);
+
+      expect(warnSpy).not.toHaveBeenCalled();
+      expect(ctx.getMetricsManager().trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.WXAPP_OFFER_PARTICIPANT_FIELDS_MISSING,
+        expect.anything(),
+        expect.anything()
+      );
+    });
+  });
+});