@webex/contact-center 3.12.0-next.9 → 3.12.0-task-refactor.2

package/test/unit/spec/services/core/Utils.ts

@@ -1,5 +1,4 @@
 import * as Utils from '../../../../../src/services/core/Utils';
-import {FALLBACK_DIAL_NUMBER_REGEX} from '../../../../../src/services/core/Utils';
 import LoggerProxy from '../../../../../src/logger-proxy';
 import WebexRequest from '../../../../../src/services/core/WebexRequest';
 import {LoginOption, WebexRequestPayload} from '../../../../../src/types';
@@ -245,7 +244,7 @@ describe('Utils', () => {
       const result = Utils.getStationLoginErrorData(failure, LoginOption.AGENT_DN);
       expect(result).toEqual({
         message:
-          'Enter a valid dial number. For help, reach out to your administrator or support team.',
+          'Enter a valid US dial number. For help, reach out to your administrator or support team.',
         fieldName: LoginOption.AGENT_DN,
       });
     });
@@ -531,7 +530,7 @@ describe('Utils', () => {
       };
 
       const result = Utils.calculateDestAgentId(interaction, currentAgentId);
-      expect(result).toBeUndefined();
+      expect(result).toBe('');
     });
 
     it('should handle CBT scenario when phone number is not a direct participant key', () => {
@@ -558,65 +557,117 @@ describe('Utils', () => {
     });
   });
 
-  describe('isValidDialNumber', () => {
-    const anyFormatEntry = {
-      name: 'Any Format',
-      prefix: '',
-      regex: '([0-9a-zA-Z]+[-._])*[0-9a-zA-Z]+',
-      strippedChars: '( )-',
-    };
-
-    const usOnlyEntry = {
-      name: 'US',
-      prefix: '1',
-      regex: FALLBACK_DIAL_NUMBER_REGEX.source,
-      strippedChars: '( )-',
-    };
-
-    describe('with multiple dial plan entries (Any Format + US)', () => {
-      const dialPlanEntries = [anyFormatEntry, usOnlyEntry];
-
-      it('should return true for a valid US phone number', () => {
-        const result = Utils.isValidDialNumber('12223334567', dialPlanEntries);
-        expect(result).toBe(true);
-      });
+  describe('calculateDestType', () => {
+    const currentAgentId = 'current-agent-123';
 
-      it('should return true for a UK phone number', () => {
-        const result = Utils.isValidDialNumber('+442030484377', dialPlanEntries);
-        expect(result).toBe(true);
-      });
+    it('should return DIALNUMBER when pType is DN', () => {
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, 'dest-agent-456'],
+          },
+        },
+        participants: {
+          [currentAgentId]: {type: 'Agent', pType: 'Agent'},
+          'dest-agent-456': {type: 'Agent', pType: 'DN', id: 'dest-agent-456'},
+        },
+      };
+
+      const result = Utils.calculateDestType(interaction, currentAgentId);
+      expect(result).toBe('dialNumber');
     });
 
-    describe('with US-only dial plan entry', () => {
-      const dialPlanEntries = [usOnlyEntry];
+    it('should return ENTRYPOINT when pType is EP-DN', () => {
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, 'dest-agent-456'],
+          },
+        },
+        participants: {
+          [currentAgentId]: {type: 'Agent', pType: 'Agent'},
+          'dest-agent-456': {type: 'Agent', pType: 'EP-DN', id: 'dest-agent-456'},
+        },
+      };
 
-      it('should return true for a valid US phone number', () => {
-        const result = Utils.isValidDialNumber('12223334567', dialPlanEntries);
-        expect(result).toBe(true);
-      });
+      const result = Utils.calculateDestType(interaction, currentAgentId);
+      expect(result).toBe('entryPoint');
+    });
 
-      it('should return false for a UK phone number', () => {
-        const result = Utils.isValidDialNumber('+442030484377', dialPlanEntries);
-        expect(result).toBe(false);
-      });
+    it('should return lowercase pType for other types', () => {
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, 'dest-agent-456'],
+          },
+        },
+        participants: {
+          [currentAgentId]: {type: 'Agent', pType: 'Agent'},
+          'dest-agent-456': {type: 'Agent', pType: 'Agent', id: 'dest-agent-456'},
+        },
+      };
 
-      it('should return false for an invalid US number format', () => {
-        const result = Utils.isValidDialNumber('1234567890', dialPlanEntries);
-        expect(result).toBe(false);
-      });
+      const result = Utils.calculateDestType(interaction, currentAgentId);
+      expect(result).toBe('agent');
     });
 
