@webex/calling 3.8.0-web-workers-keepalive.2 → 3.8.1-next.1

package/dist/CallingClient/registration/register.test.js

@@ -28,6 +28,7 @@ var _types3 = require("../../Errors/types");
 var _constants = require("../constants");
 var _types4 = require("../line/types");
 var _LineError = require("../../Errors/catalog/LineError");
+var _types5 = require("../../Metrics/types");
 function _getRequireWildcardCache(e) { if ("function" != typeof _WeakMap) return null; var r = new _WeakMap(), t = new _WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = _Object$defineProperty && _Object$getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? _Object$getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? _Object$defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function ownKeys(e, r) { var t = _Object$keys2(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; }
@@ -37,9 +38,11 @@ var MockServiceData = {
   indicator: _types.ServiceIndicator.CALLING,
   domain: ''
 };
-var logSpy = jest.spyOn(_Logger.default, 'info');
+var logSpy = jest.spyOn(_Logger.default, 'log');
+var infoSpy = jest.spyOn(_Logger.default, 'info');
 var warnSpy = jest.spyOn(_Logger.default, 'warn');
 var handleErrorSpy = jest.spyOn(utils, 'handleRegistrationErrors');
+jest.spyOn(utils, 'uploadLogs').mockResolvedValue();
 describe('Registration Tests', function () {
   var originalProcessNextTick = process.nextTick;
   function flushPromises() {
@@ -70,30 +73,64 @@ describe('Registration Tests', function () {
   });
   var failurePayload = {
     statusCode: 500,
-    body: _registerFixtures.mockPostResponse
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      trackingid: 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15'
+    }
+  };
+  var failurePayload429One = {
+    statusCode: 429,
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      'retry-after': 42
+    }
+  };
+  var failurePayload429Two = {
+    statusCode: 429,
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      'retry-after': 33
+    }
+  };
+  var failurePayload429Three = {
+    statusCode: 429,
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      'retry-after': 136
+    }
   };
-  var failurePayload429 = {
+  var failurePayload429Four = {
     statusCode: 429,
-    body: _registerFixtures.mockPostResponse
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      'retry-after': 81
+    }
   };
   var successPayload = {
     statusCode: 200,
-    body: _registerFixtures.mockPostResponse
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      trackingid: 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15'
+    }
   };
   var reg;
   var restartSpy;
-  var failbackRetry429Spy;
   var restoreSpy;
   var postRegistrationSpy;
