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

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

@@ -0,0 +1,113 @@
+import WxAppTelephonyMercurySync, {
+  TELEPHONY_CALL_MUTED,
+  TELEPHONY_CALL_UNMUTED,
+} from '../../../../src/services/WxAppTelephonyMercurySync';
+
+describe('WxAppTelephonyMercurySync', () => {
+  const agentId = 'agent-123';
+  let mercury: {on: jest.Mock; off: jest.Mock};
+  let webex: {internal: {mercury?: typeof mercury}};
+  let sync: WxAppTelephonyMercurySync;
+  let onMuteChange: jest.Mock;
+
+  beforeEach(() => {
+    mercury = {on: jest.fn(), off: jest.fn()};
+    webex = {internal: {mercury}};
+    sync = new WxAppTelephonyMercurySync(webex as never);
+    onMuteChange = jest.fn();
+  });
+
+  afterEach(() => {
+    sync.unsubscribe();
+  });
+
+  it('subscribes to muted and unmuted Mercury events', () => {
+    sync.subscribe(agentId, onMuteChange);
+
+    expect(mercury.on).toHaveBeenCalledWith(TELEPHONY_CALL_MUTED, expect.any(Function));
+    expect(mercury.on).toHaveBeenCalledWith(TELEPHONY_CALL_UNMUTED, expect.any(Function));
+    expect(sync.isSubscribed()).toBe(true);
+  });
+
+  it('invokes callback with decoded callId and muted when actorId matches agent', () => {
+    const callId = 'prefix:call-half-1';
+    const encodedCallId = btoa(callId);
+    const encodedActorId = btoa(`some-prefix-${agentId}`);
+
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    muteHandler({data: {actorId: encodedActorId, callId: encodedCallId, muted: true}});
+
+    expect(onMuteChange).toHaveBeenCalledWith(callId, true);
+  });
+
+  it('ignores events when decoded actorId does not end with agentId', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    muteHandler({data: {actorId: btoa('other-agent'), callId: btoa('call-1'), muted: true}});
+
+    expect(onMuteChange).not.toHaveBeenCalled();
+  });
+
+  it('ignores events with missing payload fields', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    muteHandler({data: {actorId: btoa(agentId), callId: btoa('call-1')}});
+
+    expect(onMuteChange).not.toHaveBeenCalled();
+  });
+
+  it('unsubscribes and removes Mercury listeners', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const muteHandler = mercury.on.mock.calls.find(([event]) => event === TELEPHONY_CALL_MUTED)![1];
+    const unmuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_UNMUTED
+    )![1];
+
+    sync.unsubscribe();
+
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_MUTED, muteHandler);
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_UNMUTED, unmuteHandler);
+    expect(sync.isSubscribed()).toBe(false);
+  });
+
+  it('does not subscribe when mercury is unavailable', () => {
+    sync = new WxAppTelephonyMercurySync({internal: {}} as never);
+    sync.subscribe(agentId, onMuteChange);
+
+    expect(sync.isSubscribed()).toBe(false);
+    expect(onMuteChange).not.toHaveBeenCalled();
+  });
+
+  it('invokes callback with muted false on unmuted Mercury event', () => {
+    const callId = 'prefix:call-half-1';
+    const encodedCallId = btoa(callId);
+    const encodedActorId = btoa(`some-prefix-${agentId}`);
+
+    sync.subscribe(agentId, onMuteChange);
+    const unmuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_UNMUTED
+    )![1];
+    unmuteHandler({data: {actorId: encodedActorId, callId: encodedCallId, muted: false}});
+
+    expect(onMuteChange).toHaveBeenCalledWith(callId, false);
+  });
+
+  it('resubscribe replaces previous Mercury listeners', () => {
+    sync.subscribe(agentId, onMuteChange);
+    const firstMuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_MUTED
+    )![1];
+    const firstUnmuteHandler = mercury.on.mock.calls.find(
+      ([event]) => event === TELEPHONY_CALL_UNMUTED
+    )![1];
+    expect(mercury.on).toHaveBeenCalledTimes(2);
+
+    const secondHandler = jest.fn();
+    sync.subscribe(agentId, secondHandler);
+
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_MUTED, firstMuteHandler);
+    expect(mercury.off).toHaveBeenCalledWith(TELEPHONY_CALL_UNMUTED, firstUnmuteHandler);
+    expect(mercury.on).toHaveBeenCalledTimes(4);
+  });
+});

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

