@webex/contact-center 3.9.0-next.9 → 3.10.0-next.1

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

@@ -75,6 +75,9 @@ describe('Task', () => {
       wrapup: jest.fn().mockResolvedValue({}),
       pauseRecording: jest.fn().mockResolvedValue({}),
       resumeRecording: jest.fn().mockResolvedValue({}),
+      consultConference: jest.fn().mockResolvedValue({}),
+      exitConference: jest.fn().mockResolvedValue({}),
+      conferenceTransfer: jest.fn().mockResolvedValue({}),
     };
 
     mockMetricsManager = {
@@ -214,7 +217,7 @@ describe('Task', () => {
   });
 
   describe('updateTaskData cases', () => {
-    it('test updating the task data by overwrite', async () => {
+    it('updates the task data by overwrite', async () => {
       const newData = {
         type: CC_EVENTS.AGENT_CONTACT_ASSIGNED,
         agentId: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
@@ -263,12 +266,12 @@ describe('Task', () => {
       expect(task.data).toEqual(newData);
     });
 
-    it('test updating the task data by merging', async () => {
+    it('updates the task data by merging with key removal', async () => {
       const newData = {
-        // ...taskDataMock, // Purposefully omit this to test scenario when other keys isn't present
+        // Purposefully omit other keys to test remove and merge behavior
         isConsulting: true, // Add a new custom key to test persistence
         interaction: {
-          // ...taskDataMock.interaction, // Purposefully omit this to test scenario when a nested key isn't present
+          // Purposefully omit other interaction keys to test removal
           media: {
             '58a45567-4e61-4f4b-a580-5bc86357bef0': {
               holdTimestamp: null,
@@ -295,11 +298,12 @@ describe('Task', () => {
         },
       };
 
+      // The reconcileData method removes keys from oldData that are not in newData
+      // This means only keys present in newData will remain in the final result
       const expectedData: TaskData = {
-        ...taskDataMock,
-        isConsulting: true,
+        isConsulting: true, // New key is added
         interaction: {
-          ...taskDataMock.interaction,
+          // Only the media key from newData.interaction remains
           media: {
             '58a45567-4e61-4f4b-a580-5bc86357bef0': {
               holdTimestamp: null,
@@ -332,6 +336,60 @@ describe('Task', () => {
 
       expect(task.data).toEqual(expectedData);
     });
+
+    it('updates the task data by merging and preserving existing keys', async () => {
+      const newData = {
+        ...taskDataMock, // Include all existing keys to test merge without removal
+        isConsulting: true, // Add a new custom key
+        interaction: {
+          ...taskDataMock.interaction, // Include existing interaction data
+          media: {
+            ...taskDataMock.interaction.media, // Include existing media
+            '58a45567-4e61-4f4b-a580-5bc86357bef0': {
+              holdTimestamp: null,
+              isHold: true,
+              mType: 'consult',
+              mediaMgr: 'callmm',
+              mediaResourceId: '58a45567-4e61-4f4b-a580-5bc86357bef0',
+              mediaType: 'telephony',
+              participants: [
+                'f520d6b5-28ad-4f2f-b83e-781bb64af617',
+                '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+              ],
+            },
+          },
+        },
+      };
+
+      const expectedData: TaskData = {
+        ...taskDataMock,
+        isConsulting: true,
+        interaction: {
+          ...taskDataMock.interaction,
+          media: {
+            ...taskDataMock.interaction.media,
+            '58a45567-4e61-4f4b-a580-5bc86357bef0': {
+              holdTimestamp: null,
+              isHold: true,
+              mType: 'consult',
+              mediaMgr: 'callmm',
+              mediaResourceId: '58a45567-4e61-4f4b-a580-5bc86357bef0',
+              mediaType: 'telephony',
+              participants: [
+                'f520d6b5-28ad-4f2f-b83e-781bb64af617',
+                '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
+              ],
+            },
+          },
+        },
+      };
+
+      expect(task.data).toEqual(taskDataMock);
+      const shouldOverwrite = false;
+      task.updateTaskData(newData, shouldOverwrite);
+
+      expect(task.data).toEqual(expectedData);
+    });
   });
 
   it('should accept a task and answer call when using BROWSER login option', async () => {
@@ -567,6 +625,40 @@ describe('Task', () => {
     );
   });
 
+  it('should hold the task with custom mediaResourceId and return the expected response', async () => {
+    const customMediaResourceId = 'custom-media-resource-id-123';
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.hold.mockResolvedValue(expectedResponse);
+
+    const response = await task.hold(customMediaResourceId);
+
+    expect(contactMock.hold).toHaveBeenCalledWith({
+      interactionId: taskId,
+      data: {mediaResourceId: customMediaResourceId},
+    });
+    expect(response).toEqual(expectedResponse);
+    expect(loggerInfoSpy).toHaveBeenCalledWith(`Holding task`, {
+      module: TASK_FILE,
+      method: 'hold',
+      interactionId: task.data.interactionId,
+    });
+    expect(loggerLogSpy).toHaveBeenCalledWith(`Task placed on hold successfully`, {
+      module: TASK_FILE,
+      method: 'hold',
+      interactionId: task.data.interactionId,
+    });
+    expect(mockMetricsManager.trackEvent).toHaveBeenNthCalledWith(
+      1,
+      METRIC_EVENT_NAMES.TASK_HOLD_SUCCESS,
+      {
+        ...MetricsManager.getCommonTrackingFieldForAQMResponse(expectedResponse),
+        taskId: taskDataMock.interactionId,
+        mediaResourceId: customMediaResourceId,
+      },
+      ['operational', 'behavioral']
+    );
+  });
+
   it('should handle errors in hold method', async () => {
     const error = {details: (global as any).makeFailure('Hold Failed')};
     contactMock.hold.mockImplementation(() => {
@@ -596,6 +688,36 @@ describe('Task', () => {
     );
   });
 
+  it('should handle errors in hold method with custom mediaResourceId', async () => {
+    const customMediaResourceId = 'custom-media-resource-id-456';
+    const error = {details: (global as any).makeFailure('Hold Failed with custom mediaResourceId')};
+    contactMock.hold.mockImplementation(() => {
+      throw error;
+    });
+
+    await expect(task.hold(customMediaResourceId)).rejects.toThrow(error.details.data.reason);
+    expect(generateTaskErrorObjectSpy).toHaveBeenCalledWith(error, 'hold', TASK_FILE);
+    const expectedTaskErrorFieldsHold = {
+      trackingId: error.details.trackingId,
+      errorMessage: error.details.data.reason,
+      errorType: '',
+      errorData: '',
+      reasonCode: 0,
+    };
+    expect(mockMetricsManager.trackEvent).toHaveBeenNthCalledWith(
+      1,
+      METRIC_EVENT_NAMES.TASK_HOLD_FAILED,
+      {
+        taskId: taskDataMock.interactionId,
+        mediaResourceId: customMediaResourceId,
+        error: error.toString(),
+        ...expectedTaskErrorFieldsHold,
+        ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details),
+      },
+      ['operational', 'behavioral']
+    );
+  });
+
   it('should resume the task and return the expected response', async () => {
     const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
     contactMock.unHold.mockResolvedValue(expectedResponse);
@@ -620,6 +742,29 @@ describe('Task', () => {
     );
   });
 
+  it('should resume the task with custom mediaResourceId and return the expected response', async () => {
+    const customMediaResourceId = 'custom-media-resource-id-789';
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.unHold.mockResolvedValue(expectedResponse);
+    const response = await task.resume(customMediaResourceId);
+    expect(contactMock.unHold).toHaveBeenCalledWith({
+      interactionId: taskId,
+      data: {mediaResourceId: customMediaResourceId},
+    });
+    expect(response).toEqual(expectedResponse);
+    expect(mockMetricsManager.trackEvent).toHaveBeenNthCalledWith(
+      1,
+      METRIC_EVENT_NAMES.TASK_RESUME_SUCCESS,
+      {
+        taskId: taskDataMock.interactionId,
+        mainInteractionId: taskDataMock.interaction.mainInteractionId,
+        mediaResourceId: customMediaResourceId,
+        ...MetricsManager.getCommonTrackingFieldForAQMResponse(expectedResponse),
+      },
+      ['operational', 'behavioral']
+    );
+  });
+
   it('should handle errors in resume method', async () => {
     const error = {details: (global as any).makeFailure('Resume Failed')};
     contactMock.unHold.mockImplementation(() => {
@@ -651,6 +796,36 @@ describe('Task', () => {
     );
   });
 
+  it('should handle errors in resume method with custom mediaResourceId', async () => {
+    const customMediaResourceId = 'custom-media-resource-id-999';
+    const error = {details: (global as any).makeFailure('Resume Failed with custom mediaResourceId')};
+    contactMock.unHold.mockImplementation(() => {
+      throw error;
+    });
+
+    await expect(task.resume(customMediaResourceId)).rejects.toThrow(error.details.data.reason);
+    expect(generateTaskErrorObjectSpy).toHaveBeenCalledWith(error, 'resume', TASK_FILE);
+    const expectedTaskErrorFieldsResume = {
+      trackingId: error.details.trackingId,
+      errorMessage: error.details.data.reason,
+      errorType: '',
+      errorData: '',
+      reasonCode: 0,
+    };
+    expect(mockMetricsManager.trackEvent).toHaveBeenNthCalledWith(
+      1,
+      METRIC_EVENT_NAMES.TASK_RESUME_FAILED,
+      {
+        taskId: taskDataMock.interactionId,
+        mainInteractionId: taskDataMock.interaction.mainInteractionId,
+        mediaResourceId: customMediaResourceId,
+        ...expectedTaskErrorFieldsResume,
+        ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details),
+      },
+      ['operational', 'behavioral']
+    );
+  });
+
   it('should initiate a consult call and return the expected response', async () => {
     const consultPayload = {
       to: '1234',
@@ -671,8 +846,8 @@ describe('Task', () => {
     expect(loggerLogSpy).toHaveBeenCalledWith(`Consult started successfully to ${consultPayload.to}`, {
       module: TASK_FILE,
       method: 'consult',
-      trackingId: expectedResponse.trackingId,
       interactionId: task.data.interactionId,
+      trackingId: '1234',
     });
     expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
       METRIC_EVENT_NAMES.TASK_CONSULT_START_SUCCESS,
@@ -1575,4 +1750,180 @@ describe('Task', () => {
       });
     });
   });
+
+  describe('Conference methods', () => {
+    beforeEach(() => {
+      contactMock = {
+        consultConference: jest.fn(),
+        exitConference: jest.fn(),
+        conferenceTransfer: jest.fn(),
+      };
+
+      // Re-setup the getDestinationAgentId spy for conference methods
+      getDestinationAgentIdSpy = jest
+        .spyOn(Utils, 'getDestinationAgentId')
+        .mockReturnValue(taskDataMock.destAgentId);
+
+
+      task = new Task(contactMock, webCallingService, taskDataMock, {
+        wrapUpProps: { wrapUpReasonList: [] },
+        autoWrapEnabled: false,
+        autoWrapAfterSeconds: 0
+      }, taskDataMock.agentId);
+    });
+
+    describe('consultConference', () => {
+
+      it('should successfully start conference and emit event', async () => {
+        const mockResponse = {
+          trackingId: 'test-tracking-id',
+          interactionId: taskId,
+        };
+        contactMock.consultConference.mockResolvedValue(mockResponse);
+        
+
+        const result = await task.consultConference();
+
+        expect(contactMock.consultConference).toHaveBeenCalledWith({
+          interactionId: taskId,
+          data: {
+            agentId: taskDataMock.agentId, // From task data agent ID
+            to: taskDataMock.destAgentId, // From getDestinationAgentId() using task participants
+            destinationType: 'agent', // From consultation data
+          },
+        });
+        expect(result).toEqual(mockResponse);
+        expect(LoggerProxy.info).toHaveBeenCalledWith(`Initiating consult conference to ${taskDataMock.destAgentId}`, {
+          module: TASK_FILE,
+          method: 'consultConference',
+          interactionId: taskId,
+        });
+        expect(LoggerProxy.log).toHaveBeenCalledWith('Consult conference started successfully', {
+          module: TASK_FILE,
+          method: 'consultConference',
+          interactionId: taskId,
+        });
+      });
+
+      it('should handle basic validation scenarios', async () => {
+        // Agent Desktop logic validates data structure but not participant availability
+        // This test confirms the method works with the Agent Desktop data flow
+        const mockResponse = {
+          trackingId: 'test-tracking-validation',
+          interactionId: taskId,
+        };
+        contactMock.consultConference.mockResolvedValue(mockResponse);
+
+        const result = await task.consultConference();
+        expect(result).toEqual(mockResponse);
+      });
+
+      it('should handle and rethrow contact method errors', async () => {
+        const mockError = new Error('Conference start failed');
+        contactMock.consultConference.mockRejectedValue(mockError);
+        generateTaskErrorObjectSpy.mockReturnValue(mockError);
+
+        await expect(task.consultConference()).rejects.toThrow('Conference start failed');
+        expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to start consult conference', {
+          module: TASK_FILE,
+          method: 'consultConference',
+          interactionId: taskId,
+        });
+      });
+    });
+
+    describe('exitConference', () => {
+      it('should successfully end conference and emit event', async () => {
+        const mockResponse = {
+          trackingId: 'test-tracking-id-end',
+          interactionId: taskId,
+        };
+        contactMock.exitConference.mockResolvedValue(mockResponse);
+
+        const result = await task.exitConference();
+
+        expect(contactMock.exitConference).toHaveBeenCalledWith({
+          interactionId: taskId,
+        });
+        expect(result).toEqual(mockResponse);
+        expect(LoggerProxy.info).toHaveBeenCalledWith('Exiting consult conference', {
+          module: TASK_FILE,
+          method: 'exitConference',
+          interactionId: taskId,
+        });
+        expect(LoggerProxy.log).toHaveBeenCalledWith('Consult conference exited successfully', {
+          module: TASK_FILE,
+          method: 'exitConference',
+          interactionId: taskId,
+        });
+      });
+
+      it('should throw error for invalid interaction ID', async () => {
+        task.data.interactionId = '';
+
+        await expect(task.exitConference()).rejects.toThrow('Error while performing exitConference');
+        expect(contactMock.exitConference).not.toHaveBeenCalled();
+      });
+
+      it('should handle and rethrow contact method errors', async () => {
+        const mockError = new Error('Conference end failed');
+        contactMock.exitConference.mockRejectedValue(mockError);
+        generateTaskErrorObjectSpy.mockReturnValue(mockError);
+
+        await expect(task.exitConference()).rejects.toThrow('Conference end failed');
+        expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to exit consult conference', {
+          module: TASK_FILE,
+          method: 'exitConference',
+          interactionId: taskId,
+        });
+      });
+    });
+
+    describe('transferConference', () => {
+      it('should successfully transfer conference', async () => {
+        const mockResponse = {
+          trackingId: 'test-tracking-id-transfer',
+          interactionId: taskId,
+        };
+        contactMock.conferenceTransfer.mockResolvedValue(mockResponse);
+        
+        const result = await task.transferConference();
+
+        expect(contactMock.conferenceTransfer).toHaveBeenCalledWith({
+          interactionId: taskId,
+        });
+        expect(result).toEqual(mockResponse);
+        expect(LoggerProxy.info).toHaveBeenCalledWith('Transferring conference', {
+          module: TASK_FILE,
+          method: 'transferConference',
+          interactionId: taskId,
+        });
+        expect(LoggerProxy.log).toHaveBeenCalledWith('Conference transferred successfully', {
+          module: TASK_FILE,
+          method: 'transferConference',
+          interactionId: taskId,
+        });
+      });
+
+      it('should throw error for invalid interaction ID', async () => {
+        task.data.interactionId = '';
+
+        await expect(task.transferConference()).rejects.toThrow('Error while performing transferConference');
+        expect(contactMock.conferenceTransfer).not.toHaveBeenCalled();
+      });
+
+      it('should handle and rethrow contact method errors', async () => {
+        const mockError = new Error('Conference transfer failed');
+        contactMock.conferenceTransfer.mockRejectedValue(mockError);
+        generateTaskErrorObjectSpy.mockReturnValue(mockError);
+
+        await expect(task.transferConference()).rejects.toThrow('Conference transfer failed');
+        expect(LoggerProxy.error).toHaveBeenCalledWith('Failed to transfer conference', {
+          module: TASK_FILE,
+          method: 'transferConference',
+          interactionId: taskId,
+        });
+      });
+    });
+  });
 });