+  var failoverSpy;
+  var retry429Spy;
+  var metricSpy;
   var setupRegistration = function setupRegistration(mockServiceData) {
     var mutex = new _asyncMutex.Mutex();
     reg = (0, _register.createRegistration)(webex, mockServiceData, mutex, lineEmitter, _types2.LOGGER.INFO);
     reg.setMobiusServers(mobiusUris.primary, mobiusUris.backup);
     jest.clearAllMocks();
     restartSpy = jest.spyOn(reg, 'restartRegistration');
-    failbackRetry429Spy = jest.spyOn(reg, _constants.FAILBACK_429_RETRY_UTIL);
     restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
     postRegistrationSpy = jest.spyOn(reg, 'postRegistration');
+    failoverSpy = jest.spyOn(reg, 'startFailoverTimer');
+    retry429Spy = jest.spyOn(reg, 'handle429Retry');
+    metricSpy = jest.spyOn(reg.metricManager, 'submitRegistrationMetric');
   };
   beforeEach(function () {
     setupRegistration(MockServiceData);
@@ -109,7 +146,10 @@ describe('Registration Tests', function () {
       while (1) switch (_context.prev = _context.next) {
         case 0:
           webex.request.mockReturnValueOnce({
-            body: _registerFixtures.mockPostResponse
+            body: _registerFixtures.mockPostResponse,
+            headers: {
+              trackingid: 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15'
+            }
           });
           _context.next = 3;
           return reg.triggerRegistration();
@@ -121,7 +161,14 @@ describe('Registration Tests', function () {
           expect(lineEmitter).toBeCalledTimes(2);
           expect(lineEmitter).toBeCalledWith(_types4.LINE_EVENTS.CONNECTING);
           expect(lineEmitter).toBeCalledWith(_types4.LINE_EVENTS.REGISTERED, _registerFixtures.mockPostResponse);
-        case 8:
+
+          // Check that log.log was called for successful registration
+          expect(logSpy).toBeCalledWith("Registration successful for deviceId: ".concat(_registerFixtures.mockPostResponse.device.deviceId, " userId: ").concat(_registerFixtures.mockPostResponse.userId), expect.objectContaining({
+            file: _constants.REGISTRATION_FILE,
+            method: expect.any(String)
+          }));
+          expect(metricSpy).toBeCalledWith(_types5.METRIC_EVENT.REGISTRATION, _types5.REG_ACTION.REGISTER, _types5.METRIC_TYPE.BEHAVIORAL, _constants.REGISTRATION_UTIL, 'PRIMARY', 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15', undefined, undefined);
+        case 10:
         case "end":
           return _context.stop();
       }
@@ -134,7 +181,8 @@ describe('Registration Tests', function () {
         case 0:
           webex.request.mockRejectedValue({
             body: _registerFixtures.mockPostResponse,
-            statusCode: 401
+            statusCode: 401,
+            headers: {}
           });
           _context2.next = 3;
           return reg.triggerRegistration();
@@ -147,7 +195,8 @@ describe('Registration Tests', function () {
           expect(lineEmitter).toBeCalledTimes(2);
           expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.CONNECTING);
           expect(lineEmitter).nthCalledWith(2, _types4.LINE_EVENTS.ERROR, undefined, error);
-        case 9:
+          expect(metricSpy).toBeCalledWith(_types5.METRIC_EVENT.REGISTRATION_ERROR, _types5.REG_ACTION.REGISTER, _types5.METRIC_TYPE.BEHAVIORAL, _constants.REGISTRATION_UTIL, 'PRIMARY', '', undefined, error);
+        case 10:
         case "end":
           return _context2.stop();
       }
@@ -166,7 +215,10 @@ describe('Registration Tests', function () {
             statusCode: 403
           }).mockResolvedValueOnce({
             statusCode: 200,
-            body: _registerFixtures.mockPostResponse
+            body: _registerFixtures.mockPostResponse,
+            headers: {
+              trackingid: 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15'
+            }
           });
           global.fetch = jest.fn(function () {
             return _promise.default.resolve({
@@ -188,34 +240,360 @@ describe('Registration Tests', function () {
             headers: expect.anything()
           });
           expect(warnSpy).toBeCalledWith('User device limit exceeded', expect.anything());
-          expect(logSpy).toBeCalledWith('Registration restoration in progress.', expect.anything());
-          expect(logSpy).toBeCalledWith('Registration restored successfully.', expect.anything());
+          expect(infoSpy).toBeCalledWith('Registration restoration in progress.', expect.anything());
+          expect(infoSpy).toBeCalledWith('Registration restored successfully.', expect.anything());
           expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
           expect(lineEmitter).toBeCalledTimes(4);
           expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.CONNECTING);
           expect(lineEmitter).nthCalledWith(2, _types4.LINE_EVENTS.UNREGISTERED);
           expect(lineEmitter).nthCalledWith(3, _types4.LINE_EVENTS.CONNECTING);
           expect(lineEmitter).nthCalledWith(4, _types4.LINE_EVENTS.REGISTERED, _registerFixtures.mockPostResponse);
-        case 17:
+          expect(metricSpy).toBeCalledWith(_types5.METRIC_EVENT.REGISTRATION, _types5.REG_ACTION.REGISTER, _types5.METRIC_TYPE.BEHAVIORAL, _constants.REGISTRATION_UTIL, 'UNKNOWN', 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15', undefined, undefined);
+        case 18:
         case "end":
           return _context3.stop();
       }
     }, _callee3);
   })));
-  describe('Registration failover tests', function () {
-    it('verify unreachable primary with reachable backup servers', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
+  describe('429 handling tests', function () {
+    var loggerContext = {
+      file: _constants.REGISTRATION_FILE,
+      method: _constants.FAILOVER_UTIL
+    };
+    var logSpy = jest.spyOn(_Logger.default, 'log');
+    beforeEach(function () {
+      mobiusUris.backup.pop();
+    });
+    afterEach(function () {
+      mobiusUris.backup.push(_registerFixtures.URL);
+      jest.clearAllMocks();
+    });
+    it('handle 429 received during initial registration failure and first attempt with primary', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4() {
       return _regenerator.default.wrap(function _callee4$(_context4) {
         while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            jest.useFakeTimers();
+            logSpy.mockClear();
+            webex.request.mockRejectedValueOnce(failurePayload429One).mockRejectedValueOnce(failurePayload429Two).mockRejectedValueOnce(failurePayload);
+            _context4.next = 5;
+            return reg.triggerRegistration();
+          case 5:
+            /* Initial registration failed with 429 with higher retyrAfter, interval should be updtaed with retryAfter.
+             * The first attempt to register with primary should be made after retryAfter seconds.
+             */
+
+            expect(webex.request).toHaveBeenNthCalledWith(1, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(retry429Spy).toBeCalledOnceWith(failurePayload429One.headers['retry-after'], 'triggerRegistration');
+            expect(reg.retryAfter).toEqual(failurePayload429One.headers['retry-after']);
+            expect(failoverSpy).toBeCalledOnceWith();
+            expect(logSpy).toBeCalledWith("Scheduled retry with primary in ".concat(failurePayload429One.headers['retry-after'], " seconds, number of attempts : 1"), loggerContext);
+            retry429Spy.mockClear();
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(Number(failurePayload429One.headers['retry-after']) * _constants.SEC_TO_MSEC_MFACTOR);
+            _context4.next = 16;
+            return flushPromises();
+          case 16:
+            /* The first attempt to register with primary failed with 429 with lower retryAfter, interval should remain the same.
+             * The second attempt to register with primary will be scheduled as per the interval calculated.
+             */
+
+            expect(webex.request).toHaveBeenNthCalledWith(2, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(retry429Spy).toBeCalledOnceWith(failurePayload429Two.headers['retry-after'], 'startFailoverTimer');
+            expect(reg.retryAfter).toEqual(failurePayload429Two.headers['retry-after']);
+            expect(failoverSpy).toBeCalledOnceWith(2, failurePayload429One.headers['retry-after']);
+            retry429Spy.mockClear();
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(43 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context4.next = 25;
+            return flushPromises();
+          case 25:
+            /* The second attempt to register with primary failed with 500, the retryAfter should be undefined.
+             * The third attempt to register with primary will be scheduled as per the interval calculated.
+             */
+            expect(webex.request).toHaveBeenNthCalledWith(3, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(retry429Spy).not.toBeCalled();
+            expect(reg.retryAfter).toEqual(undefined);
+            expect(failoverSpy).toBeCalledOnceWith(3, 85);
+          case 29:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+    it('handle 429 received with higher retryAfter than the interval when interval with elapsedTime is already reaching threshold timer so we failover immediately', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      return _regenerator.default.wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            reg.isCCFlow = true;
+            jest.spyOn(reg, 'getRegRetryInterval').mockReturnValueOnce(33).mockReturnValueOnce(40).mockReturnValueOnce(47).mockReturnValueOnce(52);
+            jest.useFakeTimers();
+            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload429One).mockResolvedValueOnce(successPayload);
+            _context5.next = 6;
+            return reg.triggerRegistration();
+          case 6:
+            expect(webex.request).toHaveBeenNthCalledWith(1, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(retry429Spy).not.toBeCalled();
+            expect(failoverSpy).toBeCalledOnceWith();
+            expect(logSpy).toBeCalledWith("Scheduled retry with primary in 33 seconds, number of attempts : 1", loggerContext);
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(33 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context5.next = 15;
+            return flushPromises();
+          case 15:
+            expect(webex.request).toHaveBeenNthCalledWith(2, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(retry429Spy).not.toBeCalled();
+            expect(failoverSpy).toBeCalledOnceWith(2, 33);
+            expect(logSpy).toBeCalledWith("Scheduled retry with primary in 40 seconds, number of attempts : 2", loggerContext);
+            logSpy.mockClear();
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(40 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context5.next = 24;
+            return flushPromises();
+          case 24:
+            expect(webex.request).toHaveBeenNthCalledWith(3, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(retry429Spy).toBeCalledOnceWith(failurePayload429One.headers['retry-after'], 'startFailoverTimer');
+            expect(failoverSpy).toBeCalledOnceWith(3, 73);
+            expect(logSpy).not.toBeCalledWith("Scheduled retry with primary in ".concat(failurePayload429One.headers['retry-after'], " seconds, number of attempts : 3"), loggerContext);
+            expect(infoSpy).toBeCalledWith("Failing over to backup servers.", loggerContext);
+            expect(webex.request).toHaveBeenNthCalledWith(4, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          case 31:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+    it('handle 429 received while the last attempt for primary', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      return _regenerator.default.wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            reg.isCCFlow = true;
+            jest.spyOn(reg, 'getRegRetryInterval').mockReturnValueOnce(33).mockReturnValueOnce(40).mockReturnValueOnce(47).mockReturnValueOnce(52);
+            jest.useFakeTimers();
+            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload429One).mockResolvedValueOnce(successPayload);
+            _context6.next = 6;
+            return reg.triggerRegistration();
+          case 6:
+            /* Initial registration and first 2 attempts with primary failed with non-final 5xx error responses.
+             * Last attempt with primary failed with 429, the retryAfter should be used to schedule the next attempt but
+             * the failover is triggered before the scheduling logic kicks in.
+             */
+            expect(webex.request).toHaveBeenNthCalledWith(1, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(retry429Spy).not.toBeCalled();
+            expect(failoverSpy).toBeCalledOnceWith();
+            expect(logSpy).toBeCalledWith("Scheduled retry with primary in 33 seconds, number of attempts : 1", loggerContext);
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(33 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context6.next = 15;
+            return flushPromises();
+          case 15:
+            expect(webex.request).toHaveBeenNthCalledWith(2, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(retry429Spy).not.toBeCalled();
+            expect(failoverSpy).toBeCalledOnceWith(2, 33);
+            expect(logSpy).toBeCalledWith("Scheduled retry with primary in 40 seconds, number of attempts : 2", loggerContext);
+            logSpy.mockClear();
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(40 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context6.next = 24;
+            return flushPromises();
+          case 24:
+            expect(webex.request).toHaveBeenNthCalledWith(3, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(retry429Spy).not.toBeCalled();
+            expect(failoverSpy).toBeCalledOnceWith(3, 73);
+            expect(logSpy).toBeCalledWith("Scheduled retry with primary in 41 seconds, number of attempts : 3", loggerContext);
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(41 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context6.next = 32;
+            return flushPromises();
+          case 32:
+            expect(webex.request).toHaveBeenNthCalledWith(4, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(retry429Spy).toBeCalledOnceWith(failurePayload429One.headers['retry-after'], 'startFailoverTimer');
+            expect(failoverSpy).toBeCalledOnceWith(4, 114);
+            expect(infoSpy).toBeCalledWith("Failing over to backup servers.", loggerContext);
+            expect(webex.request).toHaveBeenNthCalledWith(5, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          case 38:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    })));
+    it('handle 429 received while failing over to backup server for CC flow', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+      return _regenerator.default.wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            reg.isCCFlow = true;
+            jest.useFakeTimers();
+            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload429One).mockResolvedValueOnce(successPayload);
+            _context7.next = 5;
+            return reg.triggerRegistration();
+          case 5:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context7.next = 8;
+            return flushPromises();
+          case 8:
+            expect(webex.request).toBeCalledTimes(3);
+            expect(webex.request).toHaveBeenNthCalledWith(1, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(webex.request).toHaveBeenNthCalledWith(2, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+
+            /* Failover to backup server failed with 429, the retryAfter is used to schedule the next attempt with backup server.
+             * Interval will be updated with retryAfter as interval calculated is less than the retryAfter.
+             */
+            expect(webex.request).toHaveBeenNthCalledWith(3, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            expect(retry429Spy).toBeCalledOnceWith(failurePayload429One.headers['retry-after'], 'startFailoverTimer');
+            expect(logSpy).toBeCalledWith("Scheduled retry with backup servers in ".concat(failurePayload429One.headers['retry-after'], " seconds."), loggerContext);
+            webex.request.mockClear();
+            jest.advanceTimersByTime(Number(failurePayload429One.headers['retry-after']) * _constants.SEC_TO_MSEC_MFACTOR);
+            _context7.next = 18;
+            return flushPromises();
+          case 18:
+            expect(webex.request).toBeCalledOnceWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          case 20:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7);
+    })));
+    it('checking the retryAfter exceeding the threshold timers in first attempt itself', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+      return _regenerator.default.wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            reg.isCCFlow = true;
+            jest.useFakeTimers();
+            jest.spyOn(reg, 'getRegRetryInterval').mockReturnValueOnce(40);
+            webex.request.mockRejectedValueOnce(failurePayload429Three);
+            _context8.next = 6;
+            return reg.triggerRegistration();
+          case 6:
+            expect(webex.request).toHaveBeenNthCalledWith(1, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(failoverSpy).toBeCalledOnceWith();
+            expect(infoSpy).toBeCalledWith("Failing over to backup servers.", loggerContext);
+            expect(logSpy).not.toBeCalledWith("Scheduled retry with primary in 40 seconds, number of attempts : 1", loggerContext);
+            expect(logSpy).not.toBeCalledWith("Scheduled retry with primary in ".concat(failurePayload429Three.headers['retry-after'], " seconds, number of attempts : 1"), loggerContext);
+            expect(webex.request).toHaveBeenNthCalledWith(2, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+          case 13:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    })));
+    it('checking the retryAfter exceeding the threshold timers in later attempts', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      return _regenerator.default.wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            reg.isCCFlow = true;
+            jest.useFakeTimers();
+            jest.spyOn(reg, 'getRegRetryInterval').mockReturnValueOnce(39).mockReturnValueOnce(43);
+            webex.request.mockRejectedValueOnce(failurePayload429One).mockRejectedValueOnce(failurePayload429Four).mockResolvedValueOnce(successPayload);
+            _context9.next = 6;
+            return reg.triggerRegistration();
+          case 6:
+            expect(webex.request).toHaveBeenNthCalledWith(1, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(failoverSpy).toBeCalledOnceWith();
+            expect(logSpy).toBeCalledWith("Scheduled retry with primary in ".concat(failurePayload429One.headers['retry-after'], " seconds, number of attempts : 1"), loggerContext);
+            failoverSpy.mockClear();
+            jest.advanceTimersByTime(Number(failurePayload429One.headers['retry-after']) * _constants.SEC_TO_MSEC_MFACTOR);
+            _context9.next = 14;
+            return flushPromises();
+          case 14:
+            expect(webex.request).toHaveBeenNthCalledWith(2, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(failoverSpy).toBeCalledOnceWith(2, failurePayload429One.headers['retry-after']);
+            expect(logSpy).not.toBeCalledWith("Scheduled retry with primary in 43 seconds, number of attempts : 2", loggerContext);
+            expect(infoSpy).toBeCalledWith("Failing over to backup servers.", loggerContext);
+            expect(logSpy).not.toBeCalledWith("Scheduled retry with primary in ".concat(failurePayload429Four.headers['retry-after'], " seconds, number of attempts : 2"), loggerContext);
+            expect(infoSpy).toBeCalledWith("Failing over to backup servers.", loggerContext);
+            expect(webex.request).toHaveBeenNthCalledWith(3, _objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          case 22:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    })));
+  });
+  describe('Registration failover tests', function () {
+    it('verify unreachable primary with reachable backup servers', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10() {
+      return _regenerator.default.wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
           case 0:
             jest.useFakeTimers();
             // try the primary twice and register successfully with backup servers
             webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValueOnce(successPayload);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.IDLE);
-            _context4.next = 5;
+            _context10.next = 5;
             return reg.triggerRegistration();
           case 5:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context4.next = 8;
+            _context10.next = 8;
             return flushPromises();
           case 8:
             expect(webex.request).toBeCalledTimes(3);
@@ -230,15 +608,16 @@ describe('Registration Tests', function () {
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
             /* Active Url must match with the backup url as per the test */
             expect(reg.getActiveMobiusUrl()).toEqual(mobiusUris.backup[0]);
-          case 13:
+            expect(metricSpy).toHaveBeenNthCalledWith(3, _types5.METRIC_EVENT.REGISTRATION, _types5.REG_ACTION.REGISTER, _types5.METRIC_TYPE.BEHAVIORAL, _constants.FAILOVER_UTIL, 'BACKUP', 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15', undefined, undefined);
+          case 14:
           case "end":
-            return _context4.stop();
+            return _context10.stop();
         }
-      }, _callee4);
+      }, _callee10);
     })));
-    it('cc: verify unreachable primary with reachable backup server', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
-      return _regenerator.default.wrap(function _callee5$(_context5) {
-        while (1) switch (_context5.prev = _context5.next) {
+    it('cc: verify unreachable primary with reachable backup server', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
+      return _regenerator.default.wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
           case 0:
             setupRegistration(_objectSpread(_objectSpread({}, MockServiceData), {}, {
               indicator: _types.ServiceIndicator.CONTACT_CENTER
@@ -246,11 +625,11 @@ describe('Registration Tests', function () {
             jest.useFakeTimers();
             webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValueOnce(successPayload);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.IDLE);
-            _context5.next = 6;
+            _context11.next = 6;
             return reg.triggerRegistration();
           case 6:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context5.next = 9;
+            _context11.next = 9;
             return flushPromises();
           case 9:
             expect(webex.request).toBeCalledTimes(3);
@@ -267,27 +646,27 @@ describe('Registration Tests', function () {
             expect(reg.getActiveMobiusUrl()).toEqual(mobiusUris.backup[0]);
           case 14:
           case "end":
-            return _context5.stop();
+            return _context11.stop();
         }
-      }, _callee5);
+      }, _callee11);
     })));
-    it('verify unreachable primary and backup servers', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
-      return _regenerator.default.wrap(function _callee6$(_context6) {
-        while (1) switch (_context6.prev = _context6.next) {
+    it('verify unreachable primary and backup servers', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12() {
+      return _regenerator.default.wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
           case 0:
             jest.useFakeTimers();
             // try the primary twice and register successfully with backup servers
             webex.request.mockRejectedValue(failurePayload);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.IDLE);
-            _context6.next = 5;
+            _context12.next = 5;
             return reg.triggerRegistration();
           case 5:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context6.next = 8;
+            _context12.next = 8;
             return flushPromises();
           case 8:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context6.next = 11;
+            _context12.next = 11;
             return flushPromises();
           case 11:
             /*
@@ -312,26 +691,27 @@ describe('Registration Tests', function () {
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
           case 17:
           case "end":
-            return _context6.stop();
+            return _context12.stop();
         }
-      }, _callee6);
+      }, _callee12);
     })));
   });
   describe('Registration failback tests', function () {
-    beforeEach( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
-      return _regenerator.default.wrap(function _callee7$(_context7) {
-        while (1) switch (_context7.prev = _context7.next) {
+    beforeEach( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
+      return _regenerator.default.wrap(function _callee13$(_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
           case 0:
             /* keep keepalive as active so that it wont interfere with the failback tests */
+            jest.spyOn(reg, 'postKeepAlive').mockResolvedValue(successPayload);
             jest.useFakeTimers();
             postRegistrationSpy.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValueOnce(successPayload);
-            _context7.next = 4;
+            _context13.next = 5;
             return reg.triggerRegistration();
-          case 4:
+          case 5:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context7.next = 7;
+            _context13.next = 8;
             return flushPromises();
-          case 7:
+          case 8:
             reg.rehomingIntervalMin = _constants.DEFAULT_REHOMING_INTERVAL_MIN;
             reg.rehomingIntervalMax = _constants.DEFAULT_REHOMING_INTERVAL_MAX;
 
@@ -341,19 +721,19 @@ describe('Registration Tests', function () {
             /* Active Url must match with the backup url as per the test */
             expect(reg.getActiveMobiusUrl()).toStrictEqual(mobiusUris.backup[0]);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-          case 12:
+          case 13:
           case "end":
-            return _context7.stop();
+            return _context13.stop();
         }
-      }, _callee7);
+      }, _callee13);
     })));
     afterEach(function () {
       jest.clearAllTimers();
       jest.clearAllMocks();
     });
-    it('verify 429 error with failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
-      return _regenerator.default.wrap(function _callee8$(_context8) {
-        while (1) switch (_context8.prev = _context8.next) {
+    it('verify 429 error with failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
+      return _regenerator.default.wrap(function _callee14$(_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
           case 0:
             // delete should be successful
             global.fetch = jest.fn(function () {
@@ -363,61 +743,66 @@ describe('Registration Tests', function () {
                 }
               });
             });
-            postRegistrationSpy.mockRejectedValue(failurePayload429);
+            postRegistrationSpy.mockRejectedValue(failurePayload429Two);
 
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context8.next = 5;
+            _context14.next = 5;
             return flushPromises();
           case 5:
-            expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
               method: 'executeFailback',
               file: _constants.REGISTRATION_FILE
             });
-            expect(failbackRetry429Spy).toBeCalledOnceWith();
+            jest.advanceTimersByTime(10000);
+            _context14.next = 9;
+            return flushPromises();
+          case 9:
+            expect(retry429Spy).toBeCalledWith(failurePayload429Two.headers['retry-after'], 'executeFailback');
             expect(reg.failback429RetryAttempts).toBe(0);
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
-            expect(restoreSpy).toBeCalledOnceWith(_constants.FAILBACK_429_RETRY_UTIL);
-            expect(restartSpy).toBeCalledOnceWith(_constants.FAILBACK_429_RETRY_UTIL);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.REG_429_RETRY_UTIL);
+            expect(restartSpy).toBeCalledOnceWith(_constants.REG_429_RETRY_UTIL);
             expect(reg.failbackTimer).toBe(undefined);
             expect(reg.rehomingIntervalMin).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MIN);
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
-          case 14:
+          case 17:
           case "end":
-            return _context8.stop();
+            return _context14.stop();
         }
-      }, _callee8);
+      }, _callee14);
     })));
-    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
-      return _regenerator.default.wrap(function _callee9$(_context9) {
-        while (1) switch (_context9.prev = _context9.next) {
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
+      return _regenerator.default.wrap(function _callee15$(_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
           case 0:
             postRegistrationSpy.mockRejectedValue(failurePayload);
 
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context9.next = 4;
+            _context15.next = 4;
             return flushPromises();
           case 4:
-            expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
               method: 'executeFailback',
               file: _constants.REGISTRATION_FILE
             });
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
             expect(restoreSpy).toBeCalledOnceWith(_constants.FAILBACK_UTIL);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
             expect(restartSpy).toBeCalledOnceWith(_constants.FAILBACK_UTIL);
             expect(reg.rehomingIntervalMin).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MIN);
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
-          case 10:
+          case 11:
           case "end":
-            return _context9.stop();
+            return _context15.stop();
         }
-      }, _callee9);
+      }, _callee15);
     })));
-    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure with final error', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10() {
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure with final error', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16() {
       var finalErrorPayload;
-      return _regenerator.default.wrap(function _callee10$(_context10) {
-        while (1) switch (_context10.prev = _context10.next) {
+      return _regenerator.default.wrap(function _callee16$(_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
           case 0:
             finalErrorPayload = {
               statusCode: 401,
@@ -427,10 +812,10 @@ describe('Registration Tests', function () {
             postRegistrationSpy.mockRejectedValue(finalErrorPayload).mockRejectedValueOnce(failurePayload);
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context10.next = 6;
+            _context16.next = 6;
             return flushPromises();
           case 6:
-            expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
               method: 'executeFailback',
               file: _constants.REGISTRATION_FILE
             });
@@ -442,22 +827,22 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 13:
           case "end":
-            return _context10.stop();
+            return _context16.stop();
         }
-      }, _callee10);
+      }, _callee16);
     })));
-    it('verify unsuccessful failback to primary after initial registration with backup: Restore success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
-      return _regenerator.default.wrap(function _callee11$(_context11) {
-        while (1) switch (_context11.prev = _context11.next) {
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17() {
+      return _regenerator.default.wrap(function _callee17$(_context17) {
+        while (1) switch (_context17.prev = _context17.next) {
           case 0:
             postRegistrationSpy.mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
 
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context11.next = 4;
+            _context17.next = 4;
             return flushPromises();
           case 4:
-            expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
               method: 'executeFailback',
               file: _constants.REGISTRATION_FILE
             });
@@ -470,22 +855,22 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 11:
           case "end":
-            return _context11.stop();
+            return _context17.stop();
         }
-      }, _callee11);
+      }, _callee17);
     })));
-    it('verify successful failback to primary after initial registration with backup', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12() {
-      return _regenerator.default.wrap(function _callee12$(_context12) {
-        while (1) switch (_context12.prev = _context12.next) {
+    it('verify successful failback to primary after initial registration with backup', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18() {
+      return _regenerator.default.wrap(function _callee18$(_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
           case 0:
             postRegistrationSpy.mockResolvedValue(successPayload);
 
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context12.next = 4;
+            _context18.next = 4;
             return flushPromises();
           case 4:
-            expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
               method: 'executeFailback',
               file: _constants.REGISTRATION_FILE
             });
@@ -499,13 +884,13 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_registerFixtures.mockPostResponse.rehomingIntervalMax);
           case 11:
           case "end":
-            return _context12.stop();
+            return _context18.stop();
         }
-      }, _callee12);
+      }, _callee18);
     })));
