@webex/contact-center 3.12.0-next.16 → 3.12.0-next.161

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;
   }
@@ -90,21 +94,23 @@ describe('WebSocketManager', () => {
     };
 
     global.Worker = jest.fn(() => mockWorker) as any;
-    global.WebSocket = MockWebSocket as any;
+    global.WebSocket = jest.fn(function (this: any, ...args: any[]) {
+      return new MockWebSocket(...(args as []));
+    }) 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,10 +121,58 @@ describe('WebSocketManager', () => {
     expect(webSocketManager).toBeDefined();
   });
 
+  describe('webSocketUrl validation', () => {
+    it('rejects a non-wss webSocketUrl and does not construct a socket', async () => {
+      const subscribeResponse = {
+        body: {
+          webSocketUrl: 'http://fake-url.cisco.com',
+        },
+      };
+
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+      await expect(
+        webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API})
+      ).rejects.toBeDefined();
+
+      expect(global.WebSocket).not.toHaveBeenCalled();
+    });
+
+    it('rejects a wss webSocketUrl with a non-allow-listed host and does not construct a socket', async () => {
+      const subscribeResponse = {
+        body: {
+          webSocketUrl: 'wss://evil.attacker.com',
+        },
+      };
+
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+      await expect(
+        webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API})
+      ).rejects.toBeDefined();
+
+      expect(global.WebSocket).not.toHaveBeenCalled();
+    });
+
+    it('connects for a valid wss allow-listed webSocketUrl', async () => {
+      const subscribeResponse = {
+        body: {
+          webSocketUrl: 'wss://notifs.wxcc-us1.cisco.com',
+        },
+      };
+
+      (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+      await webSocketManager.initWebSocket({body: fakeSubscribeRequest, resource: SUBSCRIBE_API});
+
+      expect(global.WebSocket).toHaveBeenCalledWith('wss://notifs.wxcc-us1.cisco.com');
+    });
+  });
+
   it('should register and connect to WebSocket with X-ORGANIZATION-ID header for INT environment', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
@@ -126,7 +180,7 @@ describe('WebSocketManager', () => {
     (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,
@@ -137,13 +191,35 @@ describe('WebSocketManager', () => {
     });
   });
 
-  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',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
+    (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
+
+    await webSocketManager.initWebSocket({
+      body: fakeSubscribeRequest,
+      resource: RTD_SUBSCRIBE_API,
+    });
+
+    expect(mockWebex.request).toHaveBeenCalledWith({
+      service: WCC_API_GATEWAY,
+      resource: RTD_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 () => {
+  const subscribeResponse = {
+    body: {
+      webSocketUrl: 'wss://fake-url.cisco.com',
+    },
+  };
     // Mock production environment (services.isIntegrationEnvironment returns false)
     (mockWebex.internal.services.isIntegrationEnvironment as jest.Mock).mockReturnValue(false);
     (mockWebex.request as jest.Mock).mockResolvedValueOnce(subscribeResponse);
@@ -170,7 +246,7 @@ describe('WebSocketManager', () => {
   it('should not send X-ORGANIZATION-ID header when services.isIntegrationEnvironment is not available', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
@@ -219,54 +295,54 @@ describe('WebSocketManager', () => {
   it('should close WebSocket connection', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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 () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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 () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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 +365,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
@@ -307,59 +383,59 @@ describe('WebSocketManager', () => {
   it('should handle WebSocket error event', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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'}
     );
   });
 
   it('should handle WebSocket message event with AGENT_MULTI_LOGIN', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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'}
     );
   });
 
   it('should handle WebSocket message event with Welcome', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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);
 
@@ -369,13 +445,13 @@ describe('WebSocketManager', () => {
   it('should handle WebSocket close with forceCloseWebSocketOnTimeout', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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,23 +470,23 @@ 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'}
     );
   });
 
   it('should handle WebSocket close without reconnect', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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,26 +497,26 @@ 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'}
     );
   });
 
   it('should handle WebSocket close with clean close', async () => {
     const subscribeResponse = {
       body: {
-        webSocketUrl: 'wss://fake-url',
+        webSocketUrl: 'wss://fake-url.cisco.com',
       },
     };
 
     (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 +531,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/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);
+  });
+});
+