@vida-global/core 2.0.11 → 2.1.0

package/test/server/controllerMixins/validations.test.js

@@ -0,0 +1,509 @@
+const { FooController }        = require('../helpers/controllers/fooController');
+const { camelize }             = require('inflection');
+const   Errors                 = require('../../../lib/server/errors');
+const   TestHelpers            = require('@vida-global/test-helpers');
+const { VidaServerController } = require('../../../lib/server/serverController');
+
+
+describe('VidaServerController', () => {
+    describe('.validateParameters', () => {
+        const paramName1      = TestHelpers.Faker.Text.randomString();
+        const paramName2      = TestHelpers.Faker.Text.randomString();
+        const value1          = TestHelpers.Faker.Text.randomString();
+        const value2          = TestHelpers.Faker.Text.randomString();
+        const validationType1 = TestHelpers.Faker.Text.randomString();
+        const validationType2 = TestHelpers.Faker.Text.randomString();
+        const options1        = [TestHelpers.Faker.Text.randomString()];
+        const options2        = [TestHelpers.Faker.Text.randomString()];
+        const error1          = TestHelpers.Faker.Text.randomString()
+        const error2          = TestHelpers.Faker.Text.randomString()
+
+        let params;
+        let controller;
+        let response;
+        let validator1;
+        let validator2;
+        beforeEach(() => {
+            params                                             = {[paramName1]: value1, [paramName2]: value2};
+            response                                           = {json: jest.fn(), statusCode: 200};
+            controller                                         = new FooController({params}, response);
+            controller.render                                  = jest.fn();
+            validator1                                         = jest.fn();
+            validator2                                         = jest.fn();
+            controller[`validate${camelize(validationType1)}`] = validator1;
+            controller[`validate${camelize(validationType2)}`] = validator2;
+        });
+
+        const validations = {
+            [paramName1]: {[validationType1]: options1, [validationType2]: options2},
+            [paramName2]: {[validationType1]: options2}
+        };
+
+        it ('runs validation checkers based on inputs', async () => {
+            await controller.validateParameters(validations);
+            expect(validator1).toHaveBeenCalledTimes(2);
+            expect(validator1).toHaveBeenCalledWith(value1, options1);
+            expect(validator1).toHaveBeenCalledWith(value2, options2);
+
+            expect(validator2).toHaveBeenCalledTimes(1);
+            expect(validator2).toHaveBeenCalledWith(value1, options2);
+        });
+
+        it ('throws a `ValidationError` when there\'s an error', async () => {
+            validator1.mockImplementation(() => error1);
+            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
+        });
+
+        it ('attaches the failing parameter and error message to the ValidationError fields', async () => {
+            validator1.mockImplementation(() => error1);
+            await expect(controller.validateParameters(validations)).rejects.toMatchObject({
+                fields: {[paramName1]: [error1], [paramName2]: [error1]}
+            });
+        });
+
+        it ('throws a `ValidationError` when there are multiple errors', async () => {
+            validator1.mockImplementation(() => error1);
+            validator2.mockImplementation(() => error2);
+
+            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
+        });
+
+        it ('sets nothing when there is no error', async () => {
+            await controller.validateParameters(validations);
+            expect(controller.render).toHaveBeenCalledTimes(0);
+            expect(response.statusCode).toEqual(200);
+        });
+
+        it ('ignores details where there is no validator', async () => {
+            const validations = {
+                [paramName2]: {[validationType1]: options2, 'foo': true}
+            };
+            await controller.validateParameters(validations);
+
+            expect(validator1).toHaveBeenCalledTimes(1);
+            expect(validator1).toHaveBeenCalledWith(value2, options2);
+        });
+
+        it ('does not error when optional parameters are not included', async () => {
+            const validations = {foo: {isString: true, optional: true}};
+            await expect(controller.validateParameters(validations)).resolves.not.toThrow();
+        });
+
+        it ('does error when optional parameters are invalid', async () => {
+            const validations = {foo: {isString: {length: {gte: 2}}, optional: true}};
+            params.foo = '';
+
+            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
+        });
+    });
+
+
+    describe('.validateAction', () => {
+        it ('is a no-op when the controller has no parametersFor<Action> method', async () => {
+            class C extends VidaServerController {}
+            const controller = new C({}, {});
+            controller.validateParameters = jest.fn();
+
+            await controller.validateAction('getThing');
+            expect(controller.validateParameters).not.toHaveBeenCalled();
+        });
+
+        it ('calls validateParameters with the value returned by parametersFor<Action>', async () => {
+            const params = {foo: {isString: true}};
+            class C extends VidaServerController {
+                static parametersForGetThing() { return params; }
+            }
+            const controller = new C({}, {});
+            controller.validateParameters = jest.fn();
+
+            await controller.validateAction('getThing');
+            expect(controller.validateParameters).toHaveBeenCalledTimes(1);
+            expect(controller.validateParameters).toHaveBeenCalledWith(params);
+        });
+
+        it ('camelizes the action name when looking up the parametersFor method', async () => {
+            const params = {foo: {isString: true}};
+            class C extends VidaServerController {
+                static parametersForGetFooBar() { return params; }
+            }
+            const controller = new C({}, {});
+            controller.validateParameters = jest.fn();
+
+            await controller.validateAction('getFooBar');
+            expect(controller.validateParameters).toHaveBeenCalledWith(params);
+        });
+
+        it ('propagates ValidationError thrown by validateParameters', async () => {
+            class C extends VidaServerController {
+                static parametersForGetThing() { return {foo: {isString: true}}; }
+            }
+            const request = { params: {}, query: {}, body: {foo: 42} };
+            const controller = new C(request, {});
+
+            await expect(controller.validateAction('getThing')).rejects.toThrow(Errors.ValidationError);
+        });
+    });
+
+
+    describe('.parametersForAction', () => {
+        it ('returns null when no parametersFor method is defined', () => {
+            class C extends VidaServerController {}
+            expect(C.parametersForAction('getThing')).toBe(null);
+        });
+
+        it ('returns the value of the matching parametersFor<Action> method', () => {
+            const params = {foo: {isString: true}};
+            class C extends VidaServerController {
+                static parametersForGetThing() { return params; }
+            }
+            expect(C.parametersForAction('getThing')).toBe(params);
+        });
+    });
+
+
+    describe('.parametersMethodForAction', () => {
+        it ('returns the camelized parametersFor<Action> method name', () => {
+            class C extends VidaServerController {}
+            expect(C.parametersMethodForAction('getFooBar')).toBe('parametersForGetFooBar');
+            expect(C.parametersMethodForAction('postIndex')).toBe('parametersForPostIndex');
+        });
+    });
+
+
+    describe('.validatePresence', () => {
+        const controller = new FooController({}, {});
+        it ('returns undefined when there is a value', () => {
+            const result = controller.validatePresence(TestHelpers.Faker.Text.randomString());
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns an error when there is no value', () => {
+            const result = controller.validatePresence();
+            expect(result).toEqual('required');
+        });
+    });
+
+
+    describe('.validateIsInteger', () => {
+        const controller = new FooController({}, {});
+        it ('returns undefined when there is an integer', () => {
+            const val    = Math.ceil(Math.random() * 100);
+            const result = controller.validateIsInteger(val)
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when there is an integer string', () => {
+            const val    = Math.ceil(Math.random() * 100).toString();
+            const result = controller.validateIsInteger(val)
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns an error when there is a non integer number', () => {
+            const val    = Math.random() * 100;
+            const result = controller.validateIsInteger(val)
+            expect(result).toEqual('must be an integer');
+        });
+
+        it ('returns an error when there is a non integer string', () => {
+            // starts with a number because parseFloat converts a string to a float if it starts with a number
+            const val    = '1' + TestHelpers.Faker.Text.randomString();
+            const result = controller.validateIsInteger(val)
+            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');
+        });
+
+        it ('returns undefined when the number is greater than the gte option', () => {
+            const result = controller.validateIsInteger(3, {gte: 2});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when the number is equal to the gte option', () => {
+            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('.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 date string of format YYYY-MM-DD', () => {
+            const result = controller.validateIsDateTime('2025-12-17');
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns undefined when passed a date string of format MM/DD/YY', () => {
+            const result = controller.validateIsDateTime('12/17/25');
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns undefined when passed a date string of format Month name DD, YYYY', () => {
+            const result = controller.validateIsDateTime('December 17, 2025');
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns undefined when passed a datetime string of format YYYY-MM-DD HH:MM:SS', () => {
+            const result = controller.validateIsDateTime('2025-12-17 01:05:00');
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns undefined when passed a datetime string of format MM/DD/YY HH:MM:SS', () => {
+            const result = controller.validateIsDateTime('12/17/25 01:05:00');
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns undefined when passed a datetime string of format Month name DD, YYYY HH:MM:SS', () => {
+            const result = controller.validateIsDateTime('December 17, 2025 01:05:00');
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns an error when passed an invalid date', () => {
+            const result = controller.validateIsDateTime('foo');
+            expect(result).toEqual('invalid date');
+        });
+    });
+
+
+    describe('.validateIsEnum', () => {
+        const controller = new FooController({}, {});
+        const enums      = [Math.random(), Math.random(), Math.random()];
+        const error      = TestHelpers.Faker.Text.randomString();
+        const options    = { enums, error }
+        it ('returns undefined when passed a valid value', () => {
+            const result = controller.validateIsEnum(enums[2], options);
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns an error when passed an invalid date', () => {
+            const result = controller.validateIsEnum('foo', options);
+            expect(result).toBe(error);
+        });
+    });
+
+
+    describe('.validateIsBoolean', () => {
+        const controller = new FooController({}, {});
+        it ('returns undefined when passed a matching boolean', () => {
+            const result1 = controller.validateIsBoolean(true, true);
+            const result2 = controller.validateIsBoolean(false, false);
+            expect(result1).toBe(undefined);
+            expect(result2).toBe(undefined);
+        });
+
+        it ('returns an error when passed an non matching boolean', () => {
+            const result1 = controller.validateIsBoolean(true, false);
+            const result2 = controller.validateIsBoolean(false, true);
+            expect(result1).toBe('must be false');
+            expect(result2).toBe('must be true');
+        });
+
+        it ('returns an error when passed an non boolean', () => {
+            const result1 = controller.validateIsBoolean('', false);
+            const result2 = controller.validateIsBoolean(0, false);
+            const result3 = controller.validateIsBoolean('foo', true);
+            const result4 = controller.validateIsBoolean(1, true);
+            expect(result1).toBe('must be false');
+            expect(result2).toBe('must be false');
+            expect(result3).toBe('must be true');
+            expect(result4).toBe('must be true');
+        });
+    });
+
+
+    describe('.validateIsNumber', () => {
+        const controller = new FooController({}, {});
+        it ('accepts integers and decimals', () => {
+            expect(controller.validateIsNumber('3')).toBeUndefined();
+            expect(controller.validateIsNumber('3.14')).toBeUndefined();
+        });
+
+        it ('rejects non-numeric values', () => {
+            expect(controller.validateIsNumber('abc')).toEqual('must be a number');
+            expect(controller.validateIsNumber('abc123')).toEqual('must be a number');
+            expect(controller.validateIsNumber('123abc')).toEqual('must be a number');
+        });
+
+        it ('enforces gte and lte bounds', () => {
+            expect(controller.validateIsNumber('0.5', { gte: 1 })).toEqual('must be greater than or equal to 1');
+            expect(controller.validateIsNumber('9.5', { lte: 9 })).toEqual('must be less than or equal to 9');
+            expect(controller.validateIsNumber('5', { gte: 1, lte: 9 })).toBeUndefined();
+        });
+    });
+
+
+    describe('.validateIsArray', () => {
+        const controller = new FooController({}, {});
+        it ('rejects non-array values', async () => {
+            await expect(controller.validateIsArray('nope')).resolves.toEqual('must be an array');
+        });
+
+        it ('enforces length bounds', async () => {
+            await expect(controller.validateIsArray([], { length: { gte: 1 } })).resolves.toEqual('must have at least 1 items');
+            await expect(controller.validateIsArray([1, 2, 3], { length: { lte: 2 } })).resolves.toEqual('must have at most 2 items');
+        });
+
+        it ('validates each element against the of definition', async () => {
+            await expect(controller.validateIsArray([1, 'x'], { of: { isInteger: true } }))
+                .resolves.toEqual('elements must be an integer');
+            await expect(controller.validateIsArray([1, 2], { of: { isInteger: true } })).resolves.toBeUndefined();
+        });
+    });
+
+
+    describe('.validateIsObject', () => {
+        const controller = new FooController({}, {});
+        it ('rejects non-object values', async () => {
+            await expect(controller.validateIsObject('nope')).resolves.toEqual('must be an object');
+            await expect(controller.validateIsObject(null)).resolves.toEqual('must be an object');
+            await expect(controller.validateIsObject([1, 2])).resolves.toEqual('must be an object');
+        });
+
+        it ('validates declared properties', async () => {
+            const options = { properties: { age: { isInteger: true } } };
+            await expect(controller.validateIsObject({ age: 'old' }, options)).resolves.toEqual('age must be an integer');
+            await expect(controller.validateIsObject({ age: 30 }, options)).resolves.toBeUndefined();
+        });
+    });
+
+
+    describe('.validateFunction', () => {
+        const controller   = new FooController({}, {});
+        const correctValue = Math.random();
+        const error        = TestHelpers.Faker.Text.randomString();
+        const validator    = (value) => value == correctValue ? undefined : error;
+
+        it ('returns undefined when passed a valid value', async () => {
+            const result = await controller.validateFunction(correctValue, validator);
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns an error when the function returns an error', async () => {
+            const result = await controller.validateFunction(Math.random(), validator);
+            expect(result).toBe(error);
+        });
+    });
+});