-    it('verify unsuccessful failback attempt due to active call', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
-      return _regenerator.default.wrap(function _callee13$(_context13) {
-        while (1) switch (_context13.prev = _context13.next) {
+    it('verify unsuccessful failback attempt due to active call', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19() {
+      return _regenerator.default.wrap(function _callee19$(_context19) {
+        while (1) switch (_context19.prev = _context19.next) {
           case 0:
             /** create a new call */
             reg.callManager.createCall();
@@ -514,10 +899,10 @@ describe('Registration Tests', function () {
 
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context13.next = 6;
+            _context19.next = 6;
             return flushPromises();
           case 6:
-            expect(logSpy).toBeCalledWith("Active calls present, deferring failback to next cycle.", {
+            expect(infoSpy).toBeCalledWith("Active calls present, deferring failback to next cycle.", {
               method: 'executeFailback',
               file: _constants.REGISTRATION_FILE
             });
@@ -527,7 +912,7 @@ describe('Registration Tests', function () {
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
             expect(restoreSpy).not.toBeCalled();
             expect(restartSpy).not.toBeCalled();
-            expect(logSpy).toBeCalledWith('Active calls present, deferring failback to next cycle.', {
+            expect(infoSpy).toBeCalledWith('Active calls present, deferring failback to next cycle.', {
               file: _constants.REGISTRATION_FILE,
               method: _constants.FAILBACK_UTIL
             });
@@ -535,470 +920,434 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 14:
           case "end":
-            return _context13.stop();
+            return _context19.stop();
         }
-      }, _callee13);
+      }, _callee19);
     })));
   });
 
   // Keep-alive related test cases
   describe('Keep-alive Tests', function () {
+    var logObj = {
+      file: _constants.REGISTRATION_FILE,
+      method: 'startKeepaliveTimer'
+    };
+    var mockKeepAliveBody = {
+      device: _registerFixtures.mockPostResponse.device
+    };
     var beforeEachSetupForKeepalive = /*#__PURE__*/function () {
-      var _ref14 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
-        return _regenerator.default.wrap(function _callee14$(_context14) {
-          while (1) switch (_context14.prev = _context14.next) {
+      var _ref20 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
+        return _regenerator.default.wrap(function _callee20$(_context20) {
+          while (1) switch (_context20.prev = _context20.next) {
             case 0:
               postRegistrationSpy.mockResolvedValueOnce(successPayload);
               jest.useFakeTimers();
-              _context14.next = 4;
+              _context20.next = 4;
               return reg.triggerRegistration();
             case 4:
               expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-              expect(reg.webWorker).toBeDefined();
-            case 6:
+            case 5:
             case "end":
-              return _context14.stop();
+              return _context20.stop();
           }
-        }, _callee14);
+        }, _callee20);
       }));
       return function beforeEachSetupForKeepalive() {
-        return _ref14.apply(this, arguments);
+        return _ref20.apply(this, arguments);
       };
     }();
     afterEach(function () {
       jest.clearAllTimers();
       jest.clearAllMocks();
-      reg.clearKeepaliveTimer();
+      if (reg.keepaliveTimer) {
+        clearInterval(reg.keepaliveTimer);
+        reg.keepaliveTimer = undefined;
+      }
       reg.reconnectPending = false;
       var calls = (0, _values.default)(reg.callManager.getActiveCalls());
       calls.forEach(function (call) {
         call.end();
       });
     });
-    it('verify successful keep-alive cases', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
-      var postMessageSpy;
-      return _regenerator.default.wrap(function _callee15$(_context15) {
-        while (1) switch (_context15.prev = _context15.next) {
+    it('verify successful keep-alive cases', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
+      var keepAlivePayload, funcSpy;
+      return _regenerator.default.wrap(function _callee21$(_context21) {
+        while (1) switch (_context21.prev = _context21.next) {
           case 0:
-            postMessageSpy = jest.spyOn(Worker.prototype, 'postMessage');
-            _context15.next = 3;
+            _context21.next = 2;
             return beforeEachSetupForKeepalive();
-          case 3:
-            expect(reg.webWorker).toBeDefined();
-            expect(postMessageSpy).toHaveBeenCalledWith(expect.objectContaining({
-              type: 'START_KEEPALIVE',
-              accessToken: expect.any(String),
-              deviceUrl: expect.any(String),
-              interval: expect.any(Number),
-              retryCountThreshold: expect.any(Number),
-              url: expect.any(String)
-            }));
-            reg.webWorker.onmessage({
-              data: {
-                type: 'KEEPALIVE_SUCCESS',
-                statusCode: 200
-              }
-            });
-            expect(lineEmitter).toBeCalledWith(_types4.LINE_EVENTS.RECONNECTED);
-          case 7:
+          case 2:
+            keepAlivePayload = {
+              statusCode: 200,
+              body: mockKeepAliveBody
+            };
+            webex.request.mockReturnValue(keepAlivePayload);
+            funcSpy = jest.spyOn(reg, 'postKeepAlive');
+            jest.advanceTimersByTime(2 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context21.next = 8;
+            return flushPromises();
+          case 8:
+            expect(funcSpy).toBeCalledTimes(2); // should be called 2 times: first try and after the interval.
+
+            expect(logSpy).toBeCalledWith('Sent Keepalive, status: 200', logObj);
+            expect(infoSpy).not.toBeCalledWith('Sent Keepalive, status: 200', logObj);
+          case 11:
           case "end":
-            return _context15.stop();
+            return _context21.stop();
         }
-      }, _callee15);
+      }, _callee21);
     })));
-    it('verify failure keep-alive cases: Retry Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16() {
-      var worker;
-      return _regenerator.default.wrap(function _callee16$(_context16) {
-        while (1) switch (_context16.prev = _context16.next) {
+    it('verify failure keep-alive cases: Retry Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22() {
+      var failurePayload, successPayload, timer;
+      return _regenerator.default.wrap(function _callee22$(_context22) {
+        while (1) switch (_context22.prev = _context22.next) {
           case 0:
-            _context16.next = 2;
+            _context22.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            worker = reg.webWorker;
+            failurePayload = {
+              statusCode: 503,
+              body: mockKeepAliveBody
+            };
+            successPayload = {
+              statusCode: 200,
+              body: mockKeepAliveBody
+            };
+            timer = reg.keepaliveTimer;
             lineEmitter.mockClear();
-            worker.onmessage({
-              data: {
-                type: 'KEEPALIVE_FAILURE',
-                err: {
-                  statusCode: 503
-                },
-                keepAliveRetryCount: 1
-              }
-            });
-            worker.onmessage({
-              data: {
-                type: 'KEEPALIVE_SUCCESS',
-                statusCode: 200
-              }
+            webex.request.mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
+            jest.advanceTimersByTime(2 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context22.next = 10;
+            return flushPromises();
+          case 10:
+            expect(handleErrorSpy).toBeCalledOnceWith(failurePayload, expect.anything(), {
+              method: 'startKeepaliveTimer',
+              file: _constants.REGISTRATION_FILE
             });
-            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.RECONNECTED);
-          case 7:
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            expect(reg.keepaliveTimer).toBe(timer);
+            expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.RECONNECTING);
+            expect(lineEmitter).nthCalledWith(2, _types4.LINE_EVENTS.RECONNECTED);
+            expect(lineEmitter).toBeCalledTimes(2);
+          case 16:
           case "end":
-            return _context16.stop();
+            return _context22.stop();
         }
-      }, _callee16);
+      }, _callee22);
     })));
-    it('verify failure keep-alive cases: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17() {
-      var reconnectSpy, RETRY_COUNT_THRESHOLD, failureEvent;
-      return _regenerator.default.wrap(function _callee17$(_context17) {
-        while (1) switch (_context17.prev = _context17.next) {
+    it('verify failure keep-alive cases: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23() {
+      var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, clearIntervalSpy, timer;
+      return _regenerator.default.wrap(function _callee23$(_context23) {
+        while (1) switch (_context23.prev = _context23.next) {
           case 0:
-            _context17.next = 2;
+            _context23.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure'); // Clear previous event emissions
+            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+            restartRegSpy = jest.spyOn(reg, 'restartRegistration');
+            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
+            failurePayload = {
+              statusCode: 503,
+              body: mockKeepAliveBody
+            };
+            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
             lineEmitter.mockClear();
-
-            // Assume registration is active
+            webex.request.mockRejectedValue(failurePayload);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-
-            // Use fake timers to trigger keepalive initialization
-            jest.useFakeTimers();
-            jest.advanceTimersByTime(_registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-
-            // Simulate the worker sending a KEEPALIVE_FAILURE message with retry count at threshold.
-            RETRY_COUNT_THRESHOLD = reg.isCCFlow ? 4 : 5;
-            failureEvent = {
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: {
-                  statusCode: 503
-                },
-                keepAliveRetryCount: RETRY_COUNT_THRESHOLD
-              }
-            };
-            reg.webWorker.onmessage(failureEvent);
-            _context17.next = 12;
+            timer = reg.keepaliveTimer;
+            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context23.next = 14;
             return flushPromises();
-          case 12:
+          case 14:
+            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
+
+            // sendKeepAlive tries to retry 5 times before accepting failure
+            // later 2 attempts to register with primary server
+            expect(handleErrorSpy).toBeCalledTimes(7);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
-            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
-            expect(reconnectSpy).toBeCalledOnceWith('startKeepaliveTimer');
-            jest.useRealTimers();
-          case 16:
+            expect(reg.reconnectPending).toStrictEqual(false);
+            expect(reconnectSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+            expect(restartRegSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+            expect(warnSpy).toHaveBeenCalledWith('Keep-alive missed 1 times. Status -> 503 ', expect.objectContaining({
+              file: _constants.REGISTRATION_FILE,
+              method: 'startKeepaliveTimer'
+            }));
+            expect(webex.request).toBeCalledTimes(7);
+            expect(reg.keepaliveTimer).toBe(undefined);
+            expect(warnSpy).toHaveBeenCalledWith('Keep-alive missed 1 times. Status -> 503 ', expect.objectContaining({
+              file: _constants.REGISTRATION_FILE,
+              method: 'startKeepaliveTimer'
+            }));
+            expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.RECONNECTING);
+            expect(lineEmitter).nthCalledWith(4, _types4.LINE_EVENTS.RECONNECTING);
+            expect(lineEmitter).nthCalledWith(5, _types4.LINE_EVENTS.UNREGISTERED);
+
+            /** there will be 2 registration attempts */
+            expect(lineEmitter).nthCalledWith(6, _types4.LINE_EVENTS.CONNECTING);
+            expect(lineEmitter).nthCalledWith(7, _types4.LINE_EVENTS.UNREGISTERED);
+            expect(lineEmitter).nthCalledWith(8, _types4.LINE_EVENTS.CONNECTING);
+            expect(lineEmitter).nthCalledWith(9, _types4.LINE_EVENTS.UNREGISTERED);
+            expect(lineEmitter).toBeCalledTimes(9);
+          case 33:
           case "end":
-            return _context17.stop();
+            return _context23.stop();
         }
-      }, _callee17);
+      }, _callee23);
     })));
-    it('verify failure keep-alive cases: Restore Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18() {
-      var reconnectSpy, url;
-      return _regenerator.default.wrap(function _callee18$(_context18) {
-        while (1) switch (_context18.prev = _context18.next) {
+    it('verify failure keep-alive cases: Restore Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee24() {
+      var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, successPayload, clearIntervalSpy, url, timer;
+      return _regenerator.default.wrap(function _callee24$(_context24) {
+        while (1) switch (_context24.prev = _context24.next) {
           case 0:
-            _context18.next = 2;
+            _context24.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            expect(reg.webWorker).toBeDefined();
+            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+            restartRegSpy = jest.spyOn(reg, 'restartRegistration');
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
-            url = 'https://mobius-dfw.webex.com/api/v1/calling/web/';
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: {
-                  statusCode: 503
-                },
-                keepAliveRetryCount: 5
-              }
-            });
-            jest.advanceTimersByTime(1000);
-            _context18.next = 9;
-            return flushPromises();
-          case 9:
-            expect(reg.webWorker).toBeUndefined();
-            expect(reconnectSpy).toBeCalledOnceWith(reg.startKeepaliveTimer.name);
-            webex.request.mockResolvedValueOnce(successPayload);
-            _context18.next = 14;
-            return reg.triggerRegistration();
-          case 14:
-            _context18.next = 16;
-            return flushPromises();
-          case 16:
-            expect(reg.webWorker).toBeDefined();
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
-                statusCode: 200
-              }
-            });
+            failurePayload = {
+              statusCode: 503,
+              body: mockKeepAliveBody
+            };
+            successPayload = {
+              statusCode: 200,
+              body: mockKeepAliveBody
+            };
+            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
+
+            /* successful registration */
+            // webex.request.mockResolvedValue(successPayload);
 
-            // Advance timers and flush any remaining promises.
-            jest.advanceTimersByTime(1000);
-            _context18.next = 21;
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+            url = 'https://mobius.asydm-m-1.prod.infra.webex.com/api/v1';
+            /* set active Url and expect the registration to restore to this url */
+            reg.setActiveMobiusUrl(url);
+            timer = reg.keepaliveTimer;
+            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context24.next = 16;
             return flushPromises();
-          case 21:
+          case 16:
+            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
+            expect(handleErrorSpy).toBeCalledTimes(5);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-            // reconnectSpy should have been called only once.
-            expect(reconnectSpy).toBeCalledTimes(1);
-            expect(restoreSpy).toBeCalledOnceWith(reg.startKeepaliveTimer.name);
-            expect(restartSpy).toBeCalledOnceWith(reg.startKeepaliveTimer.name);
-            // Active Mobius URL should remain unchanged.
+            expect(reconnectSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+            expect(restartRegSpy).not.toBeCalled();
             expect(reg.getActiveMobiusUrl()).toStrictEqual(url);
+            expect(reg.reconnectPending).toStrictEqual(false);
+            expect(reg.keepaliveTimer).toBeTruthy();
+            expect(reg.keepaliveTimer).not.toBe(timer);
           case 26:
           case "end":
-            return _context18.stop();
+            return _context24.stop();
         }
-      }, _callee18);
+      }, _callee24);
     })));
