@vida-global/core 1.4.5 → 1.4.6

package/test/server/serverController.test.js

@@ -5,7 +5,11 @@ 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');
+const {
+    NoActiveStreamError,
+    StreamInProgressError,
+    VidaServerController
+}                              = require('../../lib/server/serverController');
 
 describe('VidaServerController', () => {
     describe('.actionNames', () => {
@@ -444,6 +448,35 @@ describe('VidaServerController', () => {
     });
 
 
+    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('.validateFunction', () => {
         const controller   = new FooController({}, {});
         const correctValue = Math.random();
@@ -494,8 +527,6 @@ describe('VidaServerController', () => {
             const body       = {[key]: value};
             const message    = TestHelpers.Faker.Text.randomString();
 
-          if (!Errors[errorClsName]) console.log(errorClsName);
-
             const error      = new Errors[errorClsName](message, body);
             if (handlerName == 'renderErrors') error.errors = randomPayload();
 
@@ -708,8 +739,17 @@ describe('VidaServerController', () => {
 
 
         describe('#logger', () => {
-            it ('uses the standard logger', () => {
-                expect(controller.logger).toBe(logger);
+            it ('uses the a logger with http scope', () => {
+                expect(controller.logger.scope).toBe('http');
+            });
+
+            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);
             });
         });
 
@@ -762,4 +802,196 @@ describe('VidaServerController', () => {
 
     describe('Request Properties', () => {
     });
+
+
+    describe('#statusText', () => {
+        const cases = [
+            [200, 'ok'],
+            [201, 'created'],
+            [202, 'accepted'],
+            [204, 'no content'],
+            [301, 'moved permanently'],
+            [302, 'found'],
+            [304, 'not modified'],
+            [307, 'temporary redirect'],
+            [308, 'permanent redirect'],
+            [400, 'bad request'],
+            [401, 'unauthorized'],
+            [402, 'payment required'],
+            [403, 'forbidden'],
+            [404, 'not found'],
+            [405, 'method not allowed'],
+            [408, 'request timeout'],
+            [409, 'conflict'],
+            [410, 'gone'],
+            [413, 'content too large'],
+            [415, 'unsupported media type'],
+            [422, 'unprocessable content'],
+            [423, 'locked'],
+            [429, 'too many requests'],
+            [500, 'server error'],
+            [501, 'not implemented'],
+            [502, 'bad gateway'],
+            [503, 'service unavailable'],
+            [504, 'gateway timeout'],
+        ];
+
+        it.each(cases)('returns "%s" text for status %s', (statusCode, expected) => {
+            const controller = new FooController({}, { statusCode });
+            expect(controller.statusText).toEqual(expected);
+        });
+
+        it ('returns undefined for an unmapped status code', () => {
+            const controller = new FooController({}, { statusCode: 418 });
+            expect(controller.statusText).toBeUndefined();
+        });
+    });
+
+
+    describe('#streamSseResponse', () => {
+        let controller;
+        let response;
+        let request;
+        let setHeaderSpy;
+
+        beforeEach(() => {
+            request          = { on: jest.fn(), off: jest.fn() };
+            response         = {
+                setHeader:     jest.fn(),
+                flushHeaders:  jest.fn(),
+                write:         jest.fn(),
+                end:           jest.fn(),
+                writableEnded: false
+            };
+            controller       = new FooController(request, response);
+            setHeaderSpy     = response.setHeader;
+        });
+
+        it ('sets SSE headers, flushes them, and marks rendered before invoking handler', async () => {
+            const handler = jest.fn(async function () {
+                expect(this).toBe(controller);
+                expect(controller.rendered).toBe(true);
+                expect(setHeaderSpy).toHaveBeenCalledWith('Content-Type',      'text/event-stream; charset=utf-8');
+                expect(setHeaderSpy).toHaveBeenCalledWith('Cache-Control',     'no-cache');
+                expect(setHeaderSpy).toHaveBeenCalledWith('Connection',        'keep-alive');
+                expect(setHeaderSpy).toHaveBeenCalledWith('X-Accel-Buffering', 'no');
+                expect(response.flushHeaders).toHaveBeenCalledTimes(1);
+                expect(controller.statusCode).toBe(200);
+            });
+            await controller.streamSseResponse(handler, jest.fn());
+            expect(handler).toHaveBeenCalledTimes(1);
+        });
+
+        it ('writes [DONE] and ends the response in the finally block', async () => {
+            await controller.streamSseResponse(jest.fn(), jest.fn());
+            expect(response.write).toHaveBeenLastCalledWith('data: [DONE]\n\n');
+            expect(response.end).toHaveBeenCalledTimes(1);
+        });
+
+        it ('throws StreamInProgressError when called while already streaming', async () => {
+            await controller.streamSseResponse(async () => {
+                await expect(controller.streamSseResponse(jest.fn(), jest.fn()))
+                    .rejects.toBeInstanceOf(StreamInProgressError);
+            }, jest.fn());
+        });
+
+        it ('invokes errorHandler and rethrows when handler throws', async () => {
+            const err          = new Error('boom');
+            const handler      = jest.fn(async () => { throw err; });
+            const errorHandler = jest.fn();
+            await expect(controller.streamSseResponse(handler, errorHandler)).rejects.toThrow('boom');
+            expect(errorHandler).toHaveBeenCalledWith(err);
+        });
+
+        it ('still ends the response when handler throws', async () => {
+            const errorHandler = jest.fn();
+            await expect(controller.streamSseResponse(
+                async () => { throw new Error('boom'); },
+                errorHandler
+            )).rejects.toThrow();
+            expect(response.end).toHaveBeenCalledTimes(1);
+        });
+
+        it ('wires close listener to abortController when one is provided', async () => {
+            const abortController = { abort: jest.fn() };
+            await controller.streamSseResponse(jest.fn(), jest.fn(), abortController);
+            expect(request.on).toHaveBeenCalledWith('close', expect.any(Function));
+            expect(request.off).toHaveBeenCalledWith('close', expect.any(Function));
+            // The handler registered on 'close' should call abort.
+            const closeHandler = request.on.mock.calls.find(c => c[0] === 'close')[1];
+            closeHandler();
+            expect(abortController.abort).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does not register a close listener when no abortController is provided', async () => {
+            await controller.streamSseResponse(jest.fn(), jest.fn());
+            expect(request.on).not.toHaveBeenCalled();
+            expect(request.off).not.toHaveBeenCalled();
+        });
+
+        it ('resets streaming state after completion so a new stream can start', async () => {
+            await controller.streamSseResponse(jest.fn(), jest.fn());
+            // Second call should not throw StreamInProgressError.
+            await expect(controller.streamSseResponse(jest.fn(), jest.fn())).resolves.toBeUndefined();
+        });
+    });
+
+
+    describe('#writeStreamEvent', () => {
+        let controller;
+        let response;
+
+        beforeEach(() => {
+            response   = {
+                setHeader:     jest.fn(),
+                flushHeaders:  jest.fn(),
+                write:         jest.fn(),
+                end:           jest.fn(),
+                writableEnded: false
+            };
+            controller = new FooController({ on: jest.fn(), off: jest.fn() }, response);
+        });
+
+        it ('throws NoActiveStreamError when called outside a stream', () => {
+            expect(() => controller.writeStreamEvent('msg', 'hello'))
+                .toThrow(NoActiveStreamError);
+        });
+
+        it ('writes both event and data lines when an event name is provided', async () => {
+            await controller.streamSseResponse(async () => {
+                response.write.mockClear();
+                controller.writeStreamEvent('progress', 'halfway');
+                expect(response.write).toHaveBeenNthCalledWith(1, 'event: progress\n');
+                expect(response.write).toHaveBeenNthCalledWith(2, 'data: halfway\n\n');
+            }, jest.fn());
+        });
+
+        it ('writes only the data line when no event name is provided', async () => {
+            await controller.streamSseResponse(async () => {
+                response.write.mockClear();
+                controller.writeStreamEvent(null, 'plain');
+                expect(response.write).toHaveBeenCalledTimes(1);
+                expect(response.write).toHaveBeenCalledWith('data: plain\n\n');
+            }, jest.fn());
+        });
+
+        it ('is a no-op when the response is already ended', async () => {
+            await controller.streamSseResponse(async () => {
+                response.writableEnded = true;
+                response.write.mockClear();
+                controller.writeStreamEvent(null, 'ignored');
+                expect(response.write).not.toHaveBeenCalled();
+            }, jest.fn());
+        });
+
+        it ('is a no-op when the abort signal is aborted', async () => {
+            const abortController = { abort: jest.fn(), signal: { aborted: false } };
+            await controller.streamSseResponse(async () => {
+                abortController.signal.aborted = true;
+                response.write.mockClear();
+                controller.writeStreamEvent(null, 'ignored');
+                expect(response.write).not.toHaveBeenCalled();
+            }, jest.fn(), abortController);
+        });
+    });
 });