@@ -0,0 +1,85 @@
+import {parseAgentConfigs} from '../../../../../src/services/config/Util';
+import {AuxCode, DesktopProfileResponse} from '../../../../../src/services/config/types';
+
+const baseAgentProfile: DesktopProfileResponse = {
+  timeoutDesktopInactivityCustomEnabled: false,
+  timeoutDesktopInactivityMins: 10,
+  accessWrapUpCode: 'ALL',
+  wrapUpCodes: [],
+  accessIdleCode: 'ALL',
+  idleCodes: [],
+  autoWrapUp: false,
+  autoWrapAfterSeconds: 30,
+  lastAgentRouting: false,
+  allowAutoWrapUpExtension: false,
+  outdialEnabled: true,
+  dialPlanEnabled: false,
+  agentAvailableAfterOutdial: true,
+  outdialEntryPointId: 'ep-1',
+  consultToQueue: false,
+  viewableStatistics: {agentStats: false},
+  addressBookId: 'ab-1',
+  outdialANIId: 'ani-1',
+  loginVoiceOptions: [],
+  dialPlans: [],
+  agentDNValidation: 'PROVISIONED_VALUE',
+  accessQueue: 'SPECIFIC',
+  accessEntryPoint: 'NONE',
+  accessBuddyTeam: 'ALL',
+} as DesktopProfileResponse;
+
+const baseProfileData = {
+  userData: {
+    ciUserId: 'agent-1',
+    firstName: 'Jane',
+    lastName: 'Agent',
+    email: 'jane@example.com',
+    agentProfileId: 'profile-1',
+    skillProfileId: 'skill-1',
+    siteId: 'site-1',
+    dbId: 'db-1',
+    deafultDialledNumber: '+15551234567',
+    id: 'user-1',
+    teamIds: ['team-1'],
+  },
+  teamData: [{id: 'team-1', name: 'Support'}],
+  tenantData: {
+    timeoutDesktopInactivityEnabled: false,
+    timeoutDesktopInactivityMins: 15,
+    forceDefaultDn: false,
+    dnDefaultRegex: '',
+    dnOtherRegex: '',
+    outdialEnabled: true,
+    endCallEnabled: true,
+    endConsultEnabled: true,
+    callVariablesSuppressed: false,
+    privacyShieldVisible: false,
+  },
+  orgInfoData: {
+    tenantId: 'tenant-1',
+    timezone: 'UTC',
+    environment: 'produs1',
+  },
+  auxCodes: [] as AuxCode[],
+  orgSettingsData: {
+    campaignManagerEnabled: false,
+    webRtcEnabled: true,
+    maskSensitiveData: false,
+  },
+  agentProfileData: baseAgentProfile,
+  dialPlanData: [],
+  urlMapping: [],
+  multimediaProfileId: 'mm-1',
+  aiFeatureFlags: {data: []},
+};
+
+describe('parseAgentConfigs collaboration access fields', () => {
+  it('maps Desktop Profile collaboration access flags onto Profile', () => {
+    const profile = parseAgentConfigs(baseProfileData);
+
+    expect(profile.allowConsultToQueue).toBe(false);
+    expect(profile.accessQueue).toBe('SPECIFIC');
+    expect(profile.accessEntryPoint).toBe('NONE');
+    expect(profile.accessBuddyTeam).toBe('ALL');
+  });
+});

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

