@webex/calling 3.12.0-llmrefactor.1 → 3.12.0-llmrefactor.3

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

@@ -1905,21 +1905,289 @@ describe('Registration Tests', function () {
         }
       }, _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 _callee39() {
+    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 (_context39) {
-        while (1) switch (_context39.prev = _context39.next) {
+      return _regenerator.default.wrap(function (_context46) {
+        while (1) switch (_context46.prev = _context46.next) {
           case 0:
             pingSuccessPayload = {
               statusCode: 200
             };
             webex.request.mockResolvedValue(pingSuccessPayload);
-            _context39.next = 1;
+            _context46.next = 1;
             return reg.isPrimaryActive();
           case 1:
-            status = _context39.sent;
+            status = _context46.sent;
             expect(webex.request).toBeCalledWith(_objectSpread({
               method: 'GET',
               uri: "https://mobius-dfw.webex.com/api/v1/ping"
@@ -1927,23 +2195,23 @@ describe('Registration Tests', function () {
             expect(status).toEqual(true);
           case 2:
           case "end":
-            return _context39.stop();
+            return _context46.stop();
         }
-      }, _callee39);
+      }, _callee46);
     })));
-    it('failed: primary server status to be down', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee40() {
+    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 (_context40) {
-        while (1) switch (_context40.prev = _context40.next) {
+      return _regenerator.default.wrap(function (_context47) {
+        while (1) switch (_context47.prev = _context47.next) {
           case 0:
             pingFailurePayload = {
               statusCode: 500
             };
             webex.request.mockResolvedValue(pingFailurePayload);
-            _context40.next = 1;
+            _context47.next = 1;
             return reg.isPrimaryActive();
           case 1:
-            status = _context40.sent;
+            status = _context47.sent;
             expect(webex.request).toBeCalledWith(_objectSpread({
               method: 'GET',
               uri: "https://mobius-dfw.webex.com/api/v1/ping"
@@ -1951,9 +2219,9 @@ describe('Registration Tests', function () {
             expect(status).toEqual(false);
           case 2:
           case "end":
-            return _context40.stop();
+            return _context47.stop();
         }
-      }, _callee40);
+      }, _callee47);
     })));
   });
   describe('handleRegistrationDownEvent tests', function () {
@@ -1973,20 +2241,20 @@ describe('Registration Tests', function () {
         }
       }
     };
-    beforeEach(/*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee41() {
-      return _regenerator.default.wrap(function (_context41) {
-        while (1) switch (_context41.prev = _context41.next) {
+    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);
-            _context41.next = 1;
+            _context48.next = 1;
             return reg.triggerRegistration();
           case 1:
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.ACTIVE);
           case 2:
           case "end":
-            return _context41.stop();
+            return _context48.stop();
         }
-      }, _callee41);
+      }, _callee48);
     })));
     afterEach(function () {
       var calls = (0, _values.default)(reg.callManager.getActiveCalls());
@@ -1995,10 +2263,10 @@ describe('Registration Tests', function () {
       });
       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() {
+    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 (_context42) {
-        while (1) switch (_context42.prev = _context42.next) {
+      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');
@@ -2007,7 +2275,7 @@ describe('Registration Tests', function () {
             }), 'disconnectFromMobiusSocket');
             lineEmitter.mockClear();
             expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
-            _context42.next = 1;
+            _context49.next = 1;
             return reg.handleRegistrationDownEvent(registrationDownEvent);
           case 1:
             expect(clearKeepaliveSpy).toHaveBeenCalled();
@@ -2019,17 +2287,18 @@ describe('Registration Tests', function () {
             expect(reg.retryAfter).toBeUndefined();
             expect(reg.registerRetry).toBe(false);
             expect(disconnectSocketSpy).not.toHaveBeenCalled();
-            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            /* 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 _context42.stop();
+            return _context49.stop();
         }
-      }, _callee42);
+      }, _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 _callee43() {
+    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 (_context43) {
-        while (1) switch (_context43.prev = _context43.next) {
+      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');
@@ -2037,28 +2306,28 @@ describe('Registration Tests', function () {
             endSpy = jest.spyOn(activeCall, 'end');
             expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(1);
             lineEmitter.mockClear();
-            _context43.next = 1;
+            _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);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
           case 2:
           case "end":
-            return _context43.stop();
+            return _context50.stop();
         }
-      }, _callee43);
+      }, _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 _callee44() {
+    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 (_context44) {
-        while (1) switch (_context44.prev = _context44.next) {
+      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');
-            _context44.next = 1;
+            _context51.next = 1;
             return reg.handleRegistrationDownEvent(registrationDownEvent);
           case 1:
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
@@ -2066,23 +2335,23 @@ describe('Registration Tests', function () {
             setStatusSpy.mockClear();
             lineEmitter.mockClear();
             expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
-            _context44.next = 2;
+            _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);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
           case 3:
           case "end":
-            return _context44.stop();
+            return _context51.stop();
         }
-      }, _callee44);
+      }, _callee51);
     })));
-    it('disconnects the Mobius WebSocket when socket is enabled', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee45() {
+    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 (_context45) {
-        while (1) switch (_context45.prev = _context45.next) {
+      return _regenerator.default.wrap(function (_context52) {
+        while (1) switch (_context52.prev = _context52.next) {
           case 0:
             apiRequest = _request.APIRequest.getInstance({
               webex: webex
@@ -2091,7 +2360,7 @@ describe('Registration Tests', function () {
             disconnectSocketSpy = jest.spyOn(apiRequest, 'disconnectFromMobiusSocket').mockResolvedValue();
             lineEmitter.mockClear();
             expect((0, _keys.default)(reg.callManager.getActiveCalls()).length).toBe(0);
-            _context45.next = 1;
+            _context52.next = 1;
             return reg.handleRegistrationDownEvent(registrationDownEvent);
           case 1:
             expect(disconnectSocketSpy).toHaveBeenCalledWith({
@@ -2099,17 +2368,17 @@ describe('Registration Tests', function () {
               reason: 'done (permanent)'
             });
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
-            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
           case 2:
           case "end":
-            return _context45.stop();
+            return _context52.stop();
         }
-      }, _callee45);
+      }, _callee52);
     })));
-    it('still emits UNREGISTERED when socket disconnect fails', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee46() {
+    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 (_context46) {
-        while (1) switch (_context46.prev = _context46.next) {
+      return _regenerator.default.wrap(function (_context53) {
+        while (1) switch (_context53.prev = _context53.next) {
           case 0:
             apiRequest = _request.APIRequest.getInstance({
               webex: webex
@@ -2117,7 +2386,7 @@ describe('Registration Tests', function () {
             jest.spyOn(apiRequest, 'isSocketEnabled').mockReturnValue(true);
             disconnectSocketSpy = jest.spyOn(apiRequest, 'disconnectFromMobiusSocket').mockRejectedValue(new Error('socket teardown failed'));
             lineEmitter.mockClear();
-            _context46.next = 1;
+            _context53.next = 1;
             return reg.handleRegistrationDownEvent(registrationDownEvent);
           case 1:
             expect(disconnectSocketSpy).toHaveBeenCalled();
@@ -2126,12 +2395,12 @@ describe('Registration Tests', function () {
               method: _constants.METHODS.HANDLE_REGISTRATION_DOWN_EVENT
             });
             expect(reg.getStatus()).toBe(_types.RegistrationStatus.INACTIVE);
-            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED);
+            expect(lineEmitter).toHaveBeenCalledWith(_types4.LINE_EVENTS.UNREGISTERED, undefined, undefined);
           case 2:
           case "end":
-            return _context46.stop();
+            return _context53.stop();
         }
-      }, _callee46);
+      }, _callee53);
     })));
   });
   describe('attemptRegistrationWithServers transport alignment', function () {
@@ -2146,61 +2415,61 @@ describe('Registration Tests', function () {
       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 _callee47() {
-      return _regenerator.default.wrap(function (_context47) {
-        while (1) switch (_context47.prev = _context47.next) {
+    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:
-            _context47.next = 1;
+            _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 _context47.stop();
+            return _context54.stop();
         }
-      }, _callee47);
+      }, _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 _callee48() {
-      return _regenerator.default.wrap(function (_context48) {
-        while (1) switch (_context48.prev = _context48.next) {
+    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:
-            _context48.next = 1;
+            _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 _context48.stop();
+            return _context55.stop();
         }
-      }, _callee48);
+      }, _callee55);
     })));
-    it('does not change the transport when the server group is empty', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee49() {
-      return _regenerator.default.wrap(function (_context49) {
-        while (1) switch (_context49.prev = _context49.next) {
+    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:
-            _context49.next = 1;
+            _context56.next = 1;
             return reg.attemptRegistrationWithServers(_constants.REGISTRATION_UTIL, []);
           case 1:
             expect(setSocketEnabledSpy).not.toHaveBeenCalled();
           case 2:
           case "end":
-            return _context49.stop();
+            return _context56.stop();
         }
-      }, _callee49);
+      }, _callee56);
     })));
-    it('derives the transport from the first server in the group', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee50() {
-      return _regenerator.default.wrap(function (_context50) {
-        while (1) switch (_context50.prev = _context50.next) {
+    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:
-            _context50.next = 1;
+            _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 _context50.stop();
+            return _context57.stop();
         }
-      }, _callee50);
+      }, _callee57);
     })));
   });
 });