-    it('verify failure followed by recovery of keepalive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19() {
-      return _regenerator.default.wrap(function _callee19$(_context19) {
-        while (1) switch (_context19.prev = _context19.next) {
+    it('verify failure followed by recovery of keepalive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee25() {
+      var failurePayload, successPayload, clearIntervalSpy, timer;
+      return _regenerator.default.wrap(function _callee25$(_context25) {
+        while (1) switch (_context25.prev = _context25.next) {
           case 0:
-            _context19.next = 2;
+            _context25.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-            expect(reg.webWorker).toBeDefined();
+            failurePayload = {
+              statusCode: 503,
+              body: mockKeepAliveBody
+            };
+            successPayload = {
+              statusCode: 200,
+              body: mockKeepAliveBody
+            };
+            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
             webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: failurePayload,
-                keepAliveRetryCount: reg.isCCFlow ? 4 : 5
-              }
-            });
-            _context19.next = 8;
-            return flushPromises();
-          case 8:
-            expect(reg.webWorker).toBeUndefined();
-            expect(handleErrorSpy).toBeCalledTimes(3);
-            _context19.next = 12;
-            return reg.triggerRegistration();
-          case 12:
-            _context19.next = 14;
-            return flushPromises();
-          case 14:
-            expect(reg.webWorker).toBeDefined();
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
-                statusCode: 200
-              }
-            });
-            _context19.next = 18;
-            return flushPromises();
-          case 18:
-            // In a complete failure‐then-recovery scenario, we expect another failure event to have been handled.
-            // For that, simulate a second failure event on the new worker.
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: failurePayload,
-                keepAliveRetryCount: reg.isCCFlow ? 4 : 5
-              }
-            });
-            _context19.next = 21;
-            return flushPromises();
-          case 21:
-            expect(handleErrorSpy).toBeCalledTimes(4);
-
-            // And then re-register successfully:
-            _context19.next = 24;
-            return reg.triggerRegistration();
-          case 24:
-            _context19.next = 26;
-            return flushPromises();
-          case 26:
-            expect(reg.webWorker).toBeDefined();
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
-                statusCode: 200
-              }
-            });
-            _context19.next = 30;
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            timer = reg.keepaliveTimer; // sendKeepAlive tries to retry 3 times and receiving success on third time
+            jest.advanceTimersByTime(3 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context25.next = 11;
             return flushPromises();
-          case 30:
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-            expect(reg.webWorker).toBeDefined();
-          case 32:
+          case 11:
+            expect(webex.request).toBeCalledTimes(3);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            expect(handleErrorSpy).toBeCalledTimes(2);
+            expect(clearIntervalSpy).not.toBeCalled();
+            expect(reg.keepaliveTimer).toBe(timer);
+          case 16:
           case "end":
-            return _context19.stop();
+            return _context25.stop();
         }