-    describe('with empty dial plan entries (fallback to US regex)', () => {
-      it('should return true for a valid US phone number', () => {
-        const result = Utils.isValidDialNumber('12223334567', []);
-        expect(result).toBe(true);
-      });
+    it('should return agent when no destination agent found', () => {
+      const interaction: any = {
+        media: {},
+        participants: {
+          [currentAgentId]: {type: 'Agent', pType: 'Agent'},
+        },
+      };
 
-      it('should return false for a UK phone number', () => {
-        const result = Utils.isValidDialNumber('+442030484377', []);
-        expect(result).toBe(false);
-      });
+      const result = Utils.calculateDestType(interaction, currentAgentId);
+      expect(result).toBe('agent');
     });
   });
 
+  describe('buildConsultConferenceParamData', () => {
+    it('maps entryPoint destinationType correctly', () => {
+      const result = Utils.buildConsultConferenceParamData(
+        {
+          agentId: 'agent1',
+          destinationType: 'entryPoint',
+          destAgentId: 'ep123',
+        },
+        'interaction123'
+      );
+
+      expect(result).toEqual({
+        interactionId: 'interaction123',
+        data: {
+          agentId: 'agent1',
+          to: 'ep123',
+          destinationType: 'entryPoint',
+        },
+      });
+    });
+
+    it('maps EP-DN/EP_DN destinationType variants to entryPoint', () => {
+      const hyphenResult = Utils.buildConsultConferenceParamData(
+        {
+          agentId: 'agent1',
+          destinationType: 'EP-DN',
+          destAgentId: 'ep123',
+        },
+        'interaction123'
+      );
+      const underscoreResult = Utils.buildConsultConferenceParamData(
+        {
+          agentId: 'agent1',
+          destinationType: 'EP_DN',
+          destAgentId: 'ep123',
+        },
+        'interaction123'
+      );
+
+      expect(hyphenResult.data.destinationType).toBe('entryPoint');
+      expect(underscoreResult.data.destinationType).toBe('entryPoint');
+    });
+  });
 });

package/test/unit/spec/services/core/websocket/WebSocketManager.ts

@@ -1,7 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import {WebSocketManager} from '../../../../../../src/services/core/websocket/WebSocketManager';
 import {WebexSDK, SubscribeRequest} from '../../../../../../src/types';
-import {SUBSCRIBE_API, WCC_API_GATEWAY} from '../../../../../../src/services/constants';
+import {
+  RTD_SUBSCRIBE_API,
+  SUBSCRIBE_API,
+  WCC_API_GATEWAY,
+} from '../../../../../../src/services/constants';
 import {WEB_SOCKET_MANAGER_FILE} from '../../../../../../src/constants';
 import LoggerProxy from '../../../../../../src/logger-proxy';
 
