@vida-global/core 1.1.0

package/test/http/client.test.js

@@ -0,0 +1,271 @@
+const { HttpClient } = require('../../lib/http/client');
+const   TestHelpers  = require('@vida-global/test-helpers');
+const { logger }     = require('../../lib/logger');
+
+
+const urlRoot            = `https://${TestHelpers.Faker.Text.randomString()}.com`.toLowerCase();
+const apiEndpoint        = `/${TestHelpers.Faker.Text.randomString()}`
+const apiUrl             = `${urlRoot}${apiEndpoint}`;
+const requestReturnValue = {
+  [TestHelpers.Faker.Text.randomString()]: Math.random()
+};
+
+
+class ClientWithUrlRoot extends HttpClient {
+    get urlRoot() { return urlRoot; }
+}
+
+
+global.fetch = jest.fn().mockReturnValue({
+    json:   () => requestReturnValue,
+    status: 200
+});
+logger.info = jest.fn();
+
+
+afterEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('HttpClient#urlRoot', () => {
+    it ('prepends the url root when overriden', async () => {
+        const client = new ClientWithUrlRoot();
+        await client.post(apiEndpoint);
+        expect(fetch).toHaveBeenCalledWith(apiUrl, expect.any(Object));
+    });
+});
+
+
+/***************************************************************************************************
+* POST
+***************************************************************************************************/
+describe('HttpClient#post', () => {
+  const client = new HttpClient();
+
+  it ('returns the result of the API request', async () => {
+      const res = await client.post(apiUrl);
+      expect(res).toEqual({data: requestReturnValue, status: 200});
+  });
+
+  it ('calls fetch with the provided url and default params', async () => {
+      const expectedRequestParams = {
+          method: 'POST',
+          body: "{}",
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+          }
+      }
+
+      await client.post(apiUrl);
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('includes the provided body in the request', async () => {
+      const body = {[TestHelpers.Faker.Text.randomString()]: Math.random()};
+      await client.post(apiUrl, { body });
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expect.objectContaining({
+          body: JSON.stringify(body)
+      }));
+  });
+
+  it ('includes additional headers', async () => {
+      const headers               = {[TestHelpers.Faker.Text.randomString()]: Math.random()};
+      const expectedRequestParams = {
+          method: 'POST',
+          body: "{}",
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+              ...headers
+          },
+      }
+
+      await client.post(apiUrl, { headers });
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('logs api requests', async () => {
+      await client.post(apiUrl);
+      expect(logger.info).toHaveBeenCalledTimes(1);
+      expect(logger.info).toHaveBeenCalledWith(`API CALL: POST ${apiUrl}`);
+  });
+});
+
+
+/***************************************************************************************************
+* PUT
+***************************************************************************************************/
+describe('HttpClient#put', () => {
+  const client = new HttpClient();
+
+  it ('returns the result of the API request', async () => {
+      const res = await client.put(apiUrl);
+      expect(res).toEqual({data: requestReturnValue, status: 200});
+  });
+
+  it ('calls fetch with the provided url and default params', async () => {
+      const expectedRequestParams = {
+          method: 'PUT',
+          body: "{}",
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+          }
+      }
+
+      await client.put(apiUrl);
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('includes the provided body in the request', async () => {
+      const body = {[TestHelpers.Faker.Text.randomString()]: Math.random()};
+      await client.put(apiUrl, { body });
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expect.objectContaining({
+          body: JSON.stringify(body)
+      }));
+  });
+
+  it ('includes additional headers', async () => {
+      const headers               = {[TestHelpers.Faker.Text.randomString()]: Math.random()};
+      const expectedRequestParams = {
+          method: 'PUT',
+          body: "{}",
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+              ...headers
+          },
+      }
+
+      await client.put(apiUrl, { headers });
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('logs api requests', async () => {
+      await client.put(apiUrl);
+      expect(logger.info).toHaveBeenCalledTimes(1);
+      expect(logger.info).toHaveBeenCalledWith(`API CALL: PUT ${apiUrl}`);
+  });
+});
+
+
+/***************************************************************************************************
+* GET
+***************************************************************************************************/
+describe('HttpClient#get', () => {
+  const client = new HttpClient();
+  it ('returns the result of the API request', async () => {
+      const res = await client.get(apiUrl);
+      expect(res).toEqual({data: requestReturnValue, status: 200});
+  });
+
+  it ('calls fetch with the provided url and default params', async () => {
+      const expectedRequestParams = {
+          method: 'GET',
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+          }
+      }
+
+      await client.get(apiUrl);
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('includes the provided params in the url', async () => {
+    const param1Name    = TestHelpers.Faker.Text.randomString();
+      const param1Value   = TestHelpers.Faker.Text.randomString();
+      const param2Name    = TestHelpers.Faker.Text.randomString();
+      const param2Value   = TestHelpers.Faker.Text.randomString();
+      const requestParams = {[param1Name]: param1Value, [param2Name]: param2Value};
+      const expectedUrl   = `${apiUrl}?${param1Name}=${param1Value}&${param2Name}=${param2Value}`;
+      await client.get(apiUrl, {requestParams });
+
+      expect(fetch).toHaveBeenCalledWith(expectedUrl, expect.any(Object));
+  });
+
+  it ('includes additional headers', async () => {
+      const headers               = {[TestHelpers.Faker.Text.randomString()]: Math.random()};
+      const expectedRequestParams = {
+          method: 'GET',
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+              ...headers
+          },
+      }
+
+      await client.get(apiUrl, { headers });
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('logs api requests', async () => {
+    await client.get(apiUrl);
+    expect(logger.info).toHaveBeenCalledTimes(1);
+    expect(logger.info).toHaveBeenCalledWith(`API CALL: GET ${apiUrl}`);
+  });
+});
+
+
+/***************************************************************************************************
+* DELETE
+***************************************************************************************************/
+describe('HttpClient#delete', () => {
+  const client = new HttpClient();
+  it ('returns the result of the API request', async () => {
+      const res = await client.delete(apiUrl);
+      expect(res).toEqual({data: requestReturnValue, status: 200});
+  });
+
+  it ('calls fetch with the provided url and default params', async () => {
+      const expectedRequestParams = {
+          method: 'DELETE',
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+          }
+      }
+
+      await client.delete(apiUrl);
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('includes the provided params in the url', async () => {
+    const param1Name    = TestHelpers.Faker.Text.randomString();
+      const param1Value   = TestHelpers.Faker.Text.randomString();
+      const param2Name    = TestHelpers.Faker.Text.randomString();
+      const param2Value   = TestHelpers.Faker.Text.randomString();
+      const requestParams = {[param1Name]: param1Value, [param2Name]: param2Value};
+      const expectedUrl   = `${apiUrl}?${param1Name}=${param1Value}&${param2Name}=${param2Value}`;
+      await client.delete(apiUrl, {requestParams });
+
+      expect(fetch).toHaveBeenCalledWith(expectedUrl, expect.any(Object));
+  });
+
+  it ('includes additional headers', async () => {
+      const headers               = {[TestHelpers.Faker.Text.randomString()]: Math.random()};
+      const expectedRequestParams = {
+          method: 'DELETE',
+          headers: {
+              Accept: "application/json",
+              "Content-Type": "application/json",
+              ...headers
+          },
+      }
+
+      await client.delete(apiUrl, { headers });
+      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
+  });
+
+  it ('logs api requests', async () => {
+    await client.delete(apiUrl);
+    expect(logger.info).toHaveBeenCalledTimes(1);
+    expect(logger.info).toHaveBeenCalledWith(`API CALL: DELETE ${apiUrl}`);
+  });
+});

package/test/http/error.test.js

@@ -0,0 +1,71 @@
+const { HttpError } = require('../../lib/http/error');
+const   TestHelpers = require('@vida-global/test-helpers');
+
+const key1 = TestHelpers.Faker.Text.randomString()
+const key2 = TestHelpers.Faker.Text.randomString()
+const key3 = TestHelpers.Faker.Text.randomString()
+const key4 = TestHelpers.Faker.Text.randomString()
+const key5 = TestHelpers.Faker.Text.randomString()
+const val1 = TestHelpers.Faker.Text.randomString()
+const val2 = TestHelpers.Faker.Text.randomString()
+const val3 = TestHelpers.Faker.Text.randomString()
+const val4 = TestHelpers.Faker.Text.randomString()
+const val5 = TestHelpers.Faker.Text.randomString()
+
+const response = {
+    headers:    {
+        [key1]: val1,
+        [key2]: val2,
+    },
+    status:     Math.random(),
+    statusText: TestHelpers.Faker.Text.randomString(),
+    url:        TestHelpers.Faker.Text.randomString(),
+};
+const requestPayload = {
+  [key3]: val3,
+  [key4]: {[key5]: val5}
+};
+const error = new HttpError(response, requestPayload);
+
+
+describe('HttpError', () => {
+    it ('returns the status code in the message', () => {
+        expect(error.message).toEqual(`HTTP Error: ${response.status}`);
+    });
+
+    it ('returns the response status code as the status', () => {
+        expect(error.status).toEqual(response.status);
+    });
+
+    it ('passes through the status text', () => {
+        expect(error.statusText).toEqual(response.statusText);
+    });
+
+    it ('passes through the url', () => {
+        expect(error.url).toEqual(response.url);
+    });
+
+    it ('passes through a copy of the response headers', () => {
+        expect(error.responseHeaders).toEqual(response.headers);
+        expect(error.responseHeaders).not.toBe(response.headers);
+    });
+
+    it ('passes through a copy of the request payload', () => {
+        expect(error.requestPayload).toEqual(requestPayload);
+        expect(error.requestPayload).not.toBe(requestPayload);
+    });
+
+    it ('converts the response body to JSON if possible', async () => {
+        response.text  = () => `{"${key1}": "${val1}", "${key2}": {"${key3}": "${val3}"}}`;
+        const data     = await error.data();
+        const expected = {[key1]: val1, [key2]: {[key3]: val3}};
+        expect(data).toEqual(expected);
+    });
+
+    it ('returns text when the body is not JSON', async () => {
+        const text = TestHelpers.Faker.Text.randomString();
+        response.text  = () => text;
+        const data = await error.data();
+        expect(data).toEqual(text);
+    });
+});

package/test/release/develop.test.js

@@ -0,0 +1,57 @@
+const { develop } = require('../../lib/release/develop');
+const   Git         = require('../../lib/release/git');
+const   TestHelpers = require('@vida-global/test-helpers');
+const   utils       = require('../../lib/release/utils');
+
+
+jest.mock('../../lib/release/git', () => {
+    return { createBranch: jest.fn(), getCurrentUser: jest.fn() }
+});
+jest.mock('../../lib/release/utils', () => {
+    return { confirmContinue: jest.fn() };
+});
+
+
+let branchType;
+let description;
+let firstName;
+let issueNumber;
+let lastName;
+let sourceBranch;
+beforeEach(() => {
+    jest.resetAllMocks();
+    utils.confirmContinue.mockImplementation(() => true);
+
+    firstName = TestHelpers.Faker.User.randomFirstName();
+    lastName  = TestHelpers.Faker.User.randomLastName();
+    Git.getCurrentUser.mockImplementation(() => `${firstName} ${lastName}`);
+
+    branchType   = TestHelpers.Faker.Text.randomString();
+    sourceBranch = TestHelpers.Faker.Text.randomString();
+    description  = TestHelpers.Faker.Text.randomSentence();
+    issueNumber  = TestHelpers.Faker.Math.randomNumber();
+});
+
+
+describe('develop', () => {
+    it ('confirms and creates a branch once', async () => {
+        await develop(branchType, issueNumber, description, sourceBranch);
+        expect(utils.confirmContinue).toHaveBeenCalledTimes(1);
+        expect(Git.createBranch).toHaveBeenCalledTimes(1);
+    });
+
+    it ('generates the correct branch name', async () => {
+        const initials   = `${firstName[0]}${lastName[0]}`.toLowerCase();
+        const branchName = `${branchType}/${issueNumber}/${initials}/${description.replace(/\s+/g, '-').toLowerCase().replace(/[^a-z0-9-]/g, '')}`;
+        await develop(branchType, issueNumber, description, sourceBranch);
+
+        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to create branch ${branchName}?`);
+        expect(Git.createBranch).toHaveBeenCalledWith(branchName, sourceBranch);
+    });
+
+    it ('does not create a branch if the user does not confirm', async () => {
+        utils.confirmContinue.mockImplementation(() => false);
+        await develop(branchType, issueNumber, description, sourceBranch);
+        expect(Git.createBranch).not.toHaveBeenCalled();
+    });
+});

package/test/release/git.test.js

@@ -0,0 +1,189 @@
+const { execSync }  = require('child_process');
+const   Git         = require('../../lib/release/git');
+const   TestHelpers = require('@vida-global/test-helpers');
+
+
+jest.mock('child_process', () => {
+    const execSync = jest.fn();
+    return { execSync };
+});
+
+
+beforeEach(() => {
+    jest.resetAllMocks();
+});
+
+
+describe('Git.add', () => {
+    it ('calls git add with the file name', () => {
+        const fileName = TestHelpers.Faker.Text.randomString();
+        Git.add(fileName);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git add ${fileName}`);
+    });
+});
+
+
+describe('Git.branches', () => {
+    it ('calls git branch and returns an array of the resulting strings', () => {
+        const b1        = TestHelpers.Faker.Text.randomString();
+        const b2        = TestHelpers.Faker.Text.randomString();
+        const b3        = TestHelpers.Faker.Text.randomString();
+        const branchStr = `    ${b1}  \n    ${b2}\n${b3}    `;
+        execSync.mockImplementation(() => branchStr);
+
+        const branches = Git.branches();
+
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(branches).toEqual([b1, b2, b3]);
+        expect(execSync).toHaveBeenCalledWith(`git branch -r`);
+    });
+
+    it ('does not include the remote option when needed', () => {
+        execSync.mockImplementation(() => '');
+        const branches = Git.branches(false);
+        expect(execSync).toHaveBeenCalledWith(`git branch`);
+    });
+});
+
+
+describe('Git.checkout', () => {
+    it ('calls git checkout with the branch name', () => {
+        const branchName = TestHelpers.Faker.Text.randomString();
+        Git.checkout(branchName);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git checkout ${branchName}`);
+    });
+});
+
+
+describe('Git.commit', () => {
+    it ('calls git commit with comment', () => {
+        const comment = TestHelpers.Faker.Text.randomString();
+        Git.commit(comment);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git commit -m '${comment}'`);
+    });
+});
+
+
+describe('Git.createBranch', () => {
+    it ('creates a branch and switches to it', () => {
+        const branch1 = TestHelpers.Faker.Text.randomString();
+        const branch2 = TestHelpers.Faker.Text.randomString();
+
+        Git.createBranch(branch1, branch2);
+
+        expect(execSync).toHaveBeenCalledTimes(2);
+        expect(execSync).toHaveBeenNthCalledWith(1, `git branch ${branch1} ${branch2}`);
+        expect(execSync).toHaveBeenNthCalledWith(2, `git checkout ${branch1}`);
+    });
+
+    it ('defaults to the primary branch', () => {
+        const branch1 = TestHelpers.Faker.Text.randomString();
+
+        execSync.mockImplementation(() => 'origin/main');
+
+        Git.createBranch(branch1);
+
+        expect(execSync).toHaveBeenCalledTimes(3);
+        expect(execSync).toHaveBeenNthCalledWith(2, `git branch ${branch1} origin/main`);
+    });
+});
+
+
+describe('Git.forceRemotePush', () => {
+    it ('calls git push with the origin', () => {
+        const branch1 = TestHelpers.Faker.Text.randomString();
+        const branch2 = TestHelpers.Faker.Text.randomString();
+
+        Git.forceRemotePush(branch1, branch2);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git push origin origin/${branch1}:${branch2} --force`)
+    });
+});
+
+
+describe('Git.getCurrentUser', () => {
+    it ('returns the result of git config.name', () => {
+        const name = TestHelpers.Faker.User.randomName();
+        execSync.mockImplementation(() => name);
+
+        const response = Git.getCurrentUser();
+
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git config user.name`);
+        expect(response).toEqual(name);
+    });
+});
+
+
+describe('Git.getPrimaryBranch', () => {
+    it ('returns master when that is the primary branch', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `   origin/${branch1}\n  origin/master \n  origin/${branch2}`;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getPrimaryBranch();
+
+        expect(branch).toEqual('origin/master');
+    });
+
+    it ('returns main when that is the primary branch', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `origin/${branch1}\norigin/${branch2}\n  origin/main  `;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getPrimaryBranch();
+
+        expect(branch).toEqual('origin/main');
+    });
+
+    it ('returns undefined when it cannot determine the primary branch', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branch3    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `origin/${branch1}\norigin/${branch2}\n  origin/${branch3}  `;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getPrimaryBranch();
+
+        expect(branch).toBeUndefined();
+    });
+});
+
+
+describe('Git.getCurrentBranch', () => {
+    it ('returns the branch with the *', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branch3    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `   origin/${branch1}\n  *  ${branch3} \n  origin/${branch2}`;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getCurrentBranch();
+
+        expect(branch).toEqual(branch3);
+    });
+});
+
+
+describe('Git.pull', () => {
+    it ('calls git pull with the prune option', () => {
+        Git.pull();
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git pull --prune`);
+    });
+});
+
+
+describe('Git.push', () => {
+    it ('pushes to the current branch', () => {
+        const branch = TestHelpers.Faker.Text.randomString();
+        execSync.mockImplementation(() => `* ${branch}`);
+        Git.push();
+        expect(execSync).toHaveBeenCalledWith(`git push -u origin ${branch}`);
+    });
+});