@vida-global/core 2.0.10 → 2.1.0

package/test/server/controllerMixins/requestDetails.test.js

@@ -0,0 +1,225 @@
+const { FooController } = require('../helpers/controllers/fooController');
+const { randomPayload } = require('../helpers/serverController');
+const   TestHelpers     = require('@vida-global/test-helpers');
+
+
+describe('VidaServerController', () => {
+    describe('Request Properties', () => {
+        let request;
+        let response;
+        let controller;
+
+        beforeEach(() => {
+            request                         = {headers: randomPayload()};
+            response                        = {headers: randomPayload(), statusCode: TestHelpers.Faker.Math.randomNumber(), json: jest.fn()};
+            request.headers['content-type'] = TestHelpers.Faker.Text.randomString();
+            controller                      = new FooController(request, response);
+        });
+
+        describe('#requestHeaders', () => {
+            it ('returns a copy of the request headers', () => {
+                expect(controller.requestHeaders).not.toBe(request.headers);
+                expect(JSON.stringify(controller.requestHeaders)).toEqual(JSON.stringify(request.headers));
+            });
+        });
+
+
+        describe('#responseHeaders', () => {
+            it ('returns the request headers', () => {
+                expect(controller.responseHeaders).toBe(response.headers);
+            });
+        });
+
+
+        describe('#contentType', () => {
+            it ('returns the content-type request header', () => {
+                expect(controller.contentType).toEqual(request.headers['content-type']);
+            });
+        });
+
+
+        describe('#userAgent', () => {
+            it ('returns the user-agent request header', () => {
+                const ua = TestHelpers.Faker.Text.randomString();
+                request.headers['user-agent'] = ua;
+                expect(controller.userAgent).toEqual(ua);
+            });
+        });
+
+
+        describe('#requestBody', () => {
+            it ('returns the underlying request body', () => {
+                const body = {foo: TestHelpers.Faker.Text.randomString()};
+                request.body = body;
+                expect(controller.requestBody).toBe(body);
+            });
+        });
+
+
+        describe('#requestId', () => {
+            it ('returns the request id', () => {
+                request.id = TestHelpers.Faker.Text.randomString();
+                expect(controller.requestId).toEqual(request.id);
+            });
+        });
+
+
+        describe('#requestIp', () => {
+            it ('returns the request ip', () => {
+                request.ip = TestHelpers.Faker.Text.randomString();
+                expect(controller.requestIp).toEqual(request.ip);
+            });
+        });
+
+
+        describe('#requestMethod', () => {
+            it ('returns the request method', () => {
+                request.method = 'POST';
+                expect(controller.requestMethod).toEqual('POST');
+            });
+        });
+
+
+        describe('#url', () => {
+            it ('returns the request originalUrl', () => {
+                request.originalUrl = `/${TestHelpers.Faker.Text.randomString()}`;
+                expect(controller.url).toEqual(request.originalUrl);
+            });
+        });
+
+
+        describe('#statusCode', () => {
+            it ('returns the response status code', () => {
+                expect(controller.statusCode).toEqual(response.statusCode);
+            });
+
+            it ('sets the response status code', () => {
+                const code            = TestHelpers.Faker.Math.randomNumber();
+                controller.statusCode = code;
+                expect(response.statusCode).toEqual(code);
+            });
+        });
+
+
+        describe('#bearerToken', () => {
+            beforeEach(() => {
+                delete request.headers.authorization;
+            });
+
+            it ('returns null when there is no authorization header', () => {
+                expect(controller.bearerToken).toBe(null);
+            });
+
+            it ('returns null when the authorization header is empty', () => {
+                request.headers.authorization = '';
+                expect(controller.bearerToken).toBe(null);
+            });
+
+            it ('returns null when the authorization scheme is not bearer', () => {
+                request.headers.authorization = 'Basic dXNlcjpwYXNz';
+                expect(controller.bearerToken).toBe(null);
+            });
+
+            it ('extracts the token after a lowercase bearer scheme', () => {
+                request.headers.authorization = 'bearer abc123';
+                expect(controller.bearerToken).toBe('abc123');
+            });
+
+            it ('extracts the token regardless of bearer scheme casing', () => {
+                request.headers.authorization = 'Bearer abc123';
+                expect(controller.bearerToken).toBe('abc123');
+
+                const c2 = new FooController({headers: {authorization: 'BEARER xyz'}}, response);
+                expect(c2.bearerToken).toBe('xyz');
+            });
+
+            it ('tolerates leading whitespace and trims trailing whitespace from the token', () => {
+                request.headers.authorization = '   Bearer   tokenValue   ';
+                expect(controller.bearerToken).toBe('tokenValue');
+            });
+        });
+    });
+
+
+    describe('cookies / getCookie / setCookie', () => {
+        let request;
+        let response;
+        let controller;
+
+
+        beforeEach(() => {
+            request    = { cookies: { sessionId: 'abc', theme: 'dark' } };
+            response   = { cookie: jest.fn() };
+            controller = new FooController(request, response);
+        });
+
+
+        describe('#cookies', () => {
+            it ('returns the cookies object from the request', () => {
+                expect(controller.cookies).toEqual({ sessionId: 'abc', theme: 'dark' });
+            });
+
+
+            it ('returns an empty object when request.cookies is undefined', () => {
+                controller = new FooController({}, response);
+                expect(controller.cookies).toEqual({});
+            });
+        });
+
+
+        describe('#getCookie', () => {
+            it ('returns the value for an existing cookie', () => {
+                expect(controller.getCookie('sessionId')).toBe('abc');
+            });
+
+
+            it ('returns null for a missing cookie', () => {
+                expect(controller.getCookie('missing')).toBeNull();
+            });
+
+
+            it ('returns null when name is empty', () => {
+                expect(controller.getCookie('')).toBeNull();
+            });
+
+
+            it ('returns null when name is null', () => {
+                expect(controller.getCookie(null)).toBeNull();
+            });
+        });
+
+
+        describe('#setCookie', () => {
+            it ('invokes response.cookie with the given name, value, and options', () => {
+                const options = { path: '/foo', maxAge: 60000, httpOnly: true, secure: true, sameSite: 'None' };
+                controller.setCookie('sessionId', 'xyz', options);
+                expect(response.cookie).toHaveBeenCalledTimes(1);
+                expect(response.cookie).toHaveBeenCalledWith('sessionId', 'xyz', options);
+            });
+
+
+            it ('defaults options to an empty object', () => {
+                controller.setCookie('sessionId', 'xyz');
+                expect(response.cookie).toHaveBeenCalledWith('sessionId', 'xyz', {});
+            });
+
+
+            it ('coerces null/undefined value to an empty string', () => {
+                controller.setCookie('sessionId', null);
+                expect(response.cookie).toHaveBeenCalledWith('sessionId', '', {});
+            });
+
+
+            it ('is a no-op when name is empty', () => {
+                controller.setCookie('', 'xyz');
+                expect(response.cookie).not.toHaveBeenCalled();
+            });
+
+
+            it ('is a no-op when name is null', () => {
+                controller.setCookie(null, 'xyz');
+                expect(response.cookie).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

package/test/server/controllerMixins/routing.test.js

@@ -0,0 +1,82 @@
+const { FooController }        = require('../helpers/controllers/fooController');
+const { VidaServerController } = require('../../../lib/server/serverController');
+
+
+describe('VidaServerController', () => {
+    describe('.actionNames', () => {
+        it ('returns actions based on method names', () => {
+            const names      = FooController.actionNames;
+            const expected   = ['postIndex',
+                                'getFooBar',
+                                'getBazBan',
+                                'postFooBar',
+                                'putFooBar',
+                                'deleteFooBar',
+                                'patchFooBar'];
+            expect(names).toEqual(expected);
+        });
+    });
+
+
+    describe('._constructAction', () => {
+        class UsersController extends VidaServerController {
+            static get routes() {
+                return {getBazBan: '/baz/:id/ban'};
+            }
+        };
+
+        it ('returns an object with path, method, and action', () => {
+            const expected   = {
+              method: 'GET',
+              path:   '/users/fooBar',
+              action: 'getFooBar'
+            }
+            expect(UsersController._constructAction('getFooBar', '')).toEqual(expected);
+        });
+
+        it ('uses a blank path for index actions', () => {
+            const expected   = {
+              method: 'POST',
+              path:   '/users',
+              action: 'postIndex'
+            }
+            expect(UsersController._constructAction('postIndex', '')).toEqual(expected);
+        });
+
+        it ('creates a single resource route for Record', () => {
+            const expected   = {
+              method: 'GET',
+              path:   '/user/:id',
+              action: 'getRecord'
+            }
+            expect(UsersController._constructAction('getRecord', '')).toEqual(expected);
+        });
+
+        it ('only uses Record when checking for single resource routes', () => {
+            const expected   = {
+              method: 'GET',
+              path:   '/users/recording',
+              action: 'getRecording'
+            }
+            expect(UsersController._constructAction('getRecording', '')).toEqual(expected);
+        });
+
+        it ('creates a single sub resource route for RecordFoo', () => {
+            const expected   = {
+              method: 'GET',
+              path:   '/user/:id/foo',
+              action: 'getRecordFoo'
+            }
+            expect(UsersController._constructAction('getRecordFoo', '')).toEqual(expected);
+        });
+
+        it ('uses a custom path when defined', () => {
+            const expected   = {
+              method: 'GET',
+              path:   '/baz/:id/ban',
+              action: 'getBazBan'
+            }
+            expect(UsersController._constructAction('getBazBan', '')).toEqual(expected);
+        });
+    });
+});