@vida-global/core 1.4.5 → 2.0.0

package/test/server/apiDocsGenerator.test.js

@@ -0,0 +1,38 @@
+const { ApiDocsGenerator } = require('../../lib/server/apiDocsGenerator');
+
+
+describe('ApiDocsGenerator', () => {
+    let generator;
+
+    beforeEach(() => {
+        generator = new ApiDocsGenerator({ controllerDirectories: [] });
+    });
+
+
+    describe('#formatEndpoint', () => {
+        it ('replaces a single :param with {param}', () => {
+            expect(generator.formatEndpoint({ path: '/users/:id' })).toEqual('/users/{id}');
+        });
+
+        it ('replaces multiple :params with {params}', () => {
+            expect(generator.formatEndpoint({ path: '/users/:userId/posts/:postId' }))
+                .toEqual('/users/{userId}/posts/{postId}');
+        });
+
+        it ('returns the path unchanged when there are no params', () => {
+            expect(generator.formatEndpoint({ path: '/users' })).toEqual('/users');
+        });
+
+        it ('handles a trailing :param', () => {
+            expect(generator.formatEndpoint({ path: '/foo/bar/:baz' })).toEqual('/foo/bar/{baz}');
+        });
+
+        it ('handles an empty path', () => {
+            expect(generator.formatEndpoint({ path: '' })).toEqual('');
+        });
+
+        it ('only replaces up to the next slash', () => {
+            expect(generator.formatEndpoint({ path: '/a/:x/b/:y' })).toEqual('/a/{x}/b/{y}');
+        });
+    });
+});

package/test/server/server.test.js

@@ -5,17 +5,39 @@ const { Request }       = require('jest-express/lib/request');
 const { Response }      = require('jest-express/lib/response');
 const { TestServer }    = require('./helpers/server');
 const { VidaServer }    = require('../../lib/server');
+const   express         = require('express');
+const   IoServer        = require('socket.io');
+const { Server: HttpServer } = require('http');
+
+
+const lastApp = () => express.__instances[express.__instances.length - 1];
 
 
 jest.mock('express', () => {
-    const   express    = require('jest-express');
-    const { Response } = require('jest-express/lib/response');
+    const   jestExpress = require('jest-express');
+    const { Response }  = require('jest-express/lib/response');
 
     // missing functions in mock express
     Response.prototype.on = jest.fn();
-    express.raw           = jest.fn();
 
-    return express;
+    // Wrap the factory so tests can inspect the most recently created Express app.
+    const instances = [];
+    const wrapped   = (...args) => {
+        const app = jestExpress(...args);
+        instances.push(app);
+        return app;
+    };
+    Object.assign(wrapped, jestExpress);
+    wrapped.raw         = jest.fn();
+    wrapped.__instances = instances;
+
+    return wrapped;
+});
+
+jest.mock('socket.io', () => jest.fn());
+jest.mock('http', () => {
+    const actual = jest.requireActual('http');
+    return { ...actual, Server: jest.fn() };
 });
 
 
@@ -187,4 +209,164 @@ describe('VidaServer', () => {
             expect(afterSpy5).toHaveBeenCalledTimes(0);
         });
     });
