@kineticdata/react/lib/apis/core/space.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 _space = require("./space");
jest.mock('axios');
describe('space api', function () {
  describe('#fetchSpace', function () {
    describe('when successful', function () {
      beforeEach(function () {
        _axios["default"].get.mockResolvedValue({
          status: 200,
          data: {
            space: {
              name: 'Acme',
              slug: 'acme',
              attributes: []
            }
          }
        });
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _space.fetchSpace)().then(function (_ref) {
          var serverError = _ref.serverError;
          expect(serverError).toBeUndefined();
        });
      });
      test('returns a space', function () {
        expect.assertions(1);
        return (0, _space.fetchSpace)().then(function (_ref2) {
          var space = _ref2.space;
          expect(space).toMatchObject({
            name: 'Acme',
            slug: 'acme'
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _space.fetchSpace)({
          xlatAttributes: true
        }).then(function (_ref3) {
          var space = _ref3.space;
          expect(space.attributes).toBeDefined();
          expect(space.attributes).toBeInstanceOf(Array);
        });
      });
    });
    describe('when unsuccessful', function () {
      var response;
      beforeEach(function () {
        response = {
          status: 500,
          data: {}
        };
        _axios["default"].get.mockRejectedValue({
          response: response
        });
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _space.fetchSpace)({
          includes: 'attributes',
          xlatAttributes: true
        }).then(function (_ref4) {
          var error = _ref4.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
  describe('updateSpace', function () {
    beforeEach(function () {
      _axios["default"].put.mockReset();
    });
    test('success', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee() {
      var _yield$updateSpace, space, error;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee$(_context) {
        while (1) switch (_context.prev = _context.next) {
          case 0:
            _axios["default"].put.mockResolvedValue({
              status: 200,
              data: {
                space: {
                  name: 'Foo',
                  attributes: [{
                    name: 'Company Name',
                    values: ['Foo Bar']
                  }]
                }
              }
            });
            _context.next = 3;
            return (0, _space.updateSpace)({
              space: {
                name: 'Foo',
                attributes: [{
                  name: 'Company Name',
                  values: ['Foo Bar']
                }]
              },
              include: 'attributes'
            });
          case 3:
            _yield$updateSpace = _context.sent;
            space = _yield$updateSpace.space;
            error = _yield$updateSpace.error;
            expect(_axios["default"].put.mock.calls).toEqual([['/app/api/v1/space', {
              name: 'Foo',
              attributes: [{
                name: 'Company Name',
                values: ['Foo Bar']
              }]
            }, {
              params: {
                include: 'attributes'
              },
              headers: {
                'X-Kinetic-AuthAssumed': 'true'
              }
            }]]);
            expect(space).toEqual({
              name: 'Foo',
              attributes: [{
                name: 'Company Name',
                values: ['Foo Bar']
              }]
            });
            expect(error).toBeUndefined();
          case 9:
          case "end":
            return _context.stop();
        }
      }, _callee);
    })));
    test('missing space', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee2() {
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee2$(_context2) {
        while (1) switch (_context2.prev = _context2.next) {
          case 0:
            expect(function () {
              (0, _space.updateSpace)({});
            }).toThrow('updateSpace failed! The option "space" is required.');
          case 1:
          case "end":
            return _context2.stop();
        }
      }, _callee2);
    })));
    test('bad request', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee3() {
      var _yield$updateSpace2, space, error;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee3$(_context3) {
        while (1) switch (_context3.prev = _context3.next) {
          case 0:
            _axios["default"].put.mockRejectedValue((0, _createError["default"])('Request failed with status code 400', null, 400, null, {
              status: 400,
              statusText: 'Bad Request',
              data: {
                error: 'Invalid space'
              }
            }));
            _context3.next = 3;
            return (0, _space.updateSpace)({
              space: {
                name: null
              }
            });
          case 3:
            _yield$updateSpace2 = _context3.sent;
            space = _yield$updateSpace2.space;
            error = _yield$updateSpace2.error;
            expect(space).toBeUndefined();
            expect(error).toEqual({
              message: 'Invalid space',
              statusCode: 400,
              key: null,
              badRequest: true
            });
          case 8:
          case "end":
            return _context3.stop();
        }
      }, _callee3);
    })));
    test('serverError', /*#__PURE__*/(0, _asyncToGenerator2["default"])( /*#__PURE__*/(0, _regeneratorRuntime2["default"])().mark(function _callee4() {
      var _yield$updateSpace3, space, error;
      return (0, _regeneratorRuntime2["default"])().wrap(function _callee4$(_context4) {
        while (1) switch (_context4.prev = _context4.next) {
          case 0:
            _axios["default"].put.mockRejectedValue((0, _createError["default"])('Request failed with status code 403', null, 403, null, {
              status: 403,
              statusText: 'Forbidden',
              data: {}
            }));
            _context4.next = 3;
            return (0, _space.updateSpace)({
              space: {
                name: 'Foo'
              }
            });
          case 3:
            _yield$updateSpace3 = _context4.sent;
            space = _yield$updateSpace3.space;
            error = _yield$updateSpace3.error;
            expect(space).toBeUndefined();
            expect(error).toEqual({
              statusCode: 403,
              message: 'Forbidden',
              key: null,
              forbidden: true
            });
          case 8:
          case "end":
            return _context4.stop();
        }
      }, _callee4);
    })));
  });
});