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

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

@@ -323,16 +323,15 @@ describe('Registration Tests', function () {
         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);
-            _context7.next = 5;
+            _context7.next = 4;
             return reg.triggerRegistration();
-          case 5:
+          case 4:
             jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context7.next = 8;
+            _context7.next = 7;
             return flushPromises();
-          case 8:
+          case 7:
             reg.rehomingIntervalMin = _constants.DEFAULT_REHOMING_INTERVAL_MIN;
             reg.rehomingIntervalMax = _constants.DEFAULT_REHOMING_INTERVAL_MAX;
 
@@ -342,7 +341,7 @@ describe('Registration Tests', function () {
             /* Active Url must match with the backup url as per the test */
             expect(reg.getActiveMobiusUrl()).toStrictEqual(mobiusUris.backup[0]);
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-          case 13:
+          case 12:
           case "end":
             return _context7.stop();
         }
@@ -544,13 +543,6 @@ describe('Registration Tests', function () {
 
   // Keep-alive related test cases
   describe('Keep-alive Tests', function () {
-    var logObj = {
-      file: _constants.REGISTRATION_FILE,
-      method: 'startKeepaliveTimer'
-    };
-    var mockKeepAliveBody = {
-      device: _registerFixtures.mockPostResponse.device
-    };
     var beforeEachSetupForKeepalive = /*#__PURE__*/function () {
       var _ref14 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
         return _regenerator.default.wrap(function _callee14$(_context14) {
@@ -562,7 +554,8 @@ describe('Registration Tests', function () {
               return reg.triggerRegistration();
             case 4:
               expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-            case 5:
+              expect(reg.webWorker).toBeDefined();
+            case 6:
             case "end":
               return _context14.stop();
           }
@@ -575,10 +568,7 @@ describe('Registration Tests', function () {
     afterEach(function () {
       jest.clearAllTimers();
       jest.clearAllMocks();
-      if (reg.keepaliveTimer) {
-        clearInterval(reg.keepaliveTimer);
-        reg.keepaliveTimer = undefined;
-      }
+      reg.clearKeepaliveTimer();
       reg.reconnectPending = false;
       var calls = (0, _values.default)(reg.callManager.getActiveCalls());
       calls.forEach(function (call) {
@@ -586,165 +576,164 @@ describe('Registration Tests', function () {
       });
     });
     it('verify successful keep-alive cases', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
-      var keepAlivePayload, funcSpy;
+      var postMessageSpy;
       return _regenerator.default.wrap(function _callee15$(_context15) {
         while (1) switch (_context15.prev = _context15.next) {
           case 0:
-            _context15.next = 2;
+            postMessageSpy = jest.spyOn(Worker.prototype, 'postMessage');
+            _context15.next = 3;
             return beforeEachSetupForKeepalive();
-          case 2:
-            keepAlivePayload = {
-              statusCode: 200,
-              body: mockKeepAliveBody
-            };
-            webex.request.mockReturnValue(keepAlivePayload);
-            funcSpy = jest.spyOn(reg, 'postKeepAlive');
-            jest.advanceTimersByTime(2 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context15.next = 8;
-            return flushPromises();
-          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 10:
+          case 3:
+            expect(reg.webWorker).toBeDefined();
+            expect(postMessageSpy).toHaveBeenCalledWith(expect.objectContaining({
+              type: 'START_KEEPALIVE',
+              accessToken: expect.any(String),
+              deviceUrl: expect.any(String),
+              interval: expect.any(Number),
+              retryCountThreshold: expect.any(Number),
+              url: expect.any(String)
+            }));
+            reg.webWorker.onmessage({
+              data: {
+                type: 'KEEPALIVE_SUCCESS',
+                statusCode: 200
+              }
+            });
+            expect(lineEmitter).toBeCalledWith(_types4.LINE_EVENTS.RECONNECTED);
+          case 7:
           case "end":
             return _context15.stop();
         }
       }, _callee15);
     })));
     it('verify failure keep-alive cases: Retry Success', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16() {
-      var failurePayload, successPayload, timer;
+      var worker;
       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
-            };
-            successPayload = {
-              statusCode: 200,
-              body: mockKeepAliveBody
-            };
-            timer = reg.keepaliveTimer;
+            worker = reg.webWorker;
             lineEmitter.mockClear();
-            webex.request.mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
-            jest.advanceTimersByTime(2 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context16.next = 10;
-            return flushPromises();
-          case 10:
-            expect(handleErrorSpy).toBeCalledOnceWith(failurePayload, expect.anything(), {
-              method: 'startKeepaliveTimer',
-              file: _constants.REGISTRATION_FILE
+            worker.onmessage({
+              data: {
+                type: 'KEEPALIVE_FAILURE',
+                err: {
+                  statusCode: 503
+                },
+                keepAliveRetryCount: 1
+              }
             });
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-            expect(reg.keepaliveTimer).toBe(timer);
-            expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.RECONNECTING);
-            expect(lineEmitter).nthCalledWith(2, _types4.LINE_EVENTS.RECONNECTED);
-            expect(lineEmitter).toBeCalledTimes(2);
-          case 16:
+            worker.onmessage({
+              data: {
+                type: 'KEEPALIVE_SUCCESS',
+                statusCode: 200
+              }
+            });
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.RECONNECTED);
+          case 7:
           case "end":
             return _context16.stop();
         }
       }, _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;
+      var reconnectSpy, RETRY_COUNT_THRESHOLD, failureEvent;
       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');
-            failurePayload = {
-              statusCode: 503,
-              body: mockKeepAliveBody
-            };
-            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
+            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure'); // Clear previous event emissions
             lineEmitter.mockClear();
-            webex.request.mockRejectedValue(failurePayload);
+
+            // Assume registration is active
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-            timer = reg.keepaliveTimer;
-            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context17.next = 14;
-            return flushPromises();
-          case 14:
-            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
 
-            // sendKeepAlive tries to retry 5 times before accepting failure
-            // later 2 attempts to register with primary server
-            expect(handleErrorSpy).toBeCalledTimes(7);
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
-            expect(reg.reconnectPending).toStrictEqual(false);
-            expect(reconnectSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
-            expect(restoreSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
-            expect(restartRegSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
-            expect(webex.request).toBeCalledTimes(7);
-            expect(reg.keepaliveTimer).toBe(undefined);
-            expect(lineEmitter).nthCalledWith(1, _types4.LINE_EVENTS.RECONNECTING);
-            expect(lineEmitter).nthCalledWith(4, _types4.LINE_EVENTS.RECONNECTING);
-            expect(lineEmitter).nthCalledWith(5, _types4.LINE_EVENTS.UNREGISTERED);
+            // Use fake timers to trigger keepalive initialization
+            jest.useFakeTimers();
+            jest.advanceTimersByTime(_registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
 
-            /** there will be 2 registration attempts */
-            expect(lineEmitter).nthCalledWith(6, _types4.LINE_EVENTS.CONNECTING);
-            expect(lineEmitter).nthCalledWith(7, _types4.LINE_EVENTS.UNREGISTERED);
-            expect(lineEmitter).nthCalledWith(8, _types4.LINE_EVENTS.CONNECTING);
-            expect(lineEmitter).nthCalledWith(9, _types4.LINE_EVENTS.UNREGISTERED);
-            expect(lineEmitter).toBeCalledTimes(9);
-          case 31:
+            // Simulate the worker sending a KEEPALIVE_FAILURE message with retry count at threshold.
+            RETRY_COUNT_THRESHOLD = reg.isCCFlow ? 4 : 5;
+            failureEvent = {
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 503
+                },
+                keepAliveRetryCount: RETRY_COUNT_THRESHOLD
+              }
+            };
+            reg.webWorker.onmessage(failureEvent);
+            _context17.next = 12;
+            return flushPromises();
+          case 12:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(reconnectSpy).toBeCalledOnceWith('startKeepaliveTimer');
+            jest.useRealTimers();
+          case 16:
           case "end":
             return _context17.stop();
         }
       }, _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;
+      var reconnectSpy, url;
       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');
+            expect(reg.webWorker).toBeDefined();
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
-            failurePayload = {
-              statusCode: 503,
-              body: mockKeepAliveBody
-            };
-            successPayload = {
-              statusCode: 200,
-              body: mockKeepAliveBody
-            };
-            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
-            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
-
-            /* successful registration */
-            // webex.request.mockResolvedValue(successPayload);
-
-            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-            url = 'https://mobius.asydm-m-1.prod.infra.webex.com/api/v1';
-            /* set active Url and expect the registration to restore to this url */
-            reg.setActiveMobiusUrl(url);
-            timer = reg.keepaliveTimer;
-            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
+            url = 'https://mobius-dfw.webex.com/api/v1/calling/web/';
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 503
+                },
+                keepAliveRetryCount: 5
+              }
+            });
+            jest.advanceTimersByTime(1000);
+            _context18.next = 9;
+            return flushPromises();
+          case 9:
+            expect(reg.webWorker).toBeUndefined();
+            expect(reconnectSpy).toBeCalledOnceWith(reg.startKeepaliveTimer.name);
+            webex.request.mockResolvedValueOnce(successPayload);
+            _context18.next = 14;
+            return reg.triggerRegistration();
+          case 14:
             _context18.next = 16;
             return flushPromises();
           case 16:
-            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
-            expect(handleErrorSpy).toBeCalledTimes(5);
+            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);
+            _context18.next = 21;
+            return flushPromises();
+          case 21:
             expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
-            expect(reconnectSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
-            expect(restoreSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
-            expect(restartRegSpy).not.toBeCalled();
+            // reconnectSpy should have been called only once.
+            expect(reconnectSpy).toBeCalledTimes(1);
+            expect(restoreSpy).toBeCalledOnceWith(reg.startKeepaliveTimer.name);
+            expect(restartSpy).toBeCalledOnceWith(reg.startKeepaliveTimer.name);
+            // Active Mobius URL should remain unchanged.
             expect(reg.getActiveMobiusUrl()).toStrictEqual(url);
-            expect(reg.reconnectPending).toStrictEqual(false);
-            expect(reg.keepaliveTimer).toBeTruthy();
-            expect(reg.keepaliveTimer).not.toBe(timer);
           case 26:
           case "end":
             return _context18.stop();
@@ -752,42 +741,84 @@ describe('Registration Tests', 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 _callee19$(_context19) {
         while (1) switch (_context19.prev = _context19.next) {
           case 0:
             _context19.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            failurePayload = {
-              statusCode: 503,
-              body: mockKeepAliveBody
-            };
-            successPayload = {
-              statusCode: 200,
-              body: mockKeepAliveBody
-            };
-            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
-            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
             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);
-            _context19.next = 11;
+            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
+              }
+            });
+            _context19.next = 8;
             return flushPromises();
-          case 11:
-            expect(webex.request).toBeCalledTimes(3);
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-            expect(handleErrorSpy).toBeCalledTimes(2);
-            expect(clearIntervalSpy).not.toBeCalled();
-            expect(reg.keepaliveTimer).toBe(timer);
-          case 16:
+          case 8:
+            expect(reg.webWorker).toBeUndefined();
+            expect(handleErrorSpy).toBeCalledTimes(3);
+            _context19.next = 12;
+            return reg.triggerRegistration();
+          case 12:
+            _context19.next = 14;
+            return flushPromises();
+          case 14:
+            expect(reg.webWorker).toBeDefined();
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
+                statusCode: 200
+              }
+            });
+            _context19.next = 18;
+            return flushPromises();
+          case 18:
+            // In a complete failure‐then-recovery scenario, we expect another failure event to have been handled.
+            // For that, simulate a second failure event on the new worker.
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: failurePayload,
+                keepAliveRetryCount: reg.isCCFlow ? 4 : 5
+              }
+            });
+            _context19.next = 21;
+            return flushPromises();
+          case 21:
+            expect(handleErrorSpy).toBeCalledTimes(4);
+
+            // And then re-register successfully:
+            _context19.next = 24;
+            return reg.triggerRegistration();
+          case 24:
+            _context19.next = 26;
+            return flushPromises();
+          case 26:
+            expect(reg.webWorker).toBeDefined();
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_SUCCESS,
+                statusCode: 200
+              }
+            });
+            _context19.next = 30;
+            return flushPromises();
+          case 30:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+            expect(reg.webWorker).toBeDefined();
+          case 32:
           case "end":
             return _context19.stop();
         }
       }, _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;
