@webex/contact-center 0.0.0-next.1

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

@@ -0,0 +1,204 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {DESTINATION_TYPE} from "../../../../../src/services/task/types";
+import AqmReqs from "../../../../../src/services/core/aqm-reqs";
+import routingContact from "../../../../../src/services/task/contact";
+
+jest.mock('../../../../../src/services/core/Utils', () => ({
+  createErrDetailsObject: jest.fn(),
+  getRoutingHost: jest.fn(),
+}));
+
+jest.mock('../../../../../src/services/core/aqm-reqs');
+
+describe('AQM routing contact', () => {
+  let fakeAqm: jest.Mocked<AqmReqs>;
+  let contact: ReturnType<typeof routingContact>;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    fakeAqm = new AqmReqs() as jest.Mocked<AqmReqs>;
+    fakeAqm.reqEmpty = jest.fn().mockImplementation((fn) => fn);
+    fakeAqm.req = jest.fn().mockImplementation((fn) => fn);
+
+    contact = routingContact(fakeAqm);
+  });
+
+
+describe("Routing contacts", () => {
+  it("accept", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.accept({
+      interactionId: "interactionId"
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("hold", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.hold({
+      interactionId: "interactionId",
+      data: {mediaResourceId: ""}
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("unHold", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.unHold({ interactionId: "interactionId", data:  {mediaResourceId: ""}});
+    expect(req).toBeDefined();
+  });
+
+  it("pauseRecording", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.pauseRecording({
+      interactionId: "interactionId"
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("resumeRecording", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.resumeRecording({ interactionId: "interactionId", data: { autoResumed: "true" } } as any);
+    expect(req).toBeDefined();
+  });
+
+  it("consult queue", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.consult({
+      interactionId: "interactionId",
+      data: {
+        to: "queueId",
+        destinationType: "queue",
+        mediaType: "telephony"
+      },
+      url: ""
+    } as any);
+    expect(req).toBeDefined();
+  });
+
+  it("consult dn", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.consult({
+      interactionId: "interactionId",
+      data: {
+        to: "9372724724",
+        destinationType: "dialNumber",
+        mediaType: "telephony"
+      },
+      url: ""
+    } as any);
+    expect(req).toBeDefined();
+  });
+
+  it("consultAccept", () => {
+    const req = contact.consultAccept({} as any);
+    expect(req).toBeDefined();
+  });
+
+  it("consultEnd", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.consultEnd({
+      interactionId: "interactionId",
+      data: {
+        isConsult: true,
+        queueId: "queueId",
+        taskId: "taskId"
+      }
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("consultEnd without QueueId", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.consultEnd({
+      interactionId: "interactionId",
+      data: {
+        isConsult: true,
+        taskId: "taskId"
+      }
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("consultEnd without QueueId and isConsult false", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.consultEnd({
+      interactionId: "interactionId",
+      data: {
+        isConsult: false,
+        taskId: "taskId"
+      }
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("cancelCtq", () => {
+    const req = contact.cancelCtq({} as any);
+    expect(req).toBeDefined();
+  });
+
+  it("blindTransfer", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.blindTransfer({
+      interactionId: "interactionId",
+      data: {
+        to: "agentId",
+        destinationType: DESTINATION_TYPE.AGENT
+      }
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("vteamTransfer", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.vteamTransfer({
+      interactionId: "interactionId",
+      data: {
+        to: "queueId",
+        destinationType: DESTINATION_TYPE.QUEUE
+      }
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("consultTransfer", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.consultTransfer({
+      interactionId: "interactionId",
+      data: {
+        to: 'dn',
+        destinationType: DESTINATION_TYPE.DIALNUMBER
+      }
+    });
+    expect(req).toBeDefined();
+  });
+
+  it("contact End", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.end({
+      interactionId: "interactionId",
+      data: {}
+    } as any);
+    expect(req).toBeDefined();
+  });
+
+  it("cancel Contact", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.cancelTask({
+      interactionId: "interactionId",
+      data: {}
+    } as any);
+    expect(req).toBeDefined();
+  });
+
+  it("wrapup contact", () => {
+    fakeAqm.pendingRequests = {};
+    const req = contact.wrapup({
+      interactionId: "interactionId",
+      data: { wrapUpReason: "testWrapUpReason", auxCodeId: "auxCodeID1234", isAutoWrapup: "on" }
+    } as any);
+    expect(req).toBeDefined();
+  });
+});
+})

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

@@ -0,0 +1,157 @@
+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");
+        });
+});
+});