@webex/contact-center 3.12.0-task-refactor.10 → 3.12.0-task-refactor.12

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

@@ -1,157 +1,433 @@
-import AqmReqs from "../../../../../src/services/core/aqm-reqs";
-import aqmDialer from "../../../../../src/services/task/dialer";
+import AqmReqs from '../../../../../src/services/core/aqm-reqs';
+import aqmDialer from '../../../../../src/services/task/dialer';
 
 jest.mock('../../../../../src/services/core/Utils', () => ({
-
   createErrDetailsObject: jest.fn(),
   getRoutingHost: jest.fn(),
-
 }));
 
 jest.mock('../../../../../src/services/core/aqm-reqs');
 
 describe('AQM routing dialer', () => {
-
   let fakeAqm: jest.Mocked<AqmReqs>;
 
   beforeEach(() => {
-
     jest.clearAllMocks();
 
     fakeAqm = new AqmReqs() as jest.Mocked<AqmReqs>;
     fakeAqm.reqEmpty = jest.fn().mockImplementation((fn) => fn);
     fakeAqm.req = jest.fn().mockImplementation((fn) => fn);
+  });
+
+  describe('Routing outbound dial', () => {
+    it('should call the startdial api', () => {
+      const fakeAqm = {
+        req: () =>
+          jest.fn().mockResolvedValue(() => {
+            Promise.resolve({data: 'outdial success'});
+          }),
+        evt: jest.fn(),
+      };
+
+      const dialer = aqmDialer(fakeAqm as any);
+
+      dialer
+        .startOutdial({
+          data: {
+            entryPointId: '1212312',
+            destination: '+142356',
+            direction: 'OUTBOUND',
+            attributes: {},
+            mediaType: 'telephony',
+            outboundType: 'OUTDIAL',
+          },
+        })
+        .then((response) => {
+          expect(response.data).toBe('outdial success');
+        })
+        .catch(() => {
+          expect(true).toBe(true);
+        });
+
+      expect(dialer.startOutdial).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.startOutdial({
+          data: {
+            entryPointId: '1212312',
+            destination: '+142356',
+            direction: 'OUTBOUND',
+            attributes: {},
+            mediaType: 'telephony',
+            outboundType: 'OUTDIAL',
+          },
+        })
+      ).rejects.toThrow('Network Error');
+    });
+
+    it('should handle invalid payload', () => {
+      const fakeAqm = {
+        req: () => jest.fn().mockRejectedValue(new Error('Invalid Payload in request')),
+        evt: jest.fn(),
+      };
+
+      const dialer = aqmDialer(fakeAqm as any);
+
+      return expect(
+        dialer.startOutdial({
+          data: {
+            entryPointId: '',
+            destination: '',
+            direction: 'OUTBOUND',
+            attributes: {},
+            mediaType: 'telephony',
+            outboundType: 'OUTDIAL',
+          },
+        })
+      ).rejects.toThrow('Invalid Payload in request');
+    });
+
+    it('should handle servers errors', () => {
+      const fakeAqm = {
+        req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+        evt: jest.fn(),
+      };
+
+      const dialer = aqmDialer(fakeAqm as any);
+      return expect(
+        dialer.startOutdial({
+          data: {
+            entryPointId: '123456',
+            destination: '+142356',
+            direction: 'OUTBOUND',
+            attributes: {},
+            mediaType: 'telephony',
+            outboundType: 'OUTDIAL',
+          },
+        })
+      ).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.startOutdial({
+          data: {
+            entryPointId: '12345',
+            destination: '+123456',
+            direction: 'OUTBOUND',
+            attributes: {},
+            mediaType: 'telephony',
+            outboundType: 'OUTDIAL',
+          },
+        })
+      ).rejects.toThrow('Request Timeout');
+    });
   });
 
