@webex/calling 3.11.0 → 3.12.0

package/dist/CallHistory/CallHistory.test.js

@@ -0,0 +1,916 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs2/helpers/typeof");
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _WeakMap = require("@babel/runtime-corejs2/core-js/weak-map");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _types = require("../Logger/types");
+var _testUtil = require("../common/testUtil");
+var _types2 = require("../common/types");
+var _CallHistory = require("./CallHistory");
+var _callHistoryFixtures = require("./callHistoryFixtures");
+var _types3 = require("../Events/types");
+var _constants = require("./constants");
+var utils = _interopRequireWildcard(require("../common/Utils"));
+var _Logger = _interopRequireDefault(require("../Logger"));
+var _constants2 = require("../common/constants");
+function _interopRequireWildcard(e, t) { if ("function" == typeof _WeakMap) var r = new _WeakMap(), n = new _WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != _typeof(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t41 in e) "default" !== _t41 && {}.hasOwnProperty.call(e, _t41) && ((i = (o = _Object$defineProperty) && _Object$getOwnPropertyDescriptor(e, _t41)) && (i.get || i.set) ? o(f, _t41, i) : f[_t41] = e[_t41]); return f; })(e, t); }
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; } /* eslint-disable @typescript-eslint/no-unused-vars */ /* eslint-disable dot-notation */ /* eslint-disable @typescript-eslint/no-shadow */
+var webex = (0, _testUtil.getTestUtilsWebex)();
+var serviceErrorCodeHandlerSpy;
+var uploadLogsSpy;
+describe('Call history tests', function () {
+  var callHistory;
+  var infoSpy = jest.spyOn(_Logger.default, 'info').mockImplementation();
+  var logSpy = jest.spyOn(_Logger.default, 'log').mockImplementation();
+  var errorSpy = jest.spyOn(_Logger.default, 'error').mockImplementation();
+  beforeAll(function () {
+    callHistory = new _CallHistory.CallHistory(webex, {
+      level: _types.LOGGER.INFO
+    });
+    uploadLogsSpy = jest.spyOn(utils, 'uploadLogs').mockResolvedValue();
+  });
+  it('verify successful call history case', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+    var callHistoryPayload, response;
+    return _regenerator.default.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          callHistoryPayload = _callHistoryFixtures.mockCallHistoryBody;
+          webex.request.mockResolvedValue(callHistoryPayload);
+          _context.next = 1;
+          return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+        case 1:
+          response = _context.sent;
+          expect(response.statusCode).toBe(200);
+          expect(response.message).toBe('SUCCESS');
+
+          // Verify logging behavior
+          expect(infoSpy).toHaveBeenCalled();
+          expect(logSpy).toHaveBeenCalled();
+          expect(errorSpy).not.toHaveBeenCalled();
+
+          // Verify logs were called with correct information
+          expect(infoSpy).toHaveBeenCalledWith('invoking with days=7, limit=10, sort=DESC, sortBy=endTime', {
+            file: _constants.CALL_HISTORY_FILE,
+            method: _constants.METHODS.GET_CALL_HISTORY_DATA
+          });
+          expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Successfully retrieved call history data'), {
+            file: _constants.CALL_HISTORY_FILE,
+            method: _constants.METHODS.GET_CALL_HISTORY_DATA
+          });
+          expect(errorSpy).not.toHaveBeenCalled();
+          expect(uploadLogsSpy).not.toHaveBeenCalled();
+        case 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('verify bad request failed call history case', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+    var failurePayload, callHistoryPayload, response;
+    return _regenerator.default.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          failurePayload = {
+            statusCode: 400
+          };
+          callHistoryPayload = failurePayload;
+          webex.request.mockRejectedValue(callHistoryPayload);
+          _context2.next = 1;
+          return callHistory.getCallHistoryData(7, 2000, _types2.SORT.ASC, _types2.SORT_BY.START_TIME);
+        case 1:
+          response = _context2.sent;
+          expect(response.statusCode).toBe(400);
+          expect(response.message).toBe('FAILURE');
+
+          // Verify logs were called with correct information
+          expect(infoSpy).toHaveBeenCalledWith('invoking with days=7, limit=2000, sort=ASC, sortBy=startTime', {
+            file: _constants.CALL_HISTORY_FILE,
+            method: _constants.METHODS.GET_CALL_HISTORY_DATA
+          });
+          expect(errorSpy).toHaveBeenCalledWith("Failed to get call history: ".concat((0, _stringify.default)(failurePayload)), {
+            file: _constants.CALL_HISTORY_FILE,
+            method: _constants.METHODS.GET_CALL_HISTORY_DATA
+          });
+          expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('verify device not found call history case', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+    var failurePayload, callHistoryPayload, response;
+    return _regenerator.default.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          failurePayload = {
+            statusCode: 404
+          };
+          callHistoryPayload = failurePayload;
+          webex.request.mockRejectedValue(callHistoryPayload);
+          _context3.next = 1;
+          return callHistory.getCallHistoryData(0, 0, _types2.SORT.ASC, _types2.SORT_BY.START_TIME);
+        case 1:
+          response = _context3.sent;
+          expect(response.statusCode).toBe(404);
+          expect(response.message).toBe('FAILURE');
+
+          // Verify logs were called with correct information
+          expect(infoSpy).toHaveBeenCalledWith('invoking with days=0, limit=0, sort=ASC, sortBy=startTime', {
+            file: _constants.CALL_HISTORY_FILE,
+            method: _constants.METHODS.GET_CALL_HISTORY_DATA
+          });
+          expect(errorSpy).toHaveBeenCalledWith("Failed to get call history: ".concat((0, _stringify.default)(failurePayload)), {
+            file: _constants.CALL_HISTORY_FILE,
+            method: _constants.METHODS.GET_CALL_HISTORY_DATA
+          });
+          expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+        case 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  describe('sorting  user session response data by sortby', function () {
+    it('Array should be sort.ASC by START TIME ', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var callHistoryPayload, response, responseDetails;
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            callHistoryPayload = _callHistoryFixtures.mockCallHistoryBody;
+            webex.request.mockResolvedValue(callHistoryPayload);
+            _context4.next = 1;
+            return callHistory.getCallHistoryData(10, 20, _types2.SORT.ASC, _types2.SORT_BY.START_TIME);
+          case 1:
+            response = _context4.sent;
+            responseDetails = {
+              statusCode: _callHistoryFixtures.sortedCallHistory.body.statusCode,
+              data: {
+                userSessions: _callHistoryFixtures.sortedCallHistory.body.userSessions
+              },
+              message: 'SUCCESS'
+            };
+            expect(response).toEqual(responseDetails);
+
+            // Verify logs were called with correct information
+            expect(infoSpy).toHaveBeenCalledWith('invoking with days=10, limit=20, sort=ASC, sortBy=startTime', {
+              file: _constants.CALL_HISTORY_FILE,
+              method: _constants.METHODS.GET_CALL_HISTORY_DATA
+            });
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+  });
+  describe('Call History Session Event test', function () {
+    var mockOn = webex.internal.mercury.on;
+    var callHistory;
+    beforeEach(function () {
+      callHistory = (0, _CallHistory.createCallHistoryClient)(webex, {
+        level: _types.LOGGER.INFO
+      });
+    });
+    it('verify the recent user session event ', function (done) {
+      callHistory.on(_types3.COMMON_EVENT_KEYS.CALL_HISTORY_USER_SESSION_INFO, function (event) {
+        expect(event.data).toEqual(_callHistoryFixtures.MOCK_SESSION_EVENT.data);
+        done();
+      });
+      expect(mockOn.mock.calls[0][0]).toEqual(_types3.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE);
+      var callSessionCallback = mockOn.mock.calls[0][1];
+      callSessionCallback(_callHistoryFixtures.MOCK_SESSION_EVENT);
+    });
+    it('verify the user session event received for locus calls', function (done) {
+      callHistory.on(_types3.COMMON_EVENT_KEYS.CALL_HISTORY_USER_SESSION_INFO, function (event) {
+        expect(event.data).toEqual(_callHistoryFixtures.MOCK_SESSION_EVENT_LEGACY.data);
+        done();
+      });
+      expect(mockOn.mock.calls[1][0]).toEqual(_types3.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_LEGACY);
+      var callSessionCallback = mockOn.mock.calls[1][1];
+      callSessionCallback(_callHistoryFixtures.MOCK_SESSION_EVENT_LEGACY);
+    });
+    it('verify the user viewed session event for missed calls update', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      return _regenerator.default.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            _context5.next = 1;
+            return new _promise.default(function (resolve) {
+              callHistory.on(_types3.COMMON_EVENT_KEYS.CALL_HISTORY_USER_VIEWED_SESSIONS, function (event) {
+                expect(event.data).toEqual(_callHistoryFixtures.MOCK_SESSION_EVENT_VIEWED.data);
+                resolve();
+              });
+              expect(mockOn.mock.calls[2][0]).toEqual(_types3.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_VIEWED);
+              var callSessionCallback = mockOn.mock.calls[2][1];
+              callSessionCallback(_callHistoryFixtures.MOCK_SESSION_EVENT_VIEWED);
+            });
+          case 1:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+    it('verify the user sessions deleted event for deleting the call history records', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      return _regenerator.default.wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            _context6.next = 1;
+            return new _promise.default(function (resolve) {
+              callHistory.on(_types3.COMMON_EVENT_KEYS.CALL_HISTORY_USER_SESSIONS_DELETED, function (event) {
+                expect(event.data).toEqual(_callHistoryFixtures.MOCK_SESSION_EVENT_DELETED.data);
+                resolve();
+              });
+              expect(mockOn.mock.calls[3][0]).toEqual(_types3.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_DELETED);
+              var callSessionCallback = mockOn.mock.calls[3][1];
+              callSessionCallback(_callHistoryFixtures.MOCK_SESSION_EVENT_DELETED);
+            });
+          case 1:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    })));
+  });
+  describe('Update missed calls test', function () {
+    var methodDetails = {
+      file: _constants.CALL_HISTORY_FILE,
+      method: _constants.METHODS.UPDATE_MISSED_CALLS
+    };
+    afterEach(function () {
+      jest.clearAllMocks();
+    });
+    beforeEach(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7() {
+      return _regenerator.default.wrap(function (_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            serviceErrorCodeHandlerSpy = jest.spyOn(utils, 'serviceErrorCodeHandler');
+            uploadLogsSpy = jest.spyOn(utils, 'uploadLogs').mockResolvedValue();
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                status: 200,
+                ok: true,
+                json: function json() {
+                  return _promise.default.resolve(_callHistoryFixtures.MOCK_UPDATE_MISSED_CALL_RESPONSE);
+                }
+              });
+            });
+          case 1:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    })));
+    it('successfully updates missed calls', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+      var endTimeSessionIds, response, convertedEndTimeSessionIds, _t, _t2, _t3, _t4, _t5, _t6, _t7;
+      return _regenerator.default.wrap(function (_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            endTimeSessionIds = [{
+              endTime: '1234568',
+              sessionId: '123'
+            }];
+            _context8.next = 1;
+            return callHistory.updateMissedCalls(endTimeSessionIds);
+          case 1:
+            response = _context8.sent;
+            convertedEndTimeSessionIds = endTimeSessionIds.map(function (session) {
+              return _objectSpread(_objectSpread({}, session), {}, {
+                endTime: new Date(session.endTime).getTime()
+              });
+            });
+            expect(response.statusCode).toEqual(200);
+            expect(response).toEqual(_callHistoryFixtures.MOCK_UPDATE_MISSED_CALL_RESPONSE);
+            _t = expect(global.fetch);
+            _t2 = _callHistoryFixtures.janusSetReadStateUrl;
+            _t3 = _types2.HTTP_METHODS.POST;
+            _t4 = _defineProperty2.default;
+            _t5 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+            _context8.next = 2;
+            return webex.credentials.getUserToken();
+          case 2:
+            _t6 = _t4(_t5, "Authorization", _context8.sent);
+            _t7 = (0, _stringify.default)({
+              endTimeSessionIds: convertedEndTimeSessionIds
+            });
+            _t.toBeCalledOnceWith.call(_t, _t2, {
+              method: _t3,
+              headers: _t6,
+              body: _t7
+            });
+            // Verify logs were called with correct information
+            expect(infoSpy).toHaveBeenCalledWith("".concat(_constants2.METHOD_START_MESSAGE, " with sessions: ").concat((0, _stringify.default)(convertedEndTimeSessionIds)), methodDetails);
+            expect(logSpy).toHaveBeenCalledWith('Missed calls are successfully read by the user', methodDetails);
+            expect(errorSpy).not.toHaveBeenCalled();
+            expect(uploadLogsSpy).not.toHaveBeenCalled();
+          case 3:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    })));
+    it('Error: updateMissedCalls throw 400 error', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      var endTimeSessionIds, response, convertedEndTimeSessionIds, _t8, _t9, _t0, _t1, _t10, _t11, _t12;
+      return _regenerator.default.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            endTimeSessionIds = [];
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                status: 400,
+                ok: false
+              });
+            });
+            _context9.next = 1;
+            return callHistory.updateMissedCalls(endTimeSessionIds);
+          case 1:
+            response = _context9.sent;
+            convertedEndTimeSessionIds = endTimeSessionIds.map(function (session) {
+              return _objectSpread(_objectSpread({}, session), {}, {
+                endTime: new Date(session.endTime).getTime()
+              });
+            });
+            expect(response).toStrictEqual(_callHistoryFixtures.ERROR_DETAILS_400);
+            expect(response.statusCode).toBe(400);
+            _t8 = expect(global.fetch);
+            _t9 = _callHistoryFixtures.janusSetReadStateUrl;
+            _t0 = _types2.HTTP_METHODS.POST;
+            _t1 = _defineProperty2.default;
+            _t10 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+            _context9.next = 2;
+            return webex.credentials.getUserToken();
+          case 2:
+            _t11 = _t1(_t10, "Authorization", _context9.sent);
+            _t12 = (0, _stringify.default)({
+              endTimeSessionIds: convertedEndTimeSessionIds
+            });
+            _t8.toBeCalledOnceWith.call(_t8, _t9, {
+              method: _t0,
+              headers: _t11,
+              body: _t12
+            });
+            expect(serviceErrorCodeHandlerSpy).toBeCalledOnceWith({
+              statusCode: 400
+            }, methodDetails);
+            expect(errorSpy).toBeCalledWith(expect.stringContaining('Failed to update missed calls'), methodDetails);
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 3:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    })));
+    it('Error: updateMissedCalls throw 401 error', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee0() {
+      var endTimeSessionIds, response, convertedEndTimeSessionIds, _t13, _t14, _t15, _t16, _t17, _t18, _t19;
+      return _regenerator.default.wrap(function (_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            endTimeSessionIds = [];
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                status: 401,
+                ok: false
+              });
+            });
+            _context0.next = 1;
+            return callHistory.updateMissedCalls(endTimeSessionIds);
+          case 1:
+            response = _context0.sent;
+            convertedEndTimeSessionIds = endTimeSessionIds.map(function (session) {
+              return _objectSpread(_objectSpread({}, session), {}, {
+                endTime: new Date(session.endTime).getTime()
+              });
+            });
+            expect(response).toStrictEqual(_callHistoryFixtures.ERROR_DETAILS_401);
+            expect(response.statusCode).toBe(401);
+            _t13 = expect(global.fetch);
+            _t14 = _callHistoryFixtures.janusSetReadStateUrl;
+            _t15 = _types2.HTTP_METHODS.POST;
+            _t16 = _defineProperty2.default;
+            _t17 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+            _context0.next = 2;
+            return webex.credentials.getUserToken();
+          case 2:
+            _t18 = _t16(_t17, "Authorization", _context0.sent);
+            _t19 = (0, _stringify.default)({
+              endTimeSessionIds: convertedEndTimeSessionIds
+            });
+            _t13.toBeCalledOnceWith.call(_t13, _t14, {
+              method: _t15,
+              headers: _t18,
+              body: _t19
+            });
+            expect(serviceErrorCodeHandlerSpy).toBeCalledOnceWith({
+              statusCode: 401
+            }, methodDetails);
+            expect(errorSpy).toHaveBeenCalled();
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 3:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0);
+    })));
+  });
+  describe('fetchUCMLinesData test', function () {
+    beforeEach(function () {
+      uploadLogsSpy = jest.spyOn(utils, 'uploadLogs').mockResolvedValue();
+    });
+    it('verify successful UCM lines API case', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee1() {
+      var ucmLinesAPIPayload, response;
+      return _regenerator.default.wrap(function (_context1) {
+        while (1) switch (_context1.prev = _context1.next) {
+          case 0:
+            ucmLinesAPIPayload = _callHistoryFixtures.MOCK_LINES_API_CALL_RESPONSE;
+            webex.request.mockResolvedValue(ucmLinesAPIPayload);
+            _context1.next = 1;
+            return callHistory['fetchUCMLinesData']();
+          case 1:
+            response = _context1.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.message).toBe('SUCCESS');
+
+            // Verify logs were called with correct information
+            expect(infoSpy).toHaveBeenCalledWith('invoking with URL: https://gw.telemetry.int-ucmgmt.cisco.com/v1/uc/config/people/8a67806f-fc4d-446b-a131-31e71ea5b0e9/lines?orgId=1704d30d-a131-4bc7-9449-948487643793', {
+              file: _constants.CALL_HISTORY_FILE,
+              method: _constants.METHODS.FETCH_UCM_LINES_DATA
+            });
+            expect(logSpy).toHaveBeenCalledWith('Line details fetched successfully', {
+              file: _constants.CALL_HISTORY_FILE,
+              method: _constants.METHODS.FETCH_UCM_LINES_DATA
+            });
+            expect(errorSpy).not.toHaveBeenCalled();
+            expect(uploadLogsSpy).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context1.stop();
+        }
+      }, _callee1);
+    })));
+    it('verify bad request failed UCM lines API case', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee10() {
+      var failurePayload, ucmLinesAPIPayload, response;
+      return _regenerator.default.wrap(function (_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            failurePayload = {
+              statusCode: 400
+            };
+            ucmLinesAPIPayload = failurePayload;
+            webex.request.mockRejectedValue(ucmLinesAPIPayload);
+            _context10.next = 1;
+            return callHistory['fetchUCMLinesData']();
+          case 1:
+            response = _context10.sent;
+            expect(response).toStrictEqual(_callHistoryFixtures.ERROR_DETAILS_400);
+            expect(response.data.error).toEqual(_callHistoryFixtures.ERROR_DETAILS_400.data.error);
+            expect(response.statusCode).toBe(400);
+            expect(response.message).toBe('FAILURE');
+            expect(serviceErrorCodeHandlerSpy).toHaveBeenCalledWith({
+              statusCode: 400
+            }, {
+              file: _constants.CALL_HISTORY_FILE,
+              method: _constants.METHODS.FETCH_UCM_LINES_DATA
+            });
+
+            // Verify logs were called with correct information
+            expect(infoSpy).toHaveBeenCalledWith("".concat(_constants2.METHOD_START_MESSAGE, " with URL: https://gw.telemetry.int-ucmgmt.cisco.com/v1/uc/config/people/8a67806f-fc4d-446b-a131-31e71ea5b0e9/lines?orgId=1704d30d-a131-4bc7-9449-948487643793"), {
+              file: _constants.CALL_HISTORY_FILE,
+              method: _constants.METHODS.FETCH_UCM_LINES_DATA
+            });
+            expect(errorSpy).toHaveBeenCalled();
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 2:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    })));
+    it('should call fetchUCMLinesData when calling backend is UCM and userSessions contain valid cucmDN', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee11() {
+      var fetchUCMLinesDataSpy, mockCallHistoryPayload, response;
+      return _regenerator.default.wrap(function (_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.UCM);
+            // Since fetchUCMLinesData is a private method, TypeScript restricts direct access to it.
+            // To bypass this restriction, we are using 'as any' to access and invoke the method for testing purposes.
+            fetchUCMLinesDataSpy = jest.spyOn(callHistory, 'fetchUCMLinesData').mockResolvedValue(_callHistoryFixtures.MOCK_LINES_API_CALL_RESPONSE);
+            mockCallHistoryPayload = _callHistoryFixtures.MOCK_CALL_HISTORY_WITH_UCM_LINE_NUMBER;
+            webex.request.mockResolvedValue(mockCallHistoryPayload);
+            _context11.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            response = _context11.sent;
+            expect(fetchUCMLinesDataSpy).toHaveBeenCalledTimes(1);
+            expect(response.statusCode).toBe(200);
+            expect(response.data.userSessions && response.data.userSessions[0].self.ucmLineNumber).toEqual(1);
+          case 2:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    })));
+    it('should fetchUCMLinesData but not assign ucmLineNumber when UCM backend has no line data', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee12() {
+      var fetchUCMLinesDataSpy, mockCallHistoryPayload, response;
+      return _regenerator.default.wrap(function (_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.UCM);
+
+            // Since fetchUCMLinesData is a private method, TypeScript restricts direct access to it.
+            // To bypass this restriction, we are using 'as any' to access and invoke the method for testing purposes.
+            fetchUCMLinesDataSpy = jest.spyOn(callHistory, 'fetchUCMLinesData').mockResolvedValue(_callHistoryFixtures.MOCK_LINES_API_CALL_RESPONSE_WITH_NO_LINEDATA);
+            mockCallHistoryPayload = _callHistoryFixtures.MOCK_CALL_HISTORY_WITHOUT_UCM_LINE_NUMBER;
+            webex.request.mockResolvedValue(mockCallHistoryPayload);
+            _context12.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            response = _context12.sent;
+            expect(fetchUCMLinesDataSpy).toHaveBeenCalledTimes(1);
+            expect(response.statusCode).toBe(200);
+            expect(response.data.userSessions && response.data.userSessions[0].self.cucmDN).toBeDefined();
+            expect(response.data.userSessions && response.data.userSessions[0].self.ucmLineNumber).toEqual(undefined);
+          case 2:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12);
+    })));
+    it('should not call fetchUCMLinesData when calling backend is UCM but no valid cucmDN is present', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee13() {
+      var fetchUCMLinesDataSpy, callHistoryPayload;
+      return _regenerator.default.wrap(function (_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.UCM);
+            // Since fetchUCMLinesData is a private method, TypeScript restricts direct access to it.
+            // To bypass this restriction, we are using 'as any' to access and invoke the method for testing purposes.
+            fetchUCMLinesDataSpy = jest.spyOn(callHistory, 'fetchUCMLinesData').mockResolvedValue({});
+            callHistoryPayload = _callHistoryFixtures.mockCallHistoryBody;
+            webex.request.mockResolvedValue(callHistoryPayload);
+            _context13.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            expect(fetchUCMLinesDataSpy).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13);
+    })));
+    it('should not call fetchUCMLinesData when calling backend is not UCM', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee14() {
+      var fetchUCMLinesDataSpy, callHistoryPayload;
+      return _regenerator.default.wrap(function (_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.WXC);
+            // Since fetchUCMLinesData is a private method, TypeScript restricts direct access to it.
+            // To bypass this restriction, we are using 'as any' to access and invoke the method for testing purposes.
+            fetchUCMLinesDataSpy = jest.spyOn(callHistory, 'fetchUCMLinesData').mockResolvedValue({});
+            callHistoryPayload = _callHistoryFixtures.mockCallHistoryBody;
+            webex.request.mockResolvedValue(callHistoryPayload);
+            _context14.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            expect(fetchUCMLinesDataSpy).not.toHaveBeenCalled(); // Check that fetchUCMLinesData was not called
+          case 2:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14);
+    })));
+  });
+  describe('Delete call history records test', function () {
+    var methodDetails = {
+      file: _constants.CALL_HISTORY_FILE,
+      method: _constants.METHODS.DELETE_CALL_HISTORY_RECORDS
+    };
+    afterEach(function () {
+      jest.clearAllMocks();
+    });
+    beforeEach(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee15() {
+      return _regenerator.default.wrap(function (_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
+          case 0:
+            serviceErrorCodeHandlerSpy = jest.spyOn(utils, 'serviceErrorCodeHandler');
+            uploadLogsSpy = jest.spyOn(utils, 'uploadLogs').mockResolvedValue();
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                status: 200,
+                ok: true,
+                json: function json() {
+                  return _promise.default.resolve(_callHistoryFixtures.MOCK_DELETE_CALL_HISTORY_RECORDS_RESPONSE);
+                }
+              });
+            });
+          case 1:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15);
+    })));
+    it('successfully deletes the call history records', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee16() {
+      var deleteSessionIds, response, convertedEndTimeSessionIds, _t20, _t21, _t22, _t23, _t24, _t25, _t26;
+      return _regenerator.default.wrap(function (_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
+          case 0:
+            deleteSessionIds = [{
+              endTime: '2024-10-22T08:50:48.603Z',
+              sessionId: '123'
+            }];
+            _context16.next = 1;
+            return callHistory.deleteCallHistoryRecords(deleteSessionIds);
+          case 1:
+            response = _context16.sent;
+            convertedEndTimeSessionIds = deleteSessionIds.map(function (session) {
+              return _objectSpread(_objectSpread({}, session), {}, {
+                endTime: new Date(session.endTime).getTime()
+              });
+            });
+            expect(response.statusCode).toEqual(200);
+            expect(response).toEqual(_callHistoryFixtures.MOCK_DELETE_CALL_HISTORY_RECORDS_RESPONSE);
+            _t20 = expect(global.fetch);
+            _t21 = _callHistoryFixtures.janusMarkAsDeletedUrl;
+            _t22 = _types2.HTTP_METHODS.POST;
+            _t23 = _defineProperty2.default;
+            _t24 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+            _context16.next = 2;
+            return webex.credentials.getUserToken();
+          case 2:
+            _t25 = _t23(_t24, "Authorization", _context16.sent);
+            _t26 = (0, _stringify.default)({
+              deleteSessionIds: convertedEndTimeSessionIds
+            });
+            _t20.toBeCalledOnceWith.call(_t20, _t21, {
+              method: _t22,
+              headers: _t25,
+              body: _t26
+            });
+            // Verify logs were called with correct information
+            expect(infoSpy).toHaveBeenCalledWith("".concat(_constants2.METHOD_START_MESSAGE, " with sessions: ").concat((0, _stringify.default)(deleteSessionIds)), methodDetails);
+            expect(logSpy).toHaveBeenCalledWith("Successfully deleted ".concat(deleteSessionIds.length, " call history records"), methodDetails);
+            expect(errorSpy).not.toHaveBeenCalled();
+            expect(uploadLogsSpy).not.toHaveBeenCalled();
+          case 3:
+          case "end":
+            return _context16.stop();
+        }
+      }, _callee16);
+    })));
+    it('Error: deleteCallHistoryRecords throw 400 error', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee17() {
+      var deleteSessionIds, response, convertedEndTimeSessionIds, _t27, _t28, _t29, _t30, _t31, _t32, _t33;
+      return _regenerator.default.wrap(function (_context17) {
+        while (1) switch (_context17.prev = _context17.next) {
+          case 0:
+            deleteSessionIds = [];
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                status: 400,
+                ok: false
+              });
+            });
+            _context17.next = 1;
+            return callHistory.deleteCallHistoryRecords(deleteSessionIds);
+          case 1:
+            response = _context17.sent;
+            convertedEndTimeSessionIds = deleteSessionIds.map(function (session) {
+              return _objectSpread(_objectSpread({}, session), {}, {
+                endTime: new Date(session.endTime).getTime()
+              });
+            });
+            expect(response).toStrictEqual(_callHistoryFixtures.ERROR_DETAILS_400);
+            expect(response.statusCode).toBe(400);
+            _t27 = expect(global.fetch);
+            _t28 = _callHistoryFixtures.janusMarkAsDeletedUrl;
+            _t29 = _types2.HTTP_METHODS.POST;
+            _t30 = _defineProperty2.default;
+            _t31 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+            _context17.next = 2;
+            return webex.credentials.getUserToken();
+          case 2:
+            _t32 = _t30(_t31, "Authorization", _context17.sent);
+            _t33 = (0, _stringify.default)({
+              deleteSessionIds: convertedEndTimeSessionIds
+            });
+            _t27.toBeCalledOnceWith.call(_t27, _t28, {
+              method: _t29,
+              headers: _t32,
+              body: _t33
+            });
+            expect(serviceErrorCodeHandlerSpy).toBeCalledOnceWith({
+              statusCode: 400
+            }, methodDetails);
+            expect(errorSpy).toHaveBeenCalled();
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 3:
+          case "end":
+            return _context17.stop();
+        }
+      }, _callee17);
+    })));
+    it('Error: deleteCallHistoryRecords throw 401 error', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee18() {
+      var deleteSessionIds, response, convertedEndTimeSessionIds, _t34, _t35, _t36, _t37, _t38, _t39, _t40;
+      return _regenerator.default.wrap(function (_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
+          case 0:
+            deleteSessionIds = [];
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                status: 401,
+                ok: false
+              });
+            });
+            _context18.next = 1;
+            return callHistory.deleteCallHistoryRecords(deleteSessionIds);
+          case 1:
+            response = _context18.sent;
+            convertedEndTimeSessionIds = deleteSessionIds.map(function (session) {
+              return _objectSpread(_objectSpread({}, session), {}, {
+                endTime: new Date(session.endTime).getTime()
+              });
+            });
+            expect(response).toStrictEqual(_callHistoryFixtures.ERROR_DETAILS_401);
+            expect(response.statusCode).toBe(401);
+            _t34 = expect(global.fetch);
+            _t35 = _callHistoryFixtures.janusMarkAsDeletedUrl;
+            _t36 = _types2.HTTP_METHODS.POST;
+            _t37 = _defineProperty2.default;
+            _t38 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+            _context18.next = 2;
+            return webex.credentials.getUserToken();
+          case 2:
+            _t39 = _t37(_t38, "Authorization", _context18.sent);
+            _t40 = (0, _stringify.default)({
+              deleteSessionIds: convertedEndTimeSessionIds
+            });
+            _t34.toBeCalledOnceWith.call(_t34, _t35, {
+              method: _t36,
+              headers: _t39,
+              body: _t40
+            });
+            expect(serviceErrorCodeHandlerSpy).toBeCalledOnceWith({
+              statusCode: 401
+            }, methodDetails);
+            expect(errorSpy).toBeCalledWith(expect.stringContaining('Failed to delete call history records'), {
+              file: _constants.CALL_HISTORY_FILE,
+              method: _constants.METHODS.DELETE_CALL_HISTORY_RECORDS
+            });
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 3:
+          case "end":
+            return _context18.stop();
+        }
+      }, _callee18);
+    })));
+    it('handles invalid date formats gracefully', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee19() {
+      var deleteSessionIds, response;
+      return _regenerator.default.wrap(function (_context19) {
+        while (1) switch (_context19.prev = _context19.next) {
+          case 0:
+            deleteSessionIds = [{
+              endTime: 'invalid-date',
+              sessionId: '123'
+            }]; // Mock the response to be 400 and trigger an error in your function
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                status: 400,
+                ok: false
+              });
+            });
+            _context19.next = 1;
+            return callHistory.deleteCallHistoryRecords(deleteSessionIds);
+          case 1:
+            response = _context19.sent;
+            expect(response.statusCode).toBe(400);
+            expect(response).toEqual(_callHistoryFixtures.MOCK_DELETE_CALL_HISTORY_INVALID_DATE_RESPONSE);
+
+            // Verify logs were called with correct information
+            expect(infoSpy).toHaveBeenCalledWith(expect.stringContaining('The provided date is malformed or invalid'), methodDetails);
+            expect(uploadLogsSpy).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context19.stop();
+        }
+      }, _callee19);
+    })));
+  });
+  describe('URL construction for shared sessions based on calling backend', function () {
+    var webexRequestSpy;
+    beforeEach(function () {
+      webexRequestSpy = jest.spyOn(webex, 'request').mockResolvedValue({
+        statusCode: 200,
+        body: {
+          statusCode: 200,
+          userSessions: []
+        }
+      });
+    });
+    afterEach(function () {
+      jest.restoreAllMocks();
+    });
+    it('should include includeSharedSessions=true for WXC backend', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee20() {
+      var callArgs;
+      return _regenerator.default.wrap(function (_context20) {
+        while (1) switch (_context20.prev = _context20.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.WXC);
+            _context20.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            callArgs = webexRequestSpy.mock.calls[0][0];
+            expect(callArgs.uri).toContain('&includeSharedSessions=true');
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.GET);
+            expect(callArgs.service).toBe('janus');
+          case 2:
+          case "end":
+            return _context20.stop();
+        }
+      }, _callee20);
+    })));
+    it('should NOT include includeSharedSessions for UCM backend', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee21() {
+      var callArgs;
+      return _regenerator.default.wrap(function (_context21) {
+        while (1) switch (_context21.prev = _context21.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.UCM);
+            _context21.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            callArgs = webexRequestSpy.mock.calls[0][0];
+            expect(callArgs.uri).not.toContain('includeSharedSessions');
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.GET);
+            expect(callArgs.service).toBe('janus');
+          case 2:
+          case "end":
+            return _context21.stop();
+        }
+      }, _callee21);
+    })));
+    it('should NOT include includeSharedSessions for BWRKS backend', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee22() {
+      var callArgs;
+      return _regenerator.default.wrap(function (_context22) {
+        while (1) switch (_context22.prev = _context22.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.BWRKS);
+            _context22.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            callArgs = webexRequestSpy.mock.calls[0][0];
+            expect(callArgs.uri).not.toContain('includeSharedSessions');
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.GET);
+            expect(callArgs.service).toBe('janus');
+          case 2:
+          case "end":
+            return _context22.stop();
+        }
+      }, _callee22);
+    })));
+    it('should NOT include includeSharedSessions for unknown/other backends', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee23() {
+      var callArgs;
+      return _regenerator.default.wrap(function (_context23) {
+        while (1) switch (_context23.prev = _context23.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue('OTHER_BACKEND');
+            _context23.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            callArgs = webexRequestSpy.mock.calls[0][0];
+            expect(callArgs.uri).not.toContain('includeSharedSessions');
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.GET);
+            expect(callArgs.service).toBe('janus');
+          case 2:
+          case "end":
+            return _context23.stop();
+        }
+      }, _callee23);
+    })));
+    it('should construct URL correctly with base parameters for all backends', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee24() {
+      var callArgs;
+      return _regenerator.default.wrap(function (_context24) {
+        while (1) switch (_context24.prev = _context24.next) {
+          case 0:
+            jest.spyOn(utils, 'getCallingBackEnd').mockReturnValue(_types2.CALLING_BACKEND.WXC);
+            _context24.next = 1;
+            return callHistory.getCallHistoryData(7, 10, _types2.SORT.DEFAULT, _types2.SORT_BY.DEFAULT);
+          case 1:
+            callArgs = webexRequestSpy.mock.calls[0][0];
+            expect(callArgs.uri).toMatch(/.*\/history\/userSessions.*limit=10.*includeNewSessionTypes=true.*sort=DESC.*/);
+            expect(callArgs.uri).toContain('&includeSharedSessions=true');
+          case 2:
+          case "end":
+            return _context24.stop();
+        }
+      }, _callee24);
+    })));
+  });
+});
+//# sourceMappingURL=CallHistory.test.js.map