@webex/calling 3.12.0-next.9 → 3.12.0-next.91

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

@@ -32,9 +32,17 @@ var _constants = require("../constants");
 var _types4 = require("../line/types");
 var _LineError = require("../../Errors/catalog/LineError");
 var _types5 = require("../../Metrics/types");
+var _request = require("../utils/request");
 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 */
+jest.mock('../../mobius-socket', function () {
+  return {
+    getMobiusSocketInstance: jest.fn().mockReturnValue({
+      sendWssRequest: jest.fn()
+    })
+  };
+});
 var webex = (0, _testUtil.getTestUtilsWebex)();
 var MockServiceData = {
   indicator: _types.ServiceIndicator.CALLING,
@@ -137,6 +145,11 @@ describe('Registration Tests', function () {
     metricSpy = jest.spyOn(reg.metricManager, 'submitRegistrationMetric');
   };
   beforeEach(function () {
+    _request.APIRequest.resetInstance();
+    _request.APIRequest.getInstance({
+      webex: webex,
+      isMobiusSocketEnabled: false
+    });
     setupRegistration(MockServiceData);
   });
   afterEach(function () {
@@ -170,7 +183,7 @@ describe('Registration Tests', function () {
           // 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'
+            method: _constants.REGISTER_UTIL
           }));
           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:
@@ -218,6 +231,9 @@ describe('Registration Tests', function () {
               devices: [_registerFixtures.mockPostResponse.device]
             },
             statusCode: 403
+          }).mockResolvedValueOnce({
+            statusCode: 200,
+            body: _registerFixtures.mockDeleteResponse
           }).mockResolvedValueOnce({
             statusCode: 200,
             body: _registerFixtures.mockPostResponse,
@@ -225,25 +241,18 @@ describe('Registration Tests', function () {
               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).toBeCalledTimes(3);
           expect(webex.request).toBeCalledWith(_objectSpread(_objectSpread({}, mockResponse), {}, {
             method: 'POST'
           }));
-          expect(global.fetch).toBeCalledOnceWith(_registerFixtures.mockPostResponse.device.uri, {
-            method: 'DELETE',
-            headers: expect.anything()
-          });
+          expect(webex.request).toBeCalledWith(expect.objectContaining({
+            uri: _registerFixtures.mockPostResponse.device.uri,
+            method: 'DELETE'
+          }));
           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());
@@ -1277,11 +1286,8 @@ describe('Registration Tests', function () {
             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)
+              retryCountThreshold: expect.any(Number)
             }));
             reg.webWorker.onmessage({
               data: {
@@ -1690,7 +1696,7 @@ describe('Registration Tests', function () {
     })));
     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;
+      var keepaliveSpy, postMessageSpy, clearTimerSpy, retry429Spy, keepaliveInterval, retryAfter, adjustedResumeDelayMs;
       return _regenerator.default.wrap(function (_context35) {
         while (1) switch (_context35.prev = _context35.next) {
           case 0:
@@ -1701,13 +1707,17 @@ describe('Registration Tests', function () {
             postMessageSpy = jest.spyOn(Worker.prototype, 'postMessage');
             clearTimerSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
             retry429Spy = jest.spyOn(reg, 'handle429Retry');
+            keepaliveInterval = reg.deviceInfo.keepaliveInterval; // Choose a retryAfter strictly greater than keepaliveInterval so the
+            // adjusted resume delay (retryAfter - keepaliveInterval) is positive and verifiable.
+            retryAfter = keepaliveInterval + 30;
+            adjustedResumeDelayMs = (retryAfter - keepaliveInterval) * _constants.SEC_TO_MSEC_MFACTOR;
             reg.webWorker.onmessage({
               data: {
                 type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
                 err: {
                   statusCode: 429,
                   headers: {
-                    'retry-after': 20
+                    'retry-after': retryAfter
                   }
                 },
                 keepAliveRetryCount: 1
@@ -1723,47 +1733,112 @@ describe('Registration Tests', function () {
             expect(handleErrorSpy).toBeCalledOnceWith({
               statusCode: 429,
               headers: {
-                'retry-after': 20
+                'retry-after': retryAfter
               }
             }, expect.anything(), {
               file: _constants.REGISTRATION_FILE,
               method: _constants.KEEPALIVE_UTIL
             }, expect.anything());
-            expect(retry429Spy).toBeCalledOnceWith(20, 'startKeepaliveTimer');
+            expect(retry429Spy).toBeCalledOnceWith(retryAfter, '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);
+
+            // Resume timer must NOT fire before the adjusted (retryAfter - keepaliveInterval) interval.
+            jest.advanceTimersByTime(adjustedResumeDelayMs - 1);
             _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', {
+            expect(keepaliveSpy).not.toBeCalled();
+            expect(reg.webWorker).toBeUndefined();
+
+            // Advance the remaining 1ms to hit the exact adjusted timeout; keepalive must resume now.
+            jest.advanceTimersByTime(1);
+            _context35.next = 4;
+            return flushPromises();
+          case 4:
+            expect(keepaliveSpy).toBeCalledOnceWith((_reg$deviceInfo$devic = reg.deviceInfo.device) === null || _reg$deviceInfo$devic === void 0 ? void 0 : _reg$deviceInfo$devic.uri, keepaliveInterval, 'UNKNOWN');
+            expect(logSpy).toBeCalledWith("Resuming keepalive after ".concat(retryAfter, " 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)
+              retryCountThreshold: expect.any(Number)
             }));
-          case 4:
+          case 5:
           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() {
+    it.each([{
+      description: 'retryAfter less than keepaliveInterval -> negative delay fires immediately',
+      retryAfterDelta: -10
+    }, {
+      description: 'retryAfter equal to keepaliveInterval -> zero delay fires immediately',
+      retryAfterDelta: 0
+    }])('adjusts retry-after with keepaliveInterval on 429 keepalive failure ($description)', /*#__PURE__*/function () {
+      var _ref37 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee36(_ref36) {
+        var _reg$deviceInfo$devic2;
+        var retryAfterDelta, keepaliveSpy, keepaliveInterval, retryAfter;
+        return _regenerator.default.wrap(function (_context36) {
+          while (1) switch (_context36.prev = _context36.next) {
+            case 0:
+              retryAfterDelta = _ref36.retryAfterDelta;
+              _context36.next = 1;
+              return beforeEachSetupForKeepalive();
+            case 1:
+              keepaliveSpy = jest.spyOn(reg, 'startKeepaliveTimer');
+              keepaliveInterval = reg.deviceInfo.keepaliveInterval;
+              retryAfter = keepaliveInterval + retryAfterDelta;
+              reg.webWorker.onmessage({
+                data: {
+                  type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                  err: {
+                    statusCode: 429,
+                    headers: {
+                      'retry-after': retryAfter
+                    }
+                  },
+                  keepAliveRetryCount: 1
+                }
+              });
+              _context36.next = 2;
+              return flushPromises();
+            case 2:
+              expect(reg.webWorker).toBeUndefined();
+              expect(keepaliveSpy).not.toBeCalled();
+
+              // With a non-positive adjusted delay, the timer should fire on the next tick.
+              jest.advanceTimersByTime(0);
+              _context36.next = 3;
+              return flushPromises();
+            case 3:
+              expect(keepaliveSpy).toBeCalledOnceWith((_reg$deviceInfo$devic2 = reg.deviceInfo.device) === null || _reg$deviceInfo$devic2 === void 0 ? void 0 : _reg$deviceInfo$devic2.uri, keepaliveInterval, 'UNKNOWN');
+              expect(logSpy).toBeCalledWith("Resuming keepalive after ".concat(retryAfter, " seconds"), {
+                file: _constants.REGISTRATION_FILE,
+                method: 'handle429Retry'
+              });
+            case 4:
+            case "end":
+              return _context36.stop();
+          }
+        }, _callee36);
+      }));
+      return function (_x) {
+        return _ref37.apply(this, arguments);
+      };
+    }());
+    it('ensure retryAfter is set when 429 occurs during failover retry', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee37() {
       var retry429Spy;
-      return _regenerator.default.wrap(function (_context36) {
-        while (1) switch (_context36.prev = _context36.next) {
+      return _regenerator.default.wrap(function (_context37) {
+        while (1) switch (_context37.prev = _context37.next) {
           case 0:
-            _context36.next = 1;
+            _context37.next = 1;
             return beforeEachSetupForKeepalive();
           case 1:
             // Simulate loss of registration so failover path attempts a new registration
@@ -1774,11 +1849,11 @@ describe('Registration Tests', function () {
             webex.request.mockRejectedValueOnce(failurePayload429One);
 
             // Directly schedule the failover attempt
-            _context36.next = 2;
+            _context37.next = 2;
             return reg.startFailoverTimer();
           case 2:
             jest.advanceTimersByTime(33 * _constants.SEC_TO_MSEC_MFACTOR);
-            _context36.next = 3;
+            _context37.next = 3;
             return flushPromises();
           case 3:
             expect(retry429Spy).toBeCalledWith(failurePayload429One.headers['retry-after'], 'startFailoverTimer');
@@ -1786,16 +1861,16 @@ describe('Registration Tests', function () {
             jest.useRealTimers();
           case 4:
           case "end":
-            return _context36.stop();
+            return _context37.stop();
         }
-      }, _callee36);
+      }, _callee37);
     })));
-    it('sets retryAfter when reconnectOnFailure caller receives 429 after keepalive threshold miss', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee37() {
+    it('sets retryAfter when reconnectOnFailure caller receives 429 after keepalive threshold miss', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee38() {
       var retry429Spy, threshold;
-      return _regenerator.default.wrap(function (_context37) {
-        while (1) switch (_context37.prev = _context37.next) {
+      return _regenerator.default.wrap(function (_context38) {
+        while (1) switch (_context38.prev = _context38.next) {
           case 0:
-            _context37.next = 1;
+            _context38.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)
@@ -1818,7 +1893,7 @@ describe('Registration Tests', function () {
                 keepAliveRetryCount: threshold
               }
             });
-            _context37.next = 2;
+            _context38.next = 2;
             return flushPromises();
           case 2:
             // handle429Retry is called with caller 'reconnectOnFailure' → else branch executes and sets retryAfter
@@ -1826,25 +1901,293 @@ describe('Registration Tests', function () {
             expect(reg.retryAfter).toEqual(undefined); // Clear retryAfter after 429 retry
           case 3:
           case "end":
-            return _context37.stop();
+            return _context38.stop();
         }
-      }, _callee37);
+      }, _callee38);
     })));
+    describe('409 Conflict on keepalive (session superseded)', function () {
+      var conflictError = {
+        statusCode: 409,
+        headers: {
+          trackingid: 'tid-409'
+        }
+      };
+      var sendKeepaliveFailure = /*#__PURE__*/function () {
+        var _ref40 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee39(err, keepAliveRetryCount) {
+          return _regenerator.default.wrap(function (_context39) {
+            while (1) switch (_context39.prev = _context39.next) {
+              case 0:
+                reg.webWorker.onmessage({
+                  data: {
+                    type: _types.WorkerMessageType.KEEPALIVE_FAILURE,
+                    err: err,
+                    keepAliveRetryCount: keepAliveRetryCount
+                  }
+                });
+                _context39.next = 1;
+                return flushPromises();
+              case 1:
+              case "end":
+                return _context39.stop();
+            }
+          }, _callee39);
+        }));
+        return function sendKeepaliveFailure(_x2, _x3) {
+          return _ref40.apply(this, arguments);
+        };
+      }();
+      var getSupersededError = function getSupersededError() {
+        var unregisteredCall = lineEmitter.mock.calls.find(function (_ref41) {
+          var _ref42 = (0, _slicedToArray2.default)(_ref41, 1),
+            event = _ref42[0];
+          return event === _types4.LINE_EVENTS.UNREGISTERED;
+        });
+        return unregisteredCall === null || unregisteredCall === void 0 ? void 0 : unregisteredCall[2];
+      };
+      it.each([{
+        description: 'on the very first keepalive failure',
+        keepAliveRetryCount: 1
+      }, {
+        description: 'when the retry count already reached the threshold',
+        keepAliveRetryCount: 5
+      }])('stops keepalive without re-registration $description', /*#__PURE__*/function () {
+        var _ref44 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee40(_ref43) {
+          var keepAliveRetryCount, clearTimerSpy, reconnectSpy, registerSpy, handle404Spy;
+          return _regenerator.default.wrap(function (_context40) {
+            while (1) switch (_context40.prev = _context40.next) {
+              case 0:
+                keepAliveRetryCount = _ref43.keepAliveRetryCount;
+                _context40.next = 1;
+                return beforeEachSetupForKeepalive();
+              case 1:
+                clearTimerSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+                reconnectSpy = jest.spyOn(reg, 'reconnectOnFailure');
+                registerSpy = jest.spyOn(reg, 'attemptRegistrationWithServers');
+                handle404Spy = jest.spyOn(reg, 'handle404KeepaliveFailure');
+                lineEmitter.mockClear();
+                _context40.next = 2;
+                return sendKeepaliveFailure(conflictError, keepAliveRetryCount);
+              case 2:
+                // The 409 is classified by the common registration error handler.
+                expect(handleErrorSpy).toHaveBeenCalledWith(conflictError, expect.anything(), {
+                  file: _constants.REGISTRATION_FILE,
+                  method: _constants.KEEPALIVE_UTIL
+                }, expect.objectContaining({
+                  sessionSupersededCb: expect.any(Function)
+                }));
+                expect(warnSpy).toBeCalledWith('409 Conflict: session superseded by another device for this user', {
+                  file: _constants.REGISTRATION_FILE,
+                  method: _constants.KEEPALIVE_UTIL
+                });
+                expect(warnSpy).toBeCalledWith("Stopping keepalive without re-registration, session superseded by another device for this user - keepaliveRetryCount: ".concat(keepAliveRetryCount), {
+                  file: _constants.REGISTRATION_FILE,
+                  method: _constants.METHODS.HANDLE_409_KEEPALIVE_FAILURE
+                });
+
+                // Keepalive is stopped and no further keepalive can be sent.
+                expect(clearTimerSpy).toHaveBeenCalled();
+                expect(reg.webWorker).toBeUndefined();
+                expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+                expect(reg.failbackTimer).toStrictEqual(undefined);
+
+                // No re-registration of any kind is attempted.
+                expect(reconnectSpy).not.toHaveBeenCalled();
+                expect(restoreSpy).not.toHaveBeenCalled();
+                expect(restartSpy).not.toHaveBeenCalled();
+                expect(failoverSpy).not.toHaveBeenCalled();
+                expect(registerSpy).not.toHaveBeenCalled();
+                expect(handle404Spy).not.toHaveBeenCalled();
+                expect(reg.reconnectPending).toStrictEqual(false);
+              case 3:
+              case "end":
+                return _context40.stop();
+            }
+          }, _callee40);
+        }));
+        return function (_x4) {
+          return _ref44.apply(this, arguments);
+        };
+      }());
+      it('notifies the consumer with a single UNREGISTERED carrying the superseded reason', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee41() {
+        var supersededError;
+        return _regenerator.default.wrap(function (_context41) {
+          while (1) switch (_context41.prev = _context41.next) {
+            case 0:
+              _context41.next = 1;
+              return beforeEachSetupForKeepalive();
+            case 1:
+              lineEmitter.mockClear();
+              _context41.next = 2;
+              return sendKeepaliveFailure(conflictError, 1);
+            case 2:
+              expect(lineEmitter.mock.calls.filter(function (_ref46) {
+                var _ref47 = (0, _slicedToArray2.default)(_ref46, 1),
+                  event = _ref47[0];
+                return event === _types4.LINE_EVENTS.UNREGISTERED;
+              })).toHaveLength(1);
+              expect(lineEmitter).not.toHaveBeenCalledWith(_types4.LINE_EVENTS.RECONNECTING);
+              expect(lineEmitter).toHaveBeenLastCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, expect.any(_LineError.LineError));
+              supersededError = getSupersededError();
+              expect(supersededError.getError()).toStrictEqual({
+                message: _constants.SESSION_SUPERSEDED_MESSAGE,
+                type: _types3.ERROR_TYPE.SESSION_SUPERSEDED,
+                status: _types.RegistrationStatus.INACTIVE,
+                context: {
+                  file: _constants.REGISTRATION_FILE,
+                  method: _constants.KEEPALIVE_UTIL
+                }
+              });
+            case 3:
+            case "end":
+              return _context41.stop();
+          }
+        }, _callee41);
+      })));
+      it('submits the keepalive failure metric and uploads logs', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee42() {
+        var uploadLogsSpy;
+        return _regenerator.default.wrap(function (_context42) {
+          while (1) switch (_context42.prev = _context42.next) {
+            case 0:
+              _context42.next = 1;
+              return beforeEachSetupForKeepalive();
+            case 1:
+              uploadLogsSpy = jest.spyOn(utils, 'uploadLogs');
+              lineEmitter.mockClear();
+              metricSpy.mockClear();
+              _context42.next = 2;
+              return sendKeepaliveFailure(conflictError, 2);
+            case 2:
+              expect(metricSpy).toBeCalledOnceWith(_types5.METRIC_EVENT.KEEPALIVE_ERROR, _types5.REG_ACTION.KEEPALIVE_FAILURE, _types5.METRIC_TYPE.BEHAVIORAL, _constants.METHODS.HANDLE_409_KEEPALIVE_FAILURE, 'PRIMARY', conflictError.headers.trackingid, 2, getSupersededError());
+              expect(uploadLogsSpy).toHaveBeenCalled();
+            case 3:
+            case "end":
+              return _context42.stop();
+          }
+        }, _callee42);
+      })));
+      it('closes the Mobius WebSocket when the socket transport is enabled', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee43() {
+        var apiRequest, disconnectSocketSpy;
+        return _regenerator.default.wrap(function (_context43) {
+          while (1) switch (_context43.prev = _context43.next) {
+            case 0:
+              _context43.next = 1;
+              return beforeEachSetupForKeepalive();
+            case 1:
+              apiRequest = _request.APIRequest.getInstance({
+                webex: webex
+              });
+              jest.spyOn(apiRequest, 'isSocketEnabled').mockReturnValue(true);
+              disconnectSocketSpy = jest.spyOn(apiRequest, 'disconnectFromMobiusSocket').mockResolvedValue();
+              lineEmitter.mockClear();
+              _context43.next = 2;
+              return sendKeepaliveFailure(conflictError, 1);
+            case 2:
+              expect(disconnectSocketSpy).toBeCalledOnceWith({
+                code: 3050,
+                reason: 'done (permanent)'
+              });
+              expect(lineEmitter).toHaveBeenLastCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, expect.any(_LineError.LineError));
+            case 3:
+            case "end":
+              return _context43.stop();
+          }
+        }, _callee43);
+      })));
+      it('still notifies the consumer when the Mobius WebSocket teardown fails', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee44() {
+        var apiRequest;
+        return _regenerator.default.wrap(function (_context44) {
+          while (1) switch (_context44.prev = _context44.next) {
+            case 0:
+              _context44.next = 1;
+              return beforeEachSetupForKeepalive();
+            case 1:
+              apiRequest = _request.APIRequest.getInstance({
+                webex: webex
+              });
+              jest.spyOn(apiRequest, 'isSocketEnabled').mockReturnValue(true);
+              jest.spyOn(apiRequest, 'disconnectFromMobiusSocket').mockRejectedValue(new Error('socket teardown failed'));
+              lineEmitter.mockClear();
+              _context44.next = 2;
+              return sendKeepaliveFailure(conflictError, 1);
+            case 2:
+              expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Mobius socket disconnect failed after session-superseded'), {
+                file: _constants.REGISTRATION_FILE,
+                method: _constants.METHODS.HANDLE_409_KEEPALIVE_FAILURE
+              });
+              expect(reg.getStatus()).toEqual(_types.RegistrationStatus.INACTIVE);
+              expect(lineEmitter).toHaveBeenLastCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, expect.any(_LineError.LineError));
+            case 3:
+            case "end":
+              return _context44.stop();
+          }
+        }, _callee44);
+      })));
+      it.each([{
+        description: '404 device not found',
+        err: {
+          statusCode: 404
+        }
+      }, {
+        description: '429 too many requests',
+        err: {
+          statusCode: 429,
+          headers: {
+            'retry-after': 5
+          }
+        }
+      }, {
+        description: '503 service unavailable',
+        err: {
+          statusCode: 503
+        }
+      }])('leaves the existing handling of $description untouched', /*#__PURE__*/function () {
+        var _ref52 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee45(_ref51) {
+          var err, handle409Spy;
+          return _regenerator.default.wrap(function (_context45) {
+            while (1) switch (_context45.prev = _context45.next) {
+              case 0:
+                err = _ref51.err;
+                _context45.next = 1;
+                return beforeEachSetupForKeepalive();
+              case 1:
+                handle409Spy = jest.spyOn(reg, 'handle409KeepaliveFailure');
+                lineEmitter.mockClear();
+                handleErrorSpy.mockClear();
+                _context45.next = 2;
+                return sendKeepaliveFailure(err, 1);
+              case 2:
+                expect(handle409Spy).not.toHaveBeenCalled();
+                expect(handleErrorSpy).toHaveBeenCalledWith(err, expect.anything(), {
+                  file: _constants.REGISTRATION_FILE,
+                  method: _constants.KEEPALIVE_UTIL
+                }, expect.anything());
+                expect(lineEmitter).not.toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, expect.anything());
+              case 3:
+              case "end":
+                return _context45.stop();
+            }
+          }, _callee45);
+        }));
+        return function (_x5) {
+          return _ref52.apply(this, arguments);
+        };
+      }());
+    });
   });
   describe('Primary server status checks', function () {
-    it('success: primary server status to be up', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee38() {
+    it('success: primary server status to be up', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee46() {
       var pingSuccessPayload, status;
-      return _regenerator.default.wrap(function (_context38) {
-        while (1) switch (_context38.prev = _context38.next) {
+      return _regenerator.default.wrap(function (_context46) {
+        while (1) switch (_context46.prev = _context46.next) {
           case 0:
             pingSuccessPayload = {
               statusCode: 200
             };
             webex.request.mockResolvedValue(pingSuccessPayload);
-            _context38.next = 1;
+            _context46.next = 1;
             return reg.isPrimaryActive();
           case 1:
-            status = _context38.sent;
+            status = _context46.sent;
             expect(webex.request).toBeCalledWith(_objectSpread({
               method: 'GET',
               uri: "https://mobius-dfw.webex.com/api/v1/ping"
@@ -1852,23 +2195,23 @@ describe('Registration Tests', function () {
             expect(status).toEqual(true);
           case 2:
           case "end":
-            return _context38.stop();
+            return _context46.stop();
         }
-      }, _callee38);
+      }, _callee46);
     })));
-    it('failed: primary server status to be down', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee39() {
+    it('failed: primary server status to be down', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee47() {
       var pingFailurePayload, status;
-      return _regenerator.default.wrap(function (_context39) {
-        while (1) switch (_context39.prev = _context39.next) {
+      return _regenerator.default.wrap(function (_context47) {
+        while (1) switch (_context47.prev = _context47.next) {
           case 0:
             pingFailurePayload = {
               statusCode: 500
             };
             webex.request.mockResolvedValue(pingFailurePayload);
-            _context39.next = 1;
+            _context47.next = 1;
             return reg.isPrimaryActive();
           case 1:
-            status = _context39.sent;
+            status = _context47.sent;
             expect(webex.request).toBeCalledWith(_objectSpread({
               method: 'GET',
               uri: "https://mobius-dfw.webex.com/api/v1/ping"
@@ -1876,9 +2219,257 @@ describe('Registration Tests', function () {
             expect(status).toEqual(false);
           case 2:
           case "end":
-            return _context39.stop();
+            return _context47.stop();
+        }
+      }, _callee47);
+    })));
+  });
+  describe('handleRegistrationDownEvent tests', function () {
+    var registrationDownEvent = {
+      type: 'async_event',
+      eventId: 'evt-1',
+      trackingId: 'tid-1',
+      data: {
+        eventType: 'registration.down',
+        deviceInfo: {
+          userId: 'u1',
+          device: {
+            deviceId: 'd1',
+            uri: 'https://mobius/device/d1',
+            status: 'ACTIVE'
+          }
+        }
+      }
+    };
+    beforeEach(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee48() {
+      return _regenerator.default.wrap(function (_context48) {
+        while (1) switch (_context48.prev = _context48.next) {
+          case 0:
+            postRegistrationSpy.mockResolvedValueOnce(successPayload);
+            _context48.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+          case 2:
+          case "end":
+            return _context48.stop();
+        }
+      }, _callee48);
+    })));
+    afterEach(function () {
+      var calls = (0, _values.default)(reg.callManager.getActiveCalls());
+      calls.forEach(function (call) {
+        call.end();
+      });
+      reg.callManager.callCollection = {};
+    });
+    it('runs cleanup immediately when no active calls are present (socket disabled)', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee49() {
+      var clearKeepaliveSpy, setStatusSpy, disconnectSocketSpy;
+      return _regenerator.default.wrap(function (_context49) {
+        while (1) switch (_context49.prev = _context49.next) {
+          case 0:
+            clearKeepaliveSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            setStatusSpy = jest.spyOn(reg, 'setStatus');
+            disconnectSocketSpy = jest.spyOn(_request.APIRequest.getInstance({
+              webex: webex
+            }), 'disconnectFromMobiusSocket');
+            lineEmitter.mockClear();
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
+            _context49.next = 1;
+            return reg.handleRegistrationDownEvent(registrationDownEvent);
+          case 1:
+            expect(clearKeepaliveSpy).toHaveBeenCalled();
+            expect(setStatusSpy).toHaveBeenCalledWith(_types.RegistrationStatus.INACTIVE);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(reg.reconnectPending).toBe(false);
+            expect(reg.scheduled429Retry).toBe(false);
+            expect(reg.failoverImmediately).toBe(false);
+            expect(reg.retryAfter).toBeUndefined();
+            expect(reg.registerRetry).toBe(false);
+            expect(disconnectSocketSpy).not.toHaveBeenCalled();
+            /* A registration-down stop has no reason to report to the consumer. */
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
+          case 2:
+          case "end":
+            return _context49.stop();
+        }
+      }, _callee49);
+    })));
+    it('ends the active call and still runs cleanup when an active call is present', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee50() {
+      var clearKeepaliveSpy, setStatusSpy, activeCall, endSpy;
+      return _regenerator.default.wrap(function (_context50) {
+        while (1) switch (_context50.prev = _context50.next) {
+          case 0:
+            clearKeepaliveSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            setStatusSpy = jest.spyOn(reg, 'setStatus');
+            activeCall = reg.callManager.createCall();
+            endSpy = jest.spyOn(activeCall, 'end');
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(1);
+            lineEmitter.mockClear();
+            _context50.next = 1;
+            return reg.handleRegistrationDownEvent(registrationDownEvent);
+          case 1:
+            expect(endSpy).toHaveBeenCalledTimes(1);
+            expect(clearKeepaliveSpy).toHaveBeenCalled();
+            expect(setStatusSpy).toHaveBeenCalledWith(_types.RegistrationStatus.INACTIVE);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
+          case 2:
+          case "end":
+            return _context50.stop();
+        }
+      }, _callee50);
+    })));
+    it('runs cleanup without calling end when no active call is present on re-invocation', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee51() {
+      var clearKeepaliveSpy, setStatusSpy;
+      return _regenerator.default.wrap(function (_context51) {
+        while (1) switch (_context51.prev = _context51.next) {
+          case 0:
+            clearKeepaliveSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            setStatusSpy = jest.spyOn(reg, 'setStatus');
+            _context51.next = 1;
+            return reg.handleRegistrationDownEvent(registrationDownEvent);
+          case 1:
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            clearKeepaliveSpy.mockClear();
+            setStatusSpy.mockClear();
+            lineEmitter.mockClear();
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
+            _context51.next = 2;
+            return reg.handleRegistrationDownEvent(registrationDownEvent);
+          case 2:
+            expect(clearKeepaliveSpy).toHaveBeenCalled();
+            expect(setStatusSpy).toHaveBeenCalledWith(_types.RegistrationStatus.INACTIVE);
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
+          case 3:
+          case "end":
+            return _context51.stop();
+        }
+      }, _callee51);
+    })));
+    it('disconnects the Mobius WebSocket when socket is enabled', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee52() {
+      var apiRequest, disconnectSocketSpy;
+      return _regenerator.default.wrap(function (_context52) {
+        while (1) switch (_context52.prev = _context52.next) {
+          case 0:
+            apiRequest = _request.APIRequest.getInstance({
+              webex: webex
+            });
+            jest.spyOn(apiRequest, 'isSocketEnabled').mockReturnValue(true);
+            disconnectSocketSpy = jest.spyOn(apiRequest, 'disconnectFromMobiusSocket').mockResolvedValue();
+            lineEmitter.mockClear();
+            expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
+            _context52.next = 1;
+            return reg.handleRegistrationDownEvent(registrationDownEvent);
+          case 1:
+            expect(disconnectSocketSpy).toHaveBeenCalledWith({
+              code: 3050,
+              reason: 'done (permanent)'
+            });
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
+          case 2:
+          case "end":
+            return _context52.stop();
+        }
+      }, _callee52);
+    })));
+    it('still emits UNREGISTERED when socket disconnect fails', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee53() {
+      var apiRequest, disconnectSocketSpy;
+      return _regenerator.default.wrap(function (_context53) {
+        while (1) switch (_context53.prev = _context53.next) {
+          case 0:
+            apiRequest = _request.APIRequest.getInstance({
+              webex: webex
+            });
+            jest.spyOn(apiRequest, 'isSocketEnabled').mockReturnValue(true);
+            disconnectSocketSpy = jest.spyOn(apiRequest, 'disconnectFromMobiusSocket').mockRejectedValue(new Error('socket teardown failed'));
+            lineEmitter.mockClear();
+            _context53.next = 1;
+            return reg.handleRegistrationDownEvent(registrationDownEvent);
+          case 1:
+            expect(disconnectSocketSpy).toHaveBeenCalled();
+            expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('Mobius socket disconnect failed after registration-down'), {
+              file: _constants.REGISTRATION_FILE,
+              method: _constants.METHODS.HANDLE_REGISTRATION_DOWN_EVENT
+            });
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
+          case 2:
+          case "end":
+            return _context53.stop();
+        }
+      }, _callee53);
+    })));
+  });
+  describe('attemptRegistrationWithServers transport alignment', function () {
+    var apiRequest;
+    var setSocketEnabledSpy;
+    beforeEach(function () {
+      apiRequest = _request.APIRequest.getInstance({
+        webex: webex
+      });
+      // Keep the actual transport on HTTP (no-op) so the registration flow stays simple;
+      // we only assert which boolean the method derives from the server group's URL scheme.
+      setSocketEnabledSpy = jest.spyOn(apiRequest, 'setSocketEnabled').mockImplementation(function () {});
+      webex.request.mockResolvedValue(successPayload);
+    });
+    it('enables the WebSocket transport when the server group uses the wss:// scheme', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee54() {
+      return _regenerator.default.wrap(function (_context54) {
+        while (1) switch (_context54.prev = _context54.next) {
+          case 0:
+            _context54.next = 1;
+            return reg.attemptRegistrationWithServers(_constants.REGISTRATION_UTIL, ['wss://mobius.example.com/api/v1/calling/web/']);
+          case 1:
+            expect(setSocketEnabledSpy).toHaveBeenCalledWith(true);
+          case 2:
+          case "end":
+            return _context54.stop();
+        }
+      }, _callee54);
+    })));
+    it('falls back to the HTTP transport when the server group uses the https:// scheme', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee55() {
+      return _regenerator.default.wrap(function (_context55) {
+        while (1) switch (_context55.prev = _context55.next) {
+          case 0:
+            _context55.next = 1;
+            return reg.attemptRegistrationWithServers(_constants.REGISTRATION_UTIL, ['https://mobius.example.com/api/v1/calling/web/']);
+          case 1:
+            expect(setSocketEnabledSpy).toHaveBeenCalledWith(false);
+          case 2:
+          case "end":
+            return _context55.stop();
+        }
+      }, _callee55);
+    })));
+    it('does not change the transport when the server group is empty', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee56() {
+      return _regenerator.default.wrap(function (_context56) {
+        while (1) switch (_context56.prev = _context56.next) {
+          case 0:
+            _context56.next = 1;
+            return reg.attemptRegistrationWithServers(_constants.REGISTRATION_UTIL, []);
+          case 1:
+            expect(setSocketEnabledSpy).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context56.stop();
+        }
+      }, _callee56);
+    })));
+    it('derives the transport from the first server in the group', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee57() {
+      return _regenerator.default.wrap(function (_context57) {
+        while (1) switch (_context57.prev = _context57.next) {
+          case 0:
+            _context57.next = 1;
+            return reg.attemptRegistrationWithServers(_constants.REGISTRATION_UTIL, ['wss://primary.example.com/api/v1/calling/web/', 'https://backup.example.com/api/v1/calling/web/']);
+          case 1:
+            expect(setSocketEnabledSpy).toHaveBeenCalledWith(true);
+          case 2:
+          case "end":
+            return _context57.stop();
         }
-      }, _callee39);
+      }, _callee57);
     })));
   });
 });