@webex/calling 3.8.0 → 3.8.1-next.2

package/dist/common/Utils.test.js

@@ -29,6 +29,7 @@ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t =
 var mockSubmitRegistrationMetric = jest.fn();
 var mockEmitterCb = jest.fn();
 var mockRestoreCb = jest.fn();
+var mock429RetryCb = jest.fn();
 var webex = (0, _testUtil.getTestUtilsWebex)();
 _SDKConnector.default.setWebex(webex);
 webex.internal.metrics.submitClientMetrics = mockSubmitRegistrationMetric;
@@ -71,48 +72,60 @@ describe('Registration Tests', function () {
    * logMsg: log message.
    */
   var errorCodes = [{
+    name: 'verify 429 error response',
+    statusCode: _types2.ERROR_CODE.TOO_MANY_REQUESTS,
+    deviceErrorCode: 0,
+    retryAfter: 30,
+    message: '',
+    errorType: _types2.ERROR_TYPE.REGISTRATION_ERROR,
+    emitterCbExpected: false,
+    finalError: false,
+    retry429CbExpected: true,
+    restoreCbExpected: false,
+    logMsg: '429 Too Many Requests'
+  }, {
     name: 'verify 404 error response',
     statusCode: _types2.ERROR_CODE.DEVICE_NOT_FOUND,
     deviceErrorCode: 0,
-    retryAfter: 0,
-    message: 'The client has unregistered. Please wait for the client to register before attempting the call. If error persists, sign out, sign back in and attempt the call.',
+    message: 'Webex Calling is unable to find your device. Sign out, then sign back in',
     errorType: _types2.ERROR_TYPE.NOT_FOUND,
     emitterCbExpected: true,
     finalError: true,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: '404 Device Not Found'
   }, {
     name: 'verify 500 error response',
     statusCode: _types2.ERROR_CODE.INTERNAL_SERVER_ERROR,
     deviceErrorCode: 0,
-    retryAfter: 0,
     message: 'An unknown error occurred while placing the request. Wait a moment and try again.',
     errorType: _types2.ERROR_TYPE.SERVICE_UNAVAILABLE,
     emitterCbExpected: true,
     finalError: false,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: '500 Internal Server Error'
   }, {
     name: 'verify 503 error response',
     statusCode: _types2.ERROR_CODE.SERVICE_UNAVAILABLE,
     deviceErrorCode: 0,
-    retryAfter: 0,
     message: 'An error occurred on the server while processing the request. Wait a moment and try again.',
     errorType: _types2.ERROR_TYPE.SERVICE_UNAVAILABLE,
     emitterCbExpected: true,
     finalError: false,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: '503 Service Unavailable'
   }, {
     name: 'verify 403 response with no response body',
     statusCode: _types2.ERROR_CODE.FORBIDDEN,
     deviceErrorCode: 0,
-    retryAfter: 0,
     message: 'An unauthorized action has been received. This action has been blocked. Please contact the administrator if this persists.',
     errorType: _types2.ERROR_TYPE.FORBIDDEN_ERROR,
     emitterCbExpected: true,
     finalError: false,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: 'Error response has no body, throwing default error',
     customBodyPresent: true,
     body: undefined
@@ -120,67 +133,78 @@ describe('Registration Tests', function () {
     name: 'verify 403 response with unknown device.errorCode',
     statusCode: _types2.ERROR_CODE.FORBIDDEN,
     deviceErrorCode: 0,
-    retryAfter: 0,
     message: 'An unknown error occurred. Wait a moment and try again. Please contact the administrator if the problem persists.',
     errorType: _types2.ERROR_TYPE.FORBIDDEN_ERROR,
     emitterCbExpected: true,
     finalError: false,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: 'Error code found : 0'
   }, {
     name: 'verify 403 response with code 101',
     statusCode: _types2.ERROR_CODE.FORBIDDEN,
     deviceErrorCode: _types2.DEVICE_ERROR_CODE.DEVICE_LIMIT_EXCEEDED,
-    retryAfter: 0,
     message: 'User device limit exceeded',
     errorType: _types2.ERROR_TYPE.FORBIDDEN_ERROR,
     emitterCbExpected: false,
     finalError: false,
     restoreCbExpected: true,
+    retry429CbExpected: false,
     logMsg: 'User device limit exceeded'
   }, {
     name: 'verify 403 response with code 102',
     statusCode: _types2.ERROR_CODE.FORBIDDEN,
     deviceErrorCode: _types2.DEVICE_ERROR_CODE.DEVICE_CREATION_DISABLED,
-    retryAfter: 0,
     message: 'User is not configured for WebRTC calling. Please contact the administrator to resolve this issue.',
     errorType: _types2.ERROR_TYPE.FORBIDDEN_ERROR,
     emitterCbExpected: true,
     finalError: true,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: 'User is not configured for WebRTC calling. Please contact the administrator to resolve this issue.'
   }, {
     name: 'verify 403 response with code 103',
     statusCode: _types2.ERROR_CODE.FORBIDDEN,
     deviceErrorCode: _types2.DEVICE_ERROR_CODE.DEVICE_CREATION_FAILED,
-    retryAfter: 0,
     message: 'An unknown error occurred while provisioning the device. Wait a moment and try again.',
     errorType: _types2.ERROR_TYPE.FORBIDDEN_ERROR,
     emitterCbExpected: true,
     finalError: false,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: 'An unknown error occurred while provisioning the device. Wait a moment and try again.'
   }, {
     name: 'verify 401 error response',
     statusCode: _types2.ERROR_CODE.UNAUTHORIZED,
     deviceErrorCode: 0,
-    retryAfter: 0,
     message: 'User is unauthorized due to an expired token. Sign out, then sign back in.',
     errorType: _types2.ERROR_TYPE.TOKEN_ERROR,
     emitterCbExpected: true,
     finalError: true,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: '401 Unauthorized'
+  }, {
+    name: 'verify 400 error response',
+    statusCode: _types2.ERROR_CODE.BAD_REQUEST,
+    deviceErrorCode: 0,
+    message: 'Invalid input. Please verify the required parameters, sign out and then sign back in with the valid data',
+    errorType: _types2.ERROR_TYPE.SERVER_ERROR,
+    emitterCbExpected: true,
+    finalError: true,
+    restoreCbExpected: false,
+    retry429CbExpected: false,
+    logMsg: '400 Bad Request'
   }, {
     name: 'verify unknown error response',
     statusCode: 206,
     deviceErrorCode: 0,
-    retryAfter: 0,
     message: 'Unknown error',
     errorType: _types2.ERROR_TYPE.DEFAULT,
     emitterCbExpected: true,
     finalError: false,
     restoreCbExpected: false,
+    retry429CbExpected: false,
     logMsg: 'Unknown Error'
   }].map(function (stat) {
     return (0, _assign.default)(stat, {
@@ -199,9 +223,11 @@ describe('Registration Tests', function () {
   it.each(errorCodes)('%s', function (codeObj) {
     var webexPayload = {
       statusCode: codeObj.statusCode,
-      headers: {
+      headers: _objectSpread({
         trackingid: 'webex-js-sdk_b5812e58-7246-4a9b-bf64-831bdf13b0cd_31'
-      },
+      }, codeObj.retryAfter && {
+        'retry-after': codeObj.retryAfter.toString()
+      }),
       body: {
         device: {
           deviceId: '8a67806f-fc4d-446b-a131-31e71ea5b010'
@@ -226,7 +252,7 @@ describe('Registration Tests', function () {
       context: logObj
     };
     var callClientError = new _Errors.CallingClientError(mockErrorEvent.message, mockErrorEvent.context, mockErrorEvent.type, _types.RegistrationStatus.ACTIVE);
-    (0, _Utils.handleRegistrationErrors)(webexPayload, mockEmitterCb, logObj, mockRestoreCb);
+    (0, _Utils.handleRegistrationErrors)(webexPayload, mockEmitterCb, logObj, mock429RetryCb, mockRestoreCb);
     if (codeObj.emitterCbExpected) {
       expect(mockEmitterCb).toBeCalledOnceWith(callClientError, codeObj.finalError);
     }
@@ -235,6 +261,11 @@ describe('Registration Tests', function () {
     } else {
       expect(mockRestoreCb).not.toHaveBeenCalled();
     }
+    if (codeObj.retry429CbExpected) {
+      expect(mock429RetryCb).toBeCalledOnceWith(codeObj.retryAfter, logObj.method);
+    } else {
+      expect(mock429RetryCb).not.toHaveBeenCalled();
+    }
     expect(logSpy).toHaveBeenCalledWith("Status code: -> ".concat(codeObj.statusCode), logObj);
     expect(logSpy).toHaveBeenCalledWith(codeObj.logMsg, logObj);
   });
@@ -1395,46 +1426,179 @@ describe('modifySdpForIPv4', function () {
     expect((0, _Utils.modifySdpForIPv4)(sdp).trim()).toEqual(expectedSdp.trim());
   });
 });
-describe('uploadLogs tests', function () {
-  it('should call submitLogs with the provided data', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
-    var mockData;
+describe('uploadLogs', function () {
+  var originalCrypto;
+  var submitLogsMock;
+  beforeEach(function () {
+    // Save original crypto and mock it
+    originalCrypto = global.crypto;
+    global.crypto = {
+      randomUUID: jest.fn().mockReturnValue('mocked-uuid-12345')
+    };
+
+    // Mock the metrics manager submit function directly
+    mockSubmitRegistrationMetric.mockClear();
+
+    // Mock webex.internal.support.submitLogs
+    submitLogsMock = jest.fn().mockResolvedValue({
+      trackingid: '1234'
+    });
+    webex.internal.support = {
+      submitLogs: submitLogsMock
+    };
+  });
+  afterEach(function () {
+    // Restore original crypto
+    global.crypto = originalCrypto;
+    jest.clearAllMocks();
+  });
+  it('should upload logs and return the response', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
+    var mockMetaData, logSpy, result;
     return _regenerator.default.wrap(function _callee13$(_context13) {
       while (1) switch (_context13.prev = _context13.next) {
         case 0:
-          mockData = {
-            someKey: 'someValue'
+          mockMetaData = {
+            correlationId: 'test-correlation'
           };
-          _context13.next = 3;
-          return (0, _Utils.uploadLogs)(mockData);
-        case 3:
-          expect(_SDKConnector.default.getWebex().internal.support.submitLogs).toHaveBeenCalledTimes(1);
-          expect(_SDKConnector.default.getWebex().internal.support.submitLogs).toHaveBeenCalledWith(mockData);
-        case 5:
+          logSpy = jest.spyOn(_Logger.default, 'info');
+          _context13.next = 4;
+          return (0, _Utils.uploadLogs)(mockMetaData, true);
+        case 4:
+          result = _context13.sent;
+          expect(result).toEqual({
+            trackingid: '1234',
+            feedbackId: 'mocked-uuid-12345'
+          });
+          expect(logSpy).toHaveBeenCalledWith("Logs uploaded successfully with feedbackId: mocked-uuid-12345", {
+            file: _constants.UTILS_FILE,
+            method: 'uploadLogs'
+          });
+          expect(mockSubmitRegistrationMetric).toHaveBeenCalledWith('web-calling-sdk-upload-logs-success', {
+            fields: {
+              call_id: undefined,
+              calling_sdk_version: 'unknown',
+              correlation_id: 'test-correlation',
+              device_url: undefined,
+              feedback_id: 'mocked-uuid-12345',
+              mobius_url: undefined,
+              tracking_id: '1234'
+            },
+            tags: {
+              action: 'upload_logs',
+              device_id: undefined,
+              service_indicator: 'calling'
+            },
+            type: 'behavioral'
+          });
+          expect(submitLogsMock).toHaveBeenCalledWith(_objectSpread(_objectSpread({}, mockMetaData), {}, {
+            feedbackId: 'mocked-uuid-12345'
+          }), undefined, {
+            type: 'diff'
+          });
+        case 9:
         case "end":
           return _context13.stop();
       }
     }, _callee13);
   })));
-  it('should handle errors when submitLogs fails', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
-    var mockError, logSpy;
+  it('should log and throw an error if the upload fails', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
+    var mockMetaData, mockError, logSpy;
     return _regenerator.default.wrap(function _callee14$(_context14) {
       while (1) switch (_context14.prev = _context14.next) {
         case 0:
-          mockError = new Error('Test error');
-          _SDKConnector.default.getWebex().internal.support.submitLogs.mockRejectedValue(mockError);
+          mockMetaData = {
+            correlationId: 'test-correlation'
+          };
+          mockError = new Error('Upload failed'); // Mock the submitLogs to fail
+          submitLogsMock.mockRejectedValueOnce(mockError);
           logSpy = jest.spyOn(_Logger.default, 'error');
-          _context14.next = 5;
-          return (0, _Utils.uploadLogs)({});
-        case 5:
-          expect(logSpy).toHaveBeenCalledWith(mockError, {
+          _context14.prev = 4;
+          _context14.next = 7;
+          return (0, _Utils.uploadLogs)(mockMetaData, true);
+        case 7:
+          // If we get here, the test should fail since we expected an exception
+          expect(true).toBe(false); // This will fail the test if no exception is thrown
+          _context14.next = 15;
+          break;
+        case 10:
+          _context14.prev = 10;
+          _context14.t0 = _context14["catch"](4);
+          expect(_context14.t0).toBe(mockError);
+          expect(logSpy).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.stringContaining('Failed to upload Logs')
+          }), {
             file: _constants.UTILS_FILE,
             method: 'uploadLogs'
           });
-        case 6:
+          expect(mockSubmitRegistrationMetric).toHaveBeenCalledWith('web-calling-sdk-upload-logs-failed', {
+            fields: {
+              call_id: undefined,
+              calling_sdk_version: 'unknown',
+              correlation_id: 'Failed to upload Logs Error: Upload failed',
+              device_url: undefined,
+              error: undefined,
+              feedback_id: 'test-correlation',
+              mobius_url: undefined,
+              tracking_id: 'mocked-uuid-12345'
+            },
+            tags: {
+              action: 'upload_logs',
+              device_id: undefined,
+              service_indicator: 'calling'
+            },
+            type: 'behavioral'
+          });
+        case 15:
         case "end":
           return _context14.stop();
       }
-    }, _callee14);
+    }, _callee14, null, [[4, 10]]);
+  })));
+  it('should log error and not throw an error if the upload fails with throw exception false', /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
+    var mockMetaData, mockError, logSpy, result;
+    return _regenerator.default.wrap(function _callee15$(_context15) {
+      while (1) switch (_context15.prev = _context15.next) {
+        case 0:
+          mockMetaData = {
+            correlationId: 'test-correlation'
+          };
+          mockError = new Error('Upload failed'); // Mock the submitLogs to fail
+          submitLogsMock.mockRejectedValueOnce(mockError);
+          logSpy = jest.spyOn(_Logger.default, 'error');
+          _context15.next = 6;
+          return (0, _Utils.uploadLogs)(mockMetaData, false);
+        case 6:
+          result = _context15.sent;
+          expect(result).toBeUndefined();
+          expect(logSpy).toHaveBeenCalledWith(expect.objectContaining({
+            message: expect.stringContaining('Failed to upload Logs')
+          }), {
+            file: _constants.UTILS_FILE,
+            method: 'uploadLogs'
+          });
+          expect(mockSubmitRegistrationMetric).toHaveBeenCalledWith('web-calling-sdk-upload-logs-failed', {
+            fields: {
+              call_id: undefined,
+              calling_sdk_version: 'unknown',
+              correlation_id: 'Failed to upload Logs Error: Upload failed',
+              device_url: undefined,
+              error: undefined,
+              feedback_id: 'test-correlation',
+              mobius_url: undefined,
+              tracking_id: 'mocked-uuid-12345'
+            },
+            tags: {
+              action: 'upload_logs',
+              device_id: undefined,
+              service_indicator: 'calling'
+            },
+            type: 'behavioral'
+          });
+        case 10:
+        case "end":
+          return _context15.stop();
+      }
+    }, _callee15);
   })));
 });
 //# sourceMappingURL=Utils.test.js.map