@vida-global/core 1.4.6 → 2.0.1

package/test/server/serverController.test.js

@@ -127,6 +127,224 @@ describe('VidaServerController', () => {
     });
 
 
+    describe('#hasParam', () => {
+        let controller;
+        beforeEach(() => {
+            const params = {foo: 'bar', empty: '', falsy: false, nully: null};
+            controller   = new FooController({params}, {});
+        });
+
+        it ('returns true when the named key exists in params', () => {
+            expect(controller.hasParam('foo')).toBe(true);
+        });
+
+        it ('returns true when the value is an empty string', () => {
+            expect(controller.hasParam('empty')).toBe(true);
+        });
+
+        it ('returns true when the value is null', () => {
+            expect(controller.hasParam('nully')).toBe(true);
+        });
+
+        it ('returns true when the value is false', () => {
+            expect(controller.hasParam('falsy')).toBe(true);
+        });
+
+        it ('returns false when the named key is not in params', () => {
+            expect(controller.hasParam('nope')).toBe(false);
+        });
+    });
+
+
+    describe('#coerceString', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns the string when passed a non-empty string', () => {
+            const value = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceString(value)).toBe(value);
+        });
+
+        it ('trims surrounding whitespace', () => {
+            const value = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceString(`  ${value}  `)).toBe(value);
+        });
+
+        it ('returns the fallback for an empty string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceString('', {fallback})).toBe(fallback);
+        });
+
+        it ('returns the fallback for a whitespace-only string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceString('   ', {fallback})).toBe(fallback);
+        });
+
+        it.each([
+            [null],
+            [undefined],
+            [123],
+            [true],
+            [false],
+            [{}],
+            [[]],
+        ])('returns the fallback for non-string input (%p)', (input) => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceString(input, {fallback})).toBe(fallback);
+        });
+
+        it ('defaults the fallback to an empty string when no options are given', () => {
+            expect(controller.coerceString(null)).toBe('');
+        });
+
+        it ('defaults the fallback to an empty string for empty input when no options are given', () => {
+            expect(controller.coerceString('   ')).toBe('');
+        });
+    });
+
+
+    describe('#coerceBoolean', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns true when passed boolean true', () => {
+            expect(controller.coerceBoolean(true)).toBe(true);
+        });
+
+        it ('returns false when passed boolean false', () => {
+            expect(controller.coerceBoolean(false)).toBe(false);
+        });
+
+        it.each([
+            ['true'],
+            ['TRUE'],
+            ['1'],
+            ['yes'],
+            ['on'],
+            ['  ON  '],
+        ])('coerces "%s" to true', (input) => {
+            expect(controller.coerceBoolean(input)).toBe(true);
+        });
+
+        it.each([
+            ['false'],
+            ['FALSE'],
+            ['0'],
+            ['no'],
+            ['off'],
+            ['  off  '],
+        ])('coerces "%s" to false', (input) => {
+            expect(controller.coerceBoolean(input)).toBe(false);
+        });
+
+        it ('returns the fallback for an unrecognized string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceBoolean('maybe', {fallback})).toBe(fallback);
+        });
+
+        it ('returns the fallback for an empty/whitespace string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceBoolean('   ', {fallback})).toBe(fallback);
+        });
+
+        it.each([
+            [null],
+            [undefined],
+            [123],
+            [{}],
+            [[]],
+        ])('returns the fallback for non-string, non-boolean input (%p)', (input) => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceBoolean(input, {fallback})).toBe(fallback);
+        });
+
+        it ('defaults the fallback to undefined when no options are given', () => {
+            expect(controller.coerceBoolean('maybe')).toBe(undefined);
+        });
+    });
+
+
+    describe('#coerceInteger', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns the fallback for null', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(null, {fallback})).toBe(fallback);
+        });
+
+        it ('returns the fallback for undefined', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(undefined, {fallback})).toBe(fallback);
+        });
+
+        it.each([
+            [''],
+            ['   '],
+        ])('returns the fallback for empty/whitespace string (%p)', (input) => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(input, {fallback})).toBe(fallback);
+        });
+
+        it ('returns the fallback for a non-numeric string', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger('abc', {fallback})).toBe(fallback);
+        });
+
+        it ('parses an integer string to an integer', () => {
+            expect(controller.coerceInteger('42')).toBe(42);
+        });
+
+        it ('floors a decimal string value', () => {
+            expect(controller.coerceInteger('3.7')).toBe(3);
+        });
+
+        it ('accepts an integer value directly', () => {
+            expect(controller.coerceInteger(42)).toBe(42);
+        });
+
+        it ('floors a decimal numeric value', () => {
+            expect(controller.coerceInteger(3.7)).toBe(3);
+        });
+
+        it ('clamps to min when the value is below min', () => {
+            expect(controller.coerceInteger(1, {min: 5})).toBe(5);
+        });
+
+        it ('clamps to max when the value is above max', () => {
+            expect(controller.coerceInteger(100, {max: 50})).toBe(50);
+        });
+
+        it ('returns the fallback when nonNegative is set and the value is negative', () => {
+            const fallback = TestHelpers.Faker.Text.randomString();
+            expect(controller.coerceInteger(-3, {nonNegative: true, fallback})).toBe(fallback);
+        });
+    });
+
+
+    describe('#coerceObject', () => {
+        const controller = new FooController({}, {});
+
+        it ('returns a plain object unchanged', () => {
+            const input = {foo: TestHelpers.Faker.Text.randomString()};
+            expect(controller.coerceObject(input)).toBe(input);
+        });
+
+        it.each([
+            [null],
+            [undefined],
+            [[1, 2]],
+            ['string'],
+            [42],
+            [true],
+        ])('returns the fallback for non-plain-object input (%p)', (input) => {
+            const fallback = {foo: TestHelpers.Faker.Text.randomString()};
+            expect(controller.coerceObject(input, {fallback})).toBe(fallback);
+        });
+
+        it ('defaults the fallback to an empty object', () => {
+            expect(controller.coerceObject(null)).toEqual({});
+        });
+    });
+
+
     describe('.validateParameters', () => {
         const paramName1      = TestHelpers.Faker.Text.randomString();
         const paramName2      = TestHelpers.Faker.Text.randomString();
@@ -739,17 +957,15 @@ describe('VidaServerController', () => {
 
 
         describe('#logger', () => {
-            it ('uses the a logger with http scope', () => {
-                expect(controller.logger.scope).toBe('http');
-            });
+            it ('returns a child of the passed logger, scoped to the request id', () => {
+                const childLogger  = {};
+                const passedLogger = { child: jest.fn(() => childLogger) };
+                request.id         = TestHelpers.Faker.Text.randomString();
+
+                const c = new FooController(request, response, passedLogger);
 
-            it ('uses the request id', () => {
-                const id1         = TestHelpers.Faker.Text.randomString();
-                const id2         = TestHelpers.Faker.Text.randomString();
-                const controller1 = new FooController({ id: id1 }, response);
-                const controller2 = new FooController({ id: id2 }, response);
-                expect(controller1.logger.id).toBe(id1);
-                expect(controller2.logger.id).toBe(id2);
+                expect(passedLogger.child).toHaveBeenCalledWith(request.id);
+                expect(c.logger).toBe(childLogger);
             });
         });