@vida-global/core 1.2.5 → 1.3.0

package/test/http/client.test.js

@@ -1,26 +1,6 @@
 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();
+const   Helpers      = require('./helpers/client');
 
 
 afterEach(() => {
@@ -28,244 +8,86 @@ afterEach(() => {
 });
 
 
-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}`);
-  });
+beforeEach(() => {
+    Helpers.mockFetchSuccess();
+    logger.info = jest.fn();
 });
 
 
-/***************************************************************************************************
-* 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);
-  });
+describe('HttpClient', () => {
+    describe('HttpClient#urlRoot', () => {
+        it('prepends the url root when overridden', async () => {
+            const client = new Helpers.ClientWithUrlRoot();
 
-  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}`);
-  });
-});
+            await client.post(Helpers.endpoint);
 
+            expect(fetch).toHaveBeenCalledWith(Helpers.apiUrl, expect.any(Object));
+        });
+    });
 
-/***************************************************************************************************
-* 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",
-          }
-      }
+    const httpMethods = [
+        ['post',   'POST',   { supportsBody: true }],
+        ['put',    'PUT',    { supportsBody: true }],
+        ['get',    'GET',    { supportsParams: true }],
+        ['delete', 'DELETE', { supportsParams: true }],
+    ];
+    describe.each(httpMethods)('HttpClient#%s', (methodName, httpMethod, behavior) => {
+        const client = new HttpClient();
 
-      await client.get(apiUrl);
-      expect(fetch).toHaveBeenCalledTimes(1);
-      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
-  });
+        it ('returns the API result payload and status', async () => {
+            const result = await client[methodName](Helpers.apiUrl);
 
-  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(result).toEqual({ data: Helpers.responsePayload, status: 200 });
+        });
 
-      expect(fetch).toHaveBeenCalledWith(expectedUrl, expect.any(Object));
-  });
+        it ('calls fetch with default headers', async () => {
+            await client[methodName](Helpers.apiUrl);
 
-  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
-          },
-      }
+            const expectedBody = behavior.supportsBody ? {} : undefined;
+            Helpers.expectRequest(httpMethod, Helpers.apiUrl, { body: expectedBody });
+        });
 
-      await client.get(apiUrl, { headers });
-      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
-  });
+        it ('merges additional headers', async () => {
+            const headers = Helpers.randomPayload();
 
-  it ('logs api requests', async () => {
-    await client.get(apiUrl);
-    expect(logger.info).toHaveBeenCalledTimes(1);
-    expect(logger.info).toHaveBeenCalledWith(`API CALL: GET ${apiUrl}`);
-  });
-});
+            await client[methodName](Helpers.apiUrl, { headers });
 
+            const expectedBody = behavior.supportsBody ? {} : undefined;
+            Helpers.expectRequest(httpMethod, Helpers.apiUrl, { headers, body: expectedBody });
+        });
 
-/***************************************************************************************************
-* 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 ('logs API requests', async () => {
+            await client[methodName](Helpers.apiUrl);
 
-  it ('calls fetch with the provided url and default params', async () => {
-      const expectedRequestParams = {
-          method: 'DELETE',
-          headers: {
-              Accept: "application/json",
-              "Content-Type": "application/json",
-          }
-      }
+            expect(logger.info).toHaveBeenCalledTimes(1);
+            expect(logger.info).toHaveBeenCalledWith(`API CALL: ${httpMethod} ${Helpers.apiUrl}`);
+        });
 
-      await client.delete(apiUrl);
-      expect(fetch).toHaveBeenCalledTimes(1);
-      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
-  });
+        if (behavior.supportsBody) {
+            it('serializes and sends request body', async () => {
+                const body = Helpers.randomPayload();
 
-  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 });
+                await client[methodName](Helpers.apiUrl, { body });
 
-      expect(fetch).toHaveBeenCalledWith(expectedUrl, expect.any(Object));
-  });
+                expect(fetch).toHaveBeenCalledWith(
+                    Helpers.apiUrl,
+                    expect.objectContaining({ body: JSON.stringify(body) }),
+                );
+            });
+        }
 
-  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
-          },
-      }
+        if (behavior.supportsParams) {
+            it('adds request params to url', async () => {
+                const requestParams = {
+                    first: 'one',
+                    second: 'two',
+                };
 
-      await client.delete(apiUrl, { headers });
-      expect(fetch).toHaveBeenCalledWith(apiUrl, expectedRequestParams);
-  });
+                await client[methodName](Helpers.apiUrl, { requestParams });
 
-  it ('logs api requests', async () => {
-    await client.delete(apiUrl);
-    expect(logger.info).toHaveBeenCalledTimes(1);
-    expect(logger.info).toHaveBeenCalledWith(`API CALL: DELETE ${apiUrl}`);
-  });
+                expect(fetch).toHaveBeenCalledWith(`${Helpers.apiUrl}?first=one&second=two`, expect.any(Object));
+            });
+        }
+    });
 });

package/test/http/error.test.js

@@ -1,71 +1,47 @@
-const { HttpError } = require('../../lib/http/error');
-const   TestHelpers = require('@vida-global/test-helpers');
+const { HttpError }                          = require('../../lib/http/error');
+const   TestHelpers                          = require('@vida-global/test-helpers');
+const { buildRequestPayload, buildResponse } = require('./helpers/error');
 
-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);
+let response;
+let requestPayload;
+let error;
+
+beforeEach(() => {
+    response       = buildResponse();
+    requestPayload = buildRequestPayload();
+    error          = new HttpError(response, requestPayload);
+});
 
 
 describe('HttpError', () => {
-    it ('returns the status code in the message', () => {
+    it ('sets the status code in the message', () => {
         expect(error.message).toEqual(`HTTP Error: ${response.status}`);
     });
 
-    it ('returns the response status code as the status', () => {
+    it ('exposes core response metadata', () => {
         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', () => {
+    it ('stores copies of headers and request payload', () => {
         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 ('parses json text bodies', async () => {
+        response.text = () => '{"ok":true,"nested":{"count":1}}';
+
+        await expect(error.data()).resolves.toEqual({ ok: true, nested: { count: 1 } });
     });
 
-    it ('returns text when the body is not JSON', async () => {
+    it ('falls back to raw text when parsing fails', async () => {
         const text = TestHelpers.Faker.Text.randomString();
-        response.text  = () => text;
-        const data = await error.data();
-        expect(data).toEqual(text);
+        response.text = () => text;
+
+        await expect(error.data()).resolves.toEqual(text);
     });
 });

package/test/http/helpers/client.js

@@ -0,0 +1,80 @@
+const { HttpClient } = require('../../../lib/http/client');
+const   TestHelpers  = require('@vida-global/test-helpers');
+
+
+/***************************************************************************************************
+* VARIABLES / VARIABLE GENERATION
+***************************************************************************************************/
+const randomPayload = () => {
+    return {
+        [TestHelpers.Faker.Text.randomString()]: Math.random(),
+    };
+}
+
+
+const baseUrl          = `https://${TestHelpers.Faker.Text.randomString()}.com`.toLowerCase();
+const endpoint         = `/${TestHelpers.Faker.Text.randomString()}`;
+const apiUrl           = `${baseUrl}${endpoint}`;
+const responsePayload  = randomPayload();
+
+
+class ClientWithUrlRoot extends HttpClient {
+    get urlRoot() {
+        return baseUrl;
+    }
+}
+
+
+/***************************************************************************************************
+* MOCKS
+***************************************************************************************************/
+const mockFetchSuccess = () => {
+    global.fetch = jest.fn().mockResolvedValue({
+        json: jest.fn().mockResolvedValue(responsePayload),
+        status: 200,
+    });
+}
+
+
+/***************************************************************************************************
+* ASSERTIONS
+***************************************************************************************************/
+function expectRequest(method, expectedUrl, options = {}) {
+    const expectedRequest = buildExpectedRequest({
+        method,
+        headers: options.headers,
+        body: options.body,
+    });
+
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(expectedUrl, expectedRequest);
+}
+
+
+function buildExpectedRequest({ method, headers, body }) {
+    const request = {
+        method,
+        headers: {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            ...(headers || {}),
+        },
+    };
+
+    if (body !== undefined) {
+        request.body = JSON.stringify(body);
+    }
+
+    return request;
+}
+
+
+module.exports = {
+    apiUrl,
+    ClientWithUrlRoot,
+    endpoint,
+    expectRequest,
+    mockFetchSuccess,
+    randomPayload,
+    responsePayload,
+};

