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

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/UserPreference.ts

@@ -0,0 +1,401 @@
+import {expect} from '@jest/globals';
+import UserPreference from '../../../../src/services/UserPreference';
+import {HTTP_METHODS, WebexSDK, IHttpResponse} from '../../../../src/types';
+import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
+import WebexRequest from '../../../../src/services/core/WebexRequest';
+import MetricsManager from '../../../../src/metrics/MetricsManager';
+import LoggerProxy from '../../../../src/logger-proxy';
+
+jest.mock('../../../../src/metrics/MetricsManager');
+jest.mock('../../../../src/logger-proxy');
+
+describe('UserPreference', () => {
+  let userPreferenceAPI: UserPreference;
+  let mockWebex: WebexSDK;
+  let mockMetricsManager: jest.Mocked<MetricsManager>;
+
+  const mockGetUserId = jest.fn().mockReturnValue('test-user-id');
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (WebexRequest as any).instance = undefined;
+
+    mockWebex = {
+      credentials: {
+        getOrgId: jest.fn().mockReturnValue('test-org-id'),
+      },
+      request: jest.fn(),
+      internal: {
+        newMetrics: {
+          submitBehavioralEvent: jest.fn(),
+          submitOperationalEvent: jest.fn(),
+          submitBusinessEvent: jest.fn(),
+        },
+      },
+      ready: true,
+      once: jest.fn(),
+    } as unknown as WebexSDK;
+
+    mockMetricsManager = {
+      trackEvent: jest.fn(),
+      timeEvent: jest.fn(),
+    } as unknown as jest.Mocked<MetricsManager>;
+    (MetricsManager.getInstance as jest.Mock).mockReturnValue(mockMetricsManager);
+
+    userPreferenceAPI = new UserPreference(mockWebex, mockGetUserId);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with all required dependencies', () => {
+      expect(WebexRequest.getInstance({webex: mockWebex})).toBeDefined();
+      expect(MetricsManager.getInstance).toHaveBeenCalledWith({webex: mockWebex});
+    });
+  });
+
+  describe('getUserPreference', () => {
+    const mockPreference = {
+      id: 'pref-123',
+      organizationId: 'test-org-id',
+      userId: 'test-user-id',
+      preferences: {e911Reminder: true},
+      createdTime: 1234567890,
+      lastUpdatedTime: 1234567890,
+    };
+
+    const mockResponse: IHttpResponse = {
+      statusCode: 200,
+      method: 'GET',
+      url: '/organization/test-org-id/user-preference/test-user-id',
+      headers: {} as any,
+      body: mockPreference,
+    };
+
+    beforeEach(() => {
+      jest.spyOn(Date, 'now').mockReturnValue(1000);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should fetch user preferences successfully with default userId', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await userPreferenceAPI.getUserPreference();
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: 'organization/test-org-id/user-preference/test-user-id',
+        method: HTTP_METHODS.GET,
+        body: undefined,
+      });
+      expect(result).toEqual(mockPreference);
+      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_GET_SUCCESS
+      );
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_GET_SUCCESS,
+        expect.objectContaining({
+          orgId: 'test-org-id',
+          userId: 'test-user-id',
+          statusCode: 200,
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should fetch user preferences for a specific userId', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await userPreferenceAPI.getUserPreference({userId: 'specific-user-id'});
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: 'organization/test-org-id/user-preference/specific-user-id',
+        method: HTTP_METHODS.GET,
+        body: undefined,
+      });
+      expect(result).toEqual(mockPreference);
+    });
+
+    it('should fetch user preferences with pagination parameters', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await userPreferenceAPI.getUserPreference({page: 1, pageSize: 50});
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: 'organization/test-org-id/user-preference/test-user-id?page=1&pageSize=50',
+        method: HTTP_METHODS.GET,
+        body: undefined,
+      });
+      expect(result).toEqual(mockPreference);
+    });
+
+    it('should throw error when userId is not available', async () => {
+      mockGetUserId.mockReturnValueOnce('');
+
+      await expect(userPreferenceAPI.getUserPreference()).rejects.toThrow(
+        'UserPreference: userId is not available.'
+      );
+
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should handle API errors', async () => {
+      const mockError = new Error('API call failed');
+      (mockWebex.request as jest.Mock).mockRejectedValue(mockError);
+
+      await expect(userPreferenceAPI.getUserPreference()).rejects.toThrow('API call failed');
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_GET_FAILED,
+        expect.objectContaining({
+          error: 'API call failed',
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+  });
+
+  describe('createUserPreference', () => {
+    const mockCreateRequest = {
+      userId: 'test-user-id',
+      desktopPreference: '{}',
+    };
+
+    const mockCreatedPreference = {
+      id: 'pref-123',
+      organizationId: 'test-org-id',
+      userId: 'test-user-id',
+      preferences: {e911Reminder: true},
+      createdTime: 1234567890,
+      lastUpdatedTime: 1234567890,
+    };
+
+    const mockResponse: IHttpResponse = {
+      statusCode: 201,
+      method: 'POST',
+      url: '/organization/test-org-id/user-preference',
+      headers: {} as any,
+      body: mockCreatedPreference,
+    };
+
+    beforeEach(() => {
+      jest.spyOn(Date, 'now').mockReturnValue(1000);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should create user preferences successfully', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await userPreferenceAPI.createUserPreference(mockCreateRequest);
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: 'organization/test-org-id/user-preference',
+        method: HTTP_METHODS.POST,
+        body: mockCreateRequest,
+      });
+      expect(result).toEqual(mockCreatedPreference);
+      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_SUCCESS
+      );
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_SUCCESS,
+        expect.objectContaining({
+          orgId: 'test-org-id',
+          userId: 'test-user-id',
+          statusCode: 201,
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should throw error when userId is missing in request', async () => {
+      const invalidRequest = {
+        userId: '',
+        desktopPreference: '{}',
+      };
+
+      await expect(userPreferenceAPI.createUserPreference(invalidRequest)).rejects.toThrow(
+        'UserPreference: userId is required to create user preferences.'
+      );
+
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should handle API errors', async () => {
+      const mockError = new Error('API call failed');
+      (mockWebex.request as jest.Mock).mockRejectedValue(mockError);
+
+      await expect(userPreferenceAPI.createUserPreference(mockCreateRequest)).rejects.toThrow(
+        'API call failed'
+      );
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_CREATE_FAILED,
+        expect.objectContaining({
+          error: 'API call failed',
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+  });
+
+  describe('updateUserPreference', () => {
+    const mockUpdateRequest = {
+      desktopPreference: '{}',
+    };
+
+    const mockUpdatedPreference = {
+      id: 'pref-123',
+      organizationId: 'test-org-id',
+      userId: 'test-user-id',
+      preferences: {e911Reminder: false},
+      createdTime: 1234567890,
+      lastUpdatedTime: 1234567899,
+    };
+
+    const mockResponse: IHttpResponse = {
+      statusCode: 200,
+      method: 'PUT',
+      url: '/organization/test-org-id/user-preference/test-user-id',
+      headers: {} as any,
+      body: mockUpdatedPreference,
+    };
+
+    beforeEach(() => {
+      jest.spyOn(Date, 'now').mockReturnValue(1000);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should update user preferences successfully', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await userPreferenceAPI.updateUserPreference(
+        'test-user-id',
+        mockUpdateRequest
+      );
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: 'organization/test-org-id/user-preference/test-user-id',
+        method: HTTP_METHODS.PUT,
+        body: mockUpdateRequest,
+      });
+      expect(result).toEqual(mockUpdatedPreference);
+      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_SUCCESS
+      );
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_SUCCESS,
+        expect.objectContaining({
+          orgId: 'test-org-id',
+          userId: 'test-user-id',
+          statusCode: 200,
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should throw error when userId is missing', async () => {
+      await expect(userPreferenceAPI.updateUserPreference('', mockUpdateRequest)).rejects.toThrow(
+        'UserPreference: userId is required to update user preferences.'
+      );
+
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should handle API errors', async () => {
+      const mockError = new Error('API call failed');
+      (mockWebex.request as jest.Mock).mockRejectedValue(mockError);
+
+      await expect(
+        userPreferenceAPI.updateUserPreference('test-user-id', mockUpdateRequest)
+      ).rejects.toThrow('API call failed');
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_UPDATE_FAILED,
+        expect.objectContaining({
+          error: 'API call failed',
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+  });
+
+  describe('deleteUserPreference', () => {
+    const mockResponse: IHttpResponse = {
+      statusCode: 204,
+      method: 'DELETE',
+      url: '/organization/test-org-id/user-preference/test-user-id',
+      headers: {} as any,
+      body: null,
+    };
+
+    beforeEach(() => {
+      jest.spyOn(Date, 'now').mockReturnValue(1000);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should delete user preferences successfully', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await userPreferenceAPI.deleteUserPreference('test-user-id');
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: 'organization/test-org-id/user-preference/test-user-id',
+        method: HTTP_METHODS.DELETE,
+        body: undefined,
+      });
+      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_SUCCESS
+      );
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_SUCCESS,
+        expect.objectContaining({
+          orgId: 'test-org-id',
+          userId: 'test-user-id',
+          statusCode: 204,
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should throw error when userId is missing', async () => {
+      await expect(userPreferenceAPI.deleteUserPreference('')).rejects.toThrow(
+        'UserPreference: userId is required to delete user preferences.'
+      );
+
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+    });
+
+    it('should handle API errors', async () => {
+      const mockError = new Error('API call failed');
+      (mockWebex.request as jest.Mock).mockRejectedValue(mockError);
+
+      await expect(userPreferenceAPI.deleteUserPreference('test-user-id')).rejects.toThrow(
+        'API call failed'
+      );
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.USER_PREFERENCE_DELETE_FAILED,
+        expect.objectContaining({
+          error: 'API call failed',
+        }),
+        ['behavioral', 'operational']
+      );
+    });
+  });
+});

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

@@ -200,11 +200,17 @@ describe('WebCallingService', () => {
 
     it('should reject if registration times out', async () => {
       line = callingClient.getLines().line1 as ILine;
+      jest.spyOn(global, 'setTimeout').mockImplementation(((handler: TimerHandler) => {
+        if (typeof handler === 'function') {
+          handler();
+        }
+        return 0 as unknown as NodeJS.Timeout;
+      }) as typeof setTimeout);
 
       const promise = webRTCCalling.registerWebCallingLine();
 
       await expect(promise).rejects.toThrow('WebCallingService Registration timed out');
-    }, 20003); // Increased timeout to 20 seconds
+    });
 
     it('should handle incoming calls', async () => {
       line = callingClient.getLines().line1 as ILine;