@webex/contact-center 3.12.0-next.7 → 3.12.0-next.70

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

@@ -84,7 +84,12 @@ describe('TaskManager', () => {
     onSpy = jest.spyOn(webCallingService, 'on');
     offSpy = jest.spyOn(webCallingService, 'off');
 
-    taskManager = new TaskManager(mockApiAIAssistant, contactMock, webCallingService, webSocketManagerMock);
+    taskManager = new TaskManager(
+      mockApiAIAssistant,
+      contactMock,
+      webCallingService,
+      webSocketManagerMock
+    );
     const taskMock = {
       emit: jest.fn(),
       accept: jest.fn(),
@@ -314,6 +319,10 @@ describe('TaskManager', () => {
       TASK_EVENTS.TASK_ASSIGNED,
       taskManager.getTask(taskId)
     );
+    expect(taskIncomingSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+      taskManager.getTask(taskId)
+    );
   });
 
   it('should handle WebSocket message for AGENT_CONTACT_RESERVED and emit task:incoming for extension case', () => {
@@ -1146,7 +1155,7 @@ describe('TaskManager', () => {
       taskManager.setAgentId(agentId);
     });
 
-    it('should set wrapUpRequired to true when agent is in agentsPendingWrapUp array', () => {
+    it('should set wrapUpRequired to true when agent is in agentsPendingWrapUp array for non-campaign tasks', () => {
       const task = taskManager.getTask(taskId);
       task.updateTaskData = jest.fn().mockImplementation((newData) => {
         task.data = {
@@ -1306,7 +1315,7 @@ describe('TaskManager', () => {
       );
     });
 
-    it('should set wrapUpRequired correctly when agent is the only one in agentsPendingWrapUp', () => {
+    it('should set wrapUpRequired to true when agent is the only one in agentsPendingWrapUp for non-campaign tasks', () => {
       const task = taskManager.getTask(taskId);
       task.updateTaskData = jest.fn().mockImplementation((newData) => {
         task.data = {
@@ -1338,7 +1347,7 @@ describe('TaskManager', () => {
       );
     });
 
-    it('should work correctly for different interaction states when agent is in agentsPendingWrapUp', () => {
+    it('should set wrapUpRequired to true for different interaction states when agent is in agentsPendingWrapUp for non-campaign tasks', () => {
       const task = taskManager.getTask(taskId);
       task.updateTaskData = jest.fn().mockImplementation((newData) => {
         task.data = {
@@ -1368,7 +1377,6 @@ describe('TaskManager', () => {
 
       webSocketManagerMock.emit('message', JSON.stringify(payloadConnected));
 
-      // First call should set wrapUpRequired to true
       expect(task.updateTaskData).toHaveBeenNthCalledWith(
         1,
         expect.objectContaining({
@@ -1391,7 +1399,6 @@ describe('TaskManager', () => {
 
       webSocketManagerMock.emit('message', JSON.stringify(payloadHeld));
 
-      // Second call should also set wrapUpRequired to true
       expect(task.updateTaskData).toHaveBeenNthCalledWith(
         2,
         expect.objectContaining({
@@ -1399,6 +1406,43 @@ describe('TaskManager', () => {
         })
       );
     });
+
+    it('should set wrapUpRequired to false for campaign preview tasks even when agent is in agentsPendingWrapUp', () => {
+      const task = taskManager.getTask(taskId);
+      // Set up task as a campaign preview task via outboundType
+      task.data.interaction = {
+        ...task.data.interaction,
+        outboundType: 'STANDARD_PREVIEW_CAMPAIGN',
+      };
+      task.updateTaskData = jest.fn().mockImplementation((newData) => {
+        task.data = {
+          ...task.data,
+          ...newData,
+        };
+        return task;
+      });
+      task.unregisterWebCallListeners = jest.fn();
+
+      const payload = {
+        data: {
+          type: CC_EVENTS.CONTACT_ENDED,
+          interactionId: taskId,
+          interaction: {
+            state: 'connected',
+            mediaType: 'telephony',
+          },
+          agentsPendingWrapUp: [agentId],
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(payload));
+
+      expect(task.updateTaskData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          wrapUpRequired: false,
+        })
+      );
+    });
   });
 
   it('should remove OUTDIAL task from taskCollection on AGENT_CONTACT_ASSIGN_FAILED when NOT terminated (user-declined)', () => {
@@ -1497,6 +1541,7 @@ describe('TaskManager', () => {
     });
 
     const taskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+    const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
     webSocketManagerMock.emit('message', JSON.stringify(initialConsultingPayload));
     webSocketManagerMock.emit('message', JSON.stringify(consultingPayload));
     expect(taskManager.getTask(taskId).data.isConsulted).toBe(true);
@@ -1504,6 +1549,10 @@ describe('TaskManager', () => {
       TASK_EVENTS.TASK_CONSULT_ACCEPTED,
       taskManager.getTask(taskId)
     );
+    expect(taskManagerEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+      taskManager.getTask(taskId)
+    );
   });
 
   it('should emit TASK_CONSULT_ENDED event on AGENT_CONSULT_ENDED event', () => {
@@ -1772,6 +1821,7 @@ describe('TaskManager', () => {
     webSocketManagerMock.emit('message', JSON.stringify(initalPayload));
     taskManager.getTask(taskId).data.isConsulted = false;
     const taskEmitSpy = jest.spyOn(taskManager.getTask(taskId), 'emit');
+    const taskManagerEmitSpy = jest.spyOn(taskManager, 'emit');
     const consultingPayload = {
       data: {
         ...initalPayload.data,
@@ -1785,6 +1835,10 @@ describe('TaskManager', () => {
       TASK_EVENTS.TASK_CONSULTING,
       taskManager.getTask(taskId)
     );
+    expect(taskManagerEmitSpy).toHaveBeenCalledWith(
+      TASK_EVENTS.TASK_MULTI_LOGIN_HYDRATE,
+      taskManager.getTask(taskId)
+    );
   });
 
   it('should emit TASK_END event on AGENT_CONTACT_UNASSIGNED', () => {
@@ -3294,7 +3348,7 @@ describe('TaskManager', () => {
       );
     });
 
-    it('should update task data but NOT remove task when CampaignContactUpdated is received', () => {
+    it('should emit TASK_CAMPAIGN_CONTACT_UPDATED and NOT remove task when CampaignContactUpdated is received', () => {
       const campaignInteractionId = 'campaign-interaction-123';
 
       // First create a campaign preview task
@@ -3344,8 +3398,199 @@ describe('TaskManager', () => {
       // Task should still exist in collection (not removed — non-terminal event)
       expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
 
+      // TASK_CAMPAIGN_CONTACT_UPDATED should have been emitted
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_CONTACT_UPDATED,
+        expect.objectContaining({
+          data: expect.objectContaining({
+            interactionId: campaignInteractionId,
+          }),
+        })
+      );
+
       // TASK_END should NOT have been emitted
       expect(taskEmitSpy).not.toHaveBeenCalledWith(TASK_EVENTS.TASK_END, expect.anything());
     });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED when CampaignPreviewAcceptFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      // First create a campaign preview task
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_ACCEPT_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      // Task should still exist (failure is non-terminal)
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason, campaignId) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_SKIP_FAILED when CampaignPreviewSkipFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_SKIP_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should emit TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED when CampaignPreviewRemoveFailed is received', () => {
+      const campaignInteractionId = 'campaign-interaction-123';
+
+      const reservationPayload = {
+        data: {
+          type: CC_EVENTS.AGENT_OFFER_CAMPAIGN_RESERVATION,
+          interactionId: campaignInteractionId,
+          agentId: taskDataMock.agentId,
+          orgId: taskDataMock.orgId,
+          trackingId: 'campaign-tracking-456',
+          interaction: {
+            mediaType: 'telephony',
+            callProcessingDetails: {
+              campaignId: 'campaign-789',
+            },
+          },
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(reservationPayload));
+
+      const task = taskManager['taskCollection'][campaignInteractionId];
+      expect(task).toBeDefined();
+
+      const taskEmitSpy = jest.spyOn(task, 'emit');
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_REMOVE_FAILED,
+          interactionId: campaignInteractionId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+
+      expect(taskEmitSpy).toHaveBeenCalledWith(
+        TASK_EVENTS.TASK_CAMPAIGN_PREVIEW_REMOVE_FAILED,
+        expect.objectContaining({
+          data: expect.objectContaining({interactionId: campaignInteractionId}),
+        })
+      );
+      expect(taskManager['taskCollection'][campaignInteractionId]).toBeDefined();
+
+      // Failure payload (reason) should be merged into task.data
+      expect(task.data.reason).toBe('INTERNAL_ERROR');
+
+      // Original reservation data must be preserved
+      expect(task.data.interaction).toBeDefined();
+      expect(task.data.interaction.callProcessingDetails.campaignId).toBe('campaign-789');
+    });
+
+    it('should not emit campaign preview failure events when task does not exist', () => {
+      const nonExistentId = 'non-existent-interaction';
+
+      const failPayload = {
+        data: {
+          type: CC_EVENTS.CAMPAIGN_PREVIEW_SKIP_FAILED,
+          interactionId: nonExistentId,
+          campaignId: 'campaign-789',
+          reason: 'INTERNAL_ERROR',
+        },
+      };
+
+      // Should not throw when task is not found
+      expect(() => {
+        webSocketManagerMock.emit('message', JSON.stringify(failPayload));
+      }).not.toThrow();
+
+      expect(taskManager['taskCollection'][nonExistentId]).toBeUndefined();
+    });
   });
 });

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

@@ -239,5 +239,195 @@ describe('AQM routing dialer', () => {
         ).rejects.toThrow('Request Timeout');
       });
     });
+
+    describe('skipPreviewContact', () => {
+      it('should construct the correct URL with campaignId and interactionId', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const config = dialer.skipPreviewContact({data: previewPayload}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/skip`
+        );
+      });
+
+      it('should URL-encode campaignId when it contains reserved characters', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const payloadWithSpecialChars = {
+          interactionId: 'interaction-456',
+          campaignId: 'My Campaign/Test #1',
+        };
+        const config = dialer.skipPreviewContact({data: payloadWithSpecialChars}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${encodeURIComponent(
+            payloadWithSpecialChars.campaignId
+          )}/preview-task/${payloadWithSpecialChars.interactionId}/skip`
+        );
+        expect(config.url).toContain('My%20Campaign%2FTest%20%231');
+      });
+
+      it('should call the skipPreviewContact api', () => {
+        const fakeAqm = {
+          req: () =>
+            jest.fn().mockResolvedValue(() => {
+              Promise.resolve({data: 'skip preview success'});
+            }),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        dialer
+          .skipPreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('skip preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
+
+        expect(dialer.skipPreviewContact).toHaveBeenCalled();
+      });
+
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
+
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
+
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
+
+    describe('removePreviewContact', () => {
+      it('should construct the correct URL with campaignId and interactionId', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const config = dialer.removePreviewContact({data: previewPayload}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/remove`
+        );
+      });
+
+      it('should URL-encode campaignId when it contains reserved characters', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const payloadWithSpecialChars = {
+          interactionId: 'interaction-456',
+          campaignId: 'My Campaign/Test #1',
+        };
+        const config = dialer.removePreviewContact({data: payloadWithSpecialChars}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${encodeURIComponent(
+            payloadWithSpecialChars.campaignId
+          )}/preview-task/${payloadWithSpecialChars.interactionId}/remove`
+        );
+        expect(config.url).toContain('My%20Campaign%2FTest%20%231');
+      });
+
+      it('should call the removePreviewContact api', () => {
+        const fakeAqm = {
+          req: () =>
+            jest.fn().mockResolvedValue(() => {
+              Promise.resolve({data: 'remove preview success'});
+            }),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        dialer
+          .removePreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('remove preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
+
+        expect(dialer.removePreviewContact).toHaveBeenCalled();
+      });
+
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
+
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
+
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
+
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
   });
 });

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

@@ -691,6 +691,27 @@ describe('Task', () => {
     );
   });
 
+  it('should hold using mediaResourceId from interaction.media after recording event wipes top-level mediaResourceId', async () => {
+    // Set a DIFFERENT top-level mediaResourceId so we can distinguish the two sources
+    const staleTopLevelId = 'stale-top-level-media-resource-id';
+    const correctMediaId = task.data.interaction.media[task.data.interaction.mainInteractionId].mediaResourceId;
+    task.data.mediaResourceId = staleTopLevelId;
+
+    // Simulate recording event wiping top-level mediaResourceId (as reconcileData does)
+    delete task.data.mediaResourceId;
+
+    const expectedResponse: TaskResponse = {data: {interactionId: taskId}} as AgentContact;
+    contactMock.hold.mockResolvedValue(expectedResponse);
+
+    await task.hold();
+
+    // hold() should read from interaction.media, not the (now deleted) top-level field
+    expect(contactMock.hold).toHaveBeenCalledWith({
+      interactionId: taskId,
+      data: {mediaResourceId: correctMediaId},
+    });
+  });
+
   it('should handle errors in hold method', async () => {
     const error = {details: (global as any).makeFailure('Hold Failed')};
     contactMock.hold.mockImplementation(() => {