-      }, _callee19);
+      }, _callee25);
     })));
-    it('cc: verify failover to backup server after 4 keep alive failure with primary server', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
-      var clearKeepaliveSpy, reconnectSpy;
-      return _regenerator.default.wrap(function _callee20$(_context20) {
-        while (1) switch (_context20.prev = _context20.next) {
+    it('cc: verify failover to backup server after 4 keep alive failure with primary server', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee26() {
+      var failurePayload, successPayload, clearIntervalSpy, timer;
+      return _regenerator.default.wrap(function _callee26$(_context26) {
+        while (1) switch (_context26.prev = _context26.next) {
           case 0:
             // Register with contact center service
             setupRegistration(_objectSpread(_objectSpread({}, MockServiceData), {}, {
               indicator: _types.ServiceIndicator.CONTACT_CENTER
             }));
-            _context20.next = 3;
+            _context26.next = 3;
             return beforeEachSetupForKeepalive();
           case 3:
-            webex.request.mockResolvedValueOnce(successPayload);
-            _context20.next = 6;
-            return reg.triggerRegistration();
-          case 6:
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-            expect(reg.webWorker).toBeDefined();
-
-            // Spy on clearKeepaliveTimer and simulate reconnectOnFailure behavior
-            clearKeepaliveSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
-            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure'); // Simulate a KEEPALIVE_FAILURE message from the worker with a retry count equal to threshold (4 for CC)
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: {
-                  statusCode: 503
-                },
-                keepAliveRetryCount: 4
-              }
-            });
-
-            // Wait for any asynchronous actions to complete
-            _context20.next = 13;
+            failurePayload = {
+              statusCode: 503,
+              body: mockKeepAliveBody
+            };
+            successPayload = {
+              statusCode: 200,
+              body: mockKeepAliveBody
+            };
+            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+            jest.spyOn(reg, 'postKeepAlive').mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            timer = reg.keepaliveTimer;
+            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context26.next = 12;
             return flushPromises();
-          case 13:
-            // Verify that the keepalive timer was cleared and reconnectOnFailure was triggered
-            expect(clearKeepaliveSpy).toHaveBeenCalled();
-            expect(reconnectSpy).toHaveBeenCalledWith(reg.startKeepaliveTimer.name);
-
-            // Verify that the active Mobius URL has been updated to the backup server and registration is active
+          case 12:
+            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(reg.keepaliveTimer).not.toBe(timer);
+            webex.request.mockResolvedValue(successPayload);
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context26.next = 19;
+            return flushPromises();
+          case 19:
+            /* Active Url must match with the backup url as per the test */
             expect(reg.getActiveMobiusUrl()).toEqual(mobiusUris.backup[0]);
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-          case 17:
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+          case 21:
           case "end":
-            return _context20.stop();
+            return _context26.stop();
         }
-      }, _callee20);
+      }, _callee26);
     })));