@@ -66,7 +66,6 @@ describe('AgentConfigService', () => {
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching user data using CI', {
         module: CONFIG_FILE_NAME,
         method: 'getUserUsingCI',
@@ -124,7 +123,6 @@ describe('AgentConfigService', () => {
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching desktop profile', {
         module: CONFIG_FILE_NAME,
         method: 'getDesktopProfileById',
@@ -183,7 +181,6 @@ describe('AgentConfigService', () => {
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching list of teams', {
         module: CONFIG_FILE_NAME,
         method: 'getListOfTeams',
@@ -263,11 +260,10 @@ describe('AgentConfigService', () => {
 
       expect(mockWebexRequest.request).toHaveBeenCalledWith({
         service: mockWccAPIURL,
-        resource: `organization/${mockOrgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}&filter=id=in=(${filter})&attributes=${attributes}`,
+        resource: `organization/${mockOrgId}/v2/auxiliary-code?page=${page}&pageSize=${pageSize}&filter=id=in=(${filter})&attributes=${attributes}&desktopProfileFilter=true`,
         method: 'GET',
       });
       expect(result).toEqual(mockResponse.body);
-
       expect(LoggerProxy.info).toHaveBeenCalledWith('Fetching list of aux codes', {
         module: CONFIG_FILE_NAME,
         method: 'getListOfAuxCodes',
@@ -490,6 +486,49 @@ describe('AgentConfigService', () => {
     });
   });
 
+  describe('getAIFeatureFlags', () => {
+    it('should return AI feature flags successfully', async () => {
+      const mockResponse = {
+        statusCode: 200,
+        body: {
+          data: [{realtimeTranscripts: {enable: true}}],
+        },
+      };
+      mockWebexRequest.request.mockResolvedValue(mockResponse);
+
+      const result = await agentConfigService.getAIFeatureFlags(mockOrgId);
+      expect(result).toEqual(mockResponse.body);
+      expect(LoggerProxy.log).toHaveBeenCalledWith('getAIFeatureFlags api success.', {
+        module: CONFIG_FILE_NAME,
+        method: 'getAIFeatureFlags',
+      });
+    });
+
+    it('should throw an error if API call returns non-200 status code', async () => {
+      const mockError = {statusCode: 500};
+      mockWebexRequest.request.mockResolvedValue(mockError);
+
+      await expect(agentConfigService.getAIFeatureFlags(mockOrgId)).rejects.toThrow(
+        'API call failed with 500'
+      );
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        'getAIFeatureFlags API call failed with Error: API call failed with 500',
+        {module: CONFIG_FILE_NAME, method: 'getAIFeatureFlags'}
+      );
+    });
+
+    it('should handle network errors gracefully', async () => {
+      const networkError = new Error('Network Error');
+      mockWebexRequest.request.mockRejectedValue(networkError);
+
+      await expect(agentConfigService.getAIFeatureFlags(mockOrgId)).rejects.toThrow('Network Error');
+      expect(LoggerProxy.error).toHaveBeenCalledWith(
+        'getAIFeatureFlags API call failed with Error: Network Error',
+        {module: CONFIG_FILE_NAME, method: 'getAIFeatureFlags'}
+      );
+    });
+  });
+
   describe(`getDialPlanData`, () => {
     it('should return dial plan data successfully', async () => {
       const mockResponse = {statusCode: 200, body: {data: {}}}; // Adjust data accordingly
@@ -667,6 +706,32 @@ describe('AgentConfigService', () => {
   });
 
   describe('getAgentConfig', () => {
+    const mockTeamData = [
+      {id: 'team1', name: 'Support Team'},
+      {id: 'team2', name: 'Sales Team'},
+    ];
+
+    const mockOrgInfo = {
+      tenantId: 'tenant123',
+      timezone: 'GMT',
+      environment: 'produs1',
+    };
+
+    const mockSiteInfo = {
+      id: 'c6a5451f-5ba7-49a1-aee8-fbef70c19ece',
+      name: 'Site-1',
+      multimediaProfileId: 'c5888e6f-5661-4871-9936-cbcec7658d41',
+    };
+
+    const mockURLMapping = [
+      {key: 'ACQUEON_API_URL', url: 'https://api.example.com'},
+      {key: 'ACQUEON_CONSOLE_URL', url: 'https://console.example.com'},
+    ];
+
+    const mockAIFeatureFlags = {
+      data: [{realtimeTranscripts: {enable: true}}],
+    };
+
     beforeEach(() => {
       jest.clearAllMocks();
     });
@@ -681,7 +746,7 @@ describe('AgentConfigService', () => {
         agentProfileId: 'profile123',
         siteId: 'site789',
         dbId: 'db123',
-        defaultDialledNumber: '1234567890',
+        deafultDialledNumber: '1234567890',
         id: 'user001',
         teamIds: ['team1', 'team2'],
       };
@@ -718,6 +783,7 @@ describe('AgentConfigService', () => {
       const mockOrgInfo = {
         tenantId: 'tenant123',
         timezone: 'GMT',
+        environment: 'produs1',
       };
 
       const mockOrgSettings = {
@@ -726,12 +792,6 @@ describe('AgentConfigService', () => {
         maskSensitiveData: false,
       };
 
-      const mockSiteInfo = {
-        id: 'c6a5451f-5ba7-49a1-aee8-fbef70c19ece',
-        name: 'Site-1',
-        multimediaProfileId: 'c5888e6f-5661-4871-9936-cbcec7658d41',
-      };
-
       const mockTenantData = {
         timeoutDesktopInactivityEnabled: false,
         timeoutDesktopInactivityMins: 15,
@@ -745,15 +805,13 @@ describe('AgentConfigService', () => {
         callVariablesSuppressed: false,
       };
 
-      const mockURLMapping = [
-        {key: 'ACQUEON_API_URL', url: 'https://api.example.com'},
-        {key: 'ACQUEON_CONSOLE_URL', url: 'https://console.example.com'},
-      ];
-
       const mockAuxCodes = [
         {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);
@@ -762,6 +820,7 @@ describe('AgentConfigService', () => {
       agentConfigService.getSiteInfo = jest.fn().mockResolvedValue(mockSiteInfo);
       agentConfigService.getTenantData = jest.fn().mockResolvedValue(mockTenantData);
       agentConfigService.getURLMapping = jest.fn().mockResolvedValue(mockURLMapping);
+      agentConfigService.getAIFeatureFlags = jest.fn().mockResolvedValue(mockAIFeatureFlags);
       agentConfigService.getAllAuxCodes = jest.fn().mockResolvedValue(mockAuxCodes);
       agentConfigService.getDesktopProfileById = jest.fn().mockResolvedValue(mockAgentProfile);
       agentConfigService.getDialPlanData = jest.fn().mockResolvedValue(mockDialPlanData);
@@ -801,6 +860,7 @@ describe('AgentConfigService', () => {
         dialPlanData: mockDialPlanData,
         urlMapping: mockURLMapping,
         multimediaProfileId: mockSiteInfo.multimediaProfileId,
+        aiFeatureFlags: mockAIFeatureFlags,
       });
     });
 
@@ -815,7 +875,7 @@ describe('AgentConfigService', () => {
         skillProfileId: 'skillProfile456',
         siteId: 'site789',
         dbId: 'db123',
-        defaultDialledNumber: '1234567890',
+        deafultDialledNumber: '1234567890',
         id: 'user001',
         teamIds: ['team1', 'team2'],
       };
@@ -857,6 +917,7 @@ describe('AgentConfigService', () => {
       const mockOrgInfo = {
         tenantId: 'tenant123',
         timezone: 'GMT',
+        environment: 'produs1',
       };
 
       const mockOrgSettings = {
@@ -865,12 +926,6 @@ describe('AgentConfigService', () => {
         maskSensitiveData: true,
       };
 
-      const mockSiteInfo = {
-        id: 'c6a5451f-5ba7-49a1-aee8-fbef70c19ece',
-        name: 'Site-1',
-        multimediaProfileId: 'c5888e6f-5661-4871-9936-cbcec7658d41',
-      };
-
       const mockTenantData = {
         timeoutDesktopInactivityEnabled: true,
         timeoutDesktopInactivityMins: 15,
@@ -885,15 +940,13 @@ describe('AgentConfigService', () => {
         lostConnectionRecoveryTimeout: 30,
       };
 
-      const mockURLMapping = [
-        {key: 'ACQUEON_API_URL', url: 'https://api.example.com'},
-        {key: 'ACQUEON_CONSOLE_URL', url: 'https://console.example.com'},
-      ];
-
       const mockAuxCodes = [
         {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);
@@ -902,6 +955,7 @@ describe('AgentConfigService', () => {
       agentConfigService.getSiteInfo = jest.fn().mockResolvedValue(mockSiteInfo);
       agentConfigService.getTenantData = jest.fn().mockResolvedValue(mockTenantData);
       agentConfigService.getURLMapping = jest.fn().mockResolvedValue(mockURLMapping);
+      agentConfigService.getAIFeatureFlags = jest.fn().mockResolvedValue(mockAIFeatureFlags);
       agentConfigService.getAllAuxCodes = jest.fn().mockResolvedValue(mockAuxCodes);
       agentConfigService.getDesktopProfileById = jest.fn().mockResolvedValue(mockAgentProfile);
       agentConfigService.getDialPlanData = jest.fn().mockResolvedValue(mockDialPlanData);
@@ -941,6 +995,7 @@ describe('AgentConfigService', () => {
         dialPlanData: mockDialPlanData,
         urlMapping: mockURLMapping,
         multimediaProfileId: mockSiteInfo.multimediaProfileId,
+        aiFeatureFlags: mockAIFeatureFlags,
       });
     });
 
@@ -952,6 +1007,7 @@ describe('AgentConfigService', () => {
       agentConfigService.getOrganizationSetting = jest.fn().mockResolvedValue({});
       agentConfigService.getTenantData = jest.fn().mockResolvedValue({});
       agentConfigService.getURLMapping = jest.fn().mockResolvedValue({});
+      agentConfigService.getAIFeatureFlags = jest.fn().mockResolvedValue({data: []});
       agentConfigService.getAllAuxCodes = jest.fn().mockResolvedValue({});
       agentConfigService.getDesktopProfileById = jest.fn().mockResolvedValue({});
       agentConfigService.getDialPlanData = jest.fn().mockResolvedValue({});