+      var clearKeepaliveSpy, reconnectSpy;
       return _regenerator.default.wrap(function _callee20$(_context20) {
         while (1) switch (_context20.prev = _context20.next) {
           case 0:
@@ -798,159 +829,177 @@ describe('Registration Tests', function () {
             _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.mockResolvedValue(successPayload);
-            jest.advanceTimersByTime(_constants.REG_TRY_BACKUP_TIMER_VAL_FOR_CC_IN_SEC * _constants.SEC_TO_MSEC_MFACTOR);
-            _context20.next = 19;
+            webex.request.mockResolvedValueOnce(successPayload);
+            _context20.next = 6;
+            return reg.triggerRegistration();
+          case 6:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+            expect(reg.webWorker).toBeDefined();
+
+            // Spy on clearKeepaliveTimer and simulate reconnectOnFailure behavior
+            clearKeepaliveSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure'); // Simulate a KEEPALIVE_FAILURE message from the worker with a retry count equal to threshold (4 for CC)
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 503
+                },
+                keepAliveRetryCount: 4
+              }
+            });
+
+            // Wait for any asynchronous actions to complete
+            _context20.next = 13;
             return flushPromises();
-          case 19:
-            /* Active Url must match with the backup url as per the test */
+          case 13:
+            // Verify that the keepalive timer was cleared and reconnectOnFailure was triggered
+            expect(clearKeepaliveSpy).toHaveBeenCalled();
+            expect(reconnectSpy).toHaveBeenCalledWith(reg.startKeepaliveTimer.name);
+
+            // Verify that the active Mobius URL has been updated to the backup server and registration is active
             expect(reg.getActiveMobiusUrl()).toEqual(mobiusUris.backup[0]);
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-          case 21:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+          case 17:
           case "end":
             return _context20.stop();
         }
       }, _callee20);
     })));
     it('verify final error for keep-alive', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
-      var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, clearIntervalSpy;
+      var threshold, reconnectSpy;
       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');
+            threshold = reg.isCCFlow ? 4 : 5;
             reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
-            failurePayload = {
-              statusCode: 404,
-              body: mockKeepAliveBody
-            };
-            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
-            webex.request.mockRejectedValue(failurePayload);
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-
-            /* send one keepalive */
-            jest.advanceTimersByTime(_registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context21.next = 12;
-            return flushPromises();
-          case 12:
-            expect(clearIntervalSpy).toBeCalledTimes(1);
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
-            expect(reconnectSpy).not.toBeCalled();
-            expect(restoreSpy).not.toBeCalled();
-            expect(restartRegSpy).not.toBeCalled();
-            expect(reg.reconnectPending).toStrictEqual(false);
-            expect(webex.request).toBeCalledOnceWith({
-              headers: mockResponse.headers,
-              uri: "".concat(mockKeepAliveBody.device.uri, "/status"),
-              method: 'POST',
-              service: mockResponse.service
-            });
-            expect(reg.keepaliveTimer).toBe(undefined);
-            expect(handleErrorSpy).toBeCalledOnceWith(failurePayload, expect.anything(), {
-              file: _constants.REGISTRATION_FILE,
-              method: _constants.KEEPALIVE_UTIL
+            jest.spyOn(utils, 'handleRegistrationErrors').mockResolvedValue(true);
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 404
+                },
+                keepAliveRetryCount: threshold
+              }
             });
