@webex/contact-center 3.12.0-next.12 → 3.12.0-next.121

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

@@ -0,0 +1,467 @@
+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: {
+        device: {userId, url: deviceUrl},
+      },
+    };
+    service = new WebexCrossClientService(webex as never);
+  });
+
+  afterEach(() => {
+    service.teardown();
+  });
+
+  it('publishes usersub with appName wxcc (Agent Desktop parity)', async () => {
+    await service.setManageWebexCallingInWxcc(true);
+
+    expect(webex.request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        method: 'POST',
+        service: 'usersub',
+        resource: 'publish',
+        body: expect.objectContaining({
+          users: [userId],
+          compositions: [
+            expect.objectContaining({
+              type: 'cross-client-state',
+              ttl: 900,
+              composition: {
+                devices: [
+                  {
+                    deviceId: 'device-abc',
+                    appName: 'wxcc',
+                    state: {'answer-calls-on-wxcc': true},
+                  },
+                ],
+              },
+            }),
+          ],
+        }),
+      })
+    );
+  });
+
+  it('publishes false when suppression is disabled', async () => {
+    await service.setManageWebexCallingInWxcc(false);
+
+    expect(webex.request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: expect.objectContaining({
+          compositions: [
+            expect.objectContaining({
+              composition: {
+                devices: [
+                  {
+                    deviceId: 'device-abc',
+                    appName: 'wxcc',
+                    state: {'answer-calls-on-wxcc': false},
+                  },
+                ],
+              },
+            }),
+          ],
+        }),
+      })
+    );
+  });
+
+  it('throws when user ID is unavailable', async () => {
+    webex.internal.device.userId = undefined as unknown as string;
+
+    await expect(service.setManageWebexCallingInWxcc(true)).rejects.toThrow(
+      '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 () => {
+    webex.internal.device.url = undefined as unknown as string;
+
+    await expect(service.setManageWebexCallingInWxcc(true)).rejects.toThrow(
+      '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, {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 () => {
+    await service.setManageWebexCallingInWxcc(true, {ttl: 1200});
+
+    expect(webex.request).toHaveBeenCalledWith(
+      expect.objectContaining({
+        body: expect.objectContaining({
+          compositions: [expect.objectContaining({ttl: 1200})],
+        }),
+      })
+    );
+  });
+
+  it('refreshes publish before ttl expiry while enabled', async () => {
+    jest.useFakeTimers();
+    try {
+      await service.setManageWebexCallingInWxcc(true, {ttl: 900});
+      expect(webex.request).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(840_000);
+
+      await Promise.resolve();
+
+      expect(webex.request).toHaveBeenCalledTimes(2);
+      expect(webex.request).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          body: expect.objectContaining({
+            compositions: [
+              expect.objectContaining({
+                composition: {
+                  devices: [
+                    {
+                      deviceId: 'device-abc',
+                      appName: 'wxcc',
+                      state: {'answer-calls-on-wxcc': true},
+                    },
+                  ],
+                },
+              }),
+            ],
+          }),
+        })
+      );
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('retries failed refresh publish before ttl expiry', async () => {
+    jest.useFakeTimers();
+    try {
+      const setManageSpy = jest.spyOn(service, 'setManageWebexCallingInWxcc');
+      webex.request = jest
+        .fn()
+        .mockResolvedValueOnce({body: {}})
+        .mockRejectedValueOnce(new Error('refresh failed'))
+        .mockResolvedValueOnce({body: {}});
+
+      await service.setManageWebexCallingInWxcc(true, {ttl: 900});
+      expect(webex.request).toHaveBeenCalledTimes(1);
+
+      jest.advanceTimersByTime(840_000);
+      await expect(setManageSpy.mock.results[1].value).rejects.toThrow('refresh failed');
+      expect(webex.request).toHaveBeenCalledTimes(2);
+
+      jest.advanceTimersByTime(30_000);
+      await setManageSpy.mock.results[2].value;
+
+      expect(webex.request).toHaveBeenCalledTimes(3);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('schedules bounded retry when scheduled refresh publish fails', async () => {
+    jest.useFakeTimers();
+    try {
+      const setManageSpy = jest.spyOn(service, 'setManageWebexCallingInWxcc');
+      webex.request = jest
+        .fn()
+        .mockResolvedValueOnce({body: {}})
+        .mockRejectedValueOnce(new Error('refresh failed'));
+
+      await service.setManageWebexCallingInWxcc(true, {ttl: 900});
+      const scheduleRefreshRetrySpy = jest.spyOn(service as any, 'scheduleRefreshRetry');
+
+      jest.advanceTimersByTime(840_000);
+      await expect(setManageSpy.mock.results[1].value).rejects.toThrow('refresh failed');
+      expect(scheduleRefreshRetrySpy).toHaveBeenCalledWith(userId, 900, 0, 0);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('does not retry refresh after teardown bumps generation', async () => {
+    jest.useFakeTimers();
+    try {
+      const setManageSpy = jest.spyOn(service, 'setManageWebexCallingInWxcc');
+      webex.request = jest
+        .fn()
+        .mockResolvedValueOnce({body: {}})
+        .mockRejectedValueOnce(new Error('refresh failed'));
+
+      await service.setManageWebexCallingInWxcc(true, {ttl: 900});
+
+      jest.advanceTimersByTime(840_000);
+      await expect(setManageSpy.mock.results[1].value).rejects.toThrow('refresh failed');
+
+      service.teardown();
+
+      jest.advanceTimersByTime(30_000);
+      await Promise.resolve();
+
+      expect(webex.request).toHaveBeenCalledTimes(2);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('teardown clears refresh timer so publish is not repeated', async () => {
+    jest.useFakeTimers();
+    try {
+      await service.setManageWebexCallingInWxcc(true, {ttl: 900});
+      service.teardown();
+
+      jest.advanceTimersByTime(840_000);
+      await Promise.resolve();
+
+      expect(webex.request).toHaveBeenCalledTimes(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('does not schedule refresh when disabled', async () => {
+    jest.useFakeTimers();
+    try {
+      await service.setManageWebexCallingInWxcc(false);
+
+      jest.advanceTimersByTime(840_000);
+      await Promise.resolve();
+
+      expect(webex.request).toHaveBeenCalledTimes(1);
+    } finally {
+      jest.useRealTimers();
+    }
+  });
+
+  it('reports whether answer-calls-on-wxcc true was published', async () => {
+    expect(service.isAnswerCallsStateActive()).toBe(false);
+
+    await service.setManageWebexCallingInWxcc(true);
+
+    expect(service.isAnswerCallsStateActive()).toBe(true);
+
+    await service.setManageWebexCallingInWxcc(false);
+
+    expect(service.isAnswerCallsStateActive()).toBe(false);
+  });
+});

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

@@ -0,0 +1,136 @@
+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);
+    onMuteChange = jest.fn();
+  });
+
+  afterEach(() => {
+    sync.unsubscribe();
+  });
+
+  it('subscribes to muted and unmuted Mercury events', () => {
+    sync.subscribe(agentId, onMuteChange);
+
+    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', () => {
+    const callId = 'prefix:call-half-1';
+    const encodedCallId = btoa(callId);
+    const encodedActorId = btoa(`some-prefix-${agentId}`);
+
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    muteHandler({data: {actorId: encodedActorId, callId: encodedCallId, muted: true}});
+
+    expect(onMuteChange).toHaveBeenCalledWith(callId, true);
+  });
+
+  it('ignores events when decoded actorId does not end with agentId', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    muteHandler({data: {actorId: btoa('other-agent'), callId: btoa('call-1'), muted: true}});
+
+    expect(onMuteChange).not.toHaveBeenCalled();
+  });
+
+  it('ignores events with missing payload fields', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    muteHandler({data: {actorId: btoa(agentId), callId: btoa('call-1')}});
+
+    expect(onMuteChange).not.toHaveBeenCalled();
+  });
+
+  it('unsubscribes and removes Mercury listeners', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    const unmuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_UNMUTED
+    )![1];
+
+    sync.unsubscribe();
+
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_MUTED, muteHandler);
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_UNMUTED, unmuteHandler);
+    expect(sync.isSubscribed()).toBe(false);
+  });
+
+  it('does not subscribe when mercury is unavailable', () => {
+    sync = new WxAppTelephonyMercurySync({internal: {}} as never);
+    sync.subscribe(agentId, onMuteChange);
+
+    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', () => {
+    const callId = 'prefix:call-half-1';
+    const encodedCallId = btoa(callId);
+    const encodedActorId = btoa(`some-prefix-${agentId}`);
+
+    sync.subscribe(agentId, onMuteChange);
+    const unmuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_UNMUTED
+    )![1];
+    unmuteHandler({data: {actorId: encodedActorId, callId: encodedCallId, muted: false}});
+
+    expect(onMuteChange).toHaveBeenCalledWith(callId, false);
+  });
+
+  it('resubscribe replaces previous Mercury listeners', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const firstMuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_MUTED
+    )![1];
+    const firstUnmuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_UNMUTED
+    )![1];
+    expect(mercury.on).toHaveBeenCalledTimes(2);
+
+    const secondHandler = jest.fn();
+    sync.subscribe(agentId, secondHandler);
+
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_MUTED, firstMuteHandler);
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_UNMUTED, firstUnmuteHandler);
+    expect(mercury.on).toHaveBeenCalledTimes(4);
+  });
+});

