@webex/calling 3.12.0-next.60 → 3.12.0-next.62

package/dist/CallRecording/WxcCallRecordingConnector.test.js

@@ -0,0 +1,651 @@
+"use strict";
+
+var _typeof = require("@babel/runtime-corejs2/helpers/typeof");
+var _WeakMap = require("@babel/runtime-corejs2/core-js/weak-map");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _types = require("../Logger/types");
+var _testUtil = require("../common/testUtil");
+var _types2 = require("../common/types");
+var _WxcCallRecordingConnector = require("./WxcCallRecordingConnector");
+var _types3 = require("./types");
+var _callRecordingFixtures = require("./callRecordingFixtures");
+var _types4 = require("../Events/types");
+var _constants = require("./constants");
+var utils = _interopRequireWildcard(require("../common/Utils"));
+var _Logger = _interopRequireDefault(require("../Logger"));
+var _constants2 = require("../common/constants");
+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); }
+/* eslint-disable dot-notation */
+
+var webex = (0, _testUtil.getTestUtilsWebex)();
+var uploadLogsSpy;
+var serviceErrorCodeHandlerSpy;
+describe('WxcCallRecordingConnector tests', function () {
+  var connector;
+  var infoSpy = jest.spyOn(_Logger.default, 'info').mockImplementation();
+  var errorSpy = jest.spyOn(_Logger.default, 'error').mockImplementation();
+  beforeAll(function () {
+    connector = new _WxcCallRecordingConnector.WxcCallRecordingConnector(webex, {
+      level: _types.LOGGER.INFO
+    });
+  });
+  beforeEach(function () {
+    uploadLogsSpy = jest.spyOn(utils, 'uploadLogs').mockResolvedValue();
+    serviceErrorCodeHandlerSpy = jest.spyOn(utils, 'serviceErrorCodeHandler');
+  });
+  afterEach(function () {
+    jest.clearAllMocks();
+  });
+  describe('getRecordings', function () {
+    var loggerContext = {
+      file: _constants.CALL_RECORDING_FILE,
+      method: _constants.METHODS.GET_RECORDINGS
+    };
+    it('successfully fetches the list of recordings', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
+      var _response$data$record;
+      var payload, response;
+      return _regenerator.default.wrap(function (_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.LIST
+            });
+          case 1:
+            response = _context.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.message).toBe('SUCCESS');
+            expect(response.data.recordings).toHaveLength(2);
+            expect((_response$data$record = response.data.recordings) === null || _response$data$record === void 0 ? void 0 : _response$data$record[0].id).toBe(_callRecordingFixtures.RECORDING_ONE.id);
+            expect(errorSpy).not.toHaveBeenCalled();
+            expect(uploadLogsSpy).not.toHaveBeenCalled();
+          case 2:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    })));
+    it('builds the request URL with the provided filter/pagination query params', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
+      var payload, callArgs;
+      return _regenerator.default.wrap(function (_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context2.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.LIST,
+              options: {
+                from: '2024-05-01T00:00:00.000Z',
+                to: '2024-05-31T00:00:00.000Z',
+                status: _types3.RecordingStatus.DELETED,
+                max: 25,
+                serviceType: 'calling',
+                format: 'MP3',
+                ownerType: 'user',
+                storageRegion: 'US',
+                locationId: 'location-123',
+                topic: 'Call with User7',
+                webexUserRequest: true
+              }
+            });
+          case 1:
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.GET);
+            expect(callArgs.service).toBe('hydraDeveloperApi');
+            expect(callArgs.uri).toContain('/convergedRecordings?');
+            expect(callArgs.uri).toContain('from=2024-05-01T00%3A00%3A00.000Z');
+            expect(callArgs.uri).toContain('to=2024-05-31T00%3A00%3A00.000Z');
+            expect(callArgs.uri).toContain('status=deleted');
+            expect(callArgs.uri).toContain('max=25');
+            expect(callArgs.uri).toContain('serviceType=calling');
+            expect(callArgs.uri).toContain('format=MP3');
+            expect(callArgs.uri).toContain('ownerType=user');
+            expect(callArgs.uri).toContain('storageRegion=US');
+            expect(callArgs.uri).toContain('locationId=location-123');
+            expect(callArgs.uri).toContain('topic=Call+with+User7');
+            expect(callArgs.uri).not.toContain('orderType');
+            expect(callArgs.uri).not.toContain('orderBy');
+            expect(callArgs.uri).not.toContain('offset');
+            expect(callArgs.uri).not.toContain('actorID');
+            expect(callArgs.uri).not.toContain('showAccessCount');
+            expect(callArgs.headers).toEqual({
+              WebexUserRequest: 'true'
+            });
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2);
+    })));
+    it('applies the default filter/pagination query params when no options are provided', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3() {
+      var payload, callArgs;
+      return _regenerator.default.wrap(function (_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context3.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.LIST
+            });
+          case 1:
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.uri).toContain('from=');
+            expect(callArgs.uri).toContain('to=');
+            expect(callArgs.uri).toContain('status=available');
+            expect(callArgs.uri).toContain('max=30');
+            expect(callArgs.uri).not.toContain('orderType');
+            expect(callArgs.uri).not.toContain('orderBy');
+            expect(callArgs.uri).not.toContain('offset');
+            // Optional pass-through filters are omitted when not provided.
+            expect(callArgs.uri).not.toContain('serviceType');
+            expect(callArgs.uri).not.toContain('format');
+            expect(callArgs.uri).not.toContain('ownerType');
+            expect(callArgs.uri).not.toContain('storageRegion');
+            expect(callArgs.uri).not.toContain('locationId');
+            expect(callArgs.uri).not.toContain('topic');
+          case 2:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3);
+    })));
+    it('derives the from date from the days lookback and defaults to to now when not provided', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+      var payload, callArgs;
+      return _regenerator.default.wrap(function (_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            jest.useFakeTimers().setSystemTime(new Date('2024-06-15T12:00:00.000Z'));
+            _context4.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.LIST,
+              options: {
+                days: 7
+              }
+            });
+          case 1:
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.uri).toContain("from=".concat(encodeURIComponent('2024-06-08T12:00:00.000Z')));
+            expect(callArgs.uri).toContain("to=".concat(encodeURIComponent('2024-06-15T12:00:00.000Z')));
+            jest.useRealTimers();
+          case 2:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4);
+    })));
+    it('does not send the WebexUserRequest header by default', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5() {
+      var payload, callArgs;
+      return _regenerator.default.wrap(function (_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context5.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.LIST
+            });
+          case 1:
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.headers).toBeUndefined();
+          case 2:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5);
+    })));
+    it('returns an empty list when there are no recordings', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
+      var payload, response;
+      return _regenerator.default.wrap(function (_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_EMPTY_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context6.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.LIST
+            });
+          case 1:
+            response = _context6.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.data.recordings).toEqual([]);
+          case 2:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6);
+    })));
+    it.each([{
+      statusCode: 400,
+      expected: _callRecordingFixtures.ERROR_DETAILS_400
+    }, {
+      statusCode: 401,
+      expected: _callRecordingFixtures.ERROR_DETAILS_401
+    }, {
+      statusCode: 404,
+      expected: _callRecordingFixtures.ERROR_DETAILS_404
+    }])('handles a $statusCode error', /*#__PURE__*/function () {
+      var _ref8 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7(_ref7) {
+        var statusCode, expected, failurePayload, response;
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              statusCode = _ref7.statusCode, expected = _ref7.expected;
+              failurePayload = {
+                statusCode: statusCode
+              };
+              webex.request.mockRejectedValue(failurePayload);
+              _context7.next = 1;
+              return connector.getCallRecording({
+                type: _types3.RecordingRequestType.LIST
+              });
+            case 1:
+              response = _context7.sent;
+              expect(response).toStrictEqual(expected);
+              expect(serviceErrorCodeHandlerSpy).toBeCalledOnceWith({
+                statusCode: statusCode
+              }, loggerContext);
+              expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to get recordings'), loggerContext);
+              expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+            case 2:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      return function (_x) {
+        return _ref8.apply(this, arguments);
+      };
+    }());
+  });
+  describe('getRecording', function () {
+    var loggerContext = {
+      file: _constants.CALL_RECORDING_FILE,
+      method: _constants.METHODS.GET_RECORDING
+    };
+    it('successfully fetches a single recording', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee8() {
+      var _response$data$record2;
+      var payload, response, callArgs;
+      return _regenerator.default.wrap(function (_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context8.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.DETAIL,
+              recordingId: _callRecordingFixtures.RECORDING_ONE.id
+            });
+          case 1:
+            response = _context8.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.message).toBe('SUCCESS');
+            expect((_response$data$record2 = response.data.recording) === null || _response$data$record2 === void 0 ? void 0 : _response$data$record2.id).toBe(_callRecordingFixtures.RECORDING_ONE.id);
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.uri).toContain("/convergedRecordings/".concat(_callRecordingFixtures.RECORDING_ONE.id));
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.GET);
+            expect(callArgs.service).toBe('hydraDeveloperApi');
+            expect(infoSpy).toHaveBeenCalledWith("".concat(_constants2.METHOD_START_MESSAGE, " with recordingId=").concat(_callRecordingFixtures.RECORDING_ONE.id), loggerContext);
+          case 2:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8);
+    })));
+    it('handles a 404 error when the recording does not exist', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee9() {
+      var response;
+      return _regenerator.default.wrap(function (_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            webex.request.mockRejectedValue({
+              statusCode: 404
+            });
+            _context9.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.DETAIL,
+              recordingId: 'missing-id'
+            });
+          case 1:
+            response = _context9.sent;
+            expect(response).toStrictEqual(_callRecordingFixtures.ERROR_DETAILS_404);
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 2:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9);
+    })));
+  });
+  describe('getRecordingsByCallSessionId', function () {
+    it('returns only the recordings matching the call session id', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee0() {
+      var _response$data$record3;
+      var payload, response;
+      return _regenerator.default.wrap(function (_context0) {
+        while (1) switch (_context0.prev = _context0.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context0.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.BY_CALL_SESSION,
+              callSessionId: _callRecordingFixtures.CALL_SESSION_ID
+            });
+          case 1:
+            response = _context0.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.data.recordings).toHaveLength(1);
+            expect((_response$data$record3 = response.data.recordings) === null || _response$data$record3 === void 0 ? void 0 : _response$data$record3[0].id).toBe(_callRecordingFixtures.RECORDING_ONE.id);
+          case 2:
+          case "end":
+            return _context0.stop();
+        }
+      }, _callee0);
+    })));
+    it('returns an empty list when no recording matches', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee1() {
+      var payload, response;
+      return _regenerator.default.wrap(function (_context1) {
+        while (1) switch (_context1.prev = _context1.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context1.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.BY_CALL_SESSION,
+              callSessionId: 'non-existent-session'
+            });
+          case 1:
+            response = _context1.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.data.recordings).toEqual([]);
+          case 2:
+          case "end":
+            return _context1.stop();
+        }
+      }, _callee1);
+    })));
+    it('propagates the error response from the underlying list call', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee10() {
+      var response;
+      return _regenerator.default.wrap(function (_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            webex.request.mockRejectedValue({
+              statusCode: 401
+            });
+            _context10.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.BY_CALL_SESSION,
+              callSessionId: _callRecordingFixtures.CALL_SESSION_ID
+            });
+          case 1:
+            response = _context10.sent;
+            expect(response).toStrictEqual(_callRecordingFixtures.ERROR_DETAILS_401);
+          case 2:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10);
+    })));
+    it('forwards list options to the underlying list query to widen the scan', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee11() {
+      var payload, callArgs;
+      return _regenerator.default.wrap(function (_context11) {
+        while (1) switch (_context11.prev = _context11.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_LIST_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context11.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.BY_CALL_SESSION,
+              callSessionId: _callRecordingFixtures.CALL_SESSION_ID,
+              options: {
+                from: '2024-05-01T00:00:00.000Z',
+                to: '2024-05-31T00:00:00.000Z',
+                status: _types3.RecordingStatus.DELETED,
+                max: 100
+              }
+            });
+          case 1:
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.uri).toContain('from=2024-05-01T00%3A00%3A00.000Z');
+            expect(callArgs.uri).toContain('to=2024-05-31T00%3A00%3A00.000Z');
+            expect(callArgs.uri).toContain('status=deleted');
+            expect(callArgs.uri).toContain('max=100');
+          case 2:
+          case "end":
+            return _context11.stop();
+        }
+      }, _callee11);
+    })));
+  });
+  describe('getRecordingMetadata', function () {
+    var loggerContext = {
+      file: _constants.CALL_RECORDING_FILE,
+      method: _constants.METHODS.GET_RECORDING_METADATA
+    };
+    it('successfully fetches the recording metadata', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee12() {
+      var _response$data$metada;
+      var payload, response, callArgs;
+      return _regenerator.default.wrap(function (_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            payload = _callRecordingFixtures.MOCK_RECORDING_METADATA_BODY;
+            webex.request.mockResolvedValue(payload);
+            _context12.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.METADATA,
+              recordingId: _callRecordingFixtures.RECORDING_ONE.id
+            });
+          case 1:
+            response = _context12.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.message).toBe('SUCCESS');
+            expect((_response$data$metada = response.data.metadata) === null || _response$data$metada === void 0 ? void 0 : _response$data$metada.callSessionId).toBe(_callRecordingFixtures.CALL_SESSION_ID);
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.uri).toContain("/convergedRecordings/".concat(_callRecordingFixtures.RECORDING_ONE.id, "/metadata"));
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.GET);
+            expect(callArgs.service).toBe('hydraDeveloperApi');
+          case 2:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12);
+    })));
+    it('handles a 400 error', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee13() {
+      var response;
+      return _regenerator.default.wrap(function (_context13) {
+        while (1) switch (_context13.prev = _context13.next) {
+          case 0:
+            webex.request.mockRejectedValue({
+              statusCode: 400
+            });
+            _context13.next = 1;
+            return connector.getCallRecording({
+              type: _types3.RecordingRequestType.METADATA,
+              recordingId: 'bad-id'
+            });
+          case 1:
+            response = _context13.sent;
+            expect(response).toStrictEqual(_callRecordingFixtures.ERROR_DETAILS_400);
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to get recording metadata'), loggerContext);
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 2:
+          case "end":
+            return _context13.stop();
+        }
+      }, _callee13);
+    })));
+  });
+  describe('deleteRecording', function () {
+    var loggerContext = {
+      file: _constants.CALL_RECORDING_FILE,
+      method: _constants.METHODS.DELETE_RECORDING
+    };
+    it('successfully deletes a recording without a body when no options are provided', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee14() {
+      var response, callArgs;
+      return _regenerator.default.wrap(function (_context14) {
+        while (1) switch (_context14.prev = _context14.next) {
+          case 0:
+            webex.request.mockResolvedValue({
+              statusCode: 200
+            });
+            _context14.next = 1;
+            return connector.deleteRecording(_callRecordingFixtures.RECORDING_ONE.id);
+          case 1:
+            response = _context14.sent;
+            expect(response.statusCode).toBe(200);
+            expect(response.message).toBe('SUCCESS');
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.uri).toContain("/convergedRecordings/".concat(_callRecordingFixtures.RECORDING_ONE.id));
+            expect(callArgs.uri).not.toContain('/metadata');
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.DELETE);
+            expect(callArgs.service).toBe('hydraDeveloperApi');
+            expect(callArgs.body).toBeUndefined();
+          case 2:
+          case "end":
+            return _context14.stop();
+        }
+      }, _callee14);
+    })));
+    it('sends reason and comment in the body when provided (Compliance Officer deletion)', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee15() {
+      var callArgs;
+      return _regenerator.default.wrap(function (_context15) {
+        while (1) switch (_context15.prev = _context15.next) {
+          case 0:
+            webex.request.mockResolvedValue({
+              statusCode: 200
+            });
+            _context15.next = 1;
+            return connector.deleteRecording(_callRecordingFixtures.RECORDING_ONE.id, {
+              reason: 'audit',
+              comment: 'Maintain data privacy'
+            });
+          case 1:
+            callArgs = webex.request.mock.calls[webex.request.mock.calls.length - 1][0];
+            expect(callArgs.method).toBe(_types2.HTTP_METHODS.DELETE);
+            expect(callArgs.body).toStrictEqual({
+              reason: 'audit',
+              comment: 'Maintain data privacy'
+            });
+          case 2:
+          case "end":
+            return _context15.stop();
+        }
+      }, _callee15);
+    })));
+    it('handles a 400 error', /*#__PURE__*/(0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee16() {
+      var response;
+      return _regenerator.default.wrap(function (_context16) {
+        while (1) switch (_context16.prev = _context16.next) {
+          case 0:
+            webex.request.mockRejectedValue({
+              statusCode: 400
+            });
+            _context16.next = 1;
+            return connector.deleteRecording('bad-id');
+          case 1:
+            response = _context16.sent;
+            expect(response).toStrictEqual(_callRecordingFixtures.ERROR_DETAILS_400);
+            expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to delete recording'), loggerContext);
+            expect(uploadLogsSpy).toHaveBeenCalledTimes(1);
+          case 2:
+          case "end":
+            return _context16.stop();
+        }
+      }, _callee16);
+    })));
+  });
+  describe('URL resolution', function () {
+    it('resolves the recording base URL from the services catalog (hydraDeveloperApi)', function () {
+      var localConnector = new _WxcCallRecordingConnector.WxcCallRecordingConnector((0, _testUtil.getTestUtilsWebex)(), {
+        level: _types.LOGGER.INFO
+      });
+      expect(localConnector['recordingServiceUrl']).toBe('https://integration.webexapis.com/v1');
+    });
+  });
+  describe('Recording Mercury events', function () {
+    var mockOn;
+    var findHandler = function findHandler(eventKey) {
+      var calls = mockOn.mock.calls.filter(function (call) {
+        return call[0] === eventKey;
+      });
+      return calls[calls.length - 1][1];
+    };
+    beforeEach(function () {
+      mockOn = webex.internal.mercury.on;
+      mockOn.mockClear();
+      connector = new _WxcCallRecordingConnector.WxcCallRecordingConnector(webex, {
+        level: _types.LOGGER.INFO
+      });
+    });
+    it('registers listeners for all three recording mercury events', function () {
+      var registeredKeys = mockOn.mock.calls.map(function (call) {
+        return call[0];
+      });
+      expect(registeredKeys).toContain(_callRecordingFixtures.RECORDING_MERCURY_KEYS.CREATED);
+      expect(registeredKeys).toContain(_callRecordingFixtures.RECORDING_MERCURY_KEYS.UPDATED);
+      expect(registeredKeys).toContain(_callRecordingFixtures.RECORDING_MERCURY_KEYS.DELETED);
+    });
+    it('emits the recording created event', function (done) {
+      connector.on(_types4.COMMON_EVENT_KEYS.CALL_RECORDING_CREATED, function (event) {
+        expect(event).toEqual(_callRecordingFixtures.MOCK_RECORDING_CREATED_EVENT);
+        done();
+      });
+      findHandler(_callRecordingFixtures.RECORDING_MERCURY_KEYS.CREATED)(_callRecordingFixtures.MOCK_RECORDING_CREATED_EVENT);
+    });
+
+    /**
+     * The backend delivers the recording lifecycle through `convergedRecordings.updated` events
+     * qualified by `eventSubType`. The connector routes them to the intuitive typed event:
+     * name: TestCase name
+     * event: the raw `updated` Mercury event (with its eventSubType)
+     * expectedKey: the typed event the connector should emit
+     */
+    var updatedRoutingData = [{
+      name: 'TRASH (soft delete) -> callRecording:deleted',
+      event: _callRecordingFixtures.MOCK_RECORDING_TRASH_EVENT,
+      expectedKey: _types4.COMMON_EVENT_KEYS.CALL_RECORDING_DELETED
+    }, {
+      name: 'PURGE (permanent delete) -> callRecording:deleted',
+      event: _callRecordingFixtures.MOCK_RECORDING_PURGE_EVENT,
+      expectedKey: _types4.COMMON_EVENT_KEYS.CALL_RECORDING_DELETED
+    }, {
+      name: 'RESTORE (restored from trash) -> callRecording:created',
+      event: _callRecordingFixtures.MOCK_RECORDING_RESTORE_EVENT,
+      expectedKey: _types4.COMMON_EVENT_KEYS.CALL_RECORDING_CREATED
+    }, {
+      name: 'SUMMARY_CREATE (summary/transcript ready) -> callRecording:updated',
+      event: _callRecordingFixtures.MOCK_RECORDING_UPDATED_EVENT,
+      expectedKey: _types4.COMMON_EVENT_KEYS.CALL_RECORDING_UPDATED
+    }];
+    it.each(updatedRoutingData)('routes a convergedRecordings.updated event by eventSubType: $name', function (_ref18) {
+      var event = _ref18.event,
+        expectedKey = _ref18.expectedKey;
+      var spy = jest.fn();
+      connector.on(expectedKey, spy);
+      findHandler(_callRecordingFixtures.RECORDING_MERCURY_KEYS.UPDATED)(event);
+      expect(spy).toHaveBeenCalledWith(event);
+    });
+    it('emits the recording deleted event', function (done) {
+      connector.on(_types4.COMMON_EVENT_KEYS.CALL_RECORDING_DELETED, function (event) {
+        expect(event).toEqual(_callRecordingFixtures.MOCK_RECORDING_DELETED_EVENT);
+        done();
+      });
+      findHandler(_callRecordingFixtures.RECORDING_MERCURY_KEYS.DELETED)(_callRecordingFixtures.MOCK_RECORDING_DELETED_EVENT);
+    });
+    it('ignores malformed events without an activity payload', function () {
+      var spy = jest.fn();
+      connector.on(_types4.COMMON_EVENT_KEYS.CALL_RECORDING_CREATED, spy);
+      findHandler(_callRecordingFixtures.RECORDING_MERCURY_KEYS.CREATED)({});
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+});
+//# sourceMappingURL=WxcCallRecordingConnector.test.js.map