@vida-global/core 1.3.1 → 1.3.3

package/test/server/serverController.test.js

@@ -8,7 +8,7 @@ const   TestHelpers            = require('@vida-global/test-helpers');
 const { VidaServerController } = require('../../lib/server');
 
 describe('VidaServerController', () => {
-    describe('VidaServerController.actionNames', () => {
+    describe('.actionNames', () => {
         it ('returns actions based on method names', () => {
             const names      = FooController.actionNames;
             const expected   = ['postIndex',
@@ -23,7 +23,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.autoLoadHelpers', () => {
+    describe('.autoLoadHelpers', () => {
         class AutoLoadTestController extends VidaServerController {
             static get autoLoadHelperPath() {
                 return `${process.cwd()}/test/server/helpers/autoload/${this.name}.js`;
@@ -60,7 +60,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController._constructAction', () => {
+    describe('._constructAction', () => {
         class UsersController extends VidaServerController {
             static get routes() {
                 return {getBazBan: '/baz/:id/ban'};
@@ -123,7 +123,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateParameters', () => {
+    describe('.validateParameters', () => {
         const paramName1      = TestHelpers.Faker.Text.randomString();
         const paramName2      = TestHelpers.Faker.Text.randomString();
         const value1          = TestHelpers.Faker.Text.randomString();
@@ -165,20 +165,20 @@ describe('VidaServerController', () => {
             expect(validator2).toHaveBeenCalledWith(value1, options2);
         });
 
-        it ('throws a `ValidationError` when there\'s an error', async () => {
+        it ('throws a `ValidationError` when there\'s an error', () => {
             validator1.mockImplementation(() => error1);
-            await expect(async () => {
-                await controller.validateParameters(validations);
-            }).rejects.toThrow(Errors.ValidationError);
+            expect(() => {
+                controller.validateParameters(validations);
+            }).toThrow(Errors.ValidationError);
         });
 
-        it ('throws a `ValidationError` when there are multiple errors', async () => {
+        it ('throws a `ValidationError` when there are multiple errors', () => {
             validator1.mockImplementation(() => error1);
             validator2.mockImplementation(() => error2);
 
-            await expect(async () => {
-                await controller.validateParameters(validations);
-            }).rejects.toThrow(Errors.ValidationError);
+            expect(() => {
+                controller.validateParameters(validations);
+            }).toThrow(Errors.ValidationError);
         });
 
         it ('sets nothing when there is no error', () => {
@@ -186,10 +186,38 @@ describe('VidaServerController', () => {
             expect(controller.render).toHaveBeenCalledTimes(0);
             expect(response.statusCode).toEqual(200);
         });
+
+        it ('ignores details where there is no validator', () => {
+            const validations = {
+                [paramName2]: {[validationType1]: options2, 'foo': true}
+            };
+            controller.validateParameters(validations);
+
+            expect(validator1).toHaveBeenCalledTimes(1);
+            expect(validator1).toHaveBeenCalledWith(value2, options2);
+        });
+
+        it ('does not error when optional parameters are not included', () => {
+            const validations = {foo: {isString: true, optional: true}};
+            expect(() => {
+                controller.validateParameters(validations);
+            }).not.toThrow();
+        });
+
+        it ('does  error when optional parameters are invalid', () => {
+            const validations = {foo: {isString: {length: {gte: 2}}, optional: true}};
+            params.foo = '';
+
+            expect(() => {
+                controller.validateParameters(validations);
+            }).toThrow(Errors.ValidationError);
+
+            delete params.foo;
+        });
     });
 
 
-    describe('VidaServerController.validatePresence', () => {
+    describe('.validatePresence', () => {
         const controller = new FooController({}, {});
         it ('returns undefined when there is a value', () => {
             const result = controller.validatePresence(TestHelpers.Faker.Text.randomString());
@@ -203,7 +231,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateIsInteger', () => {
+    describe('.validateIsInteger', () => {
         const controller = new FooController({}, {});
         it ('returns undefined when there is an integer', () => {
             const val    = Math.ceil(Math.random() * 100);
@@ -230,6 +258,21 @@ describe('VidaServerController', () => {
             expect(result).toEqual('must be an integer');
         });
 
+        it ('returns an error when the value is null', () => {
+            const result = controller.validateIsInteger(null)
+            expect(result).toEqual('must be an integer');
+        });
+
+        it ('returns an error when the value is undefined', () => {
+            const result = controller.validateIsInteger(undefined)
+            expect(result).toEqual('must be an integer');
+        });
+
+        it ('returns an error when the value is an object', () => {
+            const result = controller.validateIsInteger({})
+            expect(result).toEqual('must be an integer');
+        });
+
         it ('returns an error when the number is less than the gte option', () => {
             const result = controller.validateIsInteger(1, {gte: 2});
             expect(result).toEqual('must be greater than or equal to 2');
@@ -244,10 +287,116 @@ describe('VidaServerController', () => {
             const result = controller.validateIsInteger(2, {gte: 2});
             expect(result).toEqual(undefined);
         });
+
+        it ('returns an error when the number is greater than the lte option', () => {
+            const result = controller.validateIsInteger(3, {lte: 2});
+            expect(result).toEqual('must be less than or equal to 2');
+        });
+
+        it ('returns undefined when the number is less than the lte option', () => {
+            const result = controller.validateIsInteger(1, {lte: 2});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when the number is equal to the lte option', () => {
+            const result = controller.validateIsInteger(2, {lte: 2});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('supports both the lte and gte options', () => {
+            let result = controller.validateIsInteger(1, {lte: 2, gte: 0});
+            expect(result).toEqual(undefined);
+
+            result = controller.validateIsInteger(-1, {lte: 2, gte: 0});
+            expect(result).toEqual('must be greater than or equal to 0');
+
+            result = controller.validateIsInteger(3, {lte: 2, gte: 0});
+            expect(result).toEqual('must be less than or equal to 2');
+        });
     });
 
 
-    describe('VidaServerController.validateIsDateTime', () => {
+    describe('.validateIsString', () => {
+        const controller = new FooController({}, {});
+        it ('returns undefined when there is an string', () => {
+            const result = controller.validateIsString('')
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns an error when there is a number', () => {
+            const result = controller.validateIsString(Math.random());
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the value is null', () => {
+            const result = controller.validateIsString(null)
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the value is undefined', () => {
+            const result = controller.validateIsString(undefined)
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the value is an object', () => {
+            const result = controller.validateIsString({})
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the length is fewer than the gte option', () => {
+            const result = controller.validateIsString('f', {length: {gte: 2}});
+            expect(result).toEqual('must be greater than or equal to 2 characters');
+        });
+
+        it ('returns undefined when the length is greater than the gte option', () => {
+            const result = controller.validateIsString('foo', {length: {gte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when the length is equal to the gte option', () => {
+            const result = controller.validateIsString('fo', {length: {gte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns an error when the length is greater than the lte option', () => {
+            const result = controller.validateIsString('foo', {length: {lte: 2}});
+            expect(result).toEqual('must be fewer than or equal to 2 characters');
+        });
+
+        it ('returns undefined when the length is fewer than the lte option', () => {
+            const result = controller.validateIsString('f', {length: {lte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when the length is equal to the lte option', () => {
+            const result = controller.validateIsString('fo', {length: {lte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('supports both the lte and gte options', () => {
+            let result = controller.validateIsString('fo', {length: {lte: 3, gte: 1}});
+            expect(result).toEqual(undefined);
+
+            result = controller.validateIsString('', {length: {lte: 3, gte: 1}});
+            expect(result).toEqual('must be greater than or equal to 1 characters');
+
+            result = controller.validateIsString('foobar', {length: {lte: 3, gte: 1}});
+            expect(result).toEqual('must be fewer than or equal to 3 characters');
+        });
+
+        it ('returns undefined when the value matches the pattern', () => {
+            const result = controller.validateIsString('foo', {regex: /oo/})
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns an error when the value does not match the pattern', () => {
+            const result = controller.validateIsString('bar', {regex: /oo/})
+            expect(result).toBe(`must match /oo/`);
+        });
+    });
+
+
+    describe('.validateIsDateTime', () => {
         const controller = new FooController({}, {});
         it ('returns undefined when passed a string of format YYYY-MM-DD', () => {
             const result = controller.validateIsDateTime('2025-12-17');
@@ -286,7 +435,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateIsEnum', () => {
+    describe('.validateIsEnum', () => {
         const controller = new FooController({}, {});
         const enums      = [Math.random(), Math.random(), Math.random()];
         const error      = TestHelpers.Faker.Text.randomString();
@@ -303,7 +452,7 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateFunction', () => {
+    describe('.validateFunction', () => {
         const controller   = new FooController({}, {});
         const correctValue = Math.random();
         const error        = TestHelpers.Faker.Text.randomString();
@@ -321,37 +470,7 @@ describe('VidaServerController', () => {
     });
 
 
-    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', () => {
+    describe('#performRequest', () => {
         const errorHandlers = [
             ['renderUnauthorizedResponse', 'AuthorizationError'],
             ['renderForbiddenResponse',    'ForbiddenError'],
@@ -371,7 +490,7 @@ describe('VidaServerController', () => {
 
             expect(controller[handlerName]).toHaveBeenCalledTimes(1);
             if (handlerName == 'renderErrors') {
-                expect(controller[handlerName]).toHaveBeenCalledWith(message, error.errors);
+                expect(controller[handlerName]).toHaveBeenCalledWith(message, error.fields);
             } else {
                 expect(controller[handlerName]).toHaveBeenCalledWith(message);
             }
@@ -386,7 +505,7 @@ describe('VidaServerController', () => {
             await controller.performRequest('testAction');
 
             expect(controller.statusCode).toEqual(500);
-            expect(controller.render).toHaveBeenCalledWith({error: message});
+            expect(controller.render).toHaveBeenCalledWith({errors: { message }});
         });
     });
 
@@ -401,7 +520,7 @@ describe('VidaServerController', () => {
         });
 
         
-        describe('VidaServerController#renderErrors', () => {
+        describe('#renderErrors', () => {
             it ('returns a 400 response', async () => {
                 await controller.renderErrors();
                 expect(response.statusCode).toBe(400);
@@ -458,7 +577,7 @@ describe('VidaServerController', () => {
         });
 
         
-        describe('VidaServerController#renderUnauthorizedResponse', () => {
+        describe('#renderUnauthorizedResponse', () => {
             it ('returns a 401 response', async () => {
                 await controller.renderUnauthorizedResponse();
                 expect(response.statusCode).toBe(401);
@@ -467,19 +586,19 @@ describe('VidaServerController', () => {
             it ('includes a blank message by default', async () => {
                 await controller.renderUnauthorizedResponse();
                 expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: null});
+                expect(controller.render).toHaveBeenCalledWith({errors: {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});
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
             });
         });
 
         
-        describe('VidaServerController#renderForbiddenResponse', () => {
+        describe('#renderForbiddenResponse', () => {
             it ('returns a 403 response', async () => {
                 await controller.renderForbiddenResponse();
                 expect(response.statusCode).toBe(403);
@@ -488,19 +607,19 @@ describe('VidaServerController', () => {
             it ('includes a blank message by default', async () => {
                 await controller.renderForbiddenResponse();
                 expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: null});
+                expect(controller.render).toHaveBeenCalledWith({errors: {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});
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
             });
         });
 
 
-        describe('VidaServerController#renderNotFoundResponse', () => {
+        describe('#renderNotFoundResponse', () => {
             it ('returns a 404 response', async () => {
                 await controller.renderNotFoundResponse();
                 expect(response.statusCode).toBe(404);
@@ -509,14 +628,14 @@ describe('VidaServerController', () => {
             it ('includes a blank message by default', async () => {
                 await controller.renderNotFoundResponse();
                 expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({message: null});
+                expect(controller.render).toHaveBeenCalledWith({errors: {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});
+                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
             });
         });
     });
@@ -534,7 +653,7 @@ describe('VidaServerController', () => {
             controller                      = new FooController(request, response);
         });
 
-        describe('VidaServerController#requestHeaders', () => {
+        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));
@@ -542,28 +661,28 @@ describe('VidaServerController', () => {
         });
 
 
-        describe('VidaServerController#responseHeaders', () => {
+        describe('#responseHeaders', () => {
             it ('returns the request headers', () => {
                 expect(controller.responseHeaders).toBe(response.headers);
             });
         });
 
 
-        describe('VidaServerController#contentType', () => {
+        describe('#contentType', () => {
             it ('returns the content-type request header', () => {
                 expect(controller.contentType).toEqual(request.headers['content-type']);
             });
         });
 
 
-        describe('VidaServerController#logger', () => {
+        describe('#logger', () => {
             it ('uses the standard logger', () => {
                 expect(controller.logger).toBe(logger);
             });
         });
 
 
-        describe('VidaServerController#rendered', () => {
+        describe('#rendered', () => {
             it ('returns false if nothing has rendered', () => {
                 expect(controller.rendered).toBeFalsy();
             });
@@ -582,7 +701,7 @@ describe('VidaServerController', () => {
         });
 
 
-        describe('VidaServerController#statusCode', () => {
+        describe('#statusCode', () => {
             it ('returns the response status code', () => {
                 expect(controller.statusCode).toEqual(response.statusCode);
             });
@@ -594,4 +713,21 @@ describe('VidaServerController', () => {
             });
         });
     });
+
+
+    describe('#setupCallbacks', () => {
+        it ('is only called once', () => {
+            class CallbacksTestController extends VidaServerController {}
+            CallbacksTestController.prototype.setupCallbacks = jest.fn();
+            const controller = new CallbacksTestController({}, {});
+
+            expect(CallbacksTestController.prototype.setupCallbacks).toHaveBeenCalledTimes(1);
+            expect(controller.setupCallbacks).toBe(undefined);
+
+        });
+    });
+
+
+    describe('Request Properties', () => {
+    });
 });