package/test/unit/spec/services/config/Util.ts

@@ -0,0 +1,85 @@
+import {parseAgentConfigs} from '../../../../../src/services/config/Util';
+import {AuxCode, DesktopProfileResponse} from '../../../../../src/services/config/types';
+
+const baseAgentProfile: DesktopProfileResponse = {
+  timeoutDesktopInactivityCustomEnabled: false,
+  timeoutDesktopInactivityMins: 10,
+  accessWrapUpCode: 'ALL',
+  wrapUpCodes: [],
+  accessIdleCode: 'ALL',
+  idleCodes: [],
+  autoWrapUp: false,
+  autoWrapAfterSeconds: 30,
+  lastAgentRouting: false,
+  allowAutoWrapUpExtension: false,
+  outdialEnabled: true,
+  dialPlanEnabled: false,
+  agentAvailableAfterOutdial: true,
+  outdialEntryPointId: 'ep-1',
+  consultToQueue: false,
+  viewableStatistics: {agentStats: false},
+  addressBookId: 'ab-1',
+  outdialANIId: 'ani-1',
+  loginVoiceOptions: [],
+  dialPlans: [],
+  agentDNValidation: 'PROVISIONED_VALUE',
+  accessQueue: 'SPECIFIC',
+  accessEntryPoint: 'NONE',
+  accessBuddyTeam: 'ALL',
+} as DesktopProfileResponse;
+
+const baseProfileData = {
+  userData: {
+    ciUserId: 'agent-1',
+    firstName: 'Jane',
+    lastName: 'Agent',
+    email: 'jane@example.com',
+    agentProfileId: 'profile-1',
+    skillProfileId: 'skill-1',
+    siteId: 'site-1',
+    dbId: 'db-1',
+    deafultDialledNumber: '+15551234567',
+    id: 'user-1',
+    teamIds: ['team-1'],
+  },
+  teamData: [{id: 'team-1', name: 'Support'}],
+  tenantData: {
+    timeoutDesktopInactivityEnabled: false,
+    timeoutDesktopInactivityMins: 15,
+    forceDefaultDn: false,
+    dnDefaultRegex: '',
+    dnOtherRegex: '',
+    outdialEnabled: true,
+    endCallEnabled: true,
+    endConsultEnabled: true,
+    callVariablesSuppressed: false,
+    privacyShieldVisible: false,
+  },
+  orgInfoData: {
+    tenantId: 'tenant-1',
+    timezone: 'UTC',
+    environment: 'produs1',
+  },
+  auxCodes: [] as AuxCode[],
+  orgSettingsData: {
+    campaignManagerEnabled: false,
+    webRtcEnabled: true,
+    maskSensitiveData: false,
+  },
+  agentProfileData: baseAgentProfile,
+  dialPlanData: [],
+  urlMapping: [],
+  multimediaProfileId: 'mm-1',
+  aiFeatureFlags: {data: []},
+};
+
+describe('parseAgentConfigs collaboration access fields', () => {
+  it('maps Desktop Profile collaboration access flags onto Profile', () => {
+    const profile = parseAgentConfigs(baseProfileData);
+
+    expect(profile.allowConsultToQueue).toBe(false);
+    expect(profile.accessQueue).toBe('SPECIFIC');
+    expect(profile.accessEntryPoint).toBe('NONE');
+    expect(profile.accessBuddyTeam).toBe('ALL');
+  });
+});