@webex/calling 3.4.0 → 3.5.0

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

@@ -60,6 +60,14 @@ describe('Registration Tests', function () {
       }
     }
   });
+  var ccMockResponse = _objectSpread(_objectSpread({}, mockResponse), {}, {
+    body: _objectSpread(_objectSpread({}, mockResponse.body), {}, {
+      serviceData: {
+        domain: '',
+        indicator: 'contactcenter'
+      }
+    })
+  });
   var failurePayload = {
     statusCode: 500,
     body: _registerFixtures.mockPostResponse
@@ -77,15 +85,18 @@ describe('Registration Tests', function () {
   var failbackRetry429Spy;
   var restoreSpy;
   var postRegistrationSpy;
-  beforeEach(function () {
+  var setupRegistration = function setupRegistration(mockServiceData) {
     var mutex = new _asyncMutex.Mutex();
-    reg = (0, _register.createRegistration)(webex, MockServiceData, mutex, lineEmitter, _types2.LOGGER.INFO);
+    reg = (0, _register.createRegistration)(webex, mockServiceData, mutex, lineEmitter, _types2.LOGGER.INFO);
     reg.setMobiusServers(mobiusUris.primary, mobiusUris.backup);
     jest.clearAllMocks();
     restartSpy = jest.spyOn(reg, 'restartRegistration');
     failbackRetry429Spy = jest.spyOn(reg, _constants.FAILBACK_429_RETRY_UTIL);
     restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
     postRegistrationSpy = jest.spyOn(reg, 'postRegistration');
+  };
+  beforeEach(function () {
+    setupRegistration(MockServiceData);
   });
   afterEach(function () {
     webex.request = jest.fn();
@@ -225,23 +236,58 @@ describe('Registration Tests', function () {
         }
       }, _callee4);
     })));
-    it('verify unreachable primary and backup servers', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+    it('cc: verify unreachable primary with reachable backup server', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
       return _regenerator.default.wrap(function _callee5$(_context5) {
         while (1) switch (_context5.prev = _context5.next) {
+          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);
+            _context5.next = 6;
+            return reg.triggerRegistration();
+          case 6:
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context5.next = 9;
+            return flushPromises();
+          case 9:
+            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 14:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+    it('verify unreachable primary and backup servers', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      return _regenerator.default.wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
           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);
-            _context5.next = 5;
+            _context6.next = 5;
             return reg.triggerRegistration();
           case 5:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context5.next = 8;
+            _context6.next = 8;
             return flushPromises();
           case 8:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context5.next = 11;
+            _context6.next = 11;
             return flushPromises();
           case 11:
             /*
@@ -266,25 +312,25 @@ describe('Registration Tests', function () {
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
           case 17:
           case "end":
-            return _context5.stop();
+            return _context6.stop();
         }
-      }, _callee5);
+      }, _callee6);
     })));
   });
   describe('Registration failback tests', function () {
-    beforeEach( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
-      return _regenerator.default.wrap(function _callee6$(_context6) {
-        while (1) switch (_context6.prev = _context6.next) {
+    beforeEach( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+      return _regenerator.default.wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
           case 0:
             /* keep keepalive as active so that it wont interfere with the failback tests */
             jest.spyOn(reg, 'postKeepAlive').mockResolvedValue(successPayload);
             jest.useFakeTimers();
             postRegistrationSpy.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValueOnce(successPayload);
-            _context6.next = 5;
+            _context7.next = 5;
             return reg.triggerRegistration();
           case 5:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context6.next = 8;
+            _context7.next = 8;
             return flushPromises();
           case 8:
             reg.rehomingIntervalMin = _constants.DEFAULT_REHOMING_INTERVAL_MIN;
@@ -298,17 +344,17 @@ describe('Registration Tests', function () {
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
           case 13:
           case "end":
-            return _context6.stop();
+            return _context7.stop();
         }
-      }, _callee6);
+      }, _callee7);
     })));
     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 _callee7() {
-      return _regenerator.default.wrap(function _callee7$(_context7) {
-        while (1) switch (_context7.prev = _context7.next) {
+    it('verify 429 error with failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+      return _regenerator.default.wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
           case 0:
             // delete should be successful
             global.fetch = jest.fn(function () {
@@ -322,7 +368,7 @@ describe('Registration Tests', function () {
 
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context7.next = 5;
+            _context8.next = 5;
             return flushPromises();
           case 5:
             expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
@@ -339,19 +385,19 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 14:
           case "end":
-            return _context7.stop();
+            return _context8.stop();
         }
-      }, _callee7);
+      }, _callee8);
     })));
