@webex/calling 3.12.0-next.5 → 3.12.0-next.51

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,25 @@ 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('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 _callee39() {
       var pingSuccessPayload, status;
-      return _regenerator.default.wrap(function (_context38) {
-        while (1) switch (_context38.prev = _context38.next) {
+      return _regenerator.default.wrap(function (_context39) {
+        while (1) switch (_context39.prev = _context39.next) {
           case 0:
             pingSuccessPayload = {
               statusCode: 200
             };
             webex.request.mockResolvedValue(pingSuccessPayload);
-            _context38.next = 1;
+            _context39.next = 1;
             return reg.isPrimaryActive();
           case 1:
-            status = _context38.sent;
+            status = _context39.sent;
             expect(webex.request).toBeCalledWith(_objectSpread({
               method: 'GET',
               uri: "https://mobius-dfw.webex.com/api/v1/ping"
@@ -1852,23 +1927,23 @@ describe('Registration Tests', function () {
             expect(status).toEqual(true);
           case 2:
           case "end":
-            return _context38.stop();
+            return _context39.stop();
         }
-      }, _callee38);
+      }, _callee39);
     })));
-    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 _callee40() {
       var pingFailurePayload, status;
-      return _regenerator.default.wrap(function (_context39) {
-        while (1) switch (_context39.prev = _context39.next) {
+      return _regenerator.default.wrap(function (_context40) {
+        while (1) switch (_context40.prev = _context40.next) {
           case 0:
             pingFailurePayload = {
               statusCode: 500
             };
             webex.request.mockResolvedValue(pingFailurePayload);
-            _context39.next = 1;
+            _context40.next = 1;
             return reg.isPrimaryActive();
           case 1:
-            status = _context39.sent;
+            status = _context40.sent;
             expect(webex.request).toBeCalledWith(_objectSpread({
               method: 'GET',
               uri: "https://mobius-dfw.webex.com/api/v1/ping"
@@ -1876,9 +1951,187 @@ describe('Registration Tests', function () {
             expect(status).toEqual(false);
           case 2:
           case "end":
-            return _context39.stop();
+            return _context40.stop();
         }
-      }, _callee39);
+      }, _callee40);
+    })));
+  });
+  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 _callee41() {
+      return _regenerator.default.wrap(function (_context41) {
+        while (1) switch (_context41.prev = _context41.next) {
+          case 0:
+            postRegistrationSpy.mockResolvedValueOnce(successPayload);
+            _context41.next = 1;
+            return reg.triggerRegistration();
+          case 1:
+            expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
+          case 2:
+          case "end":
+            return _context41.stop();
+        }
+      }, _callee41);
+    })));
+    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 _callee42() {
+      var clearKeepaliveSpy, setStatusSpy, disconnectSocketSpy;
+      return _regenerator.default.wrap(function (_context42) {
+        while (1) switch (_context42.prev = _context42.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);
+            _context42.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();
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+          case 2:
+          case "end":
+            return _context42.stop();
+        }
+      }, _callee42);
+    })));
+    it('ends the active call and still runs cleanup when an active call is present', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee43() {
+      var clearKeepaliveSpy, setStatusSpy, activeCall, endSpy;
+      return _regenerator.default.wrap(function (_context43) {
+        while (1) switch (_context43.prev = _context43.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();
+            _context43.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);
+          case 2:
+          case "end":
+            return _context43.stop();
+        }
+      }, _callee43);
+    })));
+    it('runs cleanup without calling end when no active call is present on re-invocation', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee44() {
+      var clearKeepaliveSpy, setStatusSpy;
+      return _regenerator.default.wrap(function (_context44) {
+        while (1) switch (_context44.prev = _context44.next) {
+          case 0:
+            clearKeepaliveSpy = jest.spyOn(reg, 'clearKeepaliveTimer');
+            setStatusSpy = jest.spyOn(reg, 'setStatus');
+            _context44.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);
+            _context44.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);
+          case 3:
+          case "end":
+            return _context44.stop();
+        }
+      }, _callee44);
+    })));
+    it('disconnects the Mobius WebSocket when socket is enabled', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee45() {
+      var apiRequest, disconnectSocketSpy;
+      return _regenerator.default.wrap(function (_context45) {
+        while (1) switch (_context45.prev = _context45.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);
+            _context45.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);
+          case 2:
+          case "end":
+            return _context45.stop();
+        }
+      }, _callee45);
+    })));
+    it('still emits UNREGISTERED when socket disconnect fails', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee46() {
+      var apiRequest, disconnectSocketSpy;
+      return _regenerator.default.wrap(function (_context46) {
+        while (1) switch (_context46.prev = _context46.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();
+            _context46.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);
+          case 2:
+          case "end":
+            return _context46.stop();
+        }
+      }, _callee46);
     })));
   });
 });