-    it('verify final error for keep-alive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
-      var threshold, reconnectSpy;
-      return _regenerator.default.wrap(function _callee21$(_context21) {
-        while (1) switch (_context21.prev = _context21.next) {
+    it('verify final error for keep-alive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee27() {
+      var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, clearIntervalSpy;
+      return _regenerator.default.wrap(function _callee27$(_context27) {
+        while (1) switch (_context27.prev = _context27.next) {
           case 0:
-            _context21.next = 2;
+            _context27.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            threshold = reg.isCCFlow ? 4 : 5;
+            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+            restartRegSpy = jest.spyOn(reg, 'restartRegistration');
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
-            jest.spyOn(utils, 'handleRegistrationErrors').mockResolvedValue(true);
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: {
-                  statusCode: 404
-                },
-                keepAliveRetryCount: threshold
-              }
-            });
-            _context21.next = 8;
-            return flushPromises();
-          case 8:
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
-            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
-            expect(reconnectSpy).not.toHaveBeenCalled();
-          case 11:
-          case "end":
-            return _context21.stop();
-        }
-      }, _callee21);
-    })));
-    it('verify failure keep-alive case with active call present: Restore Success after call ends', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22() {
-      var clearTimerSpy, threshold, failureEvent;
-      return _regenerator.default.wrap(function _callee22$(_context22) {
-        while (1) switch (_context22.prev = _context22.next) {
-          case 0:
-            _context22.next = 2;
-            return beforeEachSetupForKeepalive();
-          case 2:
-            // Simulate an active call.
-            reg.callManager.createCall();
-            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBeGreaterThan(0);
-            clearTimerSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
-            threshold = reg.isCCFlow ? 4 : 5; // Simulate a KEEPALIVE_FAILURE event with a 503 error at threshold.
-            failureEvent = {
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: {
-                  statusCode: 503
-                },
-                keepAliveRetryCount: threshold
-              }
+            failurePayload = {
+              statusCode: 404,
+              body: mockKeepAliveBody
             };
-            reg.webWorker.onmessage(failureEvent);
-            _context22.next = 10;
-            return flushPromises();
-          case 10:
-            // At this point, clearKeepaliveTimer was called so the worker is terminated.
-            expect(clearTimerSpy).toHaveBeenCalled();
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
-            expect(reg.webWorker).toBeUndefined();
-
-            // Now simulate call cleanup.
-            reg.callManager.callCollection = {};
-            webex.request.mockResolvedValueOnce(successPayload);
+            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+            webex.request.mockRejectedValue(failurePayload);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
 
-            // Call reconnectOnFailure manually. With no active calls, this should trigger re-registration.
-            _context22.next = 17;
-            return reg.reconnectOnFailure('activeCallEnded');
-          case 17:
-            _context22.next = 19;
+            /* send one keepalive */
+            jest.advanceTimersByTime(_registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context27.next = 12;
             return flushPromises();
-          case 19:
-            // After re-registration, registration status becomes ACTIVE and a new worker is created.
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-            expect(reg.isReconnectPending()).toBe(false);
-            expect(reg.webWorker).toBeDefined();
+          case 12:
+            expect(clearIntervalSpy).toBeCalledTimes(1);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(reconnectSpy).not.toBeCalled();
+            expect(restoreSpy).not.toBeCalled();
+            expect(restartRegSpy).not.toBeCalled();
+            expect(reg.reconnectPending).toStrictEqual(false);
+            expect(webex.request).toBeCalledOnceWith({
+              headers: mockResponse.headers,
+              uri: "".concat(mockKeepAliveBody.device.uri, "/status"),
+              method: 'POST',
+              service: mockResponse.service
+            });
+            expect(reg.keepaliveTimer).toBe(undefined);
+            expect(handleErrorSpy).toBeCalledOnceWith(failurePayload, expect.anything(), {
+              file: _constants.REGISTRATION_FILE,
+              method: _constants.KEEPALIVE_UTIL
+            });
+            expect(warnSpy).toBeCalledWith('Keep-alive missed 1 times. Status -> 404 ', expect.objectContaining({
+              file: _constants.REGISTRATION_FILE,
+              method: 'startKeepaliveTimer'
+            }));
           case 22:
           case "end":
-            return _context22.stop();
+            return _context27.stop();
         }
-      }, _callee22);
+      }, _callee27);
     })));
