@webex/contact-center 3.10.0-next.8 → 3.10.0-wxc-disconnect.1

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

@@ -39,8 +39,7 @@ describe('Task', () => {
   let loggerInfoSpy;
   let loggerLogSpy;
   let loggerErrorSpy;
-  let calculateDestAgentIdSpy;
-  let calculateDestTypeSpy;
+  let getDestinationAgentIdSpy;
 
   const taskId = '0ae913a4-c857-4705-8d49-76dd3dde75e4';
   const mockTrack = {} as MediaStreamTrack;
@@ -120,32 +119,6 @@ describe('Task', () => {
       interaction: {
         mediaType: 'telephony',
         mainInteractionId: taskId,
-        participants: {
-          '723a8ffb-a26e-496d-b14a-ff44fb83b64f': {
-            pType: 'Agent',
-            type: 'AGENT',
-            id: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
-            hasLeft: false,
-            hasJoined: true,
-            isWrapUp: false,
-          },
-          'f520d6b5-28ad-4f2f-b83e-781bb64af617': {
-            pType: 'Agent',
-            type: 'AGENT',
-            id: 'f520d6b5-28ad-4f2f-b83e-781bb64af617',
-            hasLeft: false,
-            hasJoined: true,
-            isWrapUp: false,
-          },
-          'ebeb893b-ba67-4f36-8418-95c7492b28c2': {
-            pType: 'Agent',
-            type: 'AGENT',
-            id: 'ebeb893b-ba67-4f36-8418-95c7492b28c2',
-            hasLeft: false,
-            hasJoined: true,
-            isWrapUp: false,
-          },
-        },
         media: {
           '58a45567-4e61-4f4b-a580-5bc86357bef0': {
             holdTimestamp: null,
@@ -172,18 +145,13 @@ describe('Task', () => {
       },
     };
 
-    // Mock calculateDestAgentId to return the expected destination agent
-    calculateDestAgentIdSpy = jest.spyOn(Utils, 'calculateDestAgentId').mockReturnValue(taskDataMock.destAgentId);
-    
-    // Mock calculateDestType to return 'agent' by default
-    calculateDestTypeSpy = jest.spyOn(Utils, 'calculateDestType').mockReturnValue('agent');
+    // Mock destination agent id resolution from participants
+    getDestinationAgentIdSpy = jest
+      .spyOn(Utils, 'getDestinationAgentId')
+      .mockReturnValue(taskDataMock.destAgentId);
 
-    // Create an instance of Task with wrapupData and agentId
-    task = new Task(contactMock, webCallingService, taskDataMock, {
-      wrapUpProps: { wrapUpReasonList: [] },
-      autoWrapEnabled: false,
-      autoWrapAfterSeconds: 0
-    }, taskDataMock.agentId);
+    // Create an instance of Task
+    task = new Task(contactMock, webCallingService, taskDataMock);
 
     // Mock navigator.mediaDevices
     global.navigator.mediaDevices = {
@@ -249,7 +217,7 @@ describe('Task', () => {
   });
 
   describe('updateTaskData cases', () => {
-    it('updates the task data by overwrite', async () => {
+    it('test updating the task data by overwrite', async () => {
       const newData = {
         type: CC_EVENTS.AGENT_CONTACT_ASSIGNED,
         agentId: '723a8ffb-a26e-496d-b14a-ff44fb83b64f',
@@ -298,12 +266,12 @@ describe('Task', () => {
       expect(task.data).toEqual(newData);
     });
 
-    it('updates the task data by merging with key removal', async () => {
+    it('test updating the task data by merging', async () => {
       const newData = {
-        // Purposefully omit other keys to test remove and merge behavior
+        // ...taskDataMock, // Purposefully omit this to test scenario when other keys isn't present
         isConsulting: true, // Add a new custom key to test persistence
         interaction: {
-          // Purposefully omit other interaction keys to test removal
+          // ...taskDataMock.interaction, // Purposefully omit this to test scenario when a nested key isn't present
           media: {
             '58a45567-4e61-4f4b-a580-5bc86357bef0': {
               holdTimestamp: null,
@@ -330,12 +298,11 @@ 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 = {
-        isConsulting: true, // New key is added
+        ...taskDataMock,
+        isConsulting: true,
         interaction: {
-          // Only the media key from newData.interaction remains
+          ...taskDataMock.interaction,
           media: {
             '58a45567-4e61-4f4b-a580-5bc86357bef0': {
               holdTimestamp: null,
@@ -368,60 +335,6 @@ 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 () => {
@@ -657,40 +570,6 @@ 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(() => {
@@ -720,36 +599,6 @@ 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);
@@ -774,29 +623,6 @@ 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(() => {
@@ -828,36 +654,6 @@ 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',
@@ -1025,16 +821,15 @@ describe('Task', () => {
     );
   });
 
-  it('should send DIALNUMBER when calculateDestType returns dialNumber during consultTransfer', async () => {
+  it('should send DIALNUMBER when task destinationType is DN during consultTransfer', async () => {
     const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
     contactMock.consultTransfer.mockResolvedValue(expectedResponse);
 
-    // Mock calculateDestType to return dialNumber
-    calculateDestTypeSpy.mockReturnValue(CONSULT_TRANSFER_DESTINATION_TYPE.DIALNUMBER);
+    // Ensure task data indicates DN scenario
+    task.data.destinationType = 'DN' as unknown as string;
 
     await task.consultTransfer();
 
-    expect(calculateDestTypeSpy).toHaveBeenCalledWith(taskDataMock.interaction, taskDataMock.agentId);
     expect(contactMock.consultTransfer).toHaveBeenCalledWith({
       interactionId: taskId,
       data: {
@@ -1044,16 +839,15 @@ describe('Task', () => {
     });
   });
 
-  it('should send ENTRYPOINT when calculateDestType returns entryPoint during consultTransfer', async () => {
+  it('should send ENTRYPOINT when task destinationType is EPDN during consultTransfer', async () => {
     const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
     contactMock.consultTransfer.mockResolvedValue(expectedResponse);
 
-    // Mock calculateDestType to return entryPoint
-    calculateDestTypeSpy.mockReturnValue(CONSULT_TRANSFER_DESTINATION_TYPE.ENTRYPOINT);
+    // Ensure task data indicates EP/EPDN scenario
+    task.data.destinationType = 'EPDN' as unknown as string;
 
     await task.consultTransfer();
 
-    expect(calculateDestTypeSpy).toHaveBeenCalledWith(taskDataMock.interaction, taskDataMock.agentId);
     expect(contactMock.consultTransfer).toHaveBeenCalledWith({
       interactionId: taskId,
       data: {
@@ -1063,16 +857,15 @@ describe('Task', () => {
     });
   });
 
-  it('should use AGENT when calculateDestType returns agent during consultTransfer', async () => {
+  it('should keep AGENT when task destinationType is neither DN nor EPDN/ENTRYPOINT', async () => {
     const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
     contactMock.consultTransfer.mockResolvedValue(expectedResponse);
 
-    // Mock calculateDestType to return agent (default behavior)
-    calculateDestTypeSpy.mockReturnValue(CONSULT_TRANSFER_DESTINATION_TYPE.AGENT);
+    // Ensure task data indicates non-DN and non-EP/EPDN scenario
+    task.data.destinationType = 'SOMETHING_ELSE' as unknown as string;
 
     await task.consultTransfer();
 
-    expect(calculateDestTypeSpy).toHaveBeenCalledWith(taskDataMock.interaction, taskDataMock.agentId);
     expect(contactMock.consultTransfer).toHaveBeenCalledWith({
       interactionId: taskId,
       data: {
@@ -1109,11 +902,7 @@ describe('Task', () => {
     const taskWithoutDestAgentId = new Task(contactMock, webCallingService, {
       ...taskDataMock,
       destAgentId: undefined,
-    }, {
-      wrapUpProps: { wrapUpReasonList: [] },
-      autoWrapEnabled: false,
-      autoWrapAfterSeconds: 0
-    }, taskDataMock.agentId);
+    });
 
     const queueConsultTransferPayload: ConsultTransferPayLoad = {
       to: 'some-queue-id',
@@ -1121,123 +910,61 @@ describe('Task', () => {
     };
 
     // For this negative case, ensure computed destination is empty
-    calculateDestAgentIdSpy.mockReturnValueOnce('');
+    getDestinationAgentIdSpy.mockReturnValueOnce('');
 
     await expect(
       taskWithoutDestAgentId.consultTransfer(queueConsultTransferPayload)
-    ).rejects.toThrow('No agent has accepted this queue consult yet');
+    ).rejects.toThrow('Error while performing consultTransfer');
   });
 
-  describe('consultTransfer', () => {
-    it('should successfully perform consult transfer with agent destination', async () => {
-      const expectedResponse: TaskResponse = {
-        data: {interactionId: taskId},
-        trackingId: 'test-tracking-id'
-      } as AgentContact;
-      contactMock.consultTransfer.mockResolvedValue(expectedResponse);
-      
-      calculateDestTypeSpy.mockReturnValue(CONSULT_TRANSFER_DESTINATION_TYPE.AGENT);
+  it('should handle errors in consult transfer', async () => {
+    const consultPayload = {
+      destination: '1234',
+      destinationType: DESTINATION_TYPE.AGENT,
+    };
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.consult.mockResolvedValue(expectedResponse);
 
-      const result = await task.consultTransfer();
+    const response = await task.consult(consultPayload);
 
-      expect(calculateDestAgentIdSpy).toHaveBeenCalledWith(taskDataMock.interaction, taskDataMock.agentId);
-      expect(calculateDestTypeSpy).toHaveBeenCalledWith(taskDataMock.interaction, taskDataMock.agentId);
-      expect(contactMock.consultTransfer).toHaveBeenCalledWith({
-        interactionId: taskId,
-        data: {
-          to: taskDataMock.destAgentId,
-          destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
-        },
-      });
-      expect(result).toEqual(expectedResponse);
-      expect(loggerInfoSpy).toHaveBeenCalledWith(
-        `Initiating consult transfer to ${taskDataMock.destAgentId}`,
-        {
-          module: TASK_FILE,
-          method: 'consultTransfer',
-          interactionId: taskId,
-        }
-      );
-      expect(loggerLogSpy).toHaveBeenCalledWith(
-        `Consult transfer completed successfully to ${taskDataMock.destAgentId}`,
-        {
-          module: TASK_FILE,
-          method: 'consultTransfer',
-          trackingId: expectedResponse.trackingId,
-          interactionId: taskId,
-        }
-      );
-    });
-
-    it('should track metrics on successful consult transfer', async () => {
-      const expectedResponse: TaskResponse = {
-        data: {interactionId: taskId},
-        trackingId: 'test-tracking-id'
-      } as AgentContact;
-      contactMock.consultTransfer.mockResolvedValue(expectedResponse);
-
-      await task.consultTransfer();
-
-      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
-        METRIC_EVENT_NAMES.TASK_TRANSFER_SUCCESS,
-        {
-          taskId: taskDataMock.interactionId,
-          destination: taskDataMock.destAgentId,
-          destinationType: 'agent',
-          isConsultTransfer: true,
-          ...MetricsManager.getCommonTrackingFieldForAQMResponse(expectedResponse),
-        },
-        ['operational', 'behavioral', 'business']
-      );
-    });
+    expect(contactMock.consult).toHaveBeenCalledWith({interactionId: taskId, data: consultPayload});
+    expect(response).toEqual(expectedResponse);
 
-    it('should throw error when no destination agent is found', async () => {
-      calculateDestAgentIdSpy.mockReturnValue('');
-      
-      await expect(task.consultTransfer()).rejects.toThrow('No agent has accepted this queue consult yet');
-      
-      expect(contactMock.consultTransfer).not.toHaveBeenCalled();
+    const error = {details: (global as any).makeFailure('Consult Transfer Failed')};
+    contactMock.consultTransfer.mockImplementation(() => {
+      throw error;
     });
 
-    it('should handle and rethrow contact method errors', async () => {
-      const mockError = new Error('Consult Transfer Failed');
-      contactMock.consultTransfer.mockRejectedValue(mockError);
-      generateTaskErrorObjectSpy.mockReturnValue(mockError);
-
-      await expect(task.consultTransfer()).rejects.toThrow('Consult Transfer Failed');
-      
-      expect(generateTaskErrorObjectSpy).toHaveBeenCalledWith(mockError, 'consultTransfer', TASK_FILE);
-      expect(mockMetricsManager.trackEvent).toHaveBeenCalledWith(
-        METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
-        expect.objectContaining({
-          taskId: taskDataMock.interactionId,
-          destination: taskDataMock.destAgentId,
-          destinationType: 'agent',
-          isConsultTransfer: true,
-          error: mockError.toString(),
-        }),
-        ['operational', 'behavioral', 'business']
-      );
-    });
-
-    it('should dynamically calculate destAgentId when not available', async () => {
-      const consultedAgentId = 'dynamic-agent-123';
-      calculateDestAgentIdSpy.mockReturnValue(consultedAgentId);
-      
-      const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
-      contactMock.consultTransfer.mockResolvedValue(expectedResponse);
-
-      await task.consultTransfer();
+    const consultTransferPayload: ConsultTransferPayLoad = {
+      to: '1234',
+      destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
+    };
 
-      expect(calculateDestAgentIdSpy).toHaveBeenCalledWith(taskDataMock.interaction, taskDataMock.agentId);
-      expect(contactMock.consultTransfer).toHaveBeenCalledWith({
-        interactionId: taskId,
-        data: {
-          to: consultedAgentId,
-          destinationType: 'agent',
-        },
-      });
-    });
+    await expect(task.consultTransfer(consultTransferPayload)).rejects.toThrow(
+      error.details.data.reason
+    );
+    expect(generateTaskErrorObjectSpy).toHaveBeenCalledWith(error, 'consultTransfer', TASK_FILE);
+    const expectedTaskErrorFieldsConsultTransfer = {
+      trackingId: error.details.trackingId,
+      errorMessage: error.details.data.reason,
+      errorType: '',
+      errorData: '',
+      reasonCode: 0,
+    };
+    expect(mockMetricsManager.trackEvent).toHaveBeenNthCalledWith(
+      2,
+      METRIC_EVENT_NAMES.TASK_TRANSFER_FAILED,
+      {
+        taskId: taskDataMock.interactionId,
+        destination: taskDataMock.destAgentId,
+        destinationType: CONSULT_TRANSFER_DESTINATION_TYPE.AGENT,
+        isConsultTransfer: true,
+        error: error.toString(),
+        ...expectedTaskErrorFieldsConsultTransfer,
+        ...MetricsManager.getCommonTrackingFieldForAQMResponseFailed(error.details),
+      },
+      ['operational', 'behavioral', 'business']
+    );
   });
 
   it('should do vteamTransfer if destinationType is queue and return the expected response', async () => {
@@ -1860,6 +1587,12 @@ describe('Task', () => {
         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,
@@ -1883,7 +1616,7 @@ describe('Task', () => {
           interactionId: taskId,
           data: {
             agentId: taskDataMock.agentId, // From task data agent ID
-            to: taskDataMock.destAgentId, // From calculateDestAgentId() using task participants
+            to: taskDataMock.destAgentId, // From getDestinationAgentId() using task participants
             destinationType: 'agent', // From consultation data
           },
         });
@@ -1925,166 +1658,6 @@ describe('Task', () => {
           interactionId: taskId,
         });
       });
-
-      it('should dynamically calculate destAgentId from participants when this.data.destAgentId is null', async () => {
-        // Simulate scenario where destAgentId is not preserved (e.g., after hold/unhold)
-        task.data.destAgentId = null;
-        
-        const consultedAgentId = 'consulted-agent-123';
-        calculateDestAgentIdSpy.mockReturnValue(consultedAgentId);
-        
-        const mockResponse = {
-          trackingId: 'test-tracking-dynamic',
-          interactionId: taskId,
-        };
-        contactMock.consultConference.mockResolvedValue(mockResponse);
-
-        const result = await task.consultConference();
-
-        // Verify calculateDestAgentId was called to dynamically calculate the destination
-        expect(calculateDestAgentIdSpy).toHaveBeenCalledWith(
-          taskDataMock.interaction,
-          taskDataMock.agentId
-        );
-
-        // Verify the conference was called with the dynamically calculated destAgentId
-        expect(contactMock.consultConference).toHaveBeenCalledWith({
-          interactionId: taskId,
-          data: {
-            agentId: taskDataMock.agentId,
-            to: consultedAgentId, // Dynamically calculated value
-            destinationType: 'agent',
-          },
-        });
-        expect(result).toEqual(mockResponse);
-      });
-
-      it('should throw error when no destination agent is found (queue consult not accepted)', async () => {
-        // Simulate queue consult scenario where no agent has accepted yet
-        calculateDestAgentIdSpy.mockReturnValue(''); // No agent found
-
-        await expect(task.consultConference()).rejects.toThrow('No agent has accepted this queue consult yet');
-        
-        // Verify the conference was NOT called
-        expect(contactMock.consultConference).not.toHaveBeenCalled();
-      });
-
-      it('should calculate destination type from participant type for regular agents', async () => {
-        const destAgentId = 'consulted-agent-456';
-        
-        calculateDestAgentIdSpy = jest.spyOn(Utils, 'calculateDestAgentId').mockReturnValue(destAgentId);
-        calculateDestTypeSpy = jest.spyOn(Utils, 'calculateDestType').mockReturnValue('agent');
-
-        const mockResponse = {trackingId: 'test-tracking-id', interactionId: taskId};
-        contactMock.consultConference.mockResolvedValue(mockResponse);
-
-        await task.consultConference();
-
-        expect(calculateDestTypeSpy).toHaveBeenCalledWith(
-          task.data.interaction,
-          taskDataMock.agentId
-        );
-
-        expect(contactMock.consultConference).toHaveBeenCalledWith({
-          interactionId: taskId,
-          data: {
-            agentId: taskDataMock.agentId,
-            to: destAgentId,
-            destinationType: 'agent',
-          },
-        });
-      });
-
-      it('should use DN destination type for dial number participants', async () => {
-        const destAgentId = 'dn-uuid-123';
-        
-        calculateDestAgentIdSpy = jest.spyOn(Utils, 'calculateDestAgentId').mockReturnValue(destAgentId);
-        calculateDestTypeSpy = jest.spyOn(Utils, 'calculateDestType').mockReturnValue('dialNumber');
-
-        const mockResponse = {trackingId: 'test-tracking-id-dn', interactionId: taskId};
-        contactMock.consultConference.mockResolvedValue(mockResponse);
-
-        await task.consultConference();
-
-        expect(contactMock.consultConference).toHaveBeenCalledWith({
-          interactionId: taskId,
-          data: {
-            agentId: taskDataMock.agentId,
-            to: destAgentId,
-            destinationType: 'dialNumber',
-          },
-        });
-      });
-
-      it('should use EpDn destination type for entry point dial number participants', async () => {
-        const destAgentId = 'epdn-uuid-456';
-        
-        calculateDestAgentIdSpy = jest.spyOn(Utils, 'calculateDestAgentId').mockReturnValue(destAgentId);
-        calculateDestTypeSpy = jest.spyOn(Utils, 'calculateDestType').mockReturnValue('entryPoint');
-
-        const mockResponse = {trackingId: 'test-tracking-id-epdn', interactionId: taskId};
-        contactMock.consultConference.mockResolvedValue(mockResponse);
-
-        await task.consultConference();
-
-        expect(contactMock.consultConference).toHaveBeenCalledWith({
-          interactionId: taskId,
-          data: {
-            agentId: taskDataMock.agentId,
-            to: destAgentId,
-            destinationType: 'entryPoint',
-          },
-        });
-      });
-
-      it('should fall back to task.data.destinationType when calculateDestType returns empty', async () => {
-        const destAgentId = 'consulted-agent-789';
-        
-        calculateDestAgentIdSpy = jest.spyOn(Utils, 'calculateDestAgentId').mockReturnValue(destAgentId);
-        calculateDestTypeSpy = jest.spyOn(Utils, 'calculateDestType').mockReturnValue(''); // No type found
-
-        task.data.destinationType = 'EPDN';
-
-        const mockResponse = {trackingId: 'test-tracking-id-fallback', interactionId: taskId};
-        contactMock.consultConference.mockResolvedValue(mockResponse);
-
-        await task.consultConference();
-
-        expect(contactMock.consultConference).toHaveBeenCalledWith({
-          interactionId: taskId,
-          data: {
-            agentId: taskDataMock.agentId,
-            to: destAgentId,
-            destinationType: 'EPDN', // Falls back to task.data.destinationType
-          },
-        });
-      });
-
-      it('should handle CBT scenarios with correct destination type', async () => {
-        const destAgentId = 'agent-cbt-uuid';
-        
-        calculateDestAgentIdSpy = jest.spyOn(Utils, 'calculateDestAgentId').mockReturnValue(destAgentId);
-        calculateDestTypeSpy = jest.spyOn(Utils, 'calculateDestType').mockReturnValue('dialNumber');
-
-        const mockResponse = {trackingId: 'test-tracking-id-cbt', interactionId: taskId};
-        contactMock.consultConference.mockResolvedValue(mockResponse);
-
-        await task.consultConference();
-
-        expect(calculateDestTypeSpy).toHaveBeenCalledWith(
-          task.data.interaction,
-          taskDataMock.agentId
-        );
-
-        expect(contactMock.consultConference).toHaveBeenCalledWith({
-          interactionId: taskId,
-          data: {
-            agentId: taskDataMock.agentId,
-            to: destAgentId,
-            destinationType: 'dialNumber', // dialNumber for CBT scenarios
-          },
-        });
-      });
     });
 
     describe('exitConference', () => {
@@ -2134,6 +1707,9 @@ describe('Task', () => {
       });
     });
 
+    // TODO: Uncomment this test section in future PR for Multi-Party Conference support (>3 participants)
+    // Conference transfer tests will be uncommented when implementing enhanced multi-party conference functionality
+    /*
     describe('transferConference', () => {
       it('should successfully transfer conference', async () => {
         const mockResponse = {
@@ -2180,5 +1756,6 @@ describe('Task', () => {
         });
       });
     });
+    */
   });
 });