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

A React library for the Kinetic Platform

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
var _axios = _interopRequireDefault(require("axios"));
var _users = require("./users");
var _user_builder = require("../../../tests/utils/user_builder");
var _promises = require("../../../tests/utils/promises");
// Mock out the bundle object from a dependency.
jest.mock('../../helpers', function () {
  return {
    bundle: {
      apiLocation: function apiLocation() {
        return 'user/app/api/v1';
      },
      kappSlug: function kappSlug() {
        return 'mock-kapp';
      }
    }
  };
});
describe('users api', function () {
  describe('#fetchUsers', function () {
    describe('when successful', function () {
      var response;
      var testUser;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            users: []
          }
        };
        testUser = new _user_builder.UserBuilder().stub().withAttribute('Attribute', 'value').build();
        response.data.users.push(testUser);
        _axios["default"].get = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _users.fetchUsers)().then(function (_ref) {
          var errors = _ref.errors;
          expect(errors).toBeUndefined();
        });
      });
      test('returns an array of users', function () {
        expect.assertions(2);
        return (0, _users.fetchUsers)().then(function (_ref2) {
          var users = _ref2.users;
          expect(users).toBeInstanceOf(Array);
          expect(users[0]).toMatchObject({
            username: testUser.username,
            displayName: testUser.displayName
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _users.fetchUsers)({
          xlatAttributes: true
        }).then(function (_ref3) {
          var users = _ref3.users;
          expect(users[0].attributes).toBeDefined();
          expect(users[0].attributes).toBeInstanceOf(Array);
        });
      });
    });
  });
  describe('#fetchUser', function () {
    describe('when successful', function () {
      var response;
      var testUser;
      var username;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            user: {}
          }
        };
        testUser = new _user_builder.UserBuilder().stub().withAttribute('Attribute', 'value').build();
        username = testUser.username;
        response.data.user = testUser;
        _axios["default"].get = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _users.fetchUser)({
          username: username
        }).then(function (_ref4) {
          var errors = _ref4.errors;
          expect(errors).toBeUndefined();
        });
      });
      test('returns a user', function () {
        expect.assertions(1);
        return (0, _users.fetchUser)({
          username: username
        }).then(function (_ref5) {
          var user = _ref5.user;
          expect(user).toMatchObject({
            username: testUser.username,
            displayName: testUser.displayName
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _users.fetchUser)({
          username: username
        }).then(function (_ref6) {
          var user = _ref6.user;
          expect(user.attributes).toBeDefined();
          expect(user.attributes).toBeInstanceOf(Array);
        });
      });
    });
    describe('when unsuccessful', function () {
      var response;
      beforeEach(function () {
        response = {
          status: 500,
          data: {}
        };
        _axios["default"].get = (0, _promises.rejectPromiseWith)({
          response: response
        });
      });
      test('throws an exception when no user slug is provided', function () {
        expect(function () {
          (0, _users.fetchUser)({});
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _users.fetchUser)({
          username: 'fake'
        }).then(function (_ref7) {
          var error = _ref7.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
  describe('#updateUser', function () {
    describe('when successful', function () {
      var response;
      var testUser;
      var username;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            user: {}
          }
        };
        testUser = new _user_builder.UserBuilder().stub().withAttribute('Attribute', 'value').build();
        username = testUser.username;
        response.data.user = testUser;
        _axios["default"].put = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _users.updateUser)({
          username: username,
          user: testUser
        }).then(function (_ref8) {
          var error = _ref8.error;
          expect(error).toBeUndefined();
        });
      });
      test('returns a user', function () {
        expect.assertions(1);
        return (0, _users.updateUser)({
          username: username,
          user: testUser
        }).then(function (_ref9) {
          var user = _ref9.user;
          expect(user).toMatchObject({
            username: testUser.username,
            displayName: testUser.displayName
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _users.updateUser)({
          username: username,
          user: testUser
        }).then(function (_ref10) {
          var user = _ref10.user;
          expect(user.attributes).toBeDefined();
          expect(user.attributes).toBeInstanceOf(Array);
        });
      });
    });
    describe('when unsuccessful', function () {
      var response;
      beforeEach(function () {
        response = {
          status: 500,
          data: {}
        };
        _axios["default"].put = (0, _promises.rejectPromiseWith)({
          response: response
        });
      });
      test('throws an exception when no user slug is provided', function () {
        expect(function () {
          (0, _users.updateUser)({
            user: {}
          });
        }).toThrow();
      });
      test('throws an exception when no user object is provided', function () {
        expect(function () {
          (0, _users.updateUser)({
            username: 'fake'
          });
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _users.updateUser)({
          username: 'fake',
          user: {}
        }).then(function (_ref11) {
          var error = _ref11.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
  describe('#createUser', function () {
    describe('when successful', function () {
      var response;
      var testUser;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            user: {}
          }
        };
        testUser = new _user_builder.UserBuilder().stub().withAttribute('Attribute', 'value').build();
        response.data.user = testUser;
        _axios["default"].post = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _users.createUser)({
          user: testUser
        }).then(function (_ref12) {
          var error = _ref12.error;
          expect(error).toBeUndefined();
        });
      });
      test('returns a user', function () {
        expect.assertions(1);
        return (0, _users.createUser)({
          user: testUser
        }).then(function (_ref13) {
          var user = _ref13.user;
          expect(user).toMatchObject({
            username: testUser.username,
            displayName: testUser.displayName
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _users.createUser)({
          user: testUser
        }).then(function (_ref14) {
          var user = _ref14.user;
          expect(user.attributes).toBeDefined();
          expect(user.attributes).toBeInstanceOf(Array);
        });
      });
    });
    describe('when unsuccessful', function () {
      var response;
      beforeEach(function () {
        response = {
          status: 500,
          data: {}
        };
        _axios["default"].post = (0, _promises.rejectPromiseWith)({
          response: response
        });
      });
      test('throws an exception when no user object is provided', function () {
        expect(function () {
          (0, _users.createUser)({});
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _users.createUser)({
          user: {}
        }).then(function (_ref15) {
          var error = _ref15.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
  describe('#deleteUser', function () {
    describe('when successful', function () {
      var response;
      var username = 'testuser';
      beforeEach(function () {
        response = {
          status: 200,
          data: {}
        };
        _axios["default"]["delete"] = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _users.deleteUser)({
          username: username
        }).then(function (_ref16) {
          var error = _ref16.error;
          expect(error).toBeUndefined();
        });
      });
    });
    describe('when unsuccessful', function () {
      var response;
      beforeEach(function () {
        response = {
          status: 500,
          data: {}
        };
        _axios["default"]["delete"] = (0, _promises.rejectPromiseWith)({
          response: response
        });
      });
      test('throws an exception when no username is provided', function () {
        expect(function () {
          (0, _users.deleteUser)({});
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _users.deleteUser)({
          username: 'fake'
        }).then(function (_ref17) {
          var error = _ref17.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
});