-    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
-      return _regenerator.default.wrap(function _callee8$(_context8) {
-        while (1) switch (_context8.prev = _context8.next) {
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      return _regenerator.default.wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
           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);
-            _context8.next = 4;
+            _context9.next = 4;
             return flushPromises();
           case 4:
             expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
@@ -365,14 +411,14 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 10:
           case "end":
-            return _context8.stop();
+            return _context9.stop();
         }
-      }, _callee8);
+      }, _callee9);
     })));
-    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 _callee9() {
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore failure with final error', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10() {
       var finalErrorPayload;
-      return _regenerator.default.wrap(function _callee9$(_context9) {
-        while (1) switch (_context9.prev = _context9.next) {
+      return _regenerator.default.wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
           case 0:
             finalErrorPayload = {
               statusCode: 401,
@@ -382,7 +428,7 @@ describe('Registration Tests', function () {
             postRegistrationSpy.mockRejectedValue(finalErrorPayload).mockRejectedValueOnce(failurePayload);
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context9.next = 6;
+            _context10.next = 6;
             return flushPromises();
           case 6:
             expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
@@ -397,19 +443,19 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 13:
           case "end":
-            return _context9.stop();
+            return _context10.stop();
         }
-      }, _callee9);
+      }, _callee10);
     })));
-    it('verify unsuccessful failback to primary after initial registration with backup: Restore success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10() {
-      return _regenerator.default.wrap(function _callee10$(_context10) {
-        while (1) switch (_context10.prev = _context10.next) {
+    it('verify unsuccessful failback to primary after initial registration with backup: Restore success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
+      return _regenerator.default.wrap(function _callee11$(_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
           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);
-            _context10.next = 4;
+            _context11.next = 4;
             return flushPromises();
           case 4:
             expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
@@ -425,19 +471,19 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 11:
           case "end":
-            return _context10.stop();
+            return _context11.stop();
         }
-      }, _callee10);
+      }, _callee11);
     })));
-    it('verify successful failback to primary after initial registration with backup', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
-      return _regenerator.default.wrap(function _callee11$(_context11) {
-        while (1) switch (_context11.prev = _context11.next) {
+    it('verify successful failback to primary after initial registration with backup', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12() {
+      return _regenerator.default.wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
           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);
-            _context11.next = 4;
+            _context12.next = 4;
             return flushPromises();
           case 4:
             expect(logSpy).toBeCalledWith("Attempting failback to primary.", {
@@ -454,13 +500,13 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_registerFixtures.mockPostResponse.rehomingIntervalMax);
           case 11:
           case "end":
-            return _context11.stop();
+            return _context12.stop();
         }
-      }, _callee11);
+      }, _callee12);
     })));
-    it('verify unsuccessful failback attempt due to active call', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12() {
-      return _regenerator.default.wrap(function _callee12$(_context12) {
-        while (1) switch (_context12.prev = _context12.next) {
+    it('verify unsuccessful failback attempt due to active call', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
+      return _regenerator.default.wrap(function _callee13$(_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
           case 0:
             /** create a new call */
             reg.callManager.createCall();
@@ -469,7 +515,7 @@ describe('Registration Tests', function () {
 
             /* Wait for failback to be triggered. */
             jest.advanceTimersByTime(reg.rehomingIntervalMax * _constants.MINUTES_TO_SEC_MFACTOR * _constants.SEC_TO_MSEC_MFACTOR);
-            _context12.next = 6;
+            _context13.next = 6;
             return flushPromises();
           case 6:
             expect(logSpy).toBeCalledWith("Active calls present, deferring failback to next cycle.", {
@@ -490,9 +536,9 @@ describe('Registration Tests', function () {
             expect(reg.rehomingIntervalMax).toBe(_constants.DEFAULT_REHOMING_INTERVAL_MAX);
           case 14:
           case "end":
-            return _context12.stop();
+            return _context13.stop();
         }
-      }, _callee12);
+      }, _callee13);
     })));
   });
 
@@ -505,22 +551,27 @@ describe('Registration Tests', function () {
     var mockKeepAliveBody = {
       device: _registerFixtures.mockPostResponse.device
     };
-    beforeEach( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
-      return _regenerator.default.wrap(function _callee13$(_context13) {
-        while (1) switch (_context13.prev = _context13.next) {
-          case 0:
-            postRegistrationSpy.mockResolvedValueOnce(successPayload);
-            jest.useFakeTimers();
-            _context13.next = 4;
-            return reg.triggerRegistration();
-          case 4:
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-          case 5:
-          case "end":
-            return _context13.stop();
-        }
-      }, _callee13);
-    })));
+    var beforeEachSetupForKeepalive = /*#__PURE__*/function () {
+      var _ref14 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
+        return _regenerator.default.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              postRegistrationSpy.mockResolvedValueOnce(successPayload);
+              jest.useFakeTimers();
+              _context14.next = 4;
+              return reg.triggerRegistration();
+            case 4:
+              expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            case 5:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14);
+      }));
+      return function beforeEachSetupForKeepalive() {
+        return _ref14.apply(this, arguments);
+      };
+    }();
     afterEach(function () {
       jest.clearAllTimers();
       jest.clearAllMocks();
@@ -534,11 +585,14 @@ describe('Registration Tests', function () {
         call.end();
       });
     });