+
+
+    describe('VidaServer#listen', () => {
+        it ('starts the http server on the configured host/port and invokes the callback', async () => {
+            const fakeHttpServer = { listen: jest.fn((port, host, cb) => cb()) };
+            HttpServer.mockReturnValueOnce(fakeHttpServer);
+
+            const server   = new TestServer({ port: 4321, host: '0.0.0.0' });
+            const callback = jest.fn();
+            jest.spyOn(server, 'registerControllers').mockResolvedValue();
+
+            await server.listen(callback);
+            expect(fakeHttpServer.listen).toHaveBeenCalledWith(4321, '0.0.0.0', expect.any(Function));
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+
+        it ('does not require a callback', async () => {
+            const fakeHttpServer = { listen: jest.fn((port, host, cb) => cb()) };
+            HttpServer.mockReturnValueOnce(fakeHttpServer);
+
+            const server = new TestServer({ port: 5000, host: 'localhost' });
+            jest.spyOn(server, 'registerControllers').mockResolvedValue();
+
+            await expect(server.listen()).resolves.toBeUndefined();
+            expect(fakeHttpServer.listen).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
+    describe('VidaServer#corsOrigins', () => {
+        it ('defaults to an empty array', () => {
+            expect(new TestServer().corsOrigins).toEqual([]);
+        });
+    });
+
+
+    describe('VidaServer#viewsDirectory / staticFilesDirectory', () => {
+        it ('returns absolute paths under cwd', () => {
+            const server = new TestServer();
+            expect(server.viewsDirectory).toEqual(`${process.cwd()}/views`);
+            expect(server.staticFilesDirectory).toEqual(`${process.cwd()}/static`);
+        });
+    });
+
+
+    describe('VidaServer#controllerDirectories (default)', () => {
+        it ('returns cwd/controllers when not overridden', () => {
+            const server = new VidaServer();
+            expect(server.controllerDirectories).toEqual([`${process.cwd()}/controllers`]);
+        });
+    });
+
+
+    describe('VidaServer#connectionAbortedMiddleware', () => {
+        it ('short-circuits with a 400 when err.code === ECONNABORTED', async () => {
+            const server     = new TestServer();
+            const middleware = server.connectionAbortedMiddleware;
+            const status     = jest.fn().mockReturnValue({ end: jest.fn() });
+            const res        = { status };
+            const next       = jest.fn();
+
+            await middleware({ code: 'ECONNABORTED' }, {}, res, next);
+            expect(status).toHaveBeenCalledWith(400);
+            expect(next).not.toHaveBeenCalled();
+        });
+
+        it ('calls next() for other errors', async () => {
+            const server     = new TestServer();
+            const middleware = server.connectionAbortedMiddleware;
+            const next       = jest.fn();
+
+            await middleware(new Error('something else'), {}, {}, next);
+            expect(next).toHaveBeenCalledTimes(1);
+        });
+
+        it ('calls next() when there is no error', async () => {
+            const server     = new TestServer();
+            const middleware = server.connectionAbortedMiddleware;
+            const next       = jest.fn();
+
+            await middleware(null, {}, {}, next);
+            expect(next).toHaveBeenCalledTimes(1);
+        });
+    });
+
+
+    describe('VidaServer HTTP verb wrappers', () => {
+        const verbs = ['get', 'post', 'put', 'delete', 'patch', 'head'];
+
+        it.each(verbs)('_%s delegates to express app.%s', (verb) => {
+            const server  = new TestServer();
+            const handler = jest.fn();
+            const app     = lastApp();
+            app[verb].mockClear();
+
+            server[`_${verb}`]('/path', handler);
+            expect(app[verb]).toHaveBeenCalledWith('/path', handler);
+        });
+    });
+
+
+    describe('VidaServer deprecated routing methods', () => {
+        const verbs = ['get', 'post', 'put', 'patch', 'head', 'delete'];
+
+        it.each(verbs)('%s emits a DeprecationWarning and delegates to express app.%s', (verb) => {
+            const emitSpy = jest.spyOn(process, 'emitWarning').mockImplementation(() => {});
+            try {
+                const server  = new TestServer();
+                const handler = jest.fn();
+                const app     = lastApp();
+                app[verb].mockClear();
+
+                server[verb]('/path', handler);
+                expect(emitSpy).toHaveBeenCalledWith(expect.stringContaining(`\`${verb}\` is deprecated`), 'DeprecationWarning');
+                expect(app[verb]).toHaveBeenCalledWith('/path', handler);
+            } finally {
+                emitSpy.mockRestore();
+            }
+        });
+
+        it ('only emits the warning once per method name', () => {
+            const emitSpy = jest.spyOn(process, 'emitWarning').mockImplementation(() => {});
+            try {
+                const server = new TestServer();
+                server.post('/a', jest.fn());
+                server.post('/b', jest.fn());
+                server.post('/c', jest.fn());
+
+                const postWarnings = emitSpy.mock.calls.filter(c => c[0].includes('`post`'));
+                expect(postWarnings).toHaveLength(1);
+            } finally {
+                emitSpy.mockRestore();
+            }
+        });
+    });
+
+
+    describe('VidaServer web socket helpers', () => {
+        let fakeIo;
+        let server;
+
+        beforeEach(() => {
+            fakeIo = { to: jest.fn(() => fakeIo), emit: jest.fn(), on: jest.fn() };
+            IoServer.mockReturnValueOnce(fakeIo);
+            HttpServer.mockReturnValueOnce({ listen: jest.fn() });
+            server = new TestServer();
+        });
+
+        it ('emitWebSocketEvent forwards channel/event/data to the io server', () => {
+            server.emitWebSocketEvent('chan', 'evt', { hello: 'world' });
+            expect(fakeIo.to).toHaveBeenCalledWith('chan');
+            expect(fakeIo.emit).toHaveBeenCalledWith('evt', { hello: 'world' });
+        });
+
+        it ('addWebSocketEventHandler registers the handler on the io server', () => {
+            const handler = jest.fn();
+            server.addWebSocketEventHandler('connection', handler);
+            expect(fakeIo.on).toHaveBeenCalledWith('connection', handler);
+        });
+    });
 });