@webex/contact-center 3.8.1 → 3.9.0-multiple-llm.1

package/test/unit/spec/cc.ts

@@ -7,6 +7,11 @@ import {
   WebexSDK,
 } from '../../../src/types';
 import ContactCenter from '../../../src/cc';
+import EntryPoint from '../../../src/services/EntryPoint';
+import type {EntryPointListResponse} from '../../../src/types';
+import AddressBook from '../../../src/services/AddressBook';
+import Queue from '../../../src/services/Queue';
+import type {ContactServiceQueuesResponse} from '../../../src/types';
 import MockWebex from '@webex/test-helper-mock-webex';
 import {StationLoginSuccess, AGENT_EVENTS} from '../../../src/services/agent/types';
 import {SetStateResponse} from '../../../src/types';
@@ -134,6 +139,7 @@ describe('webex.cc', () => {
       webSocketManager: mockWebSocketManager,
       task: undefined,
       setWrapupData: jest.fn(),
+      setAgentId: jest.fn(),
       registerIncomingCallEvent: jest.fn(),
       registerTaskListeners: jest.fn(),
       getTask: jest.fn(),
@@ -1310,7 +1316,7 @@ describe('webex.cc', () => {
   });
 
   describe('startOutdial', () => {
-    it('should make outdial call successfully.', async () => {
+    it('should make outdial call successfully without origin.', async () => {
       // Setup outDialEp.
       webex.cc.agentConfig = {
         outDialEp: 'test-entry-point',
@@ -1319,9 +1325,10 @@ describe('webex.cc', () => {
       // destination number required for making outdial call.
       const destination = '1234567890';
 
-      // Construct Payload for startOutdial.
+      // Construct Payload for startOutdial without origin.
       const newPayload = {
         destination,
+        origin: undefined,
         entryPointId: 'test-entry-point',
         direction: OUTDIAL_DIRECTION,
         attributes: ATTRIBUTES,
@@ -1351,6 +1358,49 @@ describe('webex.cc', () => {
       expect(result).toEqual(mockResponse);
     });
 
+    it('should make outdial call successfully with origin.', async () => {
+      // Setup outDialEp.
+      webex.cc.agentConfig = {
+        outDialEp: 'test-entry-point',
+      };
+
+      // destination number and origin for making outdial call.
+      const destination = '1234567890';
+      const origin = '+19403016307';
+
+      // Construct Payload for startOutdial with origin.
+      const newPayload = {
+        destination,
+        origin,
+        entryPointId: 'test-entry-point',
+        direction: OUTDIAL_DIRECTION,
+        attributes: ATTRIBUTES,
+        mediaType: OUTDIAL_MEDIA_TYPE,
+        outboundType: OUTBOUND_TYPE,
+      } as const;
+
+      const mockResponse = {} as AgentContact;
+
+      const startOutdialMock = jest
+        .spyOn(webex.cc.services.dialer, 'startOutdial')
+        .mockResolvedValue(mockResponse);
+
+      const result = await webex.cc.startOutdial(destination, origin);
+
+      // Verify logging calls
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Starting outbound dial', {
+        module: CC_FILE,
+        method: 'startOutdial',
+      });
+      expect(LoggerProxy.log).toHaveBeenCalledWith('Outbound dial completed successfully', {
+        module: CC_FILE,
+        method: 'startOutdial',
+      });
+
+      expect(startOutdialMock).toHaveBeenCalledWith({data: newPayload});
+      expect(result).toEqual(mockResponse);
+    });
+
     it('should handle error during startOutdial', async () => {
       // Setup outDialEp.
       webex.cc.agentConfig = {
@@ -1387,88 +1437,6 @@ describe('webex.cc', () => {
     });
   });
 
-  describe('getQueues', () => {
-    it('should return queues response when successful', async () => {
-      const mockQueuesResponse = [
-        {
-          queueId: 'queue1',
-          queueName: 'Queue 1',
-        },
-        {
-          queueId: 'queue2',
-          queueName: 'Queue 2',
-        },
-      ];
-
-      webex.cc.services.config.getQueues = jest.fn().mockResolvedValue(mockQueuesResponse);
-
-      const result = await webex.cc.getQueues();
-
-      // Verify logging calls
-      expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching queues', {
-        module: CC_FILE,
-        method: 'getQueues',
-      });
-      expect(LoggerProxy.log).toHaveBeenCalledWith(
-        `Successfully retrieved ${result.length} queues`,
-        {
-          module: CC_FILE,
-          method: 'getQueues',
-        }
-      );
-
-      expect(webex.cc.services.config.getQueues).toHaveBeenCalledWith(
-        'mockOrgId',
-        0,
-        100,
-        undefined,
-        undefined
-      );
-      expect(result).toEqual(mockQueuesResponse);
-    });
-
-    it('should throw an error if orgId is not present', async () => {
-      jest.spyOn(webex.credentials, 'getOrgId').mockResolvedValue(undefined);
-      webex.cc.services.config.getQueues = jest.fn();
-
-      try {
-        await webex.cc.getQueues();
-      } catch (error) {
-        expect(error).toEqual(new Error('Org ID not found.'));
-        expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching queues', {
-          module: CC_FILE,
-          method: 'getQueues',
-        });
-        expect(LoggerProxy.error).toHaveBeenCalledWith('Org ID not found.', {
-          module: CC_FILE,
-          method: 'getQueues',
-        });
-        expect(webex.cc.services.config.getQueues).not.toHaveBeenCalled();
-      }
-    });
-
-    it('should throw an error if config getQueues throws an error', async () => {
-      webex.cc.services.config.getQueues = jest.fn().mockRejectedValue(new Error('Test error.'));
-
-      try {
-        await webex.cc.getQueues();
-      } catch (error) {
-        expect(error).toEqual(new Error('Test error.'));
-        expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching queues', {
-          module: CC_FILE,
-          method: 'getQueues',
-        });
-        expect(webex.cc.services.config.getQueues).toHaveBeenCalledWith(
-          'mockOrgId',
-          0,
-          100,
-          undefined,
-          undefined
-        );
-      }
-    });
-  });
-
   describe('uploadLogs', () => {
     it('should upload logs successfully', async () => {
       const uploadLogsMock = jest.spyOn(webex.cc.webexRequest, 'uploadLogs').mockResolvedValue({
@@ -1796,6 +1764,31 @@ describe('webex.cc', () => {
     });
   });
 
+  describe('API property exposure', () => {
+    it('should provide getEntryPoints wrapper that delegates to EntryPoint', async () => {
+      const spy = jest
+        .spyOn(EntryPoint.prototype, 'getEntryPoints')
+        .mockResolvedValue({} as EntryPointListResponse);
+      await webex.cc.getEntryPoints();
+      expect(spy).toHaveBeenCalled();
+      spy.mockRestore();
+    });
+
+    it('should expose addressBook API', () => {
+      expect(webex.cc.addressBook).toBeDefined();
+      expect(webex.cc.addressBook).toBeInstanceOf(AddressBook);
+    });
+
+    it('should provide getQueues wrapper that delegates to Queue', async () => {
+      const spy = jest
+        .spyOn(Queue.prototype, 'getQueues')
+        .mockResolvedValue({} as ContactServiceQueuesResponse);
+      await webex.cc.getQueues();
+      expect(spy).toHaveBeenCalled();
+      spy.mockRestore();
+    });
+  });
+
   describe('updateAgentProfile', () => {
     beforeEach(() => {
       webex.cc.agentConfig = {

package/test/unit/spec/metrics/MetricsManager.ts

@@ -3,7 +3,6 @@ import MetricsManager from '../../../../src/metrics/MetricsManager';
 import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
 import {WebexSDK} from '../../../../src/types';
 import {EventPayload} from '@webex/internal-plugin-metrics/src/metrics.types';
-import LoggerProxy from '../../../../src/logger-proxy';
 
 describe('MetricsManagerImplementation', () => {
   let webex: WebexSDK;

package/test/unit/spec/metrics/behavioral-events.ts

@@ -12,6 +12,20 @@ describe('metrics/behavioral-events', () => {
         verb: 'set',
       });
 
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.AGENT_CONTACT_ASSIGN_FAILED)).toEqual({
+        product,
+        agent: 'service',
+        target: 'agent_contact_assign',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.AGENT_INVITE_FAILED)).toEqual({
+        product,
+        agent: 'service',
+        target: 'agent_invite',
+        verb: 'fail',
+      });
+
       expect(getEventTaxonomy(METRIC_EVENT_NAMES.STATION_LOGIN_SUCCESS)).toEqual({
         product,
         agent: 'user',
@@ -96,6 +110,48 @@ describe('metrics/behavioral-events', () => {
         verb: 'fail',
       });
 
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_START_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_start',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_START_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_start',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_END_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_end',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_END_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_end',
+        verb: 'fail',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_SUCCESS)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_transfer',
+        verb: 'complete',
+      });
+
+      expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_TRANSFER_FAILED)).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_transfer',
+        verb: 'fail',
+      });
+
       expect(getEventTaxonomy('' as METRIC_EVENT_NAMES)).toEqual(undefined);
     });
   });

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

@@ -0,0 +1,332 @@
+import AddressBook from '../../../../src/services/AddressBook';
+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('AddressBook', () => {
+  let addressBookAPI: AddressBook;
+  let mockWebex: WebexSDK;
+  let mockMetricsManager: jest.Mocked<MetricsManager>;
+
+  const mockGetAddressBookId = jest.fn().mockReturnValue('test-address-book-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);
+
+    addressBookAPI = new AddressBook(mockWebex, mockGetAddressBookId);
+  });
+
+  describe('constructor', () => {
+    it('should initialize with all required dependencies', () => {
+      expect(WebexRequest.getInstance({webex: mockWebex})).toBeDefined();
+      expect(MetricsManager.getInstance).toHaveBeenCalledWith({webex: mockWebex});
+    });
+  });
+
+  describe('getEntries', () => {
+    const mockEntries = [
+      {
+        id: 'entry1',
+        name: 'John Doe',
+        number: '+1234567890',
+        organizationId: 'test-org-id',
+      },
+      {
+        id: 'entry2',
+        name: 'Jane Smith',
+        number: '+0987654321',
+        organizationId: 'test-org-id',
+      },
+    ];
+
+    const mockResponse: IHttpResponse = {
+      statusCode: 200,
+      method: 'GET',
+      url: '/organization/test-org-id/v2/address-book/test-address-book-id/entry',
+      headers: {} as any,
+      body: {
+        data: mockEntries,
+        meta: {
+          page: 0,
+          pageSize: 100,
+          totalPages: 1,
+          totalRecords: 2,
+          orgid: 'test-org-id',
+        },
+      },
+    };
+
+    beforeEach(() => {
+      jest.spyOn(Date, 'now').mockReturnValue(1000);
+    });
+
+    afterEach(() => {
+      jest.restoreAllMocks();
+    });
+
+    it('should fetch address book entries successfully with default parameters', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await addressBookAPI.getEntries();
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100',
+        method: HTTP_METHODS.GET,
+      });
+
+      expect(result).toEqual(mockResponse.body);
+      expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS);
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS,
+        {
+          orgId: 'test-org-id',
+          bookId: 'test-address-book-id',
+          statusCode: 200,
+          recordCount: 2,
+          totalRecords: 2,
+          isSearchRequest: false,
+          isFirstPage: true,
+        },
+        ['behavioral', 'operational']
+      );
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching address book entries', {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: expect.objectContaining({
+          orgId: 'test-org-id',
+          bookId: 'test-address-book-id',
+          page: 0,  
+          pageSize: 100,
+          isSearchRequest: false,
+        }),
+      });
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Making API request to fetch address book entries', {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: {
+          resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100',
+          service: 'wcc-api-gateway',
+        },
+      });
+    });
+
+    it('should fetch entries with custom parameters', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const params = {
+        addressBookId: 'custom-book-id',
+        page: 1,
+        pageSize: 25,
+        search: 'john',
+        filter: 'name=="John Doe"',
+        attributes: 'id,name,number',
+      };
+
+      const result = await addressBookAPI.getEntries(params);
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/address-book/custom-book-id/entry?page=1&pageSize=25&filter=name%3D%3D%22John+Doe%22&attributes=id%2Cname%2Cnumber&search=john',
+        method: HTTP_METHODS.GET,
+      });
+
+      expect(result).toEqual(mockResponse.body);
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS,
+        {
+          orgId: 'test-org-id',
+          bookId: 'custom-book-id',
+          statusCode: 200,
+          recordCount: 2,
+          totalRecords: 2,
+          isSearchRequest: true,
+          isFirstPage: false,
+        },
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should handle API errors and track metrics', async () => {
+      (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Internal Server Error'));
+
+      await expect(addressBookAPI.getEntries()).rejects.toThrow('Internal Server Error');
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100',
+        method: HTTP_METHODS.GET,
+      });
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_FAILED,
+        expect.objectContaining({
+          orgId: 'test-org-id',
+          bookId: 'test-address-book-id',
+          error: 'Internal Server Error',
+          isSearchRequest: false,
+          page: 0,
+          pageSize: 100,
+        }),
+        ['behavioral', 'operational']
+      );
+      expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to fetch address book entries', {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: expect.objectContaining({
+          orgId: 'test-org-id',
+          bookId: 'test-address-book-id',
+          error: 'Internal Server Error',
+          isSearchRequest: false,
+          page: 0,
+          pageSize: 100,
+        }),
+        error: expect.any(Error),
+      }); 
+    });
+
+    it('should not track metrics for subsequent pages in simple pagination', async () => {
+      const mockResponsePage2: IHttpResponse = {
+        statusCode: 200,
+        method: 'GET',
+        url: '/organization/test-org-id/v2/address-book/test-address-book-id/entry',
+        headers: {} as any,
+        body: {
+          data: mockEntries,
+          meta: {
+            page: 2,
+            pageSize: 100,
+            totalPages: 3,
+            totalRecords: 2,
+            orgid: 'test-org-id',
+          },
+        },
+      };
+
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce(mockResponsePage2);
+
+      const result = await addressBookAPI.getEntries({page: 2});
+
+      expect(result).toEqual(mockResponsePage2.body);
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS,
+        expect.any(Object),
+        expect.any(Array)
+      );
+    });
+
+    it('should track metrics for search requests on a valid non-first page', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await addressBookAPI.getEntries({page: 1, search: 'test'});
+      expect(result).toEqual(mockResponse.body);
+
+      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.ADDRESSBOOK_FETCH_SUCCESS,
+        {
+          orgId: 'test-org-id',
+          bookId: 'test-address-book-id',
+          statusCode: 200,
+          recordCount: 2,
+          totalRecords: 2,
+          isSearchRequest: true,
+          isFirstPage: false,
+        },
+        ['behavioral', 'operational']
+      );
+    });
+
+    it('should return cached data for repeat simple pagination calls', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      const first = await addressBookAPI.getEntries({page: 0});
+      expect(first).toEqual(mockResponse.body);
+
+      const callsBefore = (mockWebex.request as jest.Mock).mock.calls.length;
+      const second = await addressBookAPI.getEntries({page: 0});
+      const callsAfter = (mockWebex.request as jest.Mock).mock.calls.length;
+
+      expect(second.data).toEqual(mockResponse.body.data);
+      expect(second.meta).toEqual(
+        expect.objectContaining({
+          page: 0,
+          pageSize: 100,
+          totalPages: 1,
+          totalRecords: 2,
+        })
+      );
+      expect(callsAfter).toBe(callsBefore);
+    });
+
+    it('should call API when requested page is not cached (cache miss)', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce(mockResponse);
+
+      await addressBookAPI.getEntries({page: 0});
+
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce({
+        ...mockResponse,
+        body: {
+          data: mockEntries,
+          meta: {
+            page: 1,
+            pageSize: 100,
+            totalPages: 2,
+            totalRecords: 2,
+            orgid: 'test-org-id',
+          },
+        },
+      });
+
+      const callsBefore = (mockWebex.request as jest.Mock).mock.calls.length;
+      (LoggerProxy.info as jest.Mock).mockClear();
+      (LoggerProxy.log as jest.Mock).mockClear();
+
+      const result = await addressBookAPI.getEntries({page: 1});
+
+      const callsAfter = (mockWebex.request as jest.Mock).mock.calls.length;
+      expect(callsAfter).toBe(callsBefore + 1);
+      expect(result.meta.page).toBe(1);
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100',
+        method: HTTP_METHODS.GET,
+      });
+      expect(LoggerProxy.info).toHaveBeenCalledWith('Making API request to fetch address book entries', {
+        module: 'AddressBook',
+        method: 'getEntries',
+        data: {
+          resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100',
+          service: 'wcc-api-gateway',
+        },
+      });
+    });
+  });
+});