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

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

@@ -152,6 +152,24 @@ describe('metrics/behavioral-events', () => {
         verb: 'fail',
       });
 
+      expect(
+        getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_SUCCESS)
+      ).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_participant_drop',
+        verb: 'complete',
+      });
+
+      expect(
+        getEventTaxonomy(METRIC_EVENT_NAMES.TASK_CONFERENCE_PARTICIPANT_DROP_FAILED)
+      ).toEqual({
+        product,
+        agent: 'user',
+        target: 'task_conference_participant_drop',
+        verb: 'fail',
+      });
+
       expect(getEventTaxonomy(METRIC_EVENT_NAMES.TASK_AUTO_ANSWER_SUCCESS)).toEqual({
         product,
         agent: 'user',

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

@@ -99,7 +99,8 @@ describe('AddressBook', () => {
 
       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',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100&sort=name%2CASC',
         method: HTTP_METHODS.GET,
       });
 
@@ -133,7 +134,8 @@ describe('AddressBook', () => {
         module: 'AddressBook',
         method: 'getEntries',
         data: {
-          resource: '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100',
+          resource:
+            '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100&sort=name%2CASC',
           service: 'wcc-api-gateway',
         },
       });
@@ -155,7 +157,8 @@ describe('AddressBook', () => {
 
       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',
+        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&sort=name%2CASC',
         method: HTTP_METHODS.GET,
       });
 
@@ -175,6 +178,31 @@ describe('AddressBook', () => {
       );
     });
 
+    it('should allow callers to override the default backend sorting and bypass the default page cache', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await addressBookAPI.getEntries({
+        page: 0,
+        pageSize: 25,
+        sortBy: 'name',
+        sortOrder: 'desc',
+      });
+      await addressBookAPI.getEntries({
+        page: 0,
+        pageSize: 25,
+        sortBy: 'name',
+        sortOrder: 'desc',
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(2);
+      expect(mockWebex.request).toHaveBeenLastCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=25&sort=name%2CDESC',
+        method: HTTP_METHODS.GET,
+      });
+    });
+
     it('should handle API errors and track metrics', async () => {
       (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Internal Server Error'));
 
@@ -182,7 +210,8 @@ describe('AddressBook', () => {
 
       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',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=0&pageSize=100&sort=name%2CASC',
         method: HTTP_METHODS.GET,
       });
 
@@ -316,14 +345,16 @@ describe('AddressBook', () => {
       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',
+        resource:
+          '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100&sort=name%2CASC',
         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',
+          resource:
+            '/organization/test-org-id/v2/address-book/test-address-book-id/entry?page=1&pageSize=100&sort=name%2CASC',
           service: 'wcc-api-gateway',
         },
       });

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

@@ -0,0 +1,223 @@
+import {expect} from '@jest/globals';
+import AnswerCallOnWebexService from '../../../../src/services/AnswerCallOnWebexService';
+import {WebexSDK} from '../../../../src/types';
+import LoggerProxy from '../../../../src/logger-proxy';
+
+jest.mock('../../../../src/logger-proxy');
+jest.mock('../../../../src/services/core/WebexRequest', () => ({
+  __esModule: true,
+  default: {
+    getInstance: () => ({uploadLogs: jest.fn()}),
+  },
+}));
+
+const TELEPHONY_BASE = 'https://api.ciscospark.com';
+const CALLS_URL = `${TELEPHONY_BASE}/telephony/calls`;
+
+function makeMockWebex(overrides: Partial<{_serviceUrls: Record<string, string>}> = {}): WebexSDK {
+  return {
+    request: jest.fn().mockResolvedValue({statusCode: 200, body: {}}),
+    internal: {
+      services: {
+        _serviceUrls: {hydra: TELEPHONY_BASE, ...overrides._serviceUrls},
+        get: jest.fn(),
+      },
+    },
+  } as unknown as WebexSDK;
+}
+
+describe('AnswerCallOnWebexService', () => {
+  let webex: WebexSDK;
+  let service: AnswerCallOnWebexService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    webex = makeMockWebex();
+    service = new AnswerCallOnWebexService(webex);
+  });
+
+  describe('getTelephonyBaseUrl resolution', () => {
+    it('uses hydra URL from _serviceUrls when available', async () => {
+      await service.answerCall({callId: 'c1', endpointId: 'e1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/answer`})
+      );
+    });
+
+    it('falls back to services.get("hydra") when _serviceUrls.hydra is missing', async () => {
+      const hydraBase = 'https://api.ciscospark.com/v1';
+      const get = jest.fn().mockReturnValue(hydraBase);
+      webex = {
+        request: jest.fn().mockResolvedValue({statusCode: 200, body: {}}),
+        internal: {
+          services: {
+            _serviceUrls: {},
+            get,
+          },
+        },
+      } as unknown as WebexSDK;
+      service = new AnswerCallOnWebexService(webex);
+
+      await service.answerCall({callId: 'c1', endpointId: 'e1'});
+
+      expect(get).toHaveBeenCalledWith('hydra');
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${hydraBase}/telephony/calls/answer`})
+      );
+    });
+
+    it('throws when hydra URL is unavailable', async () => {
+      webex = {
+        request: jest.fn(),
+        internal: {
+          services: {
+            _serviceUrls: {},
+            get: jest.fn().mockReturnValue(''),
+          },
+        },
+      } as unknown as WebexSDK;
+      service = new AnswerCallOnWebexService(webex);
+
+      await expect(service.answerCall({callId: 'c1', endpointId: 'e1'})).rejects.toBeDefined();
+    });
+  });
+
+  describe('answerCall', () => {
+    it('POST /answer with callId and endpointId', async () => {
+      await service.answerCall({callId: 'call-123', endpointId: 'ep-456'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/answer`,
+        method: 'POST',
+        body: {callId: 'call-123', endpointId: 'ep-456'},
+        addAuthHeader: true,
+      });
+    });
+
+    it('includes lineOwnerId when provided', async () => {
+      await service.answerCall({callId: 'c1', endpointId: 'e1', lineOwnerId: 'lo-1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({body: {callId: 'c1', endpointId: 'e1', lineOwnerId: 'lo-1'}})
+      );
+    });
+
+    it('omits lineOwnerId when not provided', async () => {
+      await service.answerCall({callId: 'c1', endpointId: 'e1'});
+
+      const call = (webex.request as jest.Mock).mock.calls[0][0];
+      expect(call.body).not.toHaveProperty('lineOwnerId');
+    });
+
+    it('rejects and logs on request failure', async () => {
+      const err = {
+        statusCode: 400,
+        details: {
+          trackingId: 'track-wxapp-1',
+          data: {reason: 'TELEPHONY_ERROR'},
+        },
+      };
+      (webex.request as jest.Mock).mockRejectedValue(err);
+
+      await expect(service.answerCall({callId: 'c1', endpointId: 'e1'})).rejects.toMatchObject({
+        isWxAppTelephonyError: true,
+        message: 'TELEPHONY_ERROR',
+        trackingId: 'track-wxapp-1',
+        status: 400,
+      });
+      expect(LoggerProxy.error).toHaveBeenCalled();
+    });
+  });
+
+  describe('rejectCall', () => {
+    it('POST /reject with callId', async () => {
+      await service.rejectCall({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/reject`,
+        method: 'POST',
+        body: {callId: 'call-123'},
+        addAuthHeader: true,
+      });
+    });
+  });
+
+  describe('muteCall', () => {
+    it('POST /mute with callId', async () => {
+      await service.muteCall({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/mute`, body: {callId: 'call-123'}})
+      );
+    });
+  });
+
+  describe('unmuteCall', () => {
+    it('POST /unmute with callId', async () => {
+      await service.unmuteCall({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/unmute`, body: {callId: 'call-123'}})
+      );
+    });
+  });
+
+  describe('transmitDtmf', () => {
+    it('POST /transmitDtmf with callId and dtmf', async () => {
+      await service.transmitDtmf({callId: 'call-123', dtmf: '5'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/transmitDtmf`,
+        method: 'POST',
+        body: {callId: 'call-123', dtmf: '5'},
+        addAuthHeader: true,
+      });
+    });
+
+    it('includes lineOwnerId in DTMF request when provided', async () => {
+      await service.transmitDtmf({callId: 'c1', dtmf: '9', lineOwnerId: 'lo-1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({body: {callId: 'c1', dtmf: '9', lineOwnerId: 'lo-1'}})
+      );
+    });
+  });
+
+  describe('getCallDetails', () => {
+    it('GET /telephony/calls/{callId}', async () => {
+      (webex.request as jest.Mock).mockResolvedValue({body: {muted: true}});
+
+      const result = await service.getCallDetails({callId: 'call-123'});
+
+      expect(webex.request).toHaveBeenCalledWith({
+        uri: `${CALLS_URL}/call-123`,
+        method: 'GET',
+        addAuthHeader: true,
+      });
+      expect(result).toEqual({muted: true});
+    });
+
+    it('includes lineOwnerId query param when provided', async () => {
+      await service.getCallDetails({callId: 'call-123', lineOwnerId: 'lo-1'});
+
+      expect(webex.request).toHaveBeenCalledWith(
+        expect.objectContaining({uri: `${CALLS_URL}/call-123?lineOwnerId=lo-1`})
+      );
+    });
+
+    it('rejects and logs on request failure', async () => {
+      (webex.request as jest.Mock).mockRejectedValue(new Error('network fail'));
+
+      await expect(service.getCallDetails({callId: 'c1'})).rejects.toBeDefined();
+      expect(LoggerProxy.error).toHaveBeenCalled();
+    });
+
+    it('rejects without error log for expected call-not-found during mute backfill race', async () => {
+      (webex.request as jest.Mock).mockRejectedValue({status: 400, message: 'Call not found'});
+
+      await expect(service.getCallDetails({callId: 'c1'})).rejects.toBeDefined();
+      expect(LoggerProxy.error).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -1,5 +1,5 @@
 import EntryPoint from '../../../../src/services/EntryPoint';
-import {HTTP_METHODS, WebexSDK, IHttpResponse} from '../../../../src/types';
+import {HTTP_METHODS, WebexSDK, IHttpResponse, EntryPointRecord} from '../../../../src/types';
 import {METRIC_EVENT_NAMES} from '../../../../src/metrics/constants';
 import WebexRequest from '../../../../src/services/core/WebexRequest';
 import MetricsManager from '../../../../src/metrics/MetricsManager';
@@ -50,30 +50,38 @@ describe('EntryPoint', () => {
   });
 
   describe('getEntryPoints', () => {
-    const mockEntryPoints = [
+    const mockDialNumberMappings = [
       {
-        id: 'entry1',
-        name: 'Test Entry Point 1',
-        type: 'voice',
-        isActive: true,
-        orgId: 'test-org-id',
+        id: 'dial-number-1',
+        dialledNumber: '+1-555-0101',
+        entryPointId: 'entry1',
+        entryPointName: 'Test Entry Point 1',
       },
       {
-        id: 'entry2',
-        name: 'Test Entry Point 2',
-        type: 'chat',
-        isActive: true,
-        orgId: 'test-org-id',
+        id: 'dial-number-2',
+        dialledNumber: '+1-555-0102',
+        entryPointId: 'entry2',
+        entryPointName: 'Test Entry Point 2',
       },
     ];
+    const expectedEntryPoints: EntryPointRecord[] = [
+      {id: 'entry1', name: 'Test Entry Point 1', number: '+1-555-0101'},
+      {id: 'entry2', name: 'Test Entry Point 2', number: '+1-555-0102'},
+    ];
+    const defaultResource =
+      '/organization/test-org-id/v3/dial-number?page=0&pageSize=100&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true';
+    const requestHeaders = {
+      'X-ORGANIZATION-ID': 'test-org-id',
+      'x-ignore-internal-data': 'false',
+    };
 
     const mockResponse: IHttpResponse = {
       statusCode: 200,
       method: 'GET',
-      url: '/organization/test-org-id/v2/entry-point',
+      url: '/organization/test-org-id/v3/dial-number',
       headers: {} as any,
       body: {
-        data: mockEntryPoints,
+        data: mockDialNumberMappings,
         meta: {
           page: 0,
           pageSize: 100,
@@ -99,11 +107,14 @@ describe('EntryPoint', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/entry-point?page=0&pageSize=100&sortOrder=asc',
+        resource: defaultResource,
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
 
-      expect(result).toEqual(mockResponse.body);
+      expect(result).toEqual({...mockResponse.body, data: expectedEntryPoints});
+      expect(result.data[0].number).toBe('+1-555-0101');
       expect(mockMetricsManager.timeEvent).toHaveBeenCalledWith(METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS);
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS,
@@ -122,7 +133,7 @@ describe('EntryPoint', () => {
         {module: 'EntryPoint', method: 'getEntryPoints'}
       );
       expect(LoggerProxy.log).toHaveBeenCalledWith(
-        `Making API request to fetch entry points - resource: /organization/test-org-id/v2/entry-point?page=0&pageSize=100&sortOrder=asc, service: wcc-api-gateway`,
+        `Making API request to fetch entry points - resource: ${defaultResource}, service: wcc-api-gateway`,
         {module: 'EntryPoint', method: 'getEntryPoints'}
       );
     });
@@ -134,7 +145,7 @@ describe('EntryPoint', () => {
         page: 1,
         pageSize: 25,
         search: 'test',
-        filter: 'type=="voice"',
+        filter: 'entryPointId=="entry1"',
         attributes: 'id,name',
         sortBy: 'name',
         sortOrder: 'desc' as const,
@@ -144,8 +155,11 @@ describe('EntryPoint', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/entry-point?page=1&pageSize=25&sortOrder=desc&search=test&filter=type%3D%3D%22voice%22&attributes=id%2Cname&sortBy=name',
+        resource:
+          '/organization/test-org-id/v3/dial-number?page=1&pageSize=25&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName%2Cname&search=test&filter=entryPointId%3D%3D%22entry1%22&sort=entryPointName%2CDESC&desktopProfileFilter=true&includeEntryPointName=true',
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
 
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
@@ -162,6 +176,41 @@ describe('EntryPoint', () => {
       );
     });
 
+    it('should allow existing parameters to override the default entry-point mapping policy', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      const result = await entryPointAPI.getEntryPoints({
+        page: 1,
+        pageSize: 25,
+        search: 'sales',
+        filter: 'entryPointId==entry1',
+      });
+
+      expect(mockWebex.request).toHaveBeenCalledWith({
+        service: 'wcc-api-gateway',
+        resource:
+          '/organization/test-org-id/v3/dial-number?page=1&pageSize=25&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&search=sales&filter=entryPointId%3D%3Dentry1&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true',
+        method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
+      });
+      expect(result).toEqual({...mockResponse.body, data: expectedEntryPoints});
+    });
+
+    it('should issue every profile-scoped request directly', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
+
+      await entryPointAPI.getEntryPoints();
+      await entryPointAPI.getEntryPoints();
+
+      expect(mockWebex.request).toHaveBeenCalledTimes(2);
+      expect(mockWebex.request).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          resource: expect.stringContaining('desktopProfileFilter=true'),
+        })
+      );
+    });
+
     it('should handle API errors and track metrics', async () => {
       (mockWebex.request as jest.Mock).mockRejectedValue(new Error('Internal Server Error'));
 
@@ -169,8 +218,10 @@ describe('EntryPoint', () => {
 
       expect(mockWebex.request).toHaveBeenCalledWith({
         service: 'wcc-api-gateway',
-        resource: '/organization/test-org-id/v2/entry-point?page=0&pageSize=100&sortOrder=asc',
+        resource: defaultResource,
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
 
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
@@ -187,22 +238,24 @@ describe('EntryPoint', () => {
       expect(LoggerProxy.error).toHaveBeenCalled();
     });
 
-
-
-    it('should not track metrics for subsequent pages in simple pagination', async () => {
+    it('should not track success metrics for subsequent pages under the default mapping policy', async () => {
       (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
 
       const result = await entryPointAPI.getEntryPoints({page: 2});
-      expect(result).toEqual(mockResponse.body);
+      expect(result).toEqual({...mockResponse.body, data: expectedEntryPoints});
 
-      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalled();
+      expect(mockMetricsManager.trackEvent).not.toHaveBeenCalledWith(
+        METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS,
+        expect.anything(),
+        expect.anything()
+      );
     });
 
     it('should track metrics for search requests on any page', async () => {
       (mockWebex.request as jest.Mock).mockResolvedValue(mockResponse);
 
       const result2 = await entryPointAPI.getEntryPoints({page: 2, search: 'test'});
-      expect(result2).toEqual(mockResponse.body);
+      expect(result2).toEqual({...mockResponse.body, data: expectedEntryPoints});
 
       expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
         METRIC_EVENT_NAMES.ENTRYPOINT_FETCH_SUCCESS,
@@ -218,15 +271,11 @@ describe('EntryPoint', () => {
       );
     });
 
-    it('should call API when requested page is not cached (cache miss)', async () => {
-      (mockWebex.request as jest.Mock).mockResolvedValueOnce(mockResponse);
-
-      await entryPointAPI.getEntryPoints({page: 0});
-
-      (mockWebex.request as jest.Mock).mockResolvedValueOnce({
+    it('should request the specified page', async () => {
+      (mockWebex.request as jest.Mock).mockResolvedValue({
         ...mockResponse,
         body: {
-          data: mockEntryPoints,
+          data: mockDialNumberMappings,
           meta: {
             page: 1,
             pageSize: 100,
@@ -237,21 +286,19 @@ describe('EntryPoint', () => {
         },
       });
 
-      const callsBefore = (mockWebex.request as jest.Mock).mock.calls.length;
-      (LoggerProxy.log as jest.Mock).mockClear();
-
       const result = await entryPointAPI.getEntryPoints({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/entry-point?page=1&pageSize=100&sortOrder=asc',
+        resource:
+          '/organization/test-org-id/v3/dial-number?page=1&pageSize=100&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true',
         method: HTTP_METHODS.GET,
+        body: undefined,
+        headers: requestHeaders,
       });
       expect(LoggerProxy.log).toHaveBeenCalledWith(
-        `Making API request to fetch entry points - resource: /organization/test-org-id/v2/entry-point?page=1&pageSize=100&sortOrder=asc, service: wcc-api-gateway`,
+        `Making API request to fetch entry points - resource: /organization/test-org-id/v3/dial-number?page=1&pageSize=100&attributes=id%2CdialledNumber%2CentryPointId%2CentryPointName&sort=entryPointName%2CASC&desktopProfileFilter=true&includeEntryPointName=true, service: wcc-api-gateway`,
         {module: 'EntryPoint', method: 'getEntryPoints'}
       );
     });