-          case 21:
+            _context21.next = 8;
+            return flushPromises();
+          case 8:
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(reconnectSpy).not.toHaveBeenCalled();
+          case 11:
           case "end":
             return _context21.stop();
         }
       }, _callee21);
     })));
     it('verify failure keep-alive case with active call present: Restore Success after call ends', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22() {
-      var restoreSpy, restartRegSpy, reconnectSpy, failurePayload, successPayload, clearIntervalSpy, url, timer, call;
+      var clearTimerSpy, threshold, failureEvent;
       return _regenerator.default.wrap(function _callee22$(_context22) {
         while (1) switch (_context22.prev = _context22.next) {
           case 0:
             _context22.next = 2;
             return beforeEachSetupForKeepalive();
           case 2:
-            restoreSpy = jest.spyOn(reg, 'restorePreviousRegistration');
-            restartRegSpy = jest.spyOn(reg, 'restartRegistration');
-            reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
-            failurePayload = {
-              statusCode: 503,
-              body: mockKeepAliveBody
-            };
-            successPayload = {
-              statusCode: 200,
-              body: mockKeepAliveBody
+            // Simulate an active call.
+            reg.callManager.createCall();
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBeGreaterThan(0);
+            clearTimerSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            threshold = reg.isCCFlow ? 4 : 5; // Simulate a KEEPALIVE_FAILURE event with a 503 error at threshold.
+            failureEvent = {
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 503
+                },
+                keepAliveRetryCount: threshold
+              }
             };
-            clearIntervalSpy = jest.spyOn(global, 'clearInterval');
-            webex.request.mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockRejectedValueOnce(failurePayload).mockResolvedValue(successPayload);
-
-            // jest.spyOn(callingClient['registration'], 'createDevice').mockResolvedValue(successPayload);
-            url = 'https://mobius.asydm-m-1.prod.infra.webex.com/api/v1';
-            reg.setActiveMobiusUrl(url);
-            expect(reg.reconnectPending).toStrictEqual(false);
-            timer = reg.keepaliveTimer;
-            /* add a call to the callManager */
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            call = reg.callManager.createCall();
-            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(1);
-
-            /* send one keepalive */
-            jest.advanceTimersByTime(5 * _registerFixtures.mockPostResponse.keepaliveInterval * _constants.SEC_TO_MSEC_MFACTOR);
-            _context22.next = 18;
+            reg.webWorker.onmessage(failureEvent);
+            _context22.next = 10;
             return flushPromises();
-          case 18:
-            expect(clearIntervalSpy).toBeCalledOnceWith(timer);
-            expect(handleErrorSpy).toBeCalledTimes(5);
-            expect(reg.keepaliveTimer).toStrictEqual(undefined);
-            expect(reg.failbackTimer).toStrictEqual(undefined);
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
-            expect(lineEmitter).lastCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
-            expect(reconnectSpy).toBeCalledOnceWith(_constants.KEEPALIVE_UTIL);
-            expect(restoreSpy).not.toBeCalled();
-            expect(restartRegSpy).not.toBeCalled();
-            expect(reg.reconnectPending).toStrictEqual(true);
-            expect(logSpy).toBeCalledWith('Active call(s) present, deferred reconnect till call cleanup.', {
-              file: _constants.REGISTRATION_FILE,
-              method: expect.any(String)
-            });
-            reconnectSpy.mockClear();
+          case 10:
+            // At this point, clearKeepaliveTimer was called so the worker is terminated.
+            expect(clearTimerSpy).toHaveBeenCalled();
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+            expect(reg.webWorker).toBeUndefined();
 
-            /* simulate call disconnect and Calling client will trigger reconnect upon receiving disconnect event from CallManager */
+            // Now simulate call cleanup.
             reg.callManager.callCollection = {};
-            _context22.next = 33;
-            return reg.reconnectOnFailure(_constants.CALLS_CLEARED_HANDLER_UTIL);
-          case 33:
-            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
-            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
-            expect(reconnectSpy).toBeCalledOnceWith(_constants.CALLS_CLEARED_HANDLER_UTIL);
-            expect(restoreSpy).toBeCalledOnceWith(_constants.CALLS_CLEARED_HANDLER_UTIL);
-            expect(restartRegSpy).not.toBeCalled();
-            expect(reg.reconnectPending).toStrictEqual(false);
-            expect(reg.getActiveMobiusUrl()).toStrictEqual(url);
-            expect(reg.keepaliveTimer).toBeTruthy();
-            expect(reg.keepaliveTimer).not.toBe(timer);
-          case 42:
+            webex.request.mockResolvedValueOnce(successPayload);
+
+            // Call reconnectOnFailure manually. With no active calls, this should trigger re-registration.
+            _context22.next = 17;
+            return reg.reconnectOnFailure('activeCallEnded');
+          case 17:
+            _context22.next = 19;
+            return flushPromises();
+          case 19:
+            // After re-registration, registration status becomes ACTIVE and a new worker is created.
+            expect(reg.getStatus()).toEqual(_types.RegistrationStatus.ACTIVE);
+            expect(reg.isReconnectPending()).toBe(false);
+            expect(reg.webWorker).toBeDefined();
+          case 22:
           case "end":
             return _context22.stop();
         }
       }, _callee22);
     })));
