@vida-global/core 1.2.4 → 1.3.0

package/test/server/serverController.test.js

@@ -1,10 +1,11 @@
-const { ValidationError,
-        VidaServerController } = require('../../lib/server');
 const { BarController }        = require('./helpers/controllers/barController');
 const { FooController }        = require('./helpers/controllers/fooController');
 const { camelize }             = require('inflection');
+const   Errors                 = require('../../lib/server/errors');
+const { logger }               = require('../../lib/logger');
+const { randomPayload }        = require('./helpers/serverController');
 const   TestHelpers            = require('@vida-global/test-helpers');
-
+const { VidaServerController } = require('../../lib/server');
 
 describe('VidaServerController', () => {
     describe('VidaServerController.actionNames', () => {
@@ -22,23 +23,93 @@ describe('VidaServerController', () => {
     });
 
 
+    describe('VidaServerController.autoLoadHelpers', () => {
+        class AutoLoadTestController extends VidaServerController {
+            static get autoLoadHelperPath() {
+                return `${process.cwd()}/test/server/helpers/autoload/${this.name}.js`;
+            }
+        }
+
+        it ('does nothing if there is no helper', () => {
+            class TmpController extends AutoLoadTestController {}
+            TmpController.autoLoadHelpers();
+            expect(TmpController.anInstanceMethod).toBe(undefined);
+            expect(TmpController.aProperty).toBe(undefined);
+        });
+
+        it ('loads instance methods and accessors from the helper', () => {
+            class TmpWithHelpersController extends AutoLoadTestController {}
+            TmpWithHelpersController.autoLoadHelpers();
+
+            const { InstanceMethods, Accessors } = require('./helpers/autoload/TmpWithHelpersController');
+
+            expect(InstanceMethods.anInstanceMethod).not.toHaveBeenCalled();
+            expect(Accessors.aProperty.get).not.toHaveBeenCalled();
+            expect(Accessors.aProperty.set).not.toHaveBeenCalled();
+
+            const controller = new TmpWithHelpersController({}, {});
+            controller.anInstanceMethod();
+            expect(InstanceMethods.anInstanceMethod).toHaveBeenCalledTimes(1);
+
+            controller.aProperty;
+            expect(Accessors.aProperty.get).toHaveBeenCalledTimes(1);
+
+            controller.aProperty = 'foo';
+            expect(Accessors.aProperty.set).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
     describe('VidaServerController._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:   '/foo/fooBar',
+              path:   '/users/fooBar',
               action: 'getFooBar'
             }
-            expect(FooController._constructAction('getFooBar', '')).toEqual(expected);
+            expect(UsersController._constructAction('getFooBar', '')).toEqual(expected);
         });
 
         it ('uses a blank path for index actions', () => {
             const expected   = {
               method: 'POST',
-              path:   '/foo',
+              path:   '/users',
               action: 'postIndex'
             }
-            expect(FooController._constructAction('postIndex', '')).toEqual(expected);
+            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', () => {
@@ -47,7 +118,7 @@ describe('VidaServerController', () => {
               path:   '/baz/:id/ban',
               action: 'getBazBan'
             }
-            expect(FooController._constructAction('getBazBan', '')).toEqual(expected);
+            expect(UsersController._constructAction('getBazBan', '')).toEqual(expected);
         });
     });
 
@@ -98,7 +169,7 @@ describe('VidaServerController', () => {
             validator1.mockImplementation(() => error1);
             await expect(async () => {
                 await controller.validateParameters(validations);
-            }).rejects.toThrow(ValidationError);
+            }).rejects.toThrow(Errors.ValidationError);
         });
 
         it ('throws a `ValidationError` when there are multiple errors', async () => {
@@ -107,7 +178,7 @@ describe('VidaServerController', () => {
 
             await expect(async () => {
                 await controller.validateParameters(validations);
-            }).rejects.toThrow(ValidationError);
+            }).rejects.toThrow(Errors.ValidationError);
         });
 
         it ('sets nothing when there is no error', () => {
@@ -243,9 +314,284 @@ describe('VidaServerController', () => {
             expect(result).toBe(undefined);
         });
 
-        it ('returns undefiend when passed a valid value', () => {
+        it ('returns an error when the function returns an error', () => {
             const result = controller.validateFunction(Math.random(), validator);
             expect(result).toBe(error);
         });
     });
+
+
+    describe('VidaServerController.validateRegex', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns undefined when the value matches the pattern', () => {
+            const result = controller.validateRegex('foo', /oo/)
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns an error when the value does not match the pattern', () => {
+            const result = controller.validateRegex('bar', /oo/)
+            expect(result).toBe(`must match the pattern /oo/`);
+        });
+
+        it ('returns an error when the value is null', () => {
+            const result = controller.validateRegex(null, /oo/)
+            expect(result).toBe(`must match the pattern /oo/`);
+        });
+
+        it ('returns an error when the value is undefined', () => {
+            const result = controller.validateRegex(undefined, /oo/)
+            expect(result).toBe(`must match the pattern /oo/`);
+        });
+
+        it ('returns an error when the value is an object', () => {
+            const result = controller.validateRegex({}, /oo/)
+            expect(result).toBe(`must match the pattern /oo/`);
+        });
+    });
+
+
+    describe('VidaServerController#performRequest', () => {
+        const errorHandlers = [
+            ['renderUnauthorizedResponse', 'AuthorizationError'],
+            ['renderForbiddenResponse',    'ForbiddenError'],
+            ['renderNotFoundResponse',     'NotFoundError'],
+            ['renderErrors',               'ValidationError'],
+        ]
+
+        it.each(errorHandlers)('calls %s when %s is thrown', async (handlerName, errorClsName) => {
+            const controller = new FooController({}, {});
+            const message    = TestHelpers.Faker.Text.randomString();
+            const error      = new Errors[errorClsName](message);
+            if (handlerName == 'renderErrors') error.errors = randomPayload();
+
+            controller[handlerName] = jest.fn();
+            controller.testAction   = () => { throw error };
+            await controller.performRequest('testAction');
+
+            expect(controller[handlerName]).toHaveBeenCalledTimes(1);
+            if (handlerName == 'renderErrors') {
+                expect(controller[handlerName]).toHaveBeenCalledWith(message, error.errors);
+            } else {
+                expect(controller[handlerName]).toHaveBeenCalledWith(message);
+            }
+        });
+
+        it ('throws a 500 if there is a non standard error thrown', async () => {
+            const controller = new FooController({}, {});
+            const message    = TestHelpers.Faker.Text.randomString();
+
+            controller.testAction   = () => { throw new Error(message) };
+            controller.render       = jest.fn();
+            await controller.performRequest('testAction');
+
+            expect(controller.statusCode).toEqual(500);
+            expect(controller.render).toHaveBeenCalledWith({error: message});
+        });
+    });
+
+
+    describe('Rendering', () => {
+        let controller;
+        let response;
+        beforeEach(() => {
+            response          = {json: jest.fn(), statusCode: 200};
+            controller        = new FooController({}, response);
+            controller.render = jest.fn();
+        });
+
+        
+        describe('VidaServerController#renderErrors', () => {
+            it ('returns a 400 response', async () => {
+                await controller.renderErrors();
+                expect(response.statusCode).toBe(400);
+            })
+
+            it ('includes a blank message and blank fields by default', async () => {
+                await controller.renderErrors();
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {}}});
+            })
+
+            it ('includes a provided message', async () => {
+                const msg = TestHelpers.Faker.Text.randomString();
+                await controller.renderErrors(msg);
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg, fields: {}}});
+            });
+
+            it ('includes provided field data', async () => {
+                const field1 = TestHelpers.Faker.Text.randomString();
+                const msg1   = TestHelpers.Faker.Text.randomString();
+                const msg2   = TestHelpers.Faker.Text.randomString();
+                await controller.renderErrors(null, {[field1]: [msg1, msg2]});
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {[field1]: [msg1, msg2]}}});
+            });
+
+            it ('includes provided message field data', async () => {
+                const field1 = TestHelpers.Faker.Text.randomString();
+                const msg1   = TestHelpers.Faker.Text.randomString();
+                const msg2   = TestHelpers.Faker.Text.randomString();
+                const msg3   = TestHelpers.Faker.Text.randomString();
+                await controller.renderErrors(msg1, {[field1]: [msg2, msg3]});
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg1, fields: {[field1]: [msg2, msg3]}}});
+            });
+
+            it ('uses the first parameter as fields if it is an object', async () => {
+                const field1 = TestHelpers.Faker.Text.randomString();
+                const msg1   = TestHelpers.Faker.Text.randomString();
+                const msg2   = TestHelpers.Faker.Text.randomString();
+                await controller.renderErrors({[field1]: [msg1, msg2]});
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {[field1]: [msg1, msg2]}}});
+            });
+
+            it ('converts single field error messages to arrays', async () => {
+                const field1 = TestHelpers.Faker.Text.randomString();
+                const msg1   = TestHelpers.Faker.Text.randomString();
+                await controller.renderErrors({[field1]: msg1});
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: null, fields: {[field1]: [msg1]}}});
+            });
+        });
+
+        
+        describe('VidaServerController#renderUnauthorizedResponse', () => {
+            it ('returns a 401 response', async () => {
+                await controller.renderUnauthorizedResponse();
+                expect(response.statusCode).toBe(401);
+            })
+
+            it ('includes a blank message by default', async () => {
+                await controller.renderUnauthorizedResponse();
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({message: null});
+            })
+
+            it ('includes a provided message', async () => {
+                const msg = TestHelpers.Faker.Text.randomString();
+                await controller.renderUnauthorizedResponse(msg);
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({message: msg});
+            });
+        });
+
+        
+        describe('VidaServerController#renderForbiddenResponse', () => {
+            it ('returns a 403 response', async () => {
+                await controller.renderForbiddenResponse();
+                expect(response.statusCode).toBe(403);
+            })
+
+            it ('includes a blank message by default', async () => {
+                await controller.renderForbiddenResponse();
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({message: null});
+            })
+
+            it ('includes a provided message', async () => {
+                const msg = TestHelpers.Faker.Text.randomString();
+                await controller.renderForbiddenResponse(msg);
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({message: msg});
+            });
+        });
+
+
+        describe('VidaServerController#renderNotFoundResponse', () => {
+            it ('returns a 404 response', async () => {
+                await controller.renderNotFoundResponse();
+                expect(response.statusCode).toBe(404);
+            })
+
+            it ('includes a blank message by default', async () => {
+                await controller.renderNotFoundResponse();
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({message: null});
+            })
+
+            it ('includes a provided message', async () => {
+                const msg = TestHelpers.Faker.Text.randomString();
+                await controller.renderNotFoundResponse(msg);
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith({message: msg});
+            });
+        });
+    });
+
+
+    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('VidaServerController#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('VidaServerController#responseHeaders', () => {
+            it ('returns the request headers', () => {
+                expect(controller.responseHeaders).toBe(response.headers);
+            });
+        });
+
+
+        describe('VidaServerController#contentType', () => {
+            it ('returns the content-type request header', () => {
+                expect(controller.contentType).toEqual(request.headers['content-type']);
+            });
+        });
+
+
+        describe('VidaServerController#logger', () => {
+            it ('uses the standard logger', () => {
+                expect(controller.logger).toBe(logger);
+            });
+        });
+
+
+        describe('VidaServerController#rendered', () => {
+            it ('returns false if nothing has rendered', () => {
+                expect(controller.rendered).toBeFalsy();
+            });
+
+            it ('returns true if something has rendered', async () => {
+                expect(controller.rendered).toBeFalsy();
+                await controller.render({});
+                expect(controller.rendered).toBeTruthy();
+            });
+
+            it ('returns true if markRendered has been called', () => {
+                expect(controller.rendered).toBeFalsy();
+                controller.markRendered();
+                expect(controller.rendered).toBeTruthy();
+            });
+        });
+
+
+        describe('VidaServerController#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);
+            });
+        });
+    });
 });

