@webex/contact-center 3.12.0-task-refactor.11 → 3.12.0-task-refactor.13

package/test/unit/spec/services/config/index.ts

@@ -746,7 +746,7 @@ describe('AgentConfigService', () => {
         agentProfileId: 'profile123',
         siteId: 'site789',
         dbId: 'db123',
-        defaultDialledNumber: '1234567890',
+        deafultDialledNumber: '1234567890',
         id: 'user001',
         teamIds: ['team1', 'team2'],
       };
@@ -775,6 +775,17 @@ describe('AgentConfigService', () => {
 
       const mockDialPlanData = [];
 
+      const mockTeamData = [
+        {id: 'team1', name: 'Support Team'},
+        {id: 'team2', name: 'Sales Team'},
+      ];
+
+      const mockOrgInfo = {
+        tenantId: 'tenant123',
+        timezone: 'GMT',
+        environment: 'produs1',
+      };
+
       const mockOrgSettings = {
         campaignManagerEnabled: true,
         webRtcEnabled: true,
@@ -798,6 +809,9 @@ describe('AgentConfigService', () => {
         {id: 'aux1', type: 'WRAP_UP_CODE', name: 'Wrap Up Code 1', isDefault: true},
         {id: 'aux2', type: 'IDLE_CODE', name: 'Idle Code 1', isDefault: true},
       ];
+      const mockAIFeatureFlags = {
+        data: [{realtimeTranscripts: {enable: true}}],
+      };
 
       const parseAgentConfigsSpy = jest.spyOn(util, 'parseAgentConfigs');
       agentConfigService.getUserUsingCI = jest.fn().mockResolvedValue(mockUserConfig);
@@ -861,7 +875,7 @@ describe('AgentConfigService', () => {
         skillProfileId: 'skillProfile456',
         siteId: 'site789',
         dbId: 'db123',
-        defaultDialledNumber: '1234567890',
+        deafultDialledNumber: '1234567890',
         id: 'user001',
         teamIds: ['team1', 'team2'],
       };
@@ -895,6 +909,17 @@ describe('AgentConfigService', () => {
         {id: 'dialPlan2', name: 'Plan 2'},
       ];
 
+      const mockTeamData = [
+        {id: 'team1', name: 'Support Team'},
+        {id: 'team2', name: 'Sales Team'},
+      ];
+
+      const mockOrgInfo = {
+        tenantId: 'tenant123',
+        timezone: 'GMT',
+        environment: 'produs1',
+      };
+
       const mockOrgSettings = {
         campaignManagerEnabled: true,
         webRtcEnabled: true,
@@ -919,6 +944,9 @@ describe('AgentConfigService', () => {
         {id: 'aux1', type: 'WRAP_UP_CODE', name: 'Wrap Up Code 1'},
         {id: 'aux2', type: 'IDLE_CODE', name: 'Idle Code 1'},
       ];
+      const mockAIFeatureFlags = {
+        data: [{realtimeTranscripts: {enable: true}}],
+      };
 
       const parseAgentConfigsSpy = jest.spyOn(util, 'parseAgentConfigs');
       agentConfigService.getUserUsingCI = jest.fn().mockResolvedValue(mockUserConfig);

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

@@ -11,6 +11,7 @@ jest.mock('../../../../../src/logger-proxy', () => ({
     log: jest.fn(),
     error: jest.fn(),
     info: jest.fn(),
+    warn: jest.fn(),
     initialize: jest.fn(),
   },
 }));
@@ -244,7 +245,7 @@ describe('Utils', () => {
       const result = Utils.getStationLoginErrorData(failure, LoginOption.AGENT_DN);
       expect(result).toEqual({
         message:
-          'Enter a valid US dial number. For help, reach out to your administrator or support team.',
+          'Enter a valid dial number. For help, reach out to your administrator or support team.',
         fieldName: LoginOption.AGENT_DN,
       });
     });
@@ -670,4 +671,369 @@ describe('Utils', () => {
       expect(underscoreResult.data.destinationType).toBe('entryPoint');
     });
   });
+
+  describe('getDestAgentIdForCBT', () => {
+    it('should return destination agent ID for CBT scenario', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid-123': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+            id: 'agent-uuid-123',
+          },
+          'customer-1': {
+            type: 'Customer',
+            pType: 'Customer',
+            id: 'customer-1',
+          },
+        },
+      };
+      const consultingAgent = '5551234567'; // Phone number, not in participants as key
+
+      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
+      expect(result).toBe('agent-uuid-123');
+    });
+
+    it('should return empty string when consultingAgent is in participants (non-CBT)', () => {
+      const interaction: any = {
+        participants: {
+          'agent-123': {
+            type: 'Agent',
+            pType: 'Agent',
+            id: 'agent-123',
+          },
+        },
+      };
+      const consultingAgent = 'agent-123'; // Exists as key in participants
+
+      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
+      expect(result).toBe('');
+    });
+
+    it('should return empty string when no matching dial number found', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid-123': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5559999999',
+            id: 'agent-uuid-123',
+          },
+        },
+      };
+      const consultingAgent = '5551234567'; // Different number
+
+      const result = Utils.getDestAgentIdForCBT(interaction, consultingAgent);
+      expect(result).toBe('');
+    });
+
+    it('should return empty string when consultingAgent is empty', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid-123': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+          },
+        },
+      };
+
+      const result = Utils.getDestAgentIdForCBT(interaction, '');
+      expect(result).toBe('');
+    });
+
+    it('should match only when participant type is dial number and type is Agent', () => {
+      const interaction: any = {
+        participants: {
+          'participant-1': {
+            type: 'Customer',
+            pType: 'dn',
+            dn: '5551234567',
+          },
+          'participant-2': {
+            type: 'Agent',
+            pType: 'Agent',
+            dn: '5551234567',
+          },
+          'participant-3': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+            id: 'correct-agent',
+          },
+        },
+      };
+
+      const result = Utils.getDestAgentIdForCBT(interaction, '5551234567');
+      expect(result).toBe('participant-3');
+    });
+
+    it('should handle case-insensitive participant type comparison', () => {
+      const interaction: any = {
+        participants: {
+          'agent-uuid': {
+            type: 'Agent',
+            pType: 'DN', // Uppercase (dial number)
+            dn: '5551234567',
+          },
+        },
+      };
+
+      const result = Utils.getDestAgentIdForCBT(interaction, '5551234567');
+      expect(result).toBe('agent-uuid');
+    });
+  });
+
+  describe('calculateDestAgentId', () => {
+    const currentAgentId = 'agent-123';
+
+    it('should return destAgentIdCBT when found', () => {
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, '5551234567'],
+          },
+        },
+        participants: {
+          'agent-uuid-456': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567',
+            id: 'agent-uuid-456',
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe('agent-uuid-456');
+    });
+
+    it('should return participant id for regular agent when not CBT', () => {
+      const consultedAgentId = 'agent-456';
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, consultedAgentId],
+          },
+        },
+        participants: {
+          [consultedAgentId]: {
+            type: 'Agent',
+            id: consultedAgentId,
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe(consultedAgentId);
+    });
+
+    it('should return epId for EpDn type participants', () => {
+      const consultedAgentId = 'epdn-456';
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, consultedAgentId],
+          },
+        },
+        participants: {
+          [consultedAgentId]: {
+            type: 'EpDn',
+            id: consultedAgentId,
+            epId: 'entry-point-id-789',
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe('entry-point-id-789');
+    });
+
+    it('should return undefined when no consulting agent found', () => {
+      const interaction: any = {
+        media: {
+          mainCall: {
+            mType: 'mainCall',
+            participants: [currentAgentId],
+          },
+        },
+        participants: {},
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe('');
+    });
+
+    it('should handle CBT scenario when phone number is not a direct participant key', () => {
+      const interaction: any = {
+        media: {
+          consult: {
+            mType: 'consult',
+            participants: [currentAgentId, '5551234567'], // Phone number in media
+          },
+        },
+        participants: {
+          // Note: '5551234567' is NOT a key - this is CBT
+          'agent-uuid-cbt': {
+            type: 'Agent',
+            pType: 'dn',
+            dn: '5551234567', // Found by matching DN
+            id: 'agent-uuid-cbt',
+          },
+        },
+      };
+
+      const result = Utils.calculateDestAgentId(interaction, currentAgentId);
+      expect(result).toBe('agent-uuid-cbt'); // Returns the CBT agent
+    });
+  });
+
+  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: '1[0-9]{3}[2-9][0-9]{6}([,]{1,10}[0-9]+){0,1}',
+      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);
+      });
+
+      it('should return true for a UK phone number', () => {
+        const result = Utils.isValidDialNumber('+442030484377', dialPlanEntries);
+        expect(result).toBe(true);
+      });
+
+      it('should return true for a European number', () => {
+        const result = Utils.isValidDialNumber('6955577166', dialPlanEntries);
+        expect(result).toBe(true);
+      });
+    });
+
+    describe('with US-only dial plan entry', () => {
+      const dialPlanEntries = [usOnlyEntry];
+
+      it('should return true for a valid US phone number', () => {
+        const result = Utils.isValidDialNumber('12223334567', dialPlanEntries);
+        expect(result).toBe(true);
+      });
+
+      it('should return false for a UK phone number', () => {
+        const result = Utils.isValidDialNumber('+442030484377', dialPlanEntries);
+        expect(result).toBe(false);
+      });
+
+      it('should return false for an invalid US number format', () => {
+        const result = Utils.isValidDialNumber('1234567890', dialPlanEntries);
+        expect(result).toBe(false);
+      });
+    });
+
+    describe('with empty dial plan entries (defers to server)', () => {
+      it('should return true for any dial number', () => {
+        expect(Utils.isValidDialNumber('12223334567', [])).toBe(true);
+      });
+
+      it('should return true for a UK phone number', () => {
+        expect(Utils.isValidDialNumber('+442030484377', [])).toBe(true);
+      });
+
+      it('should return true for a European number', () => {
+        expect(Utils.isValidDialNumber('6955577166', [])).toBe(true);
+      });
+    });
+
+    describe('strippedChars handling', () => {
+      it('should strip characters before regex matching', () => {
+        const strictEntry = {
+          name: 'Digits Only',
+          prefix: '',
+          regex: '^[0-9]{10,15}$',
+          strippedChars: '( )-+',
+        };
+        const result = Utils.isValidDialNumber('+44 (203) 048-4377', [strictEntry]);
+        expect(result).toBe(true);
+      });
+
+      it('should handle entries with no strippedChars', () => {
+        const noStripEntry = {
+          name: 'No Strip',
+          prefix: '',
+          regex: '^[0-9]+$',
+          strippedChars: '',
+        };
+        expect(Utils.isValidDialNumber('12345', [noStripEntry])).toBe(true);
+        expect(Utils.isValidDialNumber('+12345', [noStripEntry])).toBe(false);
+      });
+    });
+
+    describe('empty or undefined dial number', () => {
+      it('should return false and log warning for undefined dial number', () => {
+        const result = Utils.isValidDialNumber(undefined as any, [anyFormatEntry]);
+        expect(result).toBe(false);
+        expect(LoggerProxy.warn).toHaveBeenCalledWith(
+          'Dial number is empty or undefined.',
+          expect.objectContaining({module: 'Utils', method: 'isValidDialNumber'})
+        );
+      });
+
+      it('should return false and log warning for empty string dial number', () => {
+        const result = Utils.isValidDialNumber('', [anyFormatEntry]);
+        expect(result).toBe(false);
+        expect(LoggerProxy.warn).toHaveBeenCalledWith(
+          'Dial number is empty or undefined.',
+          expect.objectContaining({module: 'Utils', method: 'isValidDialNumber'})
+        );
+      });
+    });
+
+    describe('invalid regex handling', () => {
+      it('should return false and log warning for invalid regex pattern', () => {
+        const badEntry = {
+          name: 'Bad Regex',
+          prefix: '',
+          regex: '[invalid(',
+          strippedChars: '',
+        };
+        const result = Utils.isValidDialNumber('12345', [badEntry]);
+        expect(result).toBe(false);
+        expect(LoggerProxy.warn).toHaveBeenCalledWith(
+          expect.stringContaining('Failed to validate dial number against entry "Bad Regex"'),
+          expect.objectContaining({module: 'Utils', method: 'isValidDialNumber'})
+        );
+      });
+    });
+  });
+
+  describe('stripDialPlanChars', () => {
+    it('should remove specified characters from input', () => {
+      expect(Utils.stripDialPlanChars('+44 (203) 048-4377', '( )-+')).toBe('442030484377');
+    });
+
+    it('should return input unchanged when strippedChars is empty', () => {
+      expect(Utils.stripDialPlanChars('+442030484377', '')).toBe('+442030484377');
+    });
+
+    it('should return input unchanged when strippedChars is null/undefined', () => {
+      expect(Utils.stripDialPlanChars('12345', null as any)).toBe('12345');
+      expect(Utils.stripDialPlanChars('12345', undefined as any)).toBe('12345');
+    });
+  });
+
 });

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