+    it('should emit LINE_EVENTS.ERROR when keepalive fails with a final error', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee24() {
+      return _regenerator.default.wrap(function _callee24$(_context24) {
+        while (1) switch (_context24.prev = _context24.next) {
+          case 0:
+            _context24.next = 2;
+            return beforeEachSetupForKeepalive();
+          case 2:
+            expect(reg.webWorker).toBeDefined();
+            lineEmitter.mockClear();
+            jest.spyOn(utils, 'handleRegistrationErrors').mockImplementationOnce( /*#__PURE__*/function () {
+              var _ref24 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23(error, callback) {
+                var clientError;
+                return _regenerator.default.wrap(function _callee23$(_context23) {
+                  while (1) switch (_context23.prev = _context23.next) {
+                    case 0:
+                      clientError = (0, _LineError.createLineError)('User is unauthorized due to an expired token. Sign out, then sign back in.', {}, _types3.ERROR_TYPE.TOKEN_ERROR, _types.RegistrationStatus.INACTIVE);
+                      callback(clientError, true);
+                      return _context23.abrupt("return", true);
+                    case 3:
+                    case "end":
+                      return _context23.stop();
+                  }
+                }, _callee23);
+              }));
+              return function (_x, _x2) {
+                return _ref24.apply(this, arguments);
+              };
+            }());
+            reg.webWorker.onmessage({
+              data: {
+                type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                err: {
+                  statusCode: 401,
+                  message: 'Unauthorized'
+                },
+                keepAliveRetryCount: 1
+              }
+            });
+            _context24.next = 8;
+            return flushPromises();
+          case 8:
+            expect(lineEmitter).toHaveBeenNthCalledWith(1, _types4.LINE_EVENTS.ERROR, undefined, new Error('User is unauthorized due to an expired token. Sign out, then sign back in.'));
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(reg.webWorker).toBeUndefined();
+          case 11:
+          case "end":
+            return _context24.stop();
+        }
+      }, _callee24);
+    })));
   });
 });
 //# sourceMappingURL=register.test.js.map