@@ -18,10 +22,10 @@ jest.mock('../../../../../../src/logger-proxy', () => ({
 
 class MockWebSocket {
   static inst: MockWebSocket;
-  onopen: () => void = () => { };
-  onerror: (event: any) => void = () => { };
-  onclose: (event: any) => void = () => { };
-  onmessage: (msg: any) => void = () => { };
+  onopen: () => void = () => {};
+  onerror: (event: any) => void = () => {};
+  onclose: (event: any) => void = () => {};
+  onmessage: (msg: any) => void = () => {};
   close = jest.fn();
   send = jest.fn();
 
@@ -37,7 +41,7 @@ class MockWebSocket {
 class MockCustomEvent<T> extends Event {
   detail: T;
 
-  constructor(event: string, params: { detail: T }) {
+  constructor(event: string, params: {detail: T}) {
     super(event);
     this.detail = params.detail;
   }
@@ -49,7 +53,7 @@ global.CustomEvent = MockCustomEvent as any;
 class MockMessageEvent extends Event {
   data: any;
 
-  constructor(type: string, eventInitDict: { data: any }) {
+  constructor(type: string, eventInitDict: {data: any}) {
     super(type);
     this.data = eventInitDict.data;
   }
@@ -74,14 +78,6 @@ describe('WebSocketManager', () => {
 
     mockWebex = {
       request: jest.fn(),
-      credentials: {
-        getOrgId: jest.fn().mockReturnValue('test-org-id'),
-      },
-      internal: {
-        services: {
-          isIntegrationEnvironment: jest.fn().mockReturnValue(true), // INT environment by default
-        },
-      },
     } as unknown as WebexSDK;
 
     mockWorker = {
@@ -93,18 +89,18 @@ describe('WebSocketManager', () => {
     global.WebSocket = MockWebSocket as any;
 
     global.Blob = function (content: any[], options: any) {
-      return { content, options };
+      return {content, options};
     } as any;
 
     global.URL.createObjectURL = function (blob: Blob) {
       return 'blob:http://localhost:3000/12345';
     };
 
-    webSocketManager = new WebSocketManager({ webex: mockWebex });
+    webSocketManager = new WebSocketManager({webex: mockWebex});
 
     setTimeout(() => {
       MockWebSocket.inst.onopen();
-      MockWebSocket.inst.onmessage({ data: JSON.stringify({ type: "Welcome" }) });
+      MockWebSocket.inst.onmessage({data: JSON.stringify({type: 'Welcome'})});
     }, 1);
 
     console.log = jest.fn();
@@ -115,107 +111,47 @@ describe('WebSocketManager', () => {
     expect(webSocketManager).toBeDefined();
   });
 
-  it('should register and connect to WebSocket with X-ORGANIZATION-ID header for INT environment', async () => {
+  it('should register and connect to WebSocket', async () => {
     const subscribeResponse = {
       body: {
         webSocketUrl: 'wss://fake-url',
       },
     };
 
-    // Mock INT environment (services.isIntegrationEnvironment returns true)
-    (mockWebex.internal.services.isIntegrationEnvironment as jest.Mock).mockReturnValue(true);
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     expect(mockWebex.request).toHaveBeenCalledWith({
       service: WCC_API_GATEWAY,
       resource: SUBSCRIBE_API,
       method: 'POST',
       body: fakeSubscribeRequest,
-      headers: {'X-ORGANIZATION-ID': 'test-org-id'},
     });
   });
 
-  it('should register and connect to WebSocket without X-ORGANIZATION-ID header for production environment', async () => {
+  it('should connect rtd websocket', async () => {
     const subscribeResponse = {
       body: {
         webSocketUrl: 'wss://fake-url',
       },
     };
 
-    // Mock production environment (services.isIntegrationEnvironment returns false)
-    (mockWebex.internal.services.isIntegrationEnvironment as jest.Mock).mockReturnValue(false);
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    // Create new WebSocketManager instance with production mock
-    webSocketManager = new WebSocketManager({ webex: mockWebex });
-
-    setTimeout(() => {
-      MockWebSocket.inst.onopen();
-      MockWebSocket.inst.onmessage({ data: JSON.stringify({ type: "Welcome" }) });
-    }, 1);
-
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
-
-    expect(mockWebex.request).toHaveBeenCalledWith({
-      service: WCC_API_GATEWAY,
-      resource: SUBSCRIBE_API,
-      method: 'POST',
+    await webSocketManager.initWebSocket({
       body: fakeSubscribeRequest,
-      headers: undefined,
+      resource: RTD_SUBSCRIBE_API,
     });
-  });
-
-  it('should not send X-ORGANIZATION-ID header when services.isIntegrationEnvironment is not available', async () => {
-    const subscribeResponse = {
-      body: {
-        webSocketUrl: 'wss://fake-url',
-      },
-    };
-
-    // Mock services not available (defaults to production behavior)
-    (mockWebex as any).internal = undefined;
-    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
-
-    webSocketManager = new WebSocketManager({ webex: mockWebex });
-
-    setTimeout(() => {
-      MockWebSocket.inst.onopen();
-      MockWebSocket.inst.onmessage({ data: JSON.stringify({ type: "Welcome" }) });
-    }, 1);
-
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
 
     expect(mockWebex.request).toHaveBeenCalledWith({
       service: WCC_API_GATEWAY,
-      resource: SUBSCRIBE_API,
+      resource: RTD_SUBSCRIBE_API,
       method: 'POST',
       body: fakeSubscribeRequest,
-      headers: undefined,
     });
   });
 
-  it('should log error and throw when register API fails in initWebSocket', async () => {
-    const error = new Error('Register API failed');
-
-    (mockWebex.request as jest.Mock).mockRejectedValueOnce(error);
-
-    await expect(
-      webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API })
-    ).rejects.toThrow(error);
-
-    expect(LoggerProxy.error).toHaveBeenCalledWith(
-      `Register API Failed, Request to RoutingNotifs websocket registration API failed ${error}`,
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'register' }
-    );
-
-    expect(LoggerProxy.error).toHaveBeenCalledWith(
-      `[WebSocketStatus] | Error in registering Websocket ${error}`,
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'initWebSocket' }
-    );
-  });
-
   it('should close WebSocket connection', async () => {
     const subscribeResponse = {
       body: {
@@ -225,12 +161,12 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     webSocketManager.close(true, 'Test reason');
 
     expect(MockWebSocket.inst.close).toHaveBeenCalled();
-    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({type: 'terminate'});
   });
 
   it('should handle WebSocket keepalive messages', async () => {
@@ -242,19 +178,19 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     setTimeout(() => {
       MockWebSocket.inst.onopen();
-      MockWebSocket.inst.onmessage({ data: JSON.stringify({ type: 'keepalive' }) });
+      MockWebSocket.inst.onmessage({data: JSON.stringify({type: 'keepalive'})});
       mockWorker.onmessage({
         data: {
-          type: 'keepalive'
-        }
+          type: 'keepalive',
+        },
       });
     }, 1);
 
-    expect(MockWebSocket.inst.send).toHaveBeenCalledWith(JSON.stringify({ keepalive: 'true' }));
+    expect(MockWebSocket.inst.send).toHaveBeenCalledWith(JSON.stringify({keepalive: 'true'}));
   });
 
   it('should handle WebSocket close due to network issue', async () => {
@@ -266,7 +202,7 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     // Mock navigator.onLine to simulate network issue
     Object.defineProperty(global, 'navigator', {
@@ -289,10 +225,10 @@ describe('WebSocketManager', () => {
     // Wait for the close event to be handled
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({type: 'terminate'});
     expect(LoggerProxy.error).toHaveBeenCalledWith(
       '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: network issue',
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler' }
+      {module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler'}
     );
 
     // Restore navigator.onLine to true
@@ -313,14 +249,14 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     const errorEvent = new Event('error');
     MockWebSocket.inst.onerror(errorEvent);
 
     expect(LoggerProxy.error).toHaveBeenCalledWith(
       '[WebSocketStatus] | event=socketConnectionFailed | WebSocket connection failed [object Event]',
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'connect' }
+      {module: WEB_SOCKET_MANAGER_FILE, method: 'connect'}
     );
   });
 
@@ -333,17 +269,17 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     const messageEvent = new MessageEvent('message', {
-      data: JSON.stringify({ type: 'AGENT_MULTI_LOGIN' }),
+      data: JSON.stringify({type: 'AGENT_MULTI_LOGIN'}),
     });
     MockWebSocket.inst.onmessage(messageEvent);
 
     expect(MockWebSocket.inst.close).toHaveBeenCalled();
     expect(LoggerProxy.error).toHaveBeenCalledWith(
       '[WebSocketStatus] | event=agentMultiLogin | WebSocket connection closed by agent multiLogin',
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'connect' }
+      {module: WEB_SOCKET_MANAGER_FILE, method: 'connect'}
     );
   });
 
@@ -356,10 +292,10 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     const messageEvent = new MessageEvent('message', {
-      data: JSON.stringify({ type: 'Welcome', data: { someData: 'data' } }),
+      data: JSON.stringify({type: 'Welcome', data: {someData: 'data'}}),
     });
     MockWebSocket.inst.onmessage(messageEvent);
 
@@ -375,7 +311,7 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     webSocketManager['forceCloseWebSocketOnTimeout'] = true;
 
@@ -394,10 +330,10 @@ describe('WebSocketManager', () => {
     // Wait for the close event to be handled
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({type: 'terminate'});
     expect(LoggerProxy.error).toHaveBeenCalledWith(
       '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: WebSocket auto close timed out. Forcefully closed websocket.',
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler' }
+      {module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler'}
     );
   });
 
@@ -410,7 +346,7 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
     webSocketManager.shouldReconnect = false;
     // Simulate the WebSocket close event
     setTimeout(() => {
@@ -421,13 +357,13 @@ describe('WebSocketManager', () => {
         target: MockWebSocket.inst,
       });
     }, 1);
-    
+
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({type: 'terminate'});
     expect(LoggerProxy.error).not.toHaveBeenCalledWith(
       '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: no reconnect',
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler' }
+      {module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler'}
     );
   });
 
@@ -440,7 +376,7 @@ describe('WebSocketManager', () => {
 
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
 
-    await webSocketManager.initWebSocket({ body: fakeSubscribeRequest, resource: SUBSCRIBE_API });
+    await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
 
     // Simulate the WebSocket close event
     setTimeout(() => {
@@ -455,10 +391,10 @@ describe('WebSocketManager', () => {
     // Wait for the close event to be handled
     await new Promise((resolve) => setTimeout(resolve, 10));
 
-    expect(mockWorker.postMessage).toHaveBeenCalledWith({ type: 'terminate' });
+    expect(mockWorker.postMessage).toHaveBeenCalledWith({type: 'terminate'});
     expect(LoggerProxy.error).not.toHaveBeenCalledWith(
       '[WebSocketStatus] | event=webSocketClose | WebSocket connection closed REASON: clean close',
-      { module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler' }
+      {module: WEB_SOCKET_MANAGER_FILE, method: 'webSocketOnCloseHandler'}
     );
   });
-});
+});

package/test/unit/spec/services/core/websocket/connection-service.ts

@@ -3,9 +3,7 @@ import {WebSocketManager} from '../../../../../../src/services/core/websocket/We
 import {SubscribeRequest} from '../../../../../../src/types';
 import LoggerProxy from '../../../../../../src/logger-proxy';
 import {CONNECTIVITY_CHECK_INTERVAL} from '../../../../../../src/services/core/constants';
-import { CONNECTION_SERVICE_FILE } from '../../../../../../src/constants';
-import {SUBSCRIBE_API} from '../../../../../../src/services/constants';
-
+import {CONNECTION_SERVICE_FILE} from '../../../../../../src/constants';
 
 jest.mock('../../../../../../src/services/core/websocket/WebSocketManager');
 jest.mock('../../../../../../src/logger-proxy', () => ({
@@ -111,7 +109,10 @@ describe('ConnectionService', () => {
       'event=socketConnectionRetry | Trying to reconnect to websocket',
       {module: CONNECTION_SERVICE_FILE, method: 'handleSocketClose'}
     );
-    expect(mockWebSocketManager.initWebSocket).toHaveBeenCalledWith({body: mockSubscribeRequest, resource: SUBSCRIBE_API});
+    expect(mockWebSocketManager.initWebSocket).toHaveBeenCalledWith({
+      body: mockSubscribeRequest,
+      resource: 'v1/notification/subscribe',
+    });
   });
 
   describe('ConnectionService onPing', () => {

package/test/unit/spec/services/task/AutoWrapup.ts

@@ -0,0 +1,63 @@
+import AutoWrapup from '../../../../../src/services/task/AutoWrapup';
+
+describe('AutoWrapup', () => {
+  beforeEach(() => {
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('starts, reports running, and completes', () => {
+    const onComplete = jest.fn();
+    const timer = new AutoWrapup(1000, true);
+
+    expect(timer.allowCancelAutoWrapup).toBe(true);
+    expect(timer.isRunning()).toBe(false);
+
+    timer.start(onComplete);
+    expect(timer.isRunning()).toBe(true);
+    expect(timer.getTimeLeft()).toBeGreaterThan(0);
+    expect(timer.getTimeLeftSeconds()).toBeGreaterThan(0);
+
+    jest.advanceTimersByTime(1000);
+    expect(onComplete).toHaveBeenCalledTimes(1);
+    expect(timer.isRunning()).toBe(false);
+  });
+
+  it('clear() is safe when not running and cancels an active timer', () => {
+    const onComplete = jest.fn();
+    const timer = new AutoWrapup(1000);
+
+    timer.clear(); // no-op
+    expect(timer.isRunning()).toBe(false);
+
+    timer.start(onComplete);
+    expect(timer.isRunning()).toBe(true);
+
+    timer.clear();
+    expect(timer.isRunning()).toBe(false);
+
+    jest.advanceTimersByTime(1000);
+    expect(onComplete).not.toHaveBeenCalled();
+  });
+
+  it('start() replaces an existing timer', () => {
+    const onComplete1 = jest.fn();
+    const onComplete2 = jest.fn();
+    const timer = new AutoWrapup(1000);
+
+    timer.start(onComplete1);
+    jest.advanceTimersByTime(500);
+
+    timer.start(onComplete2);
+    jest.advanceTimersByTime(500);
+    expect(onComplete1).not.toHaveBeenCalled();
+    expect(onComplete2).not.toHaveBeenCalled();
+
+    jest.advanceTimersByTime(500);
+    expect(onComplete2).toHaveBeenCalledTimes(1);
+  });
+});
+