@webex/contact-center 3.12.0-next.9 → 3.12.0-task-refactor.2

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

@@ -8,6 +8,11 @@ import {
   isDigitalOutbound,
   hasAgentInitiatedOutdial,
   shouldAutoAnswerTask,
+  getIsCustomerInCall,
+  getConferenceParticipantsCount,
+  isSecondaryAgent,
+  isSecondaryEpDnAgent,
+  getConsultMediaResourceId,
 } from '../../../../../src/services/task/TaskUtils';
 import {ITask, Interaction, TaskData} from '../../../../../src/services/task/types';
 import {LoginOption} from '../../../../../src/types';
@@ -430,4 +435,124 @@ describe('TaskUtils', () => {
       });
     });
   });
+
+  // Additional coverage for conference/consult utility functions
+  describe('Conference Utility Functions', () => {
+    const interactionId = 'interaction-123';
+    const createInteraction = (media: any = {}, participants: any = {}) =>
+      ({interactionId, mainInteractionId: interactionId, media, participants}) as any;
+
+    it('getIsCustomerInCall returns true when customer active', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['c1']}},
+        {'c1': {pType: 'Customer', hasLeft: false}}
+      );
+      expect(getIsCustomerInCall(interaction, interactionId)).toBe(true);
+    });
+
+    it('getConferenceParticipantsCount counts active agents only', () => {
+      const interaction = createInteraction(
+        {[interactionId]: {mType: 'mainCall', participants: ['a1', 'a2', 'c1']}},
+        {'a1': {pType: 'Agent', hasLeft: false}, 'a2': {pType: 'Agent', hasLeft: false}, 'c1': {pType: 'Customer', hasLeft: false}}
+      );
+      expect(getConferenceParticipantsCount(interaction, interactionId)).toBe(2);
+    });
+
+    it('isSecondaryAgent returns true for consult with parentInteractionId', () => {
+      const interaction = createInteraction();
+      interaction.callProcessingDetails = {relationshipType: 'consult', parentInteractionId: 'parent-456'};
+      expect(isSecondaryAgent(interaction)).toBe(true);
+    });
+
+    it('isSecondaryEpDnAgent returns true for telephony secondary agent', () => {
+      const interaction = createInteraction();
+      interaction.mediaType = 'telephony';
+      interaction.callProcessingDetails = {relationshipType: 'consult', parentInteractionId: 'parent-456'};
+      expect(isSecondaryEpDnAgent(interaction)).toBe(true);
+    });
+  });
+
+  describe('getConsultMediaResourceId', () => {
+    it('returns consultMediaResourceId directly when provided', () => {
+      const result = getConsultMediaResourceId(undefined, 'consult-media-1', 'agent1');
+      expect(result).toBe('consult-media-1');
+    });
+
+    it('returns undefined when no interaction and no consultMediaResourceId', () => {
+      const result = getConsultMediaResourceId(undefined, undefined, 'agent1');
+      expect(result).toBeUndefined();
+    });
+
+    it('returns undefined when no agentId and no consultMediaResourceId', () => {
+      const interaction = {media: {}} as any;
+      const result = getConsultMediaResourceId(interaction, undefined, undefined);
+      expect(result).toBeUndefined();
+    });
+
+    it('finds consult media leg by mType and agent participation', () => {
+      const interaction = {
+        media: {
+          'main-media': {
+            mediaResourceId: 'main-media',
+            mType: 'mainCall',
+            participants: ['agent1', 'customer1'],
+          },
+          'consult-media': {
+            mediaResourceId: 'consult-media',
+            mType: 'consult',
+            participants: ['agent1', 'agent2'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, undefined, 'agent1');
+      expect(result).toBe('consult-media');
+    });
+
+    it('returns undefined when no consult media leg matches the agent', () => {
+      const interaction = {
+        media: {
+          'main-media': {
+            mediaResourceId: 'main-media',
+            mType: 'mainCall',
+            participants: ['agent1', 'customer1'],
+          },
+          'consult-media': {
+            mediaResourceId: 'consult-media',
+            mType: 'consult',
+            participants: ['agent2', 'agent3'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, undefined, 'agent1');
+      expect(result).toBeUndefined();
+    });
+
+    it('returns undefined when media has no consult type entries', () => {
+      const interaction = {
+        media: {
+          'main-media': {
+            mediaResourceId: 'main-media',
+            mType: 'mainCall',
+            participants: ['agent1', 'customer1'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, undefined, 'agent1');
+      expect(result).toBeUndefined();
+    });
+
+    it('prioritizes direct consultMediaResourceId over interaction search', () => {
+      const interaction = {
+        media: {
+          'consult-media': {
+            mediaResourceId: 'consult-media',
+            mType: 'consult',
+            participants: ['agent1', 'agent2'],
+          },
+        },
+      } as any;
+      const result = getConsultMediaResourceId(interaction, 'direct-id', 'agent1');
+      expect(result).toBe('direct-id');
+    });
+  });
 });

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

@@ -1,243 +1,157 @@
-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('Campaign preview contact operations', () => {
-    const previewPayload = {
-      interactionId: 'interaction-123',
-      campaignId: 'TestCampaignPreview',
-    };
-
-    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`
-        );
-      });
+describe("Routing outbound dial", () => {
 
-      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 startdial api", () => {
 
-      it('should call the acceptPreviewContact api', () => {
         const fakeAqm = {
           req: () =>
             jest.fn().mockResolvedValue(() => {
-              Promise.resolve({data: 'accept preview success'});
+              Promise.resolve({ data: "outdial success" });
             }),
-          evt: jest.fn(),
+          evt: jest.fn()
         };
-
+      
         const dialer = aqmDialer(fakeAqm as any);
 
         dialer
-          .acceptPreviewContact({data: previewPayload})
-          .then((response) => {
-            expect(response.data).toBe('accept preview success');
+          .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.acceptPreviewContact).toHaveBeenCalled();
+      
+          expect(dialer.startOutdial).toHaveBeenCalled();
+        
       });
 
-      it('should handle network errors', () => {
-        const fakeAqm = {
-          req: () => jest.fn().mockRejectedValue(new Error('Network Error')),
-          evt: jest.fn(),
-        };
+      it("should handle network errors", () => {
 
-        const dialer = aqmDialer(fakeAqm as any);
+          const fakeAqm = {
+          req: () => jest.fn().mockRejectedValue(new Error("Network Error")),
+          evt: jest.fn()
+         };
 
-        return expect(
-          dialer.acceptPreviewContact({
-            data: previewPayload,
-          })
-        ).rejects.toThrow('Network Error');
-      });
+          const dialer = aqmDialer(fakeAqm as any);
 
-      it('should handle server errors', () => {
-        const fakeAqm = {
-          req: () => jest.fn().mockRejectedValue(new Error('Server Error')),
-          evt: jest.fn(),
-        };
+          return expect(dialer.startOutdial({
+          
+            data: {
+            entryPointId: "1212312",
+            destination: "+142356",
+            direction: "OUTBOUND",
+            attributes: {},
+            mediaType: "telephony",
+            outboundType: "OUTDIAL"
+           }
 
-        const dialer = aqmDialer(fakeAqm as any);
+          })).rejects.toThrow("Network Error");
+        });
+        
+        it("should handle invalid payload", () => {
 
-        return expect(
-          dialer.acceptPreviewContact({
-            data: previewPayload,
-          })
-        ).rejects.toThrow('Server Error');
-      });
+          const fakeAqm = {
 
-      it('should handle timeout scenarios', () => {
-        const fakeAqm = {
-          req: () => jest.fn().mockRejectedValue(new Error('Request Timeout')),
-          evt: jest.fn(),
-        };
+          req: () => jest.fn().mockRejectedValue(new Error("Invalid Payload in request")),
+          evt: jest.fn()
 
-        const dialer = aqmDialer(fakeAqm as any);
+         };
 
-        return expect(
-          dialer.acceptPreviewContact({
-            data: previewPayload,
-          })
-        ).rejects.toThrow('Request Timeout');
-      });
-    });
-  });
+          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");
+        });
+});
 });

package/test/unit/spec/services/task/digital/Digital.ts

@@ -0,0 +1,105 @@
+import Digital from '../../../../../../src/services/task/digital/Digital';
+import {MEDIA_CHANNEL, TaskData, TaskResponse} from '../../../../../../src/services/task/types';
+import {TaskEvent, TaskEventPayload} from '../../../../../../src/services/task/state-machine';
+
+jest.mock('../../../../../../src/services/core/WebexRequest', () => ({
+  __esModule: true,
+  default: {
+    getInstance: () => ({ uploadLogs: jest.fn() }),
+  },
+}));
+
+const sendStateEvents = (task: Digital, events: TaskEventPayload[]) => {
+  events.forEach((event) => {
+    if (!event) {
+      throw new Error('Task event payload is required');
+    }
+    task.stateMachineService?.send(event);
+  });
+};
+
+describe('Digital Task', () => {
+  const dummyData = {
+    interactionId: 'dig1',
+    interaction: {isTerminated: false, mediaType: MEDIA_CHANNEL.CHAT},
+  } as TaskData;
+  let dummyContact: { accept: jest.Mock<Promise<TaskResponse>> };
+
+  beforeEach(() => {
+    dummyContact = {
+      accept: jest.fn().mockResolvedValue({ status: 'ok' }),
+    };
+  });
+
+  it('accept() calls contact.accept with interactionId', async () => {
+    const task = new Digital(dummyContact, dummyData);
+    const res = await task.accept();
+    expect(dummyContact.accept).toHaveBeenCalledWith({ interactionId: 'dig1' });
+    expect(res).toEqual({ status: 'ok' });
+  });
+
+  it('accept() throws an error when contact.accept rejects', async () => {
+    const error = new Error('Error while performing accept');
+    (dummyContact.accept as jest.Mock).mockRejectedValue(error);
+    const task = new Digital(dummyContact, dummyData);
+    await expect(task.accept()).rejects.toThrow('Error while performing accept');
+  });
+
+  it('constructor shows accept when offered', () => {
+    const task = new Digital(dummyContact, dummyData);
+    sendStateEvents(task, [{type: TaskEvent.TASK_INCOMING, taskData: dummyData}]);
+    expect(task.uiControls.main.accept.isVisible).toBe(true);
+    expect(task.uiControls.main.accept.isEnabled).toBe(true);
+  });
+
+  describe('UI controls derived from state machine events', () => {
+    it('connected state shows transfer and end', () => {
+      const task = new Digital(dummyContact, dummyData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.ASSIGN, taskData: dummyData},
+      ]);
+      expect(task.uiControls.main.accept.isVisible).toBe(false);
+      expect(task.uiControls.main.transfer.isVisible).toBe(true);
+      expect(task.uiControls.main.end.isVisible).toBe(true);
+      expect(task.uiControls.main.wrapup.isVisible).toBe(false);
+    });
+
+    it('wrapup state hides transfer/end and shows wrapup button', () => {
+      const task = new Digital(dummyContact, dummyData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.ASSIGN, taskData: dummyData},
+        {type: TaskEvent.TASK_WRAPUP},
+      ]);
+      expect(task.uiControls.main.transfer.isVisible).toBe(false);
+      expect(task.uiControls.main.end.isVisible).toBe(false);
+      expect(task.uiControls.main.wrapup.isVisible).toBe(true);
+    });
+
+    it('terminated interaction toggles wrapup visibility even before END event', () => {
+      const task = new Digital(dummyContact, dummyData);
+      const terminatedData = {
+        ...dummyData,
+        interaction: {...(dummyData.interaction as any), isTerminated: true},
+      } as TaskData;
+      task.updateTaskData(terminatedData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.ASSIGN, taskData: terminatedData},
+      ]);
+      expect(task.uiControls.main.wrapup.isVisible).toBe(true);
+    });
+
+    it('rona hides accept controls', () => {
+      const task = new Digital(dummyContact, dummyData);
+      sendStateEvents(task, [
+        {type: TaskEvent.TASK_INCOMING, taskData: dummyData},
+        {type: TaskEvent.RONA},
+      ]);
+      expect(task.uiControls.main.accept.isVisible).toBe(false);
+      expect(task.uiControls.main.transfer.isVisible).toBe(false);
+      expect(task.uiControls.main.end.isVisible).toBe(false);
+    });
+  });
+});