api.js refactor using classes (#250)

Refactor api.js into an api module where endpoint specific models can be imported and used in components.

__tests__/api/base.test.jsx

@@ -0,0 +1,97 @@
+import Base from '../../src/api/Base';
+
+describe('Base', () => {
+  const createPromise = () => Promise.resolve();
+  const mockBaseURL = '/api/v2/organizations/';
+  const mockHttp = ({
+    delete: jest.fn(createPromise),
+    get: jest.fn(createPromise),
+    options: jest.fn(createPromise),
+    patch: jest.fn(createPromise),
+    post: jest.fn(createPromise),
+    put: jest.fn(createPromise)
+  });
+
+  const BaseAPI = new Base(mockHttp, mockBaseURL);
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('create calls http method with expected data', async (done) => {
+    const data = { name: 'test ' };
+    await BaseAPI.create(data);
+
+    expect(mockHttp.post).toHaveBeenCalledTimes(1);
+    expect(mockHttp.post.mock.calls[0][1]).toEqual(data);
+
+    done();
+  });
+
+  test('destroy calls http method with expected data', async (done) => {
+    const resourceId = 1;
+    await BaseAPI.destroy(resourceId);
+
+    expect(mockHttp.delete).toHaveBeenCalledTimes(1);
+    expect(mockHttp.delete.mock.calls[0][0]).toEqual(`${mockBaseURL}${resourceId}/`);
+
+    done();
+  });
+
+  test('read calls http method with expected data', async (done) => {
+    const defaultParams = {};
+    const testParams = { foo: 'bar' };
+
+    await BaseAPI.read(testParams);
+    await BaseAPI.read();
+
+    expect(mockHttp.get).toHaveBeenCalledTimes(2);
+    expect(mockHttp.get.mock.calls[0][1]).toEqual({ params: testParams });
+    expect(mockHttp.get.mock.calls[1][1]).toEqual({ params: defaultParams });
+    done();
+  });
+
+  test('readDetail calls http method with expected data', async (done) => {
+    const resourceId = 1;
+
+    await BaseAPI.readDetail(resourceId);
+
+    expect(mockHttp.get).toHaveBeenCalledTimes(1);
+    expect(mockHttp.get.mock.calls[0][0]).toEqual(`${mockBaseURL}${resourceId}/`);
+    done();
+  });
+
+  test('readOptions calls http method with expected data', async (done) => {
+    await BaseAPI.readOptions();
+
+    expect(mockHttp.options).toHaveBeenCalledTimes(1);
+    expect(mockHttp.options.mock.calls[0][0]).toEqual(`${mockBaseURL}`);
+    done();
+  });
+
+  test('replace calls http method with expected data', async (done) => {
+    const resourceId = 1;
+    const data = { name: 'test ' };
+
+    await BaseAPI.replace(resourceId, data);
+
+    expect(mockHttp.put).toHaveBeenCalledTimes(1);
+    expect(mockHttp.put.mock.calls[0][0]).toEqual(`${mockBaseURL}${resourceId}/`);
+    expect(mockHttp.put.mock.calls[0][1]).toEqual(data);
+
+    done();
+  });
+
+  test('update calls http method with expected data', async (done) => {
+    const resourceId = 1;
+    const data = { name: 'test ' };
+
+    await BaseAPI.update(resourceId, data);
+
+    expect(mockHttp.patch).toHaveBeenCalledTimes(1);
+    expect(mockHttp.patch.mock.calls[0][0]).toEqual(`${mockBaseURL}${resourceId}/`);
+    expect(mockHttp.patch.mock.calls[0][1]).toEqual(data);
+
+    done();
+  });
+});

__tests__/api/organizations.test.jsx

@@ -0,0 +1,36 @@
+import Organizations from '../../src/api/models/Organizations';
+
+describe('OrganizationsAPI', () => {
+  const orgId = 1;
+  const searchParams = { foo: 'bar' };
+  const createPromise = () => Promise.resolve();
+  const mockHttp = ({ get: jest.fn(createPromise) });
+
+  const OrganizationsAPI = new Organizations(mockHttp);
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('read access list calls get with expected params', async (done) => {
+    await OrganizationsAPI.readAccessList(orgId);
+    await OrganizationsAPI.readAccessList(orgId, searchParams);
+
+    expect(mockHttp.get).toHaveBeenCalledTimes(2);
+    expect(mockHttp.get.mock.calls[0]).toContainEqual(`/api/v2/organizations/${orgId}/access_list/`, { params: {} });
+    expect(mockHttp.get.mock.calls[1]).toContainEqual(`/api/v2/organizations/${orgId}/access_list/`, { params: searchParams });
+
+    done();
+  });
+
+  test('read teams calls get with expected params', async (done) => {
+    await OrganizationsAPI.readTeams(orgId);
+    await OrganizationsAPI.readTeams(orgId, searchParams);
+
+    expect(mockHttp.get).toHaveBeenCalledTimes(2);
+    expect(mockHttp.get.mock.calls[0]).toContainEqual(`/api/v2/organizations/${orgId}/teams/`, { params: {} });
+    expect(mockHttp.get.mock.calls[1]).toContainEqual(`/api/v2/organizations/${orgId}/teams/`, { params: searchParams });
+
+    done();
+  });
+});

__tests__/api/root.test.jsx

@@ -0,0 +1,45 @@
+import Root from '../../src/api/models/Root';
+
+describe('RootAPI', () => {
+  const createPromise = () => Promise.resolve();
+  const mockHttp = ({ get: jest.fn(createPromise), post: jest.fn(createPromise) });
+
+  const RootAPI = new Root(mockHttp);
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('login calls get and post with expected content headers', async (done) => {
+    const headers = { 'Content-Type': 'application/x-www-form-urlencoded' };
+
+    await RootAPI.login('username', 'password');
+
+    expect(mockHttp.get).toHaveBeenCalledTimes(1);
+    expect(mockHttp.get.mock.calls[0]).toContainEqual({ headers });
+
+    expect(mockHttp.post).toHaveBeenCalledTimes(1);
+    expect(mockHttp.post.mock.calls[0]).toContainEqual({ headers });
+
+    done();
+  });
+
+  test('login sends expected data', async (done) => {
+    await RootAPI.login('foo', 'bar');
+    await RootAPI.login('foo', 'bar', 'baz');
+
+    expect(mockHttp.post).toHaveBeenCalledTimes(2);
+    expect(mockHttp.post.mock.calls[0]).toContainEqual('username=foo&password=bar&next=%2Fapi%2Fv2%2Fconfig%2F');
+    expect(mockHttp.post.mock.calls[1]).toContainEqual('username=foo&password=bar&next=baz');
+
+    done();
+  });
+
+  test('logout calls expected http method', async (done) => {
+    await RootAPI.logout();
+
+    expect(mockHttp.get).toHaveBeenCalledTimes(1);
+
+    done();
+  });
+});

__tests__/api/teams.test.jsx

@@ -0,0 +1,35 @@
+import Teams from '../../src/api/models/Teams';
+
+describe('TeamsAPI', () => {
+  const teamId = 1;
+  const roleId = 7;
+  const createPromise = () => Promise.resolve();
+  const mockHttp = ({ post: jest.fn(createPromise) });
+
+  const TeamsAPI = new Teams(mockHttp);
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('associate role calls post with expected params', async (done) => {
+    await TeamsAPI.associateRole(teamId, roleId);
+
+    expect(mockHttp.post).toHaveBeenCalledTimes(1);
+    expect(mockHttp.post.mock.calls[0]).toContainEqual(`/api/v2/teams/${teamId}/roles/`, { id: roleId });
+
+    done();
+  });
+
+  test('read teams calls post with expected params', async (done) => {
+    await TeamsAPI.disassociateRole(teamId, roleId);
+
+    expect(mockHttp.post).toHaveBeenCalledTimes(1);
+    expect(mockHttp.post.mock.calls[0]).toContainEqual(`/api/v2/teams/${teamId}/roles/`, {
+      id: roleId,
+      disassociate: true
+    });
+
+    done();
+  });
+});

__tests__/api/users.test.jsx

@@ -0,0 +1,35 @@
+import Users from '../../src/api/models/Users';
+
+describe('UsersAPI', () => {
+  const userId = 1;
+  const roleId = 7;
+  const createPromise = () => Promise.resolve();
+  const mockHttp = ({ post: jest.fn(createPromise) });
+
+  const UsersAPI = new Users(mockHttp);
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('associate role calls post with expected params', async (done) => {
+    await UsersAPI.associateRole(userId, roleId);
+
+    expect(mockHttp.post).toHaveBeenCalledTimes(1);
+    expect(mockHttp.post.mock.calls[0]).toContainEqual(`/api/v2/users/${userId}/roles/`, { id: roleId });
+
+    done();
+  });
+
+  test('read users calls post with expected params', async (done) => {
+    await UsersAPI.disassociateRole(userId, roleId);
+
+    expect(mockHttp.post).toHaveBeenCalledTimes(1);
+    expect(mockHttp.post.mock.calls[0]).toContainEqual(`/api/v2/users/${userId}/roles/`, {
+      id: roleId,
+      disassociate: true
+    });
+
+    done();
+  });
+});