@webex/calling 3.11.0 → 3.12.0

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

@@ -0,0 +1,1885 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs2/helpers/typeof");
+var _Object$keys2 = 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 _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _now = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/date/now"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
+var _asyncMutex = require("async-mutex");
+var _register = require("./register");
+var _testUtil = require("../../common/testUtil");
+var _types = require("../../common/types");
+var utils = _interopRequireWildcard(require("../../common/Utils"));
+var _Logger = _interopRequireDefault(require("../../Logger"));
+var _types2 = require("../../Logger/types");
+var _registerFixtures = require("./registerFixtures");
+var _common = require("../../common");
+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 _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 _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = _Object$defineProperty) && _Object$getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
+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; }
+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-shadow */
+var webex = (0, _testUtil.getTestUtilsWebex)();
+var MockServiceData = {
+  indicator: _types.ServiceIndicator.CALLING,
+  domain: ''
+};
+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() {
+    return new _promise.default(function (resolve) {
+      originalProcessNextTick(resolve);
+    });
+  }
+  var lineEmitter = jest.fn();
+  var mobiusUris = (0, _common.filterMobiusUris)((0, _testUtil.getMobiusDiscoveryResponse)(), _registerFixtures.URL);
+  var mockResponse = _objectSpread(_objectSpread({}, (0, _testUtil.getMockRequestTemplate)()), {}, {
+    uri: "".concat(mobiusUris.primary[0], "device"),
+    body: {
+      userId: webex.internal.device.userId,
+      clientDeviceUri: webex.internal.device.url,
+      serviceData: {
+        domain: '',
+        indicator: 'calling'
+      }
+    }
+  });
+  var ccMockResponse = _objectSpread(_objectSpread({}, mockResponse), {}, {
+    body: _objectSpread(_objectSpread({}, mockResponse.body), {}, {
+      serviceData: {
+        domain: '',
+        indicator: 'contactcenter'
+      }
+    })
+  });
+  var failurePayload = {
+    statusCode: 500,
+    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 failurePayload429Four = {
+    statusCode: 429,
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      'retry-after': 81
+    }
+  };
+  var successPayload = {
+    statusCode: 200,
+    body: _registerFixtures.mockPostResponse,
+    headers: {
+      trackingid: 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15'
+    }
+  };
+  var reg;
+  var restartSpy;
+  var restoreSpy;
+  var postRegistrationSpy;
+  var deregisterSpy;
+  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');
+    restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+    postRegistrationSpy = jest.spyOn(reg, 'postRegistration');
+    deregisterSpy = jest.spyOn(reg, 'deregister');
+    failoverSpy = jest.spyOn(reg, 'startFailoverTimer');
+    retry429Spy = jest.spyOn(reg, 'handle429Retry');
+    metricSpy = jest.spyOn(reg.metricManager, 'submitRegistrationMetric');
+  };
+  beforeEach(function () {
+    setupRegistration(MockServiceData);
+  });
+  afterEach(function () {
+    webex.request = jest.fn();
+    jest.clearAllTimers();
+    jest.clearAllMocks();
+    jest.useRealTimers();
+    localStorage.clear();
+  });
+  it('verify successful registration', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+    return _regenerator.default.wrap(function (_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          webex.request.mockReturnValueOnce({
+            body: _registerFixtures.mockPostResponse,
+            headers: {
+              trackingid: 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15'
+            }
+          });
+          _context.next = 1;
+          return reg.triggerRegistration();
+        case 1:
+          expect(webex.request).toBeCalledOnceWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+            method: 'POST'
+          }));
+          expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          expect(lineEmitter).toBeCalledTimes(2);
+          expect(lineEmitter).toBeCalledWith(_types4.LINE_EVENTS.CONNECTING);
+          expect(lineEmitter).toBeCalledWith(_types4.LINE_EVENTS.REGISTERED, _registerFixtures.mockPostResponse);
+
+          // 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, " responseTrackingId: webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15"), expect.objectContaining({
+            file: _constants.REGISTRATION_FILE,
+            method: 'register'
+          }));
+          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 2:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  })));
+  it('verify failure registration', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+    var error;
+    return _regenerator.default.wrap(function (_context2) {
+      while (1) switch (_context2.prev = _context2.next) {
+        case 0:
+          webex.request.mockRejectedValue({
+            body: _registerFixtures.mockPostResponse,
+            statusCode: 401,
+            headers: {}
+          });
+          _context2.next = 1;
+          return reg.triggerRegistration();
+        case 1:
+          expect(webex.request).toBeCalledOnceWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+            method: 'POST'
+          }));
+          error = (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);
+          expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+          expect(lineEmitter).toBeCalledTimes(2);
+          expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.CONNECTING);
+          expect(lineEmitter).nthCalledWith(2, _types4.LINE_EVENTS.ERROR, undefined, error);
+          expect(metricSpy).toBeCalledWith(_types5.METRIC_EVENT.REGISTRATION_ERROR, _types5.REG_ACTION.REGISTER, _types5.METRIC_TYPE.BEHAVIORAL, _constants.REGISTRATION_UTIL, 'PRIMARY', '', undefined, error);
+        case 2:
+        case "end":
+          return _context2.stop();
+      }
+    }, _callee2);
+  })));
+  it('verify failure registration 403-101', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+    return _regenerator.default.wrap(function (_context3) {
+      while (1) switch (_context3.prev = _context3.next) {
+        case 0:
+          webex.request.mockRejectedValueOnce({
+            body: {
+              userId: _registerFixtures.mockPostResponse.userId,
+              errorCode: 101,
+              devices: [_registerFixtures.mockPostResponse.device]
+            },
+            statusCode: 403
+          }).mockResolvedValueOnce({
+            statusCode: 200,
+            body: _registerFixtures.mockPostResponse,
+            headers: {
+              trackingid: 'webex-js-sdk_06bafdd0-2f9b-4cd7-b438-9c0d95ecec9b_15'
+            }
+          });
+          global.fetch = jest.fn(function () {
+            return _promise.default.resolve({
+              json: function json() {
+                return _registerFixtures.mockDeleteResponse;
+              }
+            });
+          });
+          expect(reg.getStatus()).toEqual(_types.RegistrationStatus.IDLE);
+          _context3.next = 1;
+          return reg.triggerRegistration();
+        case 1:
+          expect(webex.request).toBeCalledTimes(2);
+          expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+            method: 'POST'
+          }));
+          expect(global.fetch).toBeCalledOnceWith(_registerFixtures.mockPostResponse.device.uri, {
+            method: 'DELETE',
+            headers: expect.anything()
+          });
+          expect(warnSpy).toBeCalledWith('User device limit exceeded', 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);
+          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 2:
+        case "end":
+          return _context3.stop();
+      }
+    }, _callee3);
+  })));
+  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 (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            jest.useFakeTimers();
+            logSpy.mockClear();
+            webex.request.mockRejectedValueOnce(failurePayload429One).mockRejectedValueOnce(failurePayload429Two).mockRejectedValueOnce(failurePayload);
+            _context4.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            /* 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 = 2;
+            return flushPromises();
+          case 2:
+            /* 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 = 3;
+            return flushPromises();
+          case 3:
+            /* 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 4:
+          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 (_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 = 1;
+            return reg.triggerRegistration();
+          case 1:
+            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 = 2;
+            return flushPromises();
+          case 2:
+            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 = 3;
+            return flushPromises();
+          case 3:
+            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 4:
+          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 (_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 = 1;
+            return reg.triggerRegistration();
+          case 1:
+            /* 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 = 2;
+            return flushPromises();
+          case 2:
+            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 = 3;
+            return flushPromises();
+          case 3:
+            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 = 4;
+            return flushPromises();
+          case 4:
+            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 5:
+          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 (_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 = 1;
+            return reg.triggerRegistration();
+          case 1:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context7.next = 2;
+            return flushPromises();
+          case 2:
+            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 = 3;
+            return flushPromises();
+          case 3:
+            expect(webex.request).toBeCalledOnceWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          case 4:
+          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 (_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 = 1;
+            return reg.triggerRegistration();
+          case 1:
+            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 2:
+          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 (_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 = 1;
+            return reg.triggerRegistration();
+          case 1:
+            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 = 2;
+            return flushPromises();
+          case 2:
+            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 3:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    })));
+  });
+  describe('restorePreviousRegistration 429 handling tests', function () {
+    beforeEach(function () {
+      jest.useFakeTimers();
+    });
+    afterEach(function () {
+      jest.clearAllTimers();
+      jest.clearAllMocks();
+      jest.useRealTimers();
+    });
+    it('should schedule retry when 429 with retry-after < 60 seconds during reconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee0() {
+      var failurePayload429Small;
+      return _regenerator.default.wrap(function (_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            restartSpy = jest.spyOn(reg, 'restartRegistration');
+            reg.setActiveMobiusUrl(mobiusUris.primary[0]);
+            failurePayload429Small = {
+              statusCode: 429,
+              body: _constants.RECONNECT_ON_FAILURE_UTIL,
+              headers: {
+                'retry-after': 30
+              }
+            };
+            webex.request.mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload);
+            _context0.next = 1;
+            return reg.reconnectOnFailure(_constants.RECONNECT_ON_FAILURE_UTIL);
+          case 1:
+            // This call is being used to set the retry-after value
+            // Verify restore is invoked first and retry-after captured before scheduling
+            expect(restoreSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(restartSpy).not.toBeCalled();
+            expect(reg.retryAfter).toEqual(undefined); // Clear retryAfter after 429 retry
+
+            jest.advanceTimersByTime(40 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context0.next = 2;
+            return flushPromises();
+          case 2:
+            expect(restartSpy).toHaveBeenCalledTimes(1);
+            expect(restartSpy).toHaveBeenCalledWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+          case 3:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0);
+    })));
+    it('should try backup servers when 429 with retry-after >= 60 seconds on primary during reconnect', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee1() {
+      var attemptRegistrationWithServersSpy, failurePayload429Small;
+      return _regenerator.default.wrap(function (_context1) {
+        while (1) switch (_context1.prev = _context1.next) {
+          case 0:
+            // Setup: Register successfully with primary first
+            attemptRegistrationWithServersSpy = jest.spyOn(reg, 'attemptRegistrationWithServers');
+            reg.setActiveMobiusUrl(mobiusUris.primary[0]);
+            failurePayload429Small = {
+              statusCode: 429,
+              body: _constants.RECONNECT_ON_FAILURE_UTIL,
+              headers: {
+                'retry-after': 100
+              }
+            };
+            webex.request.mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload);
+            _context1.next = 1;
+            return reg.reconnectOnFailure(_constants.RECONNECT_ON_FAILURE_UTIL);
+          case 1:
+            // This call is being used to trigger the retry
+            // Verify restore gets invoked, 429 with retry-after is observed and captured
+            expect(restoreSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(retry429Spy).toBeCalledOnceWith(100, _constants.RECONNECT_ON_FAILURE_UTIL);
+            jest.advanceTimersByTime(40 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context1.next = 2;
+            return flushPromises();
+          case 2:
+            expect(attemptRegistrationWithServersSpy).toHaveBeenCalledTimes(2);
+            expect(attemptRegistrationWithServersSpy).toHaveBeenNthCalledWith(1, _constants.RECONNECT_ON_FAILURE_UTIL, [mobiusUris.primary[0]]);
+            // Immediately try backup servers when retry-after >= 60 seconds on primary
+            expect(attemptRegistrationWithServersSpy).toHaveBeenNthCalledWith(2, _constants.RECONNECT_ON_FAILURE_UTIL, mobiusUris.backup);
+            expect(restartSpy).not.toHaveBeenCalledTimes(1);
+            expect(restartSpy).not.toHaveBeenCalledWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(reg.retryAfter).toEqual(undefined); // Clear retryAfter after 429 retry
+          case 3:
+          case "end":
+            return _context1.stop();
+        }
+      }, _callee1);
+    })));
+    it('should restart registration with primary if we get 429 while on backup', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee10() {
+      var attemptRegistrationWithServersSpy, failurePayload429Small;
+      return _regenerator.default.wrap(function (_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            // Setup: Register successfully with primary first
+            restartSpy = jest.spyOn(reg, 'restartRegistration');
+            attemptRegistrationWithServersSpy = jest.spyOn(reg, 'attemptRegistrationWithServers');
+            reg.setActiveMobiusUrl(mobiusUris.backup[0]);
+            failurePayload429Small = {
+              statusCode: 429,
+              body: _constants.RECONNECT_ON_FAILURE_UTIL,
+              headers: {
+                'retry-after': 100
+              }
+            };
+            webex.request.mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload).mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload);
+            _context10.next = 1;
+            return reg.reconnectOnFailure(_constants.RECONNECT_ON_FAILURE_UTIL);
+          case 1:
+            // This call is being used to trigger the retry
+            // Verify restore path taken first and 429 handling captured
+            expect(restoreSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(retry429Spy).toBeCalledOnceWith(100, _constants.RECONNECT_ON_FAILURE_UTIL);
+            // No failover scheduling expected in this path
+            expect(failoverSpy).not.toBeCalled();
+            jest.advanceTimersByTime(40 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context10.next = 2;
+            return flushPromises();
+          case 2:
+            expect(attemptRegistrationWithServersSpy).toHaveBeenCalledTimes(2);
+            expect(attemptRegistrationWithServersSpy).toHaveBeenNthCalledWith(1, _constants.RECONNECT_ON_FAILURE_UTIL, [mobiusUris.backup[0]]);
+            // Immediately try primary servers when retry-after >= 60 seconds on backup
+            expect(restartSpy).toHaveBeenCalledTimes(1);
+            expect(restartSpy).toHaveBeenCalledWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(attemptRegistrationWithServersSpy).toHaveBeenNthCalledWith(2, _constants.RECONNECT_ON_FAILURE_UTIL, [mobiusUris.primary[0]]);
+          case 3:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    })));
+  });
+  describe('handleConnectionRestoration 429 handling tests', function () {
+    beforeEach(function () {
+      jest.useFakeTimers();
+    });
+    afterEach(function () {
+      jest.clearAllTimers();
+      jest.clearAllMocks();
+      jest.useRealTimers();
+    });
+    it('should schedule retry when 429 with retry-after < 60 seconds during handleConnectionRestoration', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee11() {
+      var failurePayload429Small;
+      return _regenerator.default.wrap(function (_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            reg.setActiveMobiusUrl(mobiusUris.primary[0]);
+            failurePayload429Small = {
+              statusCode: 429,
+              body: _constants.RECONNECT_ON_FAILURE_UTIL,
+              headers: {
+                'retry-after': 30
+              }
+            };
+            webex.request.mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload).mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload);
+            _context11.next = 1;
+            return reg.handleConnectionRestoration(true);
+          case 1:
+            expect(restoreSpy).toBeCalledOnceWith(_constants.METHODS.HANDLE_CONNECTION_RESTORATION);
+            expect(restartSpy).not.toBeCalled();
+            expect(reg.retryAfter).toEqual(undefined); // Clear retryAfter after 429 retry
+
+            jest.advanceTimersByTime(40 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context11.next = 2;
+            return flushPromises();
+          case 2:
+            expect(restartSpy).toHaveBeenCalledTimes(1);
+            expect(restartSpy).toHaveBeenCalledWith(_constants.METHODS.HANDLE_CONNECTION_RESTORATION);
+          case 3:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    })));
+    it('should try backup servers when 429 with retry-after >= 60 seconds on primary during handleConnectionRestoration', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee12() {
+      var attemptRegistrationWithServersSpy, failurePayload429Small;
+      return _regenerator.default.wrap(function (_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            attemptRegistrationWithServersSpy = jest.spyOn(reg, 'attemptRegistrationWithServers');
+            reg.setActiveMobiusUrl(mobiusUris.primary[0]);
+            failurePayload429Small = {
+              statusCode: 429,
+              body: _constants.RECONNECT_ON_FAILURE_UTIL,
+              headers: {
+                'retry-after': 100
+              }
+            };
+            webex.request.mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload).mockRejectedValueOnce(failurePayload429Small).mockResolvedValueOnce(successPayload);
+            _context12.next = 1;
+            return reg.handleConnectionRestoration(true);
+          case 1:
+            expect(restoreSpy).toBeCalledOnceWith(_constants.METHODS.HANDLE_CONNECTION_RESTORATION);
+            expect(retry429Spy).toBeCalledOnceWith(100, _constants.METHODS.HANDLE_CONNECTION_RESTORATION);
+            jest.advanceTimersByTime(40 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context12.next = 2;
+            return flushPromises();
+          case 2:
+            expect(attemptRegistrationWithServersSpy).toHaveBeenCalledTimes(2);
+            expect(attemptRegistrationWithServersSpy).toHaveBeenNthCalledWith(1, _constants.METHODS.HANDLE_CONNECTION_RESTORATION, [mobiusUris.primary[0]]);
+            // Immediately try backup servers when retry-after >= 60 seconds on primary
+            expect(attemptRegistrationWithServersSpy).toHaveBeenNthCalledWith(2, _constants.METHODS.HANDLE_CONNECTION_RESTORATION, mobiusUris.backup);
+            expect(restartSpy).not.toHaveBeenCalledTimes(1);
+            expect(restartSpy).not.toHaveBeenCalledWith(_constants.METHODS.HANDLE_CONNECTION_RESTORATION);
+          case 3:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12);
+    })));
+  });
+  describe('Registration failover tests', function () {
+    it('persists failover state in localStorage when primary retry is scheduled', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee13() {
+      var key, raw, state;
+      return _regenerator.default.wrap(function (_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            jest.useFakeTimers();
+            // Force initial registration to fail to schedule failover
+            webex.request.mockRejectedValueOnce(failurePayload);
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.IDLE);
+            _context13.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            // A failover timer should be scheduled; verify localStorage contains state
+            key = "wxc-failover-state.".concat(webex.internal.device.userId);
+            raw = localStorage.getItem(key);
+            expect(raw).toBeTruthy();
+            state = JSON.parse(raw);
+            expect(state).toEqual(expect.objectContaining({
+              attempt: 1,
+              timeElapsed: 0,
+              retryScheduledTime: expect.any(Number),
+              serverType: 'primary'
+            }));
+          case 2:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13);
+    })));
+    it('resumes failover from localStorage on triggerRegistration', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee14() {
+      var key, now, failoverSpy, _failoverSpy$mock$cal, attemptArg, timeElapsedArg;
+      return _regenerator.default.wrap(function (_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            jest.useFakeTimers();
+            key = "wxc-failover-state.".concat(webex.internal.device.userId);
+            now = Math.floor((0, _now.default)() / 1000); // Seed a cached state indicating a retry should have already occurred 5s ago
+            localStorage.setItem(key, (0, _stringify.default)({
+              attempt: 3,
+              timeElapsed: 12,
+              retryScheduledTime: now - 5,
+              serverType: 'primary'
+            }));
+            failoverSpy = jest.spyOn(reg, 'startFailoverTimer');
+            webex.request.mockResolvedValueOnce(successPayload);
+            _context14.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            expect(failoverSpy).toHaveBeenCalledTimes(1);
+            _failoverSpy$mock$cal = (0, _slicedToArray2.default)(failoverSpy.mock.calls[0], 2), attemptArg = _failoverSpy$mock$cal[0], timeElapsedArg = _failoverSpy$mock$cal[1];
+            expect(attemptArg).toBe(3);
+            expect(timeElapsedArg).toBeGreaterThanOrEqual(12);
+          case 2:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14);
+    })));
+    it('verify unreachable primary with reachable backup servers', /*#__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:
+            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);
+            _context15.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context15.next = 2;
+            return flushPromises();
+          case 2:
+            expect(webex.request).toBeCalledTimes(3);
+            expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            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]);
+            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 3:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15);
+    })));
+    it('cc: verify unreachable primary with reachable backup server', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee16() {
+      return _regenerator.default.wrap(function (_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
+          case 0:
+            setupRegistration(_objectSpread(_objectSpread({}, MockServiceData), {}, {
+              indicator: _types.ServiceIndicator.CONTACT_CENTER
+            }));
+            jest.useFakeTimers();
+            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValueOnce(successPayload);
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.IDLE);
+            _context16.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context16.next = 2;
+            return flushPromises();
+          case 2:
+            expect(webex.request).toBeCalledTimes(3);
+            expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, ccMockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, ccMockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            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 3:
+          case "end":
+            return _context16.stop();
+        }
+      }, _callee16);
+    })));
+    it('verify unreachable primary and backup servers', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee17() {
+      return _regenerator.default.wrap(function (_context17) {
+        while (1) switch (_context17.prev = _context17.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);
+            _context17.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context17.next = 2;
+            return flushPromises();
+          case 2:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context17.next = 3;
+            return flushPromises();
+          case 3:
+            /*
+             * 2 calls for primary -> initial and after timer expiry.
+             * 2 calls for each backup entry -> 2 * 2 = 4.
+             * So a total of 6 calls to webex.request and handleErrors
+             */
+            expect(webex.request).toBeCalledTimes(6);
+            expect(handleErrorSpy).toBeCalledTimes(6);
+            expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.primary[0], "device")
+            }));
+            expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[0], "device")
+            }));
+            expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
+              method: 'POST',
+              uri: "".concat(mobiusUris.backup[1], "device")
+            }));
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+          case 4:
+          case "end":
+            return _context17.stop();
+        }
+      }, _callee17);
+    })));
+  });
+  describe('Registration failback tests', function () {
+    var isPrimaryActiveSpy;
+    beforeEach(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee18() {
+      return _regenerator.default.wrap(function (_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
+          case 0:
+            isPrimaryActiveSpy = jest.spyOn(reg, 'isPrimaryActive');
+            isPrimaryActiveSpy.mockReturnValue(true);
+            /* keep keepalive as active so that it wont interfere with the failback tests */
+            jest.useFakeTimers();
+            postRegistrationSpy.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValueOnce(successPayload);
+            _context18.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context18.next = 2;
+            return flushPromises();
+          case 2:
+            reg.rehomingIntervalMin = _constants.DEFAULT_REHOMING_INTERVAL_MIN;
+            reg.rehomingIntervalMax = _constants.DEFAULT_REHOMING_INTERVAL_MAX;
+
+            /* These 2 calls to handleErrorSpy are for primary after which it fails over to backup */
+            expect(handleErrorSpy).toBeCalledTimes(2);
+
+            /* 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 3:
+          case "end":
+            return _context18.stop();
+        }
+      }, _callee18);
+    })));
+    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 _callee19() {
+      return _regenerator.default.wrap(function (_context19) {
+        while (1) switch (_context19.prev = _context19.next) {
+          case 0:
+            // delete should be successful
+            global.fetch = jest.fn(function () {
+              return _promise.default.resolve({
+                json: function json() {
+                  return _registerFixtures.mockDeleteResponse;
+                }
+              });
+            });
+
+            // Mock to fail twice with 429 (once for executeFailback, once for restorePreviousRegistration)
+            postRegistrationSpy.mockRejectedValueOnce(failurePayload429Two).mockRejectedValueOnce(failurePayload429Two);
+
+            /* Wait for failback to be triggered. */
+            jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
+            _context19.next = 1;
+            return flushPromises();
+          case 1:
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
+              method: 'executeFailback',
+              file: _constants.REGISTRATION_FILE
+            });
+            jest.advanceTimersByTime(10000);
+            _context19.next = 2;
+            return flushPromises();
+          case 2:
+            expect(retry429Spy).toBeCalledWith(failurePayload429Two.headers['retry-after'], 'executeFailback');
+            // After handling 429 during failback, the counter is incremented to 1
+            expect(reg.failback429RetryAttempts).toBe(1);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.REG_429_RETRY_UTIL);
+            // restartRegistration is not called immediately because 429 with retry-after < 60
+            // schedules a delayed retry instead
+            expect(restartSpy).not.toBeCalled();
+            expect(reg.failbackTimer).not.toBe(undefined); // Timer is set in handle429Retry
+            expect(reg.rehomingIntervalMin).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MIN);
+            expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
+          case 3:
+          case "end":
+            return _context19.stop();
+        }
+      }, _callee19);
+    })));
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee20() {
+      return _regenerator.default.wrap(function (_context20) {
+        while (1) switch (_context20.prev = _context20.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);
+            _context20.next = 1;
+            return flushPromises();
+          case 1:
+            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 2:
+          case "end":
+            return _context20.stop();
+        }
+      }, _callee20);
+    })));
+    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 _callee21() {
+      var finalErrorPayload;
+      return _regenerator.default.wrap(function (_context21) {
+        while (1) switch (_context21.prev = _context21.next) {
+          case 0:
+            finalErrorPayload = {
+              statusCode: 401,
+              body: _registerFixtures.mockPostResponse
+            };
+            postRegistrationSpy.mockClear();
+            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);
+            _context21.next = 1;
+            return flushPromises();
+          case 1:
+            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(restartSpy).not.toBeCalled();
+            expect(reg.failbackTimer).toBe(undefined);
+            expect(reg.rehomingIntervalMin).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MIN);
+            expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
+          case 2:
+          case "end":
+            return _context21.stop();
+        }
+      }, _callee21);
+    })));
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore success', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee22() {
+      return _regenerator.default.wrap(function (_context22) {
+        while (1) switch (_context22.prev = _context22.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);
+            _context22.next = 1;
+            return flushPromises();
+          case 1:
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
+              method: 'executeFailback',
+              file: _constants.REGISTRATION_FILE
+            });
+            /* Active Url should still match backup url */
+            expect(reg.getActiveMobiusUrl()).toStrictEqual(mobiusUris.backup[0]);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.FAILBACK_UTIL);
+            expect(restartSpy).not.toBeCalled();
+            expect(reg.rehomingIntervalMin).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MIN);
+            expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
+          case 2:
+          case "end":
+            return _context22.stop();
+        }
+      }, _callee22);
+    })));
+    it('verify successful failback to primary after initial registration with backup', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee23() {
+      return _regenerator.default.wrap(function (_context23) {
+        while (1) switch (_context23.prev = _context23.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);
+            _context23.next = 1;
+            return flushPromises();
+          case 1:
+            expect(infoSpy).toBeCalledWith("Attempting failback to primary.", {
+              method: 'executeFailback',
+              file: _constants.REGISTRATION_FILE
+            });
+
+            /* Active Url must now match with the primary url */
+            expect(deregisterSpy).toBeCalledOnceWith();
+            expect(reg.getActiveMobiusUrl()).toStrictEqual(mobiusUris.primary[0]);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            expect(reg.failbackTimer).toBe(undefined);
+            expect(restoreSpy).not.toBeCalled();
+            expect(reg.rehomingIntervalMin).toBe(_registerFixtures.mockPostResponse.rehomingIntervalMin);
+            expect(reg.rehomingIntervalMax).toBe(_registerFixtures.mockPostResponse.rehomingIntervalMax);
+          case 2:
+          case "end":
+            return _context23.stop();
+        }
+      }, _callee23);
+    })));
+    it('verify unsuccessful failback attempt due to active call', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee24() {
+      return _regenerator.default.wrap(function (_context24) {
+        while (1) switch (_context24.prev = _context24.next) {
+          case 0:
+            /** create a new call */
+            reg.callManager.createCall();
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(1);
+            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);
+            _context24.next = 1;
+            return flushPromises();
+          case 1:
+            expect(infoSpy).toBeCalledWith("Active calls present or primary Mobius is down, deferring failback to next cycle.", {
+              method: 'executeFailback',
+              file: _constants.REGISTRATION_FILE
+            });
+
+            /* Active Url should still match backup url */
+            expect(reg.getActiveMobiusUrl()).toStrictEqual(mobiusUris.backup[0]);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            expect(deregisterSpy).not.toBeCalled();
+            expect(restoreSpy).not.toBeCalled();
+            expect(restartSpy).not.toBeCalled();
+            expect(infoSpy).toBeCalledWith('Active calls present or primary Mobius is down, deferring failback to next cycle.', {
+              file: _constants.REGISTRATION_FILE,
+              method: _constants.FAILBACK_UTIL
+            });
+            expect(reg.rehomingIntervalMin).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MIN);
+            expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
+          case 2:
+          case "end":
+            return _context24.stop();
+        }
+      }, _callee24);
+    })));
+    it('verify unsuccessful failback attempt due to primary server being down', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee25() {
+      return _regenerator.default.wrap(function (_context25) {
+        while (1) switch (_context25.prev = _context25.next) {
+          case 0:
+            isPrimaryActiveSpy.mockReturnValue(false);
+
+            /* Wait for failback to be triggered. */
+            jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
+            _context25.next = 1;
+            return flushPromises();
+          case 1:
+            expect(infoSpy).toBeCalledWith("Active calls present or primary Mobius is down, deferring failback to next cycle.", {
+              method: 'executeFailback',
+              file: _constants.REGISTRATION_FILE
+            });
+
+            /* Active Url should still match backup url */
+            expect(deregisterSpy).not.toBeCalled();
+            expect(reg.getActiveMobiusUrl()).toStrictEqual(mobiusUris.backup[0]);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+          case 2:
+          case "end":
+            return _context25.stop();
+        }
+      }, _callee25);
+    })));
+  });
+
+  // Keep-alive related test cases
+  describe('Keep-alive Tests', function () {
+    var beforeEachSetupForKeepalive = /*#__PURE__*/function () {
+      var _ref26 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee26() {
+        return _regenerator.default.wrap(function (_context26) {
+          while (1) switch (_context26.prev = _context26.next) {
+            case 0:
+              postRegistrationSpy.mockResolvedValueOnce(successPayload);
+              jest.useFakeTimers();
+              _context26.next = 1;
+              return reg.triggerRegistration();
+            case 1:
+              expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+              expect(reg.webWorker).toBeDefined();
+            case 2:
+            case "end":
+              return _context26.stop();
+          }
+        }, _callee26);
+      }));
+      return function beforeEachSetupForKeepalive() {
+        return _ref26.apply(this, arguments);
+      };
+    }();
+    afterEach(function () {
+      jest.clearAllTimers();
+      jest.clearAllMocks();
+      reg.clearKeepaliveTimer();
+      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 _callee27() {
+      var postMessageSpy;
+      return _regenerator.default.wrap(function (_context27) {
+        while (1) switch (_context27.prev = _context27.next) {
+          case 0:
+            postMessageSpy = jest.spyOn(Worker.prototype, 'postMessage');
+            _context27.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            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 2:
+          case "end":
+            return _context27.stop();
+        }
+      }, _callee27);
+    })));
+    it('verify failure keep-alive cases: Retry Success', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee28() {
+      var worker;
+      return _regenerator.default.wrap(function (_context28) {
+        while (1) switch (_context28.prev = _context28.next) {
+          case 0:
+            _context28.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            worker = reg.webWorker;
+            lineEmitter.mockClear();
+            worker.onmessage({
+              data: {
+                type: 'KEEPALIVE_FAILURE',
+                err: {
+                  statusCode: 503
+                },
+                keepAliveRetryCount: 1
+              }
+            });
+            worker.onmessage({
+              data: {
+                type: 'KEEPALIVE_SUCCESS',
+                statusCode: 200
+              }
+            });
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.RECONNECTED);
+          case 2:
+          case "end":
+            return _context28.stop();
+        }
+      }, _callee28);
+    })));
+    it('verify failure keep-alive cases: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee29() {
+      var reconnectSpy, restoreSpy, restartRegSpy, RETRY_COUNT_THRESHOLD, failureEvent;
+      return _regenerator.default.wrap(function (_context29) {
+        while (1) switch (_context29.prev = _context29.next) {
+          case 0:
+            _context29.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
+            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+            restartRegSpy = jest.spyOn(reg, 'restartRegistration'); // Clear previous event emissions
+            lineEmitter.mockClear();
+
+            // Assume registration is active
+            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);
+            _context29.next = 2;
+            return flushPromises();
+          case 2:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(reconnectSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(restartRegSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            jest.useRealTimers();
+            expect(warnSpy).toHaveBeenCalledWith('Keep-alive missed 5 times. Status -> 503 ', expect.objectContaining({
+              file: _constants.REGISTRATION_FILE,
+              method: 'startKeepaliveTimer'
+            }));
+          case 3:
+          case "end":
+            return _context29.stop();
+        }
+      }, _callee29);
+    })));
+    it('verify failure keep-alive cases: Restore Success', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee30() {
+      var reconnectSpy, url;
+      return _regenerator.default.wrap(function (_context30) {
+        while (1) switch (_context30.prev = _context30.next) {
+          case 0:
+            _context30.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            expect(reg.webWorker).toBeDefined();
+            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);
+            _context30.next = 2;
+            return flushPromises();
+          case 2:
+            expect(reg.webWorker).toBeUndefined();
+            expect(reconnectSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            localStorage.clear();
+            webex.request.mockResolvedValueOnce(successPayload);
+            _context30.next = 3;
+            return reg.triggerRegistration();
+          case 3:
+            _context30.next = 4;
+            return flushPromises();
+          case 4:
+            expect(reg.webWorker).toBeDefined();
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
+                statusCode: 200
+              }
+            });
+
+            // Advance timers and flush any remaining promises.
+            jest.advanceTimersByTime(1000);
+            _context30.next = 5;
+            return flushPromises();
+          case 5:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+            // reconnectSpy should have been called only once.
+            expect(reconnectSpy).toBeCalledTimes(1);
+            expect(restoreSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(restartSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+            // Active Mobius URL should remain unchanged.
+            expect(reg.getActiveMobiusUrl()).toStrictEqual(url);
+          case 6:
+          case "end":
+            return _context30.stop();
+        }
+      }, _callee30);
+    })));
+    it('verify failure followed by recovery of keepalive', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee31() {
+      return _regenerator.default.wrap(function (_context31) {
+        while (1) switch (_context31.prev = _context31.next) {
+          case 0:
+            _context31.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            expect(reg.webWorker).toBeDefined();
+            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: failurePayload,
+                keepAliveRetryCount: reg.isCCFlow ? 4 : 5
+              }
+            });
+            _context31.next = 2;
+            return flushPromises();
+          case 2:
+            expect(reg.webWorker).toBeUndefined();
+            expect(handleErrorSpy).toBeCalledTimes(3);
+            localStorage.clear();
+            _context31.next = 3;
+            return reg.triggerRegistration();
+          case 3:
+            _context31.next = 4;
+            return flushPromises();
+          case 4:
+            expect(reg.webWorker).toBeDefined();
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
+                statusCode: 200
+              }
+            });
+            _context31.next = 5;
+            return flushPromises();
+          case 5:
+            // 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
+              }
+            });
+            _context31.next = 6;
+            return flushPromises();
+          case 6:
+            expect(handleErrorSpy).toBeCalledTimes(4);
+
+            // And then re-register successfully:
+            _context31.next = 7;
+            return reg.triggerRegistration();
+          case 7:
+            _context31.next = 8;
+            return flushPromises();
+          case 8:
+            expect(reg.webWorker).toBeDefined();
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
+                statusCode: 200
+              }
+            });
+            _context31.next = 9;
+            return flushPromises();
+          case 9:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+            expect(reg.webWorker).toBeDefined();
+          case 10:
+          case "end":
+            return _context31.stop();
+        }
+      }, _callee31);
+    })));
+    it('cc: verify failover to backup server after 4 keep alive failure with primary server', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee32() {
+      var clearKeepaliveSpy, reconnectSpy;
+      return _regenerator.default.wrap(function (_context32) {
+        while (1) switch (_context32.prev = _context32.next) {
+          case 0:
+            // Register with contact center service
+            setupRegistration(_objectSpread(_objectSpread({}, MockServiceData), {}, {
+              indicator: _types.ServiceIndicator.CONTACT_CENTER
+            }));
+            _context32.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            webex.request.mockResolvedValueOnce(successPayload);
+            _context32.next = 2;
+            return reg.triggerRegistration();
+          case 2:
+            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
+            _context32.next = 3;
+            return flushPromises();
+          case 3:
+            // Verify that the keepalive timer was cleared and reconnectOnFailure was triggered
+            expect(clearKeepaliveSpy).toHaveBeenCalled();
+            expect(reconnectSpy).toHaveBeenCalledWith(_constants.RECONNECT_ON_FAILURE_UTIL);
+
+            // Verify that the active Mobius URL has been updated to the backup server and registration is active
+            expect(reg.getActiveMobiusUrl()).toEqual(mobiusUris.backup[0]);
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          case 4:
+          case "end":
+            return _context32.stop();
+        }
+      }, _callee32);
+    })));
+    it('verify failure keep-alive case with active call present: Restore Success after call ends', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee33() {
+      var reconnectSpy, restoreSpy, restartRegSpy, clearTimerSpy, threshold, failureEvent;
+      return _regenerator.default.wrap(function (_context33) {
+        while (1) switch (_context33.prev = _context33.next) {
+          case 0:
+            _context33.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
+            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+            restartRegSpy = jest.spyOn(reg, 'restartRegistration'); // Simulate an active call.
+            reg.callManager.createCall();
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(1);
+            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
+              }
+            };
+            reg.webWorker.onmessage(failureEvent);
+            _context33.next = 2;
+            return flushPromises();
+          case 2:
+            // At this point, clearKeepaliveTimer was called so the worker is terminated.
+            expect(clearTimerSpy).toHaveBeenCalled();
+            expect(reg.webWorker).toBeUndefined();
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).lastCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(reg.keepaliveTimer).toStrictEqual(undefined);
+            expect(reg.failbackTimer).toStrictEqual(undefined);
+            expect(reconnectSpy).toBeCalledOnceWith(_constants.RECONNECT_ON_FAILURE_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();
+
+            // Now simulate call cleanup.
+            reg.callManager.callCollection = {};
+            webex.request.mockResolvedValueOnce(successPayload);
+
+            // Call reconnectOnFailure manually. With no active calls, this should trigger re-registration.
+            _context33.next = 3;
+            return reg.reconnectOnFailure(_constants.CALLS_CLEARED_HANDLER_UTIL);
+          case 3:
+            _context33.next = 4;
+            return flushPromises();
+          case 4:
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
+            // After re-registration, registration status becomes ACTIVE and a new worker is created.
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+            expect(reg.webWorker).toBeDefined();
+            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);
+          case 5:
+          case "end":
+            return _context33.stop();
+        }
+      }, _callee33);
+    })));
+    it('checks for keep-alive failure with final error: 404', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee34() {
+      var reconnectSpy, restoreSpy, restartRegSpy, clearTimerSpy, handle404CbSpy, registerSpy;
+      return _regenerator.default.wrap(function (_context34) {
+        while (1) switch (_context34.prev = _context34.next) {
+          case 0:
+            _context34.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            webex.request.mockResolvedValueOnce(successPayload);
+            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
+            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
+            restartRegSpy = jest.spyOn(reg, 'restartRegistration');
+            clearTimerSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            handle404CbSpy = jest.spyOn(reg, 'handle404KeepaliveFailure');
+            registerSpy = jest.spyOn(reg, 'attemptRegistrationWithServers');
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 404
+                },
+                keepAliveRetryCount: 1
+              }
+            });
+            _context34.next = 2;
+            return flushPromises();
+          case 2:
+            expect(warnSpy).toBeCalledWith('Keep-alive missed 1 times. Status -> 404 ', expect.objectContaining({
+              file: _constants.REGISTRATION_FILE,
+              method: 'startKeepaliveTimer'
+            }));
+            expect(handleErrorSpy).toBeCalledOnceWith({
+              statusCode: 404
+            }, expect.anything(), {
+              file: _constants.REGISTRATION_FILE,
+              method: _constants.KEEPALIVE_UTIL
+            }, expect.anything());
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.ERROR, undefined, expect.anything());
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(clearTimerSpy).toBeCalledTimes(2);
+            expect(reconnectSpy).not.toHaveBeenCalled();
+            expect(restoreSpy).not.toHaveBeenCalled();
+            expect(restartRegSpy).not.toHaveBeenCalled();
+            expect(reg.reconnectPending).toStrictEqual(false);
+            expect(handle404CbSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+            expect(registerSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
+          case 3:
+          case "end":
+            return _context34.stop();
+        }
+      }, _callee34);
+    })));
+    it('checks for keep-alive failure with 429', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee35() {
+      var _reg$deviceInfo$devic;
+      var keepaliveSpy, postMessageSpy, clearTimerSpy, retry429Spy;
+      return _regenerator.default.wrap(function (_context35) {
+        while (1) switch (_context35.prev = _context35.next) {
+          case 0:
+            _context35.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            keepaliveSpy = jest.spyOn(reg, 'startKeepaliveTimer');
+            postMessageSpy = jest.spyOn(Worker.prototype, 'postMessage');
+            clearTimerSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            retry429Spy = jest.spyOn(reg, 'handle429Retry');
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 429,
+                  headers: {
+                    'retry-after': 20
+                  }
+                },
+                keepAliveRetryCount: 1
+              }
+            });
+            _context35.next = 2;
+            return flushPromises();
+          case 2:
+            expect(warnSpy).toBeCalledWith('Keep-alive missed 1 times. Status -> 429 ', expect.objectContaining({
+              file: _constants.REGISTRATION_FILE,
+              method: 'startKeepaliveTimer'
+            }));
+            expect(handleErrorSpy).toBeCalledOnceWith({
+              statusCode: 429,
+              headers: {
+                'retry-after': 20
+              }
+            }, expect.anything(), {
+              file: _constants.REGISTRATION_FILE,
+              method: _constants.KEEPALIVE_UTIL
+            }, expect.anything());
+            expect(retry429Spy).toBeCalledOnceWith(20, 'startKeepaliveTimer');
+            expect(clearTimerSpy).toBeCalledTimes(1);
+            expect(reg.reconnectPending).toStrictEqual(false);
+            expect(reg.keepaliveTimer).toBe(undefined);
+            expect(reg.webWorker).toBeUndefined();
+            jest.advanceTimersByTime(20 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context35.next = 3;
+            return flushPromises();
+          case 3:
+            expect(keepaliveSpy).toBeCalledOnceWith((_reg$deviceInfo$devic = reg.deviceInfo.device) === null || _reg$deviceInfo$devic === void 0 ? void 0 : _reg$deviceInfo$devic.uri, reg.deviceInfo.keepaliveInterval, 'UNKNOWN');
+            expect(logSpy).toBeCalledWith('Resuming keepalive after 20 seconds', {
+              file: _constants.REGISTRATION_FILE,
+              method: 'handle429Retry'
+            });
+            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)
+            }));
+          case 4:
+          case "end":
+            return _context35.stop();
+        }
+      }, _callee35);
+    })));
+    it('ensure retryAfter is set when 429 occurs during failover retry', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee36() {
+      var retry429Spy;
+      return _regenerator.default.wrap(function (_context36) {
+        while (1) switch (_context36.prev = _context36.next) {
+          case 0:
+            _context36.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            // Simulate loss of registration so failover path attempts a new registration
+            reg.clearKeepaliveTimer();
+            reg.setStatus(_types.RegistrationStatus.INACTIVE);
+            retry429Spy = jest.spyOn(reg, 'handle429Retry'); // Make the failover interval deterministic and simulate 429 on the failover attempt
+            jest.spyOn(reg, 'getRegRetryInterval').mockReturnValueOnce(33);
+            webex.request.mockRejectedValueOnce(failurePayload429One);
+
+            // Directly schedule the failover attempt
+            _context36.next = 2;
+            return reg.startFailoverTimer();
+          case 2:
+            jest.advanceTimersByTime(33 * _constants.SEC_TO_MSEC_MFACTOR);
+            _context36.next = 3;
+            return flushPromises();
+          case 3:
+            expect(retry429Spy).toBeCalledWith(failurePayload429One.headers['retry-after'], 'startFailoverTimer');
+            expect(reg.retryAfter).toEqual(failurePayload429One.headers['retry-after']);
+            jest.useRealTimers();
+          case 4:
+          case "end":
+            return _context36.stop();
+        }
+      }, _callee36);
+    })));
+    it('sets retryAfter when reconnectOnFailure caller receives 429 after keepalive threshold miss', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee37() {
+      var retry429Spy, threshold;
+      return _regenerator.default.wrap(function (_context37) {
+        while (1) switch (_context37.prev = _context37.next) {
+          case 0:
+            _context37.next = 1;
+            return beforeEachSetupForKeepalive();
+          case 1:
+            retry429Spy = jest.spyOn(reg, 'handle429Retry'); // On reconnectOnFailure(RECONNECT_ON_FAILURE_UTIL) first restore attempt, make registration respond with 429 (retry-after: 20)
+            webex.request.mockRejectedValueOnce({
+              statusCode: 429,
+              body: _registerFixtures.mockPostResponse,
+              headers: {
+                'retry-after': 20
+              }
+            });
+
+            // Trigger the keepalive failure at threshold to route to reconnectOnFailure(RECONNECT_ON_FAILURE_UTIL)
+            threshold = reg.isCCFlow ? 4 : 5;
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 503
+                },
+                keepAliveRetryCount: threshold
+              }
+            });
+            _context37.next = 2;
+            return flushPromises();
+          case 2:
+            // handle429Retry is called with caller 'reconnectOnFailure' → else branch executes and sets retryAfter
+            expect(retry429Spy).toBeCalledOnceWith(20, _constants.RECONNECT_ON_FAILURE_UTIL);
+            expect(reg.retryAfter).toEqual(undefined); // Clear retryAfter after 429 retry
+          case 3:
+          case "end":
+            return _context37.stop();
+        }
+      }, _callee37);
+    })));
+  });
+  describe('Primary server status checks', function () {
+    it('success: primary server status to be up', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee38() {
+      var pingSuccessPayload, status;
+      return _regenerator.default.wrap(function (_context38) {
+        while (1) switch (_context38.prev = _context38.next) {
+          case 0:
+            pingSuccessPayload = {
+              statusCode: 200
+            };
+            webex.request.mockResolvedValue(pingSuccessPayload);
+            _context38.next = 1;
+            return reg.isPrimaryActive();
+          case 1:
+            status = _context38.sent;
+            expect(webex.request).toBeCalledWith(_objectSpread({
+              method: 'GET',
+              uri: "https://mobius-dfw.webex.com/api/v1/ping"
+            }, (0, _testUtil.getMockRequestTemplate)()));
+            expect(status).toEqual(true);
+          case 2:
+          case "end":
+            return _context38.stop();
+        }
+      }, _callee38);
+    })));
+    it('failed: primary server status to be down', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee39() {
+      var pingFailurePayload, status;
+      return _regenerator.default.wrap(function (_context39) {
+        while (1) switch (_context39.prev = _context39.next) {
+          case 0:
+            pingFailurePayload = {
+              statusCode: 500
+            };
+            webex.request.mockResolvedValue(pingFailurePayload);
+            _context39.next = 1;
+            return reg.isPrimaryActive();
+          case 1:
+            status = _context39.sent;
+            expect(webex.request).toBeCalledWith(_objectSpread({
+              method: 'GET',
+              uri: "https://mobius-dfw.webex.com/api/v1/ping"
+            }, (0, _testUtil.getMockRequestTemplate)()));
+            expect(status).toEqual(false);
+          case 2:
+          case "end":
+            return _context39.stop();
+        }
+      }, _callee39);
+    })));
+  });
+});
+//# sourceMappingURL=register.test.js.map