-    it('verify successful keep-alive cases', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
+    it('verify successful keep-alive cases', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
       var keepAlivePayload, funcSpy;
-      return _regenerator.default.wrap(function _callee14$(_context14) {
-        while (1) switch (_context14.prev = _context14.next) {
+      return _regenerator.default.wrap(function _callee15$(_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
           case 0:
+            _context15.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
             keepAlivePayload = {
               statusCode: 200,
               body: mockKeepAliveBody
@@ -546,22 +600,25 @@ describe('Registration Tests', function () {
             webex.request.mockReturnValue(keepAlivePayload);
             funcSpy = jest.spyOn(reg, 'postKeepAlive');
             jest.advanceTimersByTime(2 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context14.next = 6;
+            _context15.next = 8;
             return flushPromises();
-          case 6:
+          case 8:
             expect(funcSpy).toBeCalledTimes(2); // should be called 2 times: first try and after the interval.
             expect(logSpy).lastCalledWith('Sent Keepalive, status: 200', logObj);
-          case 8:
+          case 10:
           case "end":
-            return _context14.stop();
+            return _context15.stop();
         }
-      }, _callee14);
+      }, _callee15);
     })));
-    it('verify failure keep-alive cases: Retry Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
+    it('verify failure keep-alive cases: Retry Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16() {
       var failurePayload, successPayload, timer;
-      return _regenerator.default.wrap(function _callee15$(_context15) {
-        while (1) switch (_context15.prev = _context15.next) {
+      return _regenerator.default.wrap(function _callee16$(_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
           case 0:
+            _context16.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
             failurePayload = {
               statusCode: 503,
               body: mockKeepAliveBody
@@ -574,9 +631,9 @@ describe('Registration Tests', function () {
             lineEmitter.mockClear();
             webex.request.mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
             jest.advanceTimersByTime(2 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context15.next = 8;
+            _context16.next = 10;
             return flushPromises();
-          case 8:
+          case 10:
             expect(handleErrorSpy).toBeCalledOnceWith(failurePayload, expect.anything(), {
               method: 'startKeepaliveTimer',
               file: _constants.REGISTRATION_FILE
@@ -586,17 +643,20 @@ describe('Registration Tests', function () {
             expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.RECONNECTING);
             expect(lineEmitter).nthCalledWith(2, _types4.LINE_EVENTS.RECONNECTED);
             expect(lineEmitter).toBeCalledTimes(2);
-          case 14:
+          case 16:
           case "end":
-            return _context15.stop();
+            return _context16.stop();
         }
-      }, _callee15);
+      }, _callee16);
     })));
-    it('verify failure keep-alive cases: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16() {
+    it('verify failure keep-alive cases: Restore failure', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17() {
       var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, clearIntervalSpy, timer;
-      return _regenerator.default.wrap(function _callee16$(_context16) {
-        while (1) switch (_context16.prev = _context16.next) {
+      return _regenerator.default.wrap(function _callee17$(_context17) {
+        while (1) switch (_context17.prev = _context17.next) {
           case 0:
+            _context17.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
             restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
             restartRegSpy = jest.spyOn(reg, 'restartRegistration');
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
@@ -610,9 +670,9 @@ describe('Registration Tests', function () {
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
             timer = reg.keepaliveTimer;
             jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context16.next = 12;
+            _context17.next = 14;
             return flushPromises();
-          case 12:
+          case 14:
             expect(clearIntervalSpy).toBeCalledOnceWith(timer);
 
             // sendKeepAlive tries to retry 5 times before accepting failure
@@ -635,17 +695,20 @@ describe('Registration Tests', function () {
             expect(lineEmitter).nthCalledWith(8, _types4.LINE_EVENTS.CONNECTING);
             expect(lineEmitter).nthCalledWith(9, _types4.LINE_EVENTS.UNREGISTERED);
             expect(lineEmitter).toBeCalledTimes(9);
-          case 29:
+          case 31:
           case "end":
-            return _context16.stop();
+            return _context17.stop();
         }
-      }, _callee16);
+      }, _callee17);
     })));
-    it('verify failure keep-alive cases: Restore Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17() {
+    it('verify failure keep-alive cases: Restore Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18() {
       var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, successPayload, clearIntervalSpy, url, timer;
-      return _regenerator.default.wrap(function _callee17$(_context17) {
-        while (1) switch (_context17.prev = _context17.next) {
+      return _regenerator.default.wrap(function _callee18$(_context18) {
+        while (1) switch (_context18.prev = _context18.next) {
           case 0:
+            _context18.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
             restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
             restartRegSpy = jest.spyOn(reg, 'restartRegistration');
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
@@ -669,9 +732,9 @@ describe('Registration Tests', function () {
             reg.setActiveMobiusUrl(url);
             timer = reg.keepaliveTimer;
             jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context17.next = 14;
+            _context18.next = 16;
             return flushPromises();
-          case 14:
+          case 16:
             expect(clearIntervalSpy).toBeCalledOnceWith(timer);
             expect(handleErrorSpy).toBeCalledTimes(5);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
@@ -682,17 +745,20 @@ describe('Registration Tests', function () {
             expect(reg.reconnectPending).toStrictEqual(false);
             expect(reg.keepaliveTimer).toBeTruthy();
             expect(reg.keepaliveTimer).not.toBe(timer);
-          case 24:
+          case 26:
           case "end":
-            return _context17.stop();
+            return _context18.stop();
         }
-      }, _callee17);
+      }, _callee18);
     })));
-    it('verify failure followed by recovery of keepalive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18() {
+    it('verify failure followed by recovery of keepalive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19() {
       var failurePayload, successPayload, clearIntervalSpy, timer;
-      return _regenerator.default.wrap(function _callee18$(_context18) {
-        while (1) switch (_context18.prev = _context18.next) {
+      return _regenerator.default.wrap(function _callee19$(_context19) {
+        while (1) switch (_context19.prev = _context19.next) {
           case 0:
+            _context19.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
             failurePayload = {
               statusCode: 503,
               body: mockKeepAliveBody
@@ -706,25 +772,73 @@ describe('Registration Tests', function () {
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
             timer = reg.keepaliveTimer; // sendKeepAlive tries to retry 3 times and receiving success on third time
             jest.advanceTimersByTime(3 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context18.next = 9;
+            _context19.next = 11;
             return flushPromises();
-          case 9:
+          case 11:
             expect(webex.request).toBeCalledTimes(3);
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
             expect(handleErrorSpy).toBeCalledTimes(2);
             expect(clearIntervalSpy).not.toBeCalled();
             expect(reg.keepaliveTimer).toBe(timer);
-          case 14:
+          case 16:
           case "end":
-            return _context18.stop();
+            return _context19.stop();
         }
-      }, _callee18);
+      }, _callee19);
+    })));
+    it('cc: verify failover to backup server after 4 keep alive failure with primary server', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
+      var failurePayload, successPayload, clearIntervalSpy, timer;
+      return _regenerator.default.wrap(function _callee20$(_context20) {
+        while (1) switch (_context20.prev = _context20.next) {
+          case 0:
+            // Register with contact center service
+            setupRegistration(_objectSpread(_objectSpread({}, MockServiceData), {}, {
+              indicator: _types.ServiceIndicator.CONTACT_CENTER
+            }));
+            _context20.next = 3;
+            return beforeEachSetupForKeepalive();
+          case 3:
+            failurePayload = {
+              statusCode: 503,
+              body: mockKeepAliveBody
+            };
+            successPayload = {
+              statusCode: 200,
+              body: mockKeepAliveBody
+            };
+            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+            jest.spyOn(reg, 'postKeepAlive').mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+            timer = reg.keepaliveTimer;
+            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            _context20.next = 12;
+            return flushPromises();
+          case 12:
+            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(reg.keepaliveTimer).not.toBe(timer);
+            webex.request.mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
+            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
+            _context20.next = 19;
+            return flushPromises();
+          case 19:
+            /* Active Url must match with the backup url as per the test */
+            expect(reg.getActiveMobiusUrl()).toEqual(mobiusUris.backup[0]);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+          case 21:
+          case "end":
+            return _context20.stop();
+        }
+      }, _callee20);
     })));
-    it('verify final error for keep-alive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19() {
+    it('verify final error for keep-alive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
       var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, clearIntervalSpy;
-      return _regenerator.default.wrap(function _callee19$(_context19) {
-        while (1) switch (_context19.prev = _context19.next) {
+      return _regenerator.default.wrap(function _callee21$(_context21) {
+        while (1) switch (_context21.prev = _context21.next) {
           case 0:
+            _context21.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
             restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
             restartRegSpy = jest.spyOn(reg, 'restartRegistration');
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
@@ -738,9 +852,9 @@ describe('Registration Tests', function () {
 
             /* send one keepalive */
             jest.advanceTimersByTime(_registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context19.next = 10;
+            _context21.next = 12;
             return flushPromises();
-          case 10:
+          case 12:
             expect(clearIntervalSpy).toBeCalledTimes(1);
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
             expect(reconnectSpy).not.toBeCalled();
@@ -758,17 +872,20 @@ describe('Registration Tests', function () {
               file: _constants.REGISTRATION_FILE,
               method: _constants.KEEPALIVE_UTIL
             });
-          case 19:
+          case 21:
           case "end":
-            return _context19.stop();
+            return _context21.stop();
         }
-      }, _callee19);
+      }, _callee21);
     })));
-    it('verify failure keep-alive case with active call present: Restore Success after call ends', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
+    it('verify failure keep-alive case with active call present: Restore Success after call ends', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22() {
       var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, successPayload, clearIntervalSpy, url, timer, call;
-      return _regenerator.default.wrap(function _callee20$(_context20) {
-        while (1) switch (_context20.prev = _context20.next) {
+      return _regenerator.default.wrap(function _callee22$(_context22) {
+        while (1) switch (_context22.prev = _context22.next) {
           case 0:
+            _context22.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
             restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
             restartRegSpy = jest.spyOn(reg, 'restartRegistration');
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
@@ -795,9 +912,9 @@ describe('Registration Tests', function () {
 
             /* send one keepalive */
             jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context20.next = 16;
+            _context22.next = 18;
             return flushPromises();
-          case 16:
+          case 18:
             expect(clearIntervalSpy).toBeCalledOnceWith(timer);
             expect(handleErrorSpy).toBeCalledTimes(5);
             expect(reg.keepaliveTimer).toStrictEqual(undefined);
@@ -816,9 +933,9 @@ describe('Registration Tests', function () {
 
             /* simulate call disconnect and Calling client will trigger reconnect upon receiving disconnect event from CallManager */
             reg.callManager.callCollection = {};
-            _context20.next = 31;
+            _context22.next = 33;
             return reg.reconnectOnFailure(_constants.CALLS_CLEARED_HANDLER_UTIL);
-          case 31:
+          case 33:
             expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
             expect(reconnectSpy).toBeCalledOnceWith(_constants.CALLS_CLEARED_HANDLER_UTIL);
@@ -828,11 +945,11 @@ describe('Registration Tests', function () {
             expect(reg.getActiveMobiusUrl()).toStrictEqual(url);
             expect(reg.keepaliveTimer).toBeTruthy();
             expect(reg.keepaliveTimer).not.toBe(timer);
-          case 40:
+          case 42:
           case "end":
-            return _context20.stop();
+            return _context22.stop();
         }
-      }, _callee20);
+      }, _callee22);
     })));
   });
 });