@kineticdata/react/lib/apis/core/webhooks.test.js

A React library for the Kinetic Platform

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
var _regeneratorRuntime2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/regeneratorRuntime"));
var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/esm/asyncToGenerator"));
var _axios = _interopRequireDefault(require("axios"));
var _createError = _interopRequireDefault(require("axios/lib/core/createError"));
var _webhooks = require("./webhooks");
jest.mock('axios');

// Mock out the bundle object from a dependency.
jest.mock('../../helpers', function () {
  return {
    bundle: {
      apiLocation: function apiLocation() {
        return 'space/app/api/v1';
      }
    }
  };
});
describe('webhooks api', function () {
  describe('fetchWebhooks', function () {
    beforeEach(function () {
      _axios["default"].get.mockReset();
    });
    test('success space scoped webhooks', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee() {
      var result;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee$(_context) {
        while (1) switch (_context.prev = _context.next) {
          case 0:
            _axios["default"].get.mockResolvedValue({
              status: 200,
              data: {
                webhooks: [{
                  authStrategy: null,
                  event: 'Login Failure',
                  filter: '',
                  name: 'Test Webhook Name',
                  type: 'Space',
                  url: 'https://myapi.com/api/v1'
                }]
              }
            });
            _context.next = 3;
            return (0, _webhooks.fetchWebhooks)();
          case 3:
            result = _context.sent;
            expect(_axios["default"].get.mock.calls).toEqual([['space/app/api/v1/webhooks', {
              params: {},
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(result).toEqual({
              webhooks: [{
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }]
            });
          case 6:
          case "end":
            return _context.stop();
        }
      }, _callee);
    })));
    test('success kapp scoped webhooks', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee2() {
      var result;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee2$(_context2) {
        while (1) switch (_context2.prev = _context2.next) {
          case 0:
            _axios["default"].get.mockResolvedValue({
              status: 200,
              data: {
                webhooks: [{
                  authStrategy: null,
                  event: 'Login Failure',
                  filter: '',
                  name: 'Test Webhook Name',
                  type: 'Space',
                  url: 'https://myapi.com/api/v1'
                }]
              }
            });
            _context2.next = 3;
            return (0, _webhooks.fetchWebhooks)({
              kappSlug: 'services'
            });
          case 3:
            result = _context2.sent;
            expect(_axios["default"].get.mock.calls).toEqual([['space/app/api/v1/kapps/services/webhooks', {
              params: {},
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(result).toEqual({
              webhooks: [{
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }]
            });
          case 6:
          case "end":
            return _context2.stop();
        }
      }, _callee2);
    })));
    test('forbidden', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee3() {
      var result;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee3$(_context3) {
        while (1) switch (_context3.prev = _context3.next) {
          case 0:
            _axios["default"].get.mockRejectedValue((0, _createError["default"])('Request failed with status code 403', null, 403, null, {
              status: 403,
              statusText: 'Forbidden'
            }));
            _context3.next = 3;
            return (0, _webhooks.fetchWebhooks)();
          case 3:
            result = _context3.sent;
            expect(_axios["default"].get.mock.calls).toEqual([['space/app/api/v1/webhooks', {
              params: {},
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(result).toEqual({
              error: {
                forbidden: true,
                statusCode: 403,
                key: null,
                message: 'Forbidden'
              }
            });
          case 6:
          case "end":
            return _context3.stop();
        }
      }, _callee3);
    })));
  });
  describe('fetchWebhook', function () {
    beforeEach(function () {
      _axios["default"].get.mockReset();
    });
    test('success', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee4() {
      var result;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee4$(_context4) {
        while (1) switch (_context4.prev = _context4.next) {
          case 0:
            _axios["default"].get.mockResolvedValue({
              status: 200,
              data: {
                webhook: {
                  authStrategy: null,
                  event: 'Login Failure',
                  filter: '',
                  name: 'Test Webhook Name',
                  type: 'Space',
                  url: 'https://myapi.com/api/v1'
                }
              }
            });
            _context4.next = 3;
            return (0, _webhooks.fetchWebhook)({
              webhookName: 'Test Webhook Name'
            });
          case 3:
            result = _context4.sent;
            expect(_axios["default"].get.mock.calls).toEqual([['space/app/api/v1/webhooks/Test%20Webhook%20Name', {
              params: {},
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(result).toEqual({
              webhook: {
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }
            });
          case 6:
          case "end":
            return _context4.stop();
        }
      }, _callee4);
    })));
  });
  describe('createWebhook', function () {
    beforeEach(function () {
      _axios["default"].post.mockReset();
    });
    test('failure kapp scoped webhook - missing kappSlug', function () {
      expect(function () {
        (0, _webhooks.createWebhook)({
          webhook: {
            type: 'Kapp'
          }
        });
      }).toThrowError('createWebhook failed! A kappSlug is required when using type: Kapp');
    });
    test('success create webhook space', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee5() {
      var result;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee5$(_context5) {
        while (1) switch (_context5.prev = _context5.next) {
          case 0:
            _axios["default"].post.mockResolvedValue({
              status: 200,
              data: {
                webhook: {
                  authStrategy: null,
                  event: 'Login Failure',
                  filter: '',
                  name: 'Test Webhook Name',
                  type: 'Space',
                  url: 'https://myapi.com/api/v1'
                }
              }
            });
            _context5.next = 3;
            return (0, _webhooks.createWebhook)({
              webhook: {
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }
            });
          case 3:
            result = _context5.sent;
            expect(_axios["default"].post.mock.calls).toEqual([['space/app/api/v1/webhooks', {
              authStrategy: null,
              event: 'Login Failure',
              filter: '',
              name: 'Test Webhook Name',
              type: 'Space',
              url: 'https://myapi.com/api/v1'
            }, {
              params: {},
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(result).toEqual({
              webhook: {
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }
            });
          case 6:
          case "end":
            return _context5.stop();
        }
      }, _callee5);
    })));
    test('success create security definition kapp', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee6() {
      var result;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee6$(_context6) {
        while (1) switch (_context6.prev = _context6.next) {
          case 0:
            _axios["default"].post.mockResolvedValue({
              status: 200,
              data: {
                webhook: {
                  authStrategy: null,
                  event: 'Login Failure',
                  filter: '',
                  name: 'Test Webhook Name',
                  type: 'Space',
                  url: 'https://myapi.com/api/v1'
                }
              }
            });
            _context6.next = 3;
            return (0, _webhooks.createWebhook)({
              kappSlug: 'services',
              webhook: {
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }
            });
          case 3:
            result = _context6.sent;
            expect(_axios["default"].post.mock.calls).toEqual([['space/app/api/v1/kapps/services/webhooks', {
              authStrategy: null,
              event: 'Login Failure',
              filter: '',
              name: 'Test Webhook Name',
              type: 'Space',
              url: 'https://myapi.com/api/v1'
            }, {
              params: {},
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(result).toEqual({
              webhook: {
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }
            });
          case 6:
          case "end":
            return _context6.stop();
        }
      }, _callee6);
    })));
  });
  describe('updateWebhook', function () {
    beforeEach(function () {
      _axios["default"].put.mockReset();
    });
    test('success update webhook', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee7() {
      var result;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee7$(_context7) {
        while (1) switch (_context7.prev = _context7.next) {
          case 0:
            _axios["default"].put.mockResolvedValue({
              status: 200,
              data: {
                webhook: {
                  authStrategy: null,
                  event: 'Login Failure',
                  filter: '',
                  name: 'New Test Webhook Name',
                  type: 'Space',
                  url: 'https://myapi.com/api/v1'
                }
              }
            });
            _context7.next = 3;
            return (0, _webhooks.updateWebhook)({
              webhookName: 'Test Webhook Name',
              webhook: {
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'New Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }
            });
          case 3:
            result = _context7.sent;
            expect(_axios["default"].put.mock.calls).toEqual([['space/app/api/v1/webhooks/Test%20Webhook%20Name', {
              authStrategy: null,
              event: 'Login Failure',
              filter: '',
              name: 'New Test Webhook Name',
              type: 'Space',
              url: 'https://myapi.com/api/v1'
            }, {
              params: {},
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(result).toEqual({
              webhook: {
                authStrategy: null,
                event: 'Login Failure',
                filter: '',
                name: 'New Test Webhook Name',
                type: 'Space',
                url: 'https://myapi.com/api/v1'
              }
            });
          case 6:
          case "end":
            return _context7.stop();
        }
      }, _callee7);
    })));
  });
});