package/test/active_record/db/connection.test.js

@@ -1,221 +0,0 @@
-const { Connection }              = require('../../../lib/active_record/db/connection');
-const { ConnectionConfiguration } = require('../../../lib/active_record/db/connectionConfiguration');
-const   TestHelpers               = require('@vida-global/test-helpers');
-
-
-jest.mock('sequelize', () => {
-    class MockSequelize {
-        constructor(_1, _2, _3, options) {
-            this.options = options;
-        }
-
-        transaction = jest.fn(callback => callback())
-        close       = jest.fn();
-    }
-    return {Sequelize: MockSequelize};
-});
-
-
-let spy;
-const origEnv = process.env.NODE_ENV;
-afterEach(() => {
-    if (spy) spy.mockRestore();
-    spy = null;
-    Connection.clearConnectionsCache();
-    process.env.NODE_ENV = origEnv;
-});
-
-
-const config1 = {
-    database: TestHelpers.Faker.Text.randomString(),
-    host:     TestHelpers.Faker.Text.randomString(),
-    password: TestHelpers.Faker.Text.randomString(),
-    port:     Math.random(),
-    username: TestHelpers.Faker.Text.randomString(),
-    pool:     {
-        min: Math.random(),
-        max: Math.random(),
-    }
-}
-
-const config2 = {
-    database: TestHelpers.Faker.Text.randomString(),
-    host:     TestHelpers.Faker.Text.randomString(),
-    password: TestHelpers.Faker.Text.randomString(),
-    port:     Math.random(),
-    username: TestHelpers.Faker.Text.randomString()
-}
-
-const config3 = {
-    database: TestHelpers.Faker.Text.randomString(),
-    host:     TestHelpers.Faker.Text.randomString(),
-    password: TestHelpers.Faker.Text.randomString(),
-    port:     Math.random(),
-    ssl:      true,
-    username: TestHelpers.Faker.Text.randomString()
-}
-
-const sqliteConfig = {
-    dialect: 'sqlite'
-};
-
-const databaseId1 = TestHelpers.Faker.Text.randomString();
-const databaseId2 = TestHelpers.Faker.Text.randomString();
-
-
-describe('Connection', () => {
-    beforeEach(() => {
-        spy = jest.spyOn(ConnectionConfiguration, '_fetchAllConfigs');
-        spy.mockImplementation(() => ({
-            default:       {test: config1, development: config1, production: config1},
-            [databaseId1]: {test: config2, production: {}},
-            [databaseId2]: {test: config3, production: {}},
-            sqlite:        {test: sqliteConfig}
-        }));
-    });
-
-    describe('Connection#_sequelize', () => {
-        it ('caches the connection to the same database', () => {
-            const conn1 = new Connection();
-            const conn2 = new Connection();
-            expect(conn1._sequelize).toBe(conn2._sequelize);
-        });
-
-        it ('does not cache connections to different databases', () => {
-            const conn1 = new Connection();
-            const conn2 = new Connection(databaseId1);
-            expect(conn1._sequelize).not.toBe(conn2._sequelize);
-        });
-
-        describe('settings (postgres)', () => {
-            it ('sets the connection settings to the correct values', () => {
-                const conn1 = new Connection();
-                expect(conn1._sequelize.options.database).toEqual(config1.database);
-                expect(conn1._sequelize.options.dialect).toEqual('postgres');
-                expect(conn1._sequelize.options.host).toEqual(config1.host);
-                expect(conn1._sequelize.options.password).toEqual(config1.password);
-                expect(conn1._sequelize.options.port).toEqual(config1.port);
-                expect(conn1._sequelize.options.username).toEqual(config1.username);
-
-                const conn2 = new Connection(databaseId1);
-                expect(conn2._sequelize.options.database).toEqual(config2.database);
-                expect(conn2._sequelize.options.dialect).toEqual('postgres');
-                expect(conn2._sequelize.options.host).toEqual(config2.host);
-                expect(conn2._sequelize.options.password).toEqual(config2.password);
-                expect(conn2._sequelize.options.port).toEqual(config2.port);
-                expect(conn2._sequelize.options.username).toEqual(config2.username);
-            });
-
-            it ('requires ssl when the configuration says to', () => {
-                const conn = new Connection(databaseId2);
-                expect(conn._sequelize.options.dialectOptions).toEqual({ssl: {require: true}});
-            });
-
-            it ('enables logging in development', () => {
-                process.env.NODE_ENV = 'development';
-                const conn = new Connection();
-                expect(conn._sequelize.options.logging).toBe(undefined); // undefined defaults to true
-            });
-
-            it ('does not enable logging in production', () => {
-                process.env.NODE_ENV = 'production';
-                const conn = new Connection();
-                expect(conn._sequelize.options.logging).toBeFalsy();
-            });
-
-            it ('sets the connection pool to the configured values', () => {
-                const conn1 = new Connection();
-                expect(conn1._sequelize.options.pool).toEqual(config1.pool);
-
-                const conn2 = new Connection(databaseId1);
-                expect(conn2._sequelize.options.pool).toEqual({min: 0, max: 5})
-            });
-
-            it ('configures the connection to use underscores for columns', () => {
-                const conn = new Connection();
-                expect(conn._sequelize.options.define.underscored).toBeTruthy();
-            });
-
-
-            describe('replication', () => {
-                it ('configures a read and writer when replicas are configured', () => {
-                    const config = {
-                        database: TestHelpers.Faker.Text.randomString(),
-                        host:     TestHelpers.Faker.Text.randomString(),
-                        password: TestHelpers.Faker.Text.randomString(),
-                        port:     Math.random(),
-                        username: TestHelpers.Faker.Text.randomString(),
-                        readers: [
-                            {
-                                database: TestHelpers.Faker.Text.randomString(),
-                                host:     TestHelpers.Faker.Text.randomString(),
-                                password: TestHelpers.Faker.Text.randomString(),
-                                port:     Math.random(),
-                                username: TestHelpers.Faker.Text.randomString(),
-                            },
-                            {
-                                database: TestHelpers.Faker.Text.randomString(),
-                                host:     TestHelpers.Faker.Text.randomString(),
-                                password: TestHelpers.Faker.Text.randomString(),
-                                port:     Math.random(),
-                                username: TestHelpers.Faker.Text.randomString(),
-                            },
-                        ]
-                    }
-                    spy.mockImplementation(() => ({default: {test: config }}));
-                    const conn    = new Connection();
-                    const options = conn._sequelize.options;
-                    expect(options.database).toBe(undefined);
-                    expect(options.dialect).toBe('postgres');
-                    expect(options.host).toBe(undefined);
-                    expect(options.password).toBe(undefined);
-                    expect(options.port).toBe(undefined);
-                    expect(options.username).toBe(undefined);
-
-                    expect(options.replication).toEqual({
-                        write: {
-                            database: config.database,
-                            host:     config.host,
-                            password: config.password,
-                            port:     config.port,
-                            username: config.username,
-                        },
-                        read: config.readers
-                    });
-                });
-            });
-        });
-
-
-        describe('settings (sqlite)', () => {
-            it ('sets the connection settings to the correct values for sqlite', () => {
-                const conn = new Connection('sqlite');
-                expect(conn._sequelize.options.dialect).toEqual('sqlite');
-                expect(conn._sequelize.options.storage).toEqual(`${process.cwd()}/config/db/database.test.sqlite`);
-            });
-        });
-    });
-
-
-    describe('Connection#close', () => {
-        it ('calls close on the underlying sequelize connection', () => {
-            const conn = new Connection();
-            conn._sequelize; // reference it to initiate the connection
-            conn.close();
-            expect(conn._sequelize.close).toHaveBeenCalledTimes(1);
-        });
-    });
-
-
-    describe('Connection.closeAll', () => {
-        it ('calls close on all cached connections', () => {
-            const conn1 = new Connection();
-            const conn2 = new Connection(databaseId1);
-            conn1._sequelize // reference it to initiate the connection
-            conn2._sequelize // reference it to initiate the connection
-            Connection.closeAll();
-            expect(conn1._sequelize.close).toHaveBeenCalledTimes(1);
-            expect(conn2._sequelize.close).toHaveBeenCalledTimes(1);
-        });
-    });
-});