-describe("Routing outbound dial", () => {
+  describe('Campaign preview contact operations', () => {
+    const previewPayload = {
+      interactionId: 'interaction-123',
+      campaignId: 'TestCampaignPreview',
+    };
 
-    it("should call the startdial api", () => {
+    describe('acceptPreviewContact', () => {
+      it('should construct the correct URL with campaignId and interactionId', () => {
+        const dialer = aqmDialer(fakeAqm as any);
+        const config = dialer.acceptPreviewContact({data: previewPayload}) as any;
 
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/accept`
+        );
+      });
+
+      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.acceptPreviewContact({data: payloadWithSpecialChars}) as any;
+
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${encodeURIComponent(
+            payloadWithSpecialChars.campaignId
+          )}/preview-task/${payloadWithSpecialChars.interactionId}/accept`
+        );
+        expect(config.url).toContain('My%20Campaign%2FTest%20%231');
+      });
+
+      it('should call the acceptPreviewContact api', () => {
         const fakeAqm = {
           req: () =>
             jest.fn().mockResolvedValue(() => {
-              Promise.resolve({ data: "outdial success" });
+              Promise.resolve({data: 'accept preview success'});
             }),
-          evt: jest.fn()
+          evt: jest.fn(),
         };
-      
+
         const dialer = aqmDialer(fakeAqm as any);
 
         dialer
-          .startOutdial({
-            data: {
-              entryPointId: "1212312",
-              destination: "+142356",
-              direction: "OUTBOUND",
-              attributes: {},
-              mediaType: "telephony",
-              outboundType: "OUTDIAL"
-            }
+          .acceptPreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('accept preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
+
+        expect(dialer.acceptPreviewContact).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.acceptPreviewContact({
+            data: previewPayload,
           })
-          .then(response => {
-            expect(response.data).toBe("outdial success");
+        ).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.acceptPreviewContact({
+            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.acceptPreviewContact({
+            data: previewPayload,
+          })
+        ).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.startOutdial).toHaveBeenCalled();
-        
+
+        expect(dialer.skipPreviewContact).toHaveBeenCalled();
       });
 
-      it("should handle network errors", () => {
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
 
-          const fakeAqm = {
-          req: () => jest.fn().mockRejectedValue(new Error("Network Error")),
-          evt: jest.fn()
-         };
+        const dialer = aqmDialer(fakeAqm as any);
 
-          const dialer = aqmDialer(fakeAqm as any);
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
 
-          return expect(dialer.startOutdial({
-          
-            data: {
-            entryPointId: "1212312",
-            destination: "+142356",
-            direction: "OUTBOUND",
-            attributes: {},
-            mediaType: "telephony",
-            outboundType: "OUTDIAL"
-           }
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
 
-          })).rejects.toThrow("Network Error");
-        });
-        
-        it("should handle invalid payload", () => {
+        const dialer = aqmDialer(fakeAqm as any);
 
-          const fakeAqm = {
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
 
-          req: () => jest.fn().mockRejectedValue(new Error("Invalid Payload in request")),
-          evt: jest.fn()
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
 
-         };
+        const dialer = aqmDialer(fakeAqm as any);
 
-          const dialer = aqmDialer(fakeAqm as any);
+        return expect(
+          dialer.skipPreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
 
-          return expect(dialer.startOutdial({
+    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;
 
-          data: {
-            entryPointId: "",
-            destination: "",
-            direction: "OUTBOUND",
-            attributes: {},
-            mediaType: "telephony",
-            outboundType: "OUTDIAL"
-           }
+        expect(config.url).toBe(
+          `/v1/dialer/campaign/${previewPayload.campaignId}/preview-task/${previewPayload.interactionId}/remove`
+        );
+      });
 
-          })).rejects.toThrow("Invalid Payload in request");
-        });
+      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(),
+        };
 
-        it("should handle servers errors", () => {
+        const dialer = aqmDialer(fakeAqm as any);
 
-          const fakeAqm = {
-          req: () => jest.fn().mockRejectedValue(new Error("Server Error")),
-          evt: jest.fn()
-         };
+        dialer
+          .removePreviewContact({data: previewPayload})
+          .then((response) => {
+            expect(response.data).toBe('remove preview success');
+          })
+          .catch(() => {
+            expect(true).toBe(true);
+          });
 
-          const dialer = aqmDialer(fakeAqm as any);
-          return expect(dialer.startOutdial({
+        expect(dialer.removePreviewContact).toHaveBeenCalled();
+      });
 
-          data: {
-            entryPointId: "123456",
-            destination: "+142356",
-            direction: "OUTBOUND",
-            attributes: {},
-            mediaType: "telephony",
-            outboundType: "OUTDIAL"
-           }
+      it('should handle network errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
+          evt: jest.fn(),
+        };
 
-          })).rejects.toThrow("Server Error");
+        const dialer = aqmDialer(fakeAqm as any);
 
-        });
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Network Error');
+      });
 
-        it("should handle Timeout scenarios", () => {
+      it('should handle server errors', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
+          evt: jest.fn(),
+        };
 
-          const fakeAqm = {
-          req: () => jest.fn().mockRejectedValue(new Error("Request Timeout")),
-          evt: jest.fn()
-         };
+        const dialer = aqmDialer(fakeAqm as any);
 
-          const dialer = aqmDialer(fakeAqm as any);
-          return expect(dialer.startOutdial({
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Server Error');
+      });
 
-          data: {
-            entryPointId: "12345",
-            destination: "+123456",
-            direction: "OUTBOUND",
-            attributes: {},
-            mediaType: "telephony",
-            outboundType: "OUTDIAL"
-           }
+      it('should handle timeout scenarios', () => {
+        const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
+          evt: jest.fn(),
+        };
 
-          })).rejects.toThrow("Request Timeout");
-        });
-});
+        const dialer = aqmDialer(fakeAqm as any);
+
+        return expect(
+          dialer.removePreviewContact({
+            data: previewPayload,
+          })
+        ).rejects.toThrow('Request Timeout');
+      });
+    });
+  });
 });

