@webex/contact-center 3.11.0 → 3.12.0-auth-prejoin-fetch.1

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,
       });
     });
@@ -530,7 +531,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', () => {
@@ -557,4 +558,482 @@ describe('Utils', () => {
     });
   });
 
+  describe('calculateDestType', () => {
+    const currentAgentId = 'current-agent-123';
+
+    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');
+    });
+
+    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'},
+        },
+      };
+
+      const result = Utils.calculateDestType(interaction, currentAgentId);
+      expect(result).toBe('entryPoint');
+    });
+
+    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'},
+        },
+      };
+
+      const result = Utils.calculateDestType(interaction, currentAgentId);
+      expect(result).toBe('agent');
+    });
+
+    it('should return agent when no destination agent found', () => {
+      const interaction: any = {
+        media: {},
+        participants: {
+          [currentAgentId]: {type: 'Agent', pType: 'Agent'},
+        },
+      };
+
+      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');
+    });
+  });
+
+  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/WebexRequest.ts

@@ -51,6 +51,7 @@ describe('WebexRequest', () => {
         resource: 'resource',
         method: HTTP_METHODS.POST,
         body: { key: 'value' },
+        headers: {'x-test-header': 'test-value'},
       });
 
       expect(result).toEqual(mockResponse);
@@ -59,6 +60,7 @@ describe('WebexRequest', () => {
         resource: 'resource',
         method: HTTP_METHODS.POST,
         body: { key: 'value' },
+        headers: {'x-test-header': 'test-value'},
       });
     });
 
@@ -141,4 +143,4 @@ describe('WebexRequest', () => {
       );
     });
   });
-});
+});

package/test/unit/spec/services/core/aqm-reqs.ts

@@ -334,6 +334,28 @@ describe('AqmReqs', () => {
   });
 
   describe('Event tests', () => {
+    const participantDropConfig = (participantId: string, timeout?: number | 'disabled') => ({
+      host: 'fake-host',
+      url: `/v1/tasks/interaction/conference/participants/${participantId}/drop`,
+      data: {},
+      timeout,
+      redactSensitiveLogs: true,
+      err: (error: any) => error,
+      notifSuccess: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantLeftConference', interactionId: 'interaction'},
+        },
+      },
+      notifFail: {
+        bind: {
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantDropConferenceFailed'},
+        },
+        errId: 'Service.aqm.task.dropConferenceParticipant' as const,
+      },
+    });
+
     it('should handle onMessage events', async () => {
       webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
     
@@ -564,5 +586,95 @@ describe('AqmReqs', () => {
       const result = await promise;
       expect(result).toEqual(eventData);
     });
+
+    it('redacts sensitive routing failure payloads from logs', async () => {
+      const participantId = '+1/failure-secret';
+      webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
+      const promise = aqm['createPromise'](participantDropConfig(participantId, 'disabled'));
+
+      webSocketManagerInstance.emit(
+        'message',
+        JSON.stringify({
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantDropConferenceFailed', participantId},
+        })
+      );
+
+      await expect(promise).rejects.toBeDefined();
+      expect(LoggerProxy.log).toHaveBeenCalledTimes(1);
+      expect(LoggerProxy.log).toHaveBeenCalledWith(
+        'Routing request failed (sensitive details redacted)',
+        expect.objectContaining({module: AQM_REQS_FILE})
+      );
+      expect(JSON.stringify((LoggerProxy.log as jest.Mock).mock.calls)).not.toContain(participantId);
+      expect(aqm['pendingRequests']).toEqual({});
+    });
+
+    it('resolves a correlated participant-left event and clears its binds', async () => {
+      jest.useFakeTimers();
+      (global.window as any).setTimeout = global.setTimeout;
+
+      try {
+        const participantId = '+1/success-secret';
+        webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
+        const promise = aqm['createPromise'](participantDropConfig(participantId));
+        const eventData = {
+          type: 'RoutingMessage',
+          data: {type: 'ParticipantLeftConference', interactionId: 'interaction'},
+        };
+
+        webSocketManagerInstance.emit('message', JSON.stringify(eventData));
+
+        await expect(promise).resolves.toEqual(eventData);
+        expect(aqm['pendingRequests']).toEqual({});
+      } finally {
+        jest.useRealTimers();
+        (global.window as any).setTimeout = global.setTimeout;
+      }
+    });
+
+    it('clears participant Drop binds after an HTTP failure without logging sensitive data', async () => {
+      jest.useFakeTimers();
+      (global.window as any).setTimeout = global.setTimeout;
+
+      try {
+        const participantId = '+1/http-secret';
+        const httpFailure = {headers: {Authorization: 'Bearer secret'}};
+        webexRequestInstance.request.mockRejectedValueOnce(httpFailure);
+        const promise = aqm['createPromise'](participantDropConfig(participantId));
+
+        await expect(promise).rejects.toBe(httpFailure);
+        expect(aqm['pendingRequests']).toEqual({});
+        expect(JSON.stringify([
+          (LoggerProxy.log as jest.Mock).mock.calls,
+          (LoggerProxy.error as jest.Mock).mock.calls,
+        ])).not.toContain(participantId);
+        expect(httpFailure.headers.Authorization).toBe('*');
+      } finally {
+        jest.useRealTimers();
+        (global.window as any).setTimeout = global.setTimeout;
+      }
+    });
+
+    it('uses the default timeout without logging a sensitive request URL', async () => {
+      jest.useFakeTimers();
+      (global.window as any).setTimeout = global.setTimeout;
+
+      try {
+        const participantId = '+1/timeout-secret';
+        webexRequestInstance.request.mockResolvedValueOnce(mockWebexRequestResolvedValue);
+        const promise = aqm['createPromise'](participantDropConfig(participantId));
+        const rejection = expect(promise).rejects.toBeDefined();
+
+        jest.advanceTimersByTime(20000);
+
+        await rejection;
+        expect(JSON.stringify((LoggerProxy.error as jest.Mock).mock.calls)).not.toContain(participantId);
+        expect(aqm['pendingRequests']).toEqual({});
+      } finally {
+        jest.useRealTimers();
+        (global.window as any).setTimeout = global.setTimeout;
+      }
+    });
   });
-});
+});