-    it('should emit LINE_EVENTS.ERROR when keepalive fails with a final error', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee24() {
-      return _regenerator.default.wrap(function _callee24$(_context24) {
-        while (1) switch (_context24.prev = _context24.next) {
+    it('verify failure keep-alive case with active call present: Restore Success after call ends', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee28() {
+      var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, successPayload, clearIntervalSpy, url, timer, call;
+      return _regenerator.default.wrap(function _callee28$(_context28) {
+        while (1) switch (_context28.prev = _context28.next) {
           case 0:
-            _context24.next = 2;
+            _context28.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            expect(reg.webWorker).toBeDefined();
-            lineEmitter.mockClear();
-            jest.spyOn(utils, 'handleRegistrationErrors').mockImplementationOnce( /*#__PURE__*/function () {
-              var _ref24 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23(error, callback) {
-                var clientError;
-                return _regenerator.default.wrap(function _callee23$(_context23) {
-                  while (1) switch (_context23.prev = _context23.next) {
-                    case 0:
-                      clientError = (0, _LineError.createLineError)('User is unauthorized due to an expired token. Sign out, then sign back in.', {}, _types3.ERROR_TYPE.TOKEN_ERROR, _types.RegistrationStatus.INACTIVE);
-                      callback(clientError, true);
-                      return _context23.abrupt("return", true);
-                    case 3:
-                    case "end":
-                      return _context23.stop();
-                  }
-                }, _callee23);
-              }));
-              return function (_x, _x2) {
-                return _ref24.apply(this, arguments);
-              };
-            }());
-            reg.webWorker.onmessage({
-              data: {
-                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
-                err: {
-                  statusCode: 401,
-                  message: 'Unauthorized'
-                },
-                keepAliveRetryCount: 1
-              }
-            });
-            _context24.next = 8;
+            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+            restartRegSpy = jest.spyOn(reg, 'restartRegistration');
+            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
+            failurePayload = {
+              statusCode: 503,
+              body: mockKeepAliveBody
+            };
+            successPayload = {
+              statusCode: 200,
+              body: mockKeepAliveBody
+            };
+            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
+
+            // jest.spyOn(callingClient['registration'], 'createDevice').mockResolvedValue(successPayload);
+            url = 'https://mobius.asydm-m-1.prod.infra.webex.com/api/v1';
+            reg.setActiveMobiusUrl(url);
+            expect(reg.reconnectPending).toStrictEqual(false);
+            timer = reg.keepaliveTimer;
+            /* add a call to the callManager */
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            call = reg.callManager.createCall();
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(1);
+
+            /* send one keepalive */
+            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context28.next = 18;
             return flushPromises();
-          case 8:
-            expect(lineEmitter).toHaveBeenNthCalledWith(1, _types4.LINE_EVENTS.ERROR, undefined, new Error('User is unauthorized due to an expired token. Sign out, then sign back in.'));
+          case 18:
+            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
+            expect(handleErrorSpy).toBeCalledTimes(5);
+            expect(reg.keepaliveTimer).toStrictEqual(undefined);
+            expect(reg.failbackTimer).toStrictEqual(undefined);
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
-            expect(reg.webWorker).toBeUndefined();
-          case 11:
+            expect(lineEmitter).lastCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(reconnectSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+            expect(restoreSpy).not.toBeCalled();
+            expect(restartRegSpy).not.toBeCalled();
+            expect(reg.reconnectPending).toStrictEqual(true);
+            expect(infoSpy).toBeCalledWith('Active call(s) present, deferred reconnect till call cleanup.', {
+              file: _constants.REGISTRATION_FILE,
+              method: expect.any(String)
+            });
+            reconnectSpy.mockClear();
+
+            /* simulate call disconnect and Calling client will trigger reconnect upon receiving disconnect event from CallManager */
+            reg.callManager.callCollection = {};
+            _context28.next = 33;
+            return reg.reconnectOnFailure(_constants.CALLS_CLEARED_HANDLER_UTIL);
+          case 33:
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            expect(reconnectSpy).toBeCalledOnceWith(_constants.CALLS_CLEARED_HANDLER_UTIL);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.CALLS_CLEARED_HANDLER_UTIL);
+            expect(restartRegSpy).not.toBeCalled();
+            expect(reg.reconnectPending).toStrictEqual(false);
+            expect(reg.getActiveMobiusUrl()).toStrictEqual(url);
+            expect(reg.keepaliveTimer).toBeTruthy();
+            expect(reg.keepaliveTimer).not.toBe(timer);
+          case 42:
           case "end":
-            return _context24.stop();
+            return _context28.stop();
         }
-      }, _callee24);
+      }, _callee28);
     })));
   });
 });