package/test/unit/spec/services/task/state-machine/uiControlsComputer.ts

@@ -1784,6 +1784,53 @@ describe('uiControlsComputer outdial accept/decline controls', () => {
   });
 });
 
+describe('uiControlsComputer WebRTC call-control end button', () => {
+  function createConnectedContext(voiceVariant: 'webrtc' | 'pstn'): TaskContext {
+    const taskData = createTaskData({
+      interaction: {
+        state: 'connected',
+      } as any,
+    });
+
+    return {
+      taskData,
+      consultInitiator: false,
+      exitingConference: false,
+      consultFromConference: false,
+      transferConferenceRequested: false,
+      consultDestinationType: null,
+      consultDestinationAgentId: null,
+      consultDestinationAgentJoined: false,
+      consultCallHeld: false,
+      recordingControlsAvailable: true,
+      recordingInProgress: true,
+      uiControlConfig: {
+        isEndTaskEnabled: false,
+        isEndConsultEnabled: true,
+        channelType: TASK_CHANNEL_TYPE.VOICE,
+        isRecordingEnabled: true,
+        agentId: taskData.agentId,
+        voiceVariant,
+      },
+      uiControls: getDefaultUIControls(),
+    };
+  }
+
+  it('shows main end for connected WebRTC call-control tasks even when end task is disabled', () => {
+    const context = createConnectedContext('webrtc');
+    const uiControls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+
+    expect(uiControls.main.end).toEqual({isVisible: true, isEnabled: true});
+  });
+
+  it('keeps main end hidden for non-WebRTC voice tasks when end task is disabled', () => {
+    const context = createConnectedContext('pstn');
+    const uiControls = computeUIControls(TaskState.CONNECTED, context, context.taskData);
+
+    expect(uiControls.main.end).toEqual({isVisible: false, isEnabled: false});
+  });
+});
+
 describe('uiControlsComputer conference controls', () => {
   function createConferenceTaskData(participantCount: number) {
     const participants: Record<string, any> = {