@kineticdata/react/lib/apis/core/teams.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 _teams = require("./teams");
var _team_builder = require("../../../tests/utils/team_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 'team/app/api/v1';
      },
      kappSlug: function kappSlug() {
        return 'mock-kapp';
      }
    }
  };
});
describe('teams api', function () {
  describe('#fetchTeams', function () {
    describe('when successful', function () {
      var response;
      var testTeam;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            teams: []
          }
        };
        testTeam = new _team_builder.TeamBuilder().stub().withAttribute('Attribute', 'value').build();
        response.data.teams.push(testTeam);
        _axios["default"].get = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _teams.fetchTeams)().then(function (_ref) {
          var error = _ref.error;
          expect(error).toBeUndefined();
        });
      });
      test('returns an array of teams', function () {
        expect.assertions(2);
        return (0, _teams.fetchTeams)().then(function (_ref2) {
          var teams = _ref2.teams;
          expect(teams).toBeInstanceOf(Array);
          expect(teams[0]).toMatchObject({
            name: testTeam.name,
            slug: testTeam.slug
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _teams.fetchTeams)().then(function (_ref3) {
          var teams = _ref3.teams;
          expect(teams[0].attributes).toBeDefined();
          expect(teams[0].attributes).toBeInstanceOf(Array);
        });
      });
    });
  });
  describe('#fetchTeam', function () {
    describe('when successful', function () {
      var response;
      var testTeam;
      var teamSlug;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            team: {}
          }
        };
        testTeam = new _team_builder.TeamBuilder().stub().withAttribute('Attribute', 'value').build();
        teamSlug = testTeam.slug;
        response.data.team = testTeam;
        _axios["default"].get = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _teams.fetchTeam)({
          teamSlug: teamSlug
        }).then(function (_ref4) {
          var error = _ref4.error;
          expect(error).toBeUndefined();
        });
      });
      test('returns a team', function () {
        expect.assertions(1);
        return (0, _teams.fetchTeam)({
          teamSlug: teamSlug
        }).then(function (_ref5) {
          var team = _ref5.team;
          expect(team).toMatchObject({
            name: testTeam.name,
            slug: testTeam.slug
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _teams.fetchTeam)({
          teamSlug: teamSlug,
          xlatAttributes: true
        }).then(function (_ref6) {
          var team = _ref6.team;
          expect(team.attributes).toBeDefined();
          expect(team.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 team slug is provided', function () {
        expect(function () {
          (0, _teams.fetchTeam)({});
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _teams.fetchTeam)({
          teamSlug: 'fake',
          xlatAttributes: true
        }).then(function (_ref7) {
          var error = _ref7.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
  describe('#updateTeam', function () {
    describe('when successful', function () {
      var response;
      var testTeam;
      var teamSlug;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            team: {}
          }
        };
        testTeam = new _team_builder.TeamBuilder().stub().withAttribute('Attribute', 'value').build();
        teamSlug = testTeam.slug;
        response.data.team = testTeam;
        _axios["default"].put = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _teams.updateTeam)({
          teamSlug: teamSlug,
          team: testTeam
        }).then(function (_ref8) {
          var error = _ref8.error;
          expect(error).toBeUndefined();
        });
      });
      test('returns a team', function () {
        expect.assertions(1);
        return (0, _teams.updateTeam)({
          teamSlug: teamSlug,
          team: testTeam
        }).then(function (_ref9) {
          var team = _ref9.team;
          expect(team).toMatchObject({
            slug: testTeam.slug,
            name: testTeam.name
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _teams.updateTeam)({
          teamSlug: teamSlug,
          team: testTeam
        }).then(function (_ref10) {
          var team = _ref10.team;
          expect(team.attributes).toBeDefined();
          expect(team.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 team slug is provided', function () {
        expect(function () {
          (0, _teams.updateTeam)({
            team: {}
          });
        }).toThrow();
      });
      test('throws an uxception when no team object is provided', function () {
        expect(function () {
          (0, _teams.updateTeam)({
            teamSlug: 'fake'
          });
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _teams.updateTeam)({
          teamSlug: 'fake',
          team: {}
        }).then(function (_ref11) {
          var error = _ref11.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
  describe('#createTeam', function () {
    describe('when successful', function () {
      var response;
      var testTeam;
      beforeEach(function () {
        response = {
          status: 200,
          data: {
            team: {}
          }
        };
        testTeam = new _team_builder.TeamBuilder().stub().withAttribute('Attribute', 'value').build();
        response.data.team = testTeam;
        _axios["default"].post = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _teams.createTeam)({
          team: testTeam
        }).then(function (_ref12) {
          var error = _ref12.error;
          expect(error).toBeUndefined();
        });
      });
      test('returns a team', function () {
        expect.assertions(1);
        return (0, _teams.createTeam)({
          team: testTeam
        }).then(function (_ref13) {
          var team = _ref13.team;
          expect(team).toMatchObject({
            slug: testTeam.slug,
            name: testTeam.name
          });
        });
      });
      test('returns attributes', function () {
        expect.assertions(2);
        return (0, _teams.createTeam)({
          team: testTeam
        }).then(function (_ref14) {
          var team = _ref14.team;
          expect(team.attributes).toBeDefined();
          expect(team.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 team object is provided', function () {
        expect(function () {
          (0, _teams.createTeam)({});
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _teams.createTeam)({
          team: {}
        }).then(function (_ref15) {
          var error = _ref15.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
  describe('#deleteTeam', function () {
    describe('when successful', function () {
      var response;
      var teamSlug = 'testteam';
      beforeEach(function () {
        response = {
          status: 200,
          data: {}
        };
        _axios["default"]["delete"] = (0, _promises.resolvePromiseWith)(response);
      });
      test('does not return errors', function () {
        expect.assertions(1);
        return (0, _teams.deleteTeam)({
          teamSlug: teamSlug
        }).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 teamSlug is provided', function () {
        expect(function () {
          (0, _teams.deleteTeam)({});
        }).toThrow();
      });
      test('does return errors', function () {
        expect.assertions(1);
        return (0, _teams.deleteTeam)({
          teamSlug: 'fake'
        }).then(function (_ref17) {
          var error = _ref17.error;
          expect(error).toBeDefined();
        });
      });
    });
  });
});