@webex/contact-center 3.12.0-llmrefactor.2 → 3.12.0-llmrefactor.3

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

@@ -143,7 +143,8 @@ describe('Queue', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
         method: HTTP_METHODS.GET,
       });
 
@@ -156,7 +157,7 @@ describe('Queue', () => {
           statusCode: 200,
           recordCount: 2,
           totalRecords: 2,
-          isSearchRequest: false,
+          isSearchRequest: true,
           isFirstPage: true,
         },
         ['behavioral', 'operational']
@@ -168,14 +169,15 @@ describe('Queue', () => {
           orgId: 'test-org-id',
           page: 0,
           pageSize: 100,
-          isSearchRequest: false,
+          isSearchRequest: true,
         }),
       });
       expect(LoggerProxy.log).toHaveBeenCalledWith('Making API request to fetch contact service queues', {
         module: 'Queue',
         method: 'getQueues',
         data: expect.objectContaining({
-          resource: '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100',
+          resource:
+            '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
           service: 'wcc-api-gateway',
         }),
       });
@@ -201,7 +203,7 @@ describe('Queue', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=25&filter=queueType%3D%3D%22INBOUND%22&attributes=id%2Cname%2CqueueType&search=support&sortBy=name&sortOrder=desc&desktopProfileFilter=true&provisioningView=false&singleObjectResponse=true',
+        resource: '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=25&filter=queueType%3D%3D%22INBOUND%22&attributes=id%2Cname%2CqueueType&search=support&sort=name%2CDESC&desktopProfileFilter=true&provisioningView=false&singleObjectResponse=true&agentView=true&firstLevelView=true',
         method: HTTP_METHODS.GET,
       });
 
@@ -215,6 +217,108 @@ describe('Queue', () => {
       );
     });
 
+    it('should default sortOrder-only requests to name and bypass cache', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await queueAPI.getQueues({sortOrder: 'desc'});
+      await queueAPI.getQueues({sortOrder: 'desc'});
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(2);
+      expect(mockWebex.request).toHaveBeenLastCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CDESC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
+        method: HTTP_METHODS.GET,
+      });
+    });
+
+    it('should allow existing parameters to override the default queue policy', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await queueAPI.getQueues({
+        page: 1,
+        pageSize: 25,
+        search: 'support',
+        filter: 'queueType==INBOUND;channelType==SOCIAL_CHANNEL;active==true',
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=25&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DSOCIAL_CHANNEL%3Bactive%3D%3Dtrue&search=support&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
+        method: HTTP_METHODS.GET,
+      });
+      expect(result).toBe(mockResponse.body);
+    });
+
+    it('should preserve defaults when optional overrides are undefined', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await queueAPI.getQueues({
+        filter: undefined,
+        sortBy: undefined,
+        sortOrder: undefined,
+        desktopProfileFilter: undefined,
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
+        method: HTTP_METHODS.GET,
+      });
+    });
+
+    it('should preserve an explicit empty filter override', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await queueAPI.getQueues({filter: ''});
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
+        method: HTTP_METHODS.GET,
+      });
+    });
+
+    it('should bypass cache for the default queue policy', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await queueAPI.getQueues();
+      await queueAPI.getQueues();
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(2);
+      expect(mockWebex.request).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          resource: expect.stringContaining('channelType%3D%3DTELEPHONY'),
+        })
+      );
+    });
+
+    it('should disable the internal agent views when desktop profile filtering is false', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await queueAPI.getQueues({
+        desktopProfileFilter: false,
+        provisioningView: false,
+        singleObjectResponse: false,
+      });
+      await queueAPI.getQueues({
+        desktopProfileFilter: false,
+        provisioningView: false,
+        singleObjectResponse: false,
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(2);
+      expect(mockWebex.request).toHaveBeenLastCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CASC&desktopProfileFilter=false&provisioningView=false&singleObjectResponse=false&agentView=false&firstLevelView=false',
+        method: HTTP_METHODS.GET,
+      });
+    });
+
     it('should handle API errors and track metrics', async () => {
       (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Internal Server Error'));
 
@@ -222,7 +326,8 @@ describe('Queue', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=0&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
         method: HTTP_METHODS.GET,
       });
 
@@ -231,7 +336,7 @@ describe('Queue', () => {
         {
           orgId: 'test-org-id',
           error: 'Internal Server Error',
-          isSearchRequest: false,
+          isSearchRequest: true,
           page: 0,
           pageSize: 100,
         },
@@ -243,7 +348,7 @@ describe('Queue', () => {
         data: expect.objectContaining({
           orgId: 'test-org-id',
           error: 'Internal Server Error',
-          isSearchRequest: false,
+          isSearchRequest: true,
           page: 0,
           pageSize: 100,
         }),
@@ -253,13 +358,17 @@ describe('Queue', () => {
 
 
 
-    it('should not track metrics for subsequent pages in simple pagination', async () => {
+    it('should track metrics for subsequent pages under the default filtered policy', async () => {
       (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
 
       const result = await queueAPI.getQueues({page: 2});
       expect(result).toEqual(mockResponse.body);
 
-      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.QUEUE_FETCH_SUCCESS,
+        expect.objectContaining({isSearchRequest: true, isFirstPage: false}),
+        ['behavioral', 'operational']
+      );
     });
 
     it('should track metrics for search requests on any page', async () => {
@@ -307,14 +416,16 @@ describe('Queue', () => {
       expect(result.meta.page).toBe(1);
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=100',
+        resource:
+          '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
         method: HTTP_METHODS.GET,
       });
       expect(LoggerProxy.log).toHaveBeenCalledWith('Making API request to fetch contact service queues', {
         module: 'Queue',
         method: 'getQueues',
         data: expect.objectContaining({
-          resource: '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=100',
+          resource:
+            '/organization/test-org-id/v2/contact-service-queue?page=1&pageSize=100&filter=queueType%3D%3DINBOUND%3BchannelType%3D%3DTELEPHONY%3Bactive%3D%3Dtrue&sort=name%2CASC&desktopProfileFilter=true&agentView=true&firstLevelView=true',
           service: 'wcc-api-gateway',
         }),
       });

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

@@ -0,0 +1,261 @@
+import WebexCrossClientService from '../../../../src/services/WebexCrossClientService';
+
+describe('WebexCrossClientService', () => {
+  const userId = 'user-123';
+  const deviceUrl = 'https://wdm.example.com/devices/device-abc';
+
+  let webex: {request: jest.Mock; internal: {device: {userId: string; url: string}}};
+  let service: WebexCrossClientService;
+
+  beforeEach(() => {
+    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();
+  });
+
+  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();
+  });
+
+  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');
+  });
+
+  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,113 @@
+import WxAppTelephonyMercurySync, {
+  TELEPHONY_CALL_MUTED,
+  TELEPHONY_CALL_UNMUTED,
+} from '../../../../src/services/WxAppTelephonyMercurySync';
+
+describe('WxAppTelephonyMercurySync', () => {
+  const agentId = 'agent-123';
+  let mercury: {on: jest.Mock; off: jest.Mock};
+  let webex: {internal: {mercury?: typeof mercury}};
+  let sync: WxAppTelephonyMercurySync;
+  let onMuteChange: jest.Mock;
+
+  beforeEach(() => {
+    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);
+  });
+
+  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();
+  });
+
+  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');
+  });
+});