@@ -78,6 +78,14 @@ 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 = {
@@ -111,13 +119,15 @@ describe('WebSocketManager', () => {
     expect(webSocketManager).toBeDefined();
   });
 
-  it('should register and connect to WebSocket', async () => {
+  it('should register and connect to WebSocket with X-ORGANIZATION-ID header for INT environment', 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});
@@ -127,6 +137,7 @@ describe('WebSocketManager', () => {
       resource: SUBSCRIBE_API,
       method: 'POST',
       body: fakeSubscribeRequest,
+      headers: {'X-ORGANIZATION-ID': 'test-org-id'},
     });
   });
 
@@ -149,9 +160,88 @@ describe('WebSocketManager', () => {
       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',
+    },
+  };
+    // 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',
+      body: fakeSubscribeRequest,
+      headers: undefined,
+    });
+  });
+
+  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,
+      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: {

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

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

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

@@ -764,6 +764,7 @@ describe('TaskManager', () => {
         destAgentId: 'ebeb893b-ba67-4f36-8418-95c7492b28c2',
         owner: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
         queueMgr: 'aqm',
+        agentsPendingWrapUp: ['test-agent-id'],
       },
     };
 
@@ -1380,7 +1381,7 @@ describe('TaskManager', () => {
         state: 'new',
         mediaType: 'telephony',
       },
-      agentsPendingWrapUp: ['agent-123'],
+      agentsPendingWrapUp: ['test-agent-id'],
     });
     task.unregisterWebCallListeners = jest.fn();
     const removeTaskSpy = jest.spyOn(taskManager, 'removeTaskFromCollection');
@@ -1394,7 +1395,7 @@ describe('TaskManager', () => {
           state: 'new',
           mediaType: 'telephony',
         },
-        agentsPendingWrapUp: ['agent-123'],
+        agentsPendingWrapUp: ['test-agent-id'],
       },
     };
 
@@ -2174,6 +2175,7 @@ describe('TaskManager', () => {
         type: CC_EVENTS.CONTACT_ENDED,
         interaction: {mediaType: 'email', state: 'connected'}, // Using 'connected' to NOT trigger cleanup
         wrapUpRequired: true,
+        agentsPendingWrapUp: ['test-agent-id'],
       },
     };