package/test/http/helpers/error.js

@@ -0,0 +1,31 @@
+const TestHelpers = require('@vida-global/test-helpers');
+
+
+function buildResponse(overrides = {}) {
+    return {
+        headers: {
+            requestId: TestHelpers.Faker.Text.randomString(),
+            traceId: TestHelpers.Faker.Text.randomString(),
+        },
+        status: Math.floor(Math.random() * 500) + 100,
+        statusText: TestHelpers.Faker.Text.randomString(),
+        url: TestHelpers.Faker.Text.randomString(),
+        ...overrides,
+    };
+}
+
+
+function buildRequestPayload() {
+    return {
+        foo: TestHelpers.Faker.Text.randomString(),
+        nested: {
+            bar: TestHelpers.Faker.Text.randomString(),
+        },
+    };
+}
+
+
+module.exports = {
+    buildRequestPayload,
+    buildResponse,
+}

package/test/server/helpers/autoload/TmpWithHelpersController.js

@@ -0,0 +1,17 @@
+const InstanceMethods = {
+    anInstanceMethod: jest.fn()
+}
+
+
+const Accessors = {
+    aProperty: {
+        get: jest.fn(),
+        set: jest.fn()
+    }
+}
+
+
+module.exports = {
+    Accessors,
+    InstanceMethods
+}

package/test/server/helpers/serverController.js

@@ -0,0 +1,13 @@
+const TestHelpers = require('@vida-global/test-helpers');
+
+
+const randomPayload = () => {
+    return {
+        [TestHelpers.Faker.Text.randomString()]: Math.random(),
+    };
+}
+
+
+module.exports = {
+    randomPayload
+}