@vida-global/core 2.0.6 → 2.0.8

package/test/jobQueue/helpers/worker.js

@@ -7,11 +7,24 @@ const FIXTURE_JOBS_DIR = path.join(__dirname, 'fixtureJobs');
 
 /***************************************************************************************************
 * WORKER FACTORY
+* bullmqMock/loggerMock/apmMock are required lazily so the mock instances align with whatever the
+* test re-requires after jest.resetModules() (used to reset the worker's module-level registeredJobs).
 ***************************************************************************************************/
 function buildWorker(Worker, queueName) {
+    const bullmqMock          = require('./bullmqMock');
+    const { buildLoggerMock } = require('./loggerMock');
+    const { buildApmMock }    = require('./apmMock');
+
+    const loggerMock = buildLoggerMock();
+    const apmMock    = buildApmMock();
+
     class TestWorker extends Worker {
         get jobDirectories() { return [FIXTURE_JOBS_DIR]; }
+        get workerClass()    { return bullmqMock.Worker; }
+        get loggerLibrary()  { return loggerMock; }
+        get apm()            { return apmMock; }
     }
+
     return new TestWorker(queueName || TestHelpers.Faker.Text.randomString());
 }
 

package/test/jobQueue/queue.test.js

@@ -1,27 +1,10 @@
-const TestHelpers           = require('@vida-global/test-helpers');
+const TestHelpers          = require('@vida-global/test-helpers');
 const { setupJobQueueEnv } = require('./helpers/env');
-
-
-jest.mock('bullmq', () => {
-    const mock = require('./helpers/bullmqMock');
-    return { Queue: mock.Queue, Worker: mock.Worker };
-});
-
-jest.mock('../../lib/logger', () => {
-    const { buildLoggerMock } = require('./helpers/loggerMock');
-    return { logger: buildLoggerMock() };
-});
-
-jest.mock('crypto', () => {
-    const actual = jest.requireActual('crypto');
-    return { ...actual, randomUUID: jest.fn() };
-});
+const { buildQueue }       = require('./helpers/queue');
 
 
 let bullmqMock;
 let getQueue;
-let logger;
-let randomUUID;
 let restoreEnv;
 
 beforeEach(() => {
@@ -30,8 +13,6 @@ beforeEach(() => {
 
     bullmqMock      = require('./helpers/bullmqMock');
     ({ getQueue }   = require('../../lib/jobQueue/queue'));
-    ({ logger }     = require('../../lib/logger'));
-    ({ randomUUID } = require('crypto'));
 });
 
 
@@ -95,7 +76,7 @@ describe('Queue', () => {
 
     beforeEach(() => {
         queueName = TestHelpers.Faker.Text.randomString();
-        queue     = getQueue(queueName);
+        queue     = buildQueue(queueName);
     });
 
 
@@ -117,8 +98,8 @@ describe('Queue', () => {
         it ('uses the queue scope keyed by fullQueueName', () => {
             const child = queue.logger;
 
-            expect(logger.queue.child).toHaveBeenCalledWith(`${queueName}-test`);
-            expect(child).toBe(logger.queue.child.mock.results[0].value);
+            expect(queue.loggerLibrary.queue.child).toHaveBeenCalledWith(`${queueName}-test`);
+            expect(child).toBe(queue.loggerLibrary.queue.child.mock.results[0].value);
         });
     });
 
@@ -157,7 +138,7 @@ describe('Queue', () => {
     describe('#queueJob', () => {
         it ('adds the job to the BullMQ queue with a generated UUID, args, and settings', async () => {
             const id       = TestHelpers.Faker.Text.randomString();
-            randomUUID.mockReturnValue(id);
+            queue.idGenerator.mockReturnValue(id);
             const args     = [TestHelpers.Faker.Text.randomString(), TestHelpers.Faker.Math.randomNumber()];
             const settings = { attempts: TestHelpers.Faker.Math.randomNumber(10) };
             const jobClass = { name: TestHelpers.Faker.Text.randomString() };
@@ -313,7 +294,7 @@ describe('Queue', () => {
 
             errorListener(err);
 
-            const child = logger.queue.child.mock.results[0].value;
+            const child = queue.loggerLibrary.queue.child.mock.results[0].value;
             expect(child.error).toHaveBeenCalledWith(err);
         });
     });

package/test/jobQueue/worker.test.js

@@ -3,26 +3,8 @@ const { setupJobQueueEnv }                 = require('./helpers/env');
 const { buildFakeBullJob, buildWorker }    = require('./helpers/worker');
 
 
-jest.mock('bullmq', () => {
-    const mock = require('./helpers/bullmqMock');
-    return { Queue: mock.Queue, Worker: mock.Worker };
-});
-
-jest.mock('../../lib/logger', () => {
-    const { buildLoggerMock } = require('./helpers/loggerMock');
-    return { logger: buildLoggerMock() };
-});
-
-jest.mock('../../lib/apm', () => {
-    const { buildApmMock } = require('./helpers/apmMock');
-    return buildApmMock();
-});
-
-
 let bullmqMock;
 let Worker;
-let logger;
-let APM;
 let TestJobA;
 let TestJobB;
 let restoreEnv;
@@ -33,8 +15,6 @@ beforeEach(() => {
 
     bullmqMock      = require('./helpers/bullmqMock');
     ({ Worker }     = require('../../lib/jobQueue/worker'));
-    ({ logger }     = require('../../lib/logger'));
-    APM             = require('../../lib/apm');
     ({ TestJobA }   = require('./helpers/fixtureJobs/testJobA'));
     ({ TestJobB }   = require('./helpers/fixtureJobs/testJobB'));
 });
@@ -110,9 +90,9 @@ describe('Worker', () => {
 
     describe('#logger', () => {
         it ('returns the worker scope', () => {
-            const worker = new Worker('q');
+            const worker = buildWorker(Worker);
 
-            expect(worker.logger).toBe(logger.worker);
+            expect(worker.logger).toBe(worker.loggerLibrary.worker);
         });
     });
 
@@ -203,8 +183,8 @@ describe('Worker', () => {
 
             await worker.listen();
 
-            expect(logger.worker.verbose).toHaveBeenCalledWith('JOB: TestJobA');
-            expect(logger.worker.verbose).toHaveBeenCalledWith('JOB: TestJobB');
+            expect(worker.loggerLibrary.worker.verbose).toHaveBeenCalledWith('JOB: TestJobA');
+            expect(worker.loggerLibrary.worker.verbose).toHaveBeenCalledWith('JOB: TestJobB');
         });
 
         it ('skips per-job verbose logging when NODE_ENV is test', async () => {
@@ -213,7 +193,7 @@ describe('Worker', () => {
 
             await worker.listen();
 
-            const verboseCalls = logger.worker.verbose.mock.calls.filter(
+            const verboseCalls = worker.loggerLibrary.worker.verbose.mock.calls.filter(
                 ([msg]) => typeof msg === 'string' && msg.startsWith('JOB:')
             );
             expect(verboseCalls).toHaveLength(0);
@@ -288,8 +268,8 @@ describe('Worker', () => {
 
             await processor(fakeBull);
 
-            expect(APM.startBackgroundTransaction).toHaveBeenCalledTimes(1);
-            expect(APM.startBackgroundTransaction).toHaveBeenCalledWith(
+            expect(worker.apm.startBackgroundTransaction).toHaveBeenCalledTimes(1);
+            expect(worker.apm.startBackgroundTransaction).toHaveBeenCalledWith(
                 'TestJobA',
                 `${queueName}-test`,
                 expect.any(Function),
@@ -304,8 +284,8 @@ describe('Worker', () => {
 
             await processor(fakeBull);
 
-            expect(APM.startSegment).toHaveBeenCalledTimes(1);
-            expect(APM.startSegment).toHaveBeenCalledWith('job:TestJobA', true, expect.any(Function));
+            expect(worker.apm.startSegment).toHaveBeenCalledTimes(1);
+            expect(worker.apm.startSegment).toHaveBeenCalledWith('job:TestJobA', true, expect.any(Function));
         });
 
         it ('adds jobId, jobName, queueName, attempt, and maxAttempts as custom attributes', async () => {
@@ -323,11 +303,11 @@ describe('Worker', () => {
 
             await processor(fakeBull);
 
-            expect(APM.addCustomAttribute).toHaveBeenCalledWith('jobId',       id);
-            expect(APM.addCustomAttribute).toHaveBeenCalledWith('jobName',     'TestJobA');
-            expect(APM.addCustomAttribute).toHaveBeenCalledWith('queueName',   queueName);
-            expect(APM.addCustomAttribute).toHaveBeenCalledWith('attempt',     2);
-            expect(APM.addCustomAttribute).toHaveBeenCalledWith('maxAttempts', 5);
+            expect(worker.apm.addCustomAttribute).toHaveBeenCalledWith('jobId',       id);
+            expect(worker.apm.addCustomAttribute).toHaveBeenCalledWith('jobName',     'TestJobA');
+            expect(worker.apm.addCustomAttribute).toHaveBeenCalledWith('queueName',   queueName);
+            expect(worker.apm.addCustomAttribute).toHaveBeenCalledWith('attempt',     2);
+            expect(worker.apm.addCustomAttribute).toHaveBeenCalledWith('maxAttempts', 5);
         });
 
         it ('records a JobCompleted custom event and a duration metric on success', async () => {
@@ -344,13 +324,13 @@ describe('Worker', () => {
 
             await processor(fakeBull);
 
-            expect(APM.recordCustomEvent).toHaveBeenCalledWith('JobCompleted', {
+            expect(worker.apm.recordCustomEvent).toHaveBeenCalledWith('JobCompleted', {
                 jobName:    'TestJobA',
                 queueName,
                 durationMs: finishedAt - startedAt,
                 attempts:   1,
             });
-            expect(APM.recordMetric).toHaveBeenCalledWith(
+            expect(worker.apm.recordMetric).toHaveBeenCalledWith(
                 `Custom/Worker/${queueName}/TestJobA/duration`,
                 finishedAt - startedAt,
             );
@@ -372,8 +352,8 @@ describe('Worker', () => {
 
             await expect(processor(fakeBull)).rejects.toBe(err);
 
-            expect(APM.reportError).toHaveBeenCalledTimes(1);
-            expect(APM.reportError).toHaveBeenCalledWith(err, {
+            expect(worker.apm.reportError).toHaveBeenCalledTimes(1);
+            expect(worker.apm.reportError).toHaveBeenCalledWith(err, {
                 jobId:        id,
                 jobName:      'TestJobA',
                 queueName,
@@ -381,7 +361,7 @@ describe('Worker', () => {
                 maxAttempts:  3,
                 isFinalRetry: false,
             });
-            expect(APM.recordCustomEvent).not.toHaveBeenCalledWith('JobFailed', expect.anything());
+            expect(worker.apm.recordCustomEvent).not.toHaveBeenCalledWith('JobFailed', expect.anything());
         });
 
         it ('records a JobFailed custom event on the final retry', async () => {
@@ -398,13 +378,13 @@ describe('Worker', () => {
 
             await expect(processor(fakeBull)).rejects.toBe(err);
 
-            expect(APM.recordCustomEvent).toHaveBeenCalledWith('JobFailed', {
+            expect(worker.apm.recordCustomEvent).toHaveBeenCalledWith('JobFailed', {
                 jobName:   'TestJobA',
                 queueName,
                 attempts:  3,
                 error:     err.message,
             });
-            expect(APM.reportError).toHaveBeenCalledWith(err, expect.objectContaining({
+            expect(worker.apm.reportError).toHaveBeenCalledWith(err, expect.objectContaining({
                 isFinalRetry: true,
             }));
         });
@@ -418,8 +398,8 @@ describe('Worker', () => {
 
             await expect(processor(fakeBull)).rejects.toBe(err);
 
-            expect(APM.recordCustomEvent).not.toHaveBeenCalledWith('JobCompleted', expect.anything());
-            expect(APM.recordMetric).not.toHaveBeenCalled();
+            expect(worker.apm.recordCustomEvent).not.toHaveBeenCalledWith('JobCompleted', expect.anything());
+            expect(worker.apm.recordMetric).not.toHaveBeenCalled();
         });
 
 /*
@@ -453,7 +433,7 @@ describe('Worker', () => {
 
             handler({ name: 'TestJobA', data: { id } }, duration);
 
-            const child = logger.worker.child.mock.results[0].value;
+            const child = worker.loggerLibrary.worker.child.mock.results[0].value;
             expect(child.debug).toHaveBeenCalledWith(`Completed in ${duration}ms`);
         });
 
@@ -466,7 +446,7 @@ describe('Worker', () => {
 
             handler({ name: 'TestJobA', data: { id } }, payload);
 
-            const child = logger.worker.child.mock.results[0].value;
+            const child = worker.loggerLibrary.worker.child.mock.results[0].value;
             expect(child.debug).toHaveBeenCalledWith(payload);
         });
 
@@ -483,7 +463,7 @@ describe('Worker', () => {
             const err = new Error('boom');
 
             expect(() => handler(job, err)).not.toThrow();
-            const child = logger.worker.child.mock.results[0].value;
+            const child = worker.loggerLibrary.worker.child.mock.results[0].value;
             expect(child.debug).toHaveBeenCalledWith('ERROR (1/3) Error: boom');
         });
 
@@ -510,7 +490,7 @@ describe('Worker', () => {
             const err = new Error(TestHelpers.Faker.Text.randomString());
 
             expect(() => handler(err)).toThrow(err);
-            expect(logger.worker.error).toHaveBeenCalledWith(err);
+            expect(worker.loggerLibrary.worker.error).toHaveBeenCalledWith(err);
         });
 
         it ('"error" handler logs and does NOT throw outside development', async () => {
@@ -520,7 +500,7 @@ describe('Worker', () => {
             const err = new Error(TestHelpers.Faker.Text.randomString());
 
             expect(() => handler(err)).not.toThrow();
-            expect(logger.worker.error).toHaveBeenCalledWith(err);
+            expect(worker.loggerLibrary.worker.error).toHaveBeenCalledWith(err);
         });
     });
 });

package/test/logger/index.test.js

@@ -46,6 +46,32 @@ describe('Logger', () => {
     });
 
 
+    describe('#child', () => {
+        it ('returns a fresh, uncached logger for an id so per-request loggers are not retained', () => {
+            const scope = randomScope();
+            const id    = TestHelpers.Faker.Text.randomString();
+            const root  = new Logger(scope);
+
+            const first  = root.child(id);
+            const second = root.child(id);
+
+            expect(first).not.toBe(second);
+            expect(first.id).toEqual(id);
+            expect(first.scopes).toEqual([scope]);
+        });
+
+        it ('caches and reuses the logger when no id is provided', () => {
+            const scope = randomScope();
+            const root  = new Logger(scope);
+
+            const first  = root.child();
+            const second = root.child();
+
+            expect(first).toBe(second);
+        });
+    });
+
+
     describe('#messageFormatter', () => {
         it ('renders every nested scope in the prefix in order', () => {
             const scopeA = randomScope();

package/test/logger/serverMiddleware.test.js

@@ -1,22 +1,13 @@
-jest.mock('express-winston', () => {
-    return {
-        logger: jest.fn(() => jest.fn()) // returns a noop middleware
-    };
-});
-
-const expressWinston = require('express-winston');
+const { LoggingMiddleware } = require('../../lib/logger/serverMiddleware');
 
-// Invoking middleware() triggers expressWinston.logger(options) — capturing options gives us
-// access to the otherwise-unexported msgFormatter
-const { middleware } = require('../../lib/logger/serverMiddleware');
-middleware({ _winstonLogger: {} });
 
-const options       = expressWinston.logger.mock.calls[0][0];
-const msgFormatter  = options.msg;
+// msgFormatter is an instance method, so we exercise it directly — no need to mock express-winston
+// or build the middleware (the logger collaborator is only read lazily when middleware is built).
+const msgFormatter = (req, res) => new LoggingMiddleware({}).msgFormatter(req, res);
 
 
-describe('logger/serverMiddleware', () => {
-    describe('msgFormatter', () => {
+describe('LoggingMiddleware', () => {
+    describe('#msgFormatter', () => {
         const baseRes = (overrides = {}) => ({
             statusCode:   200,
             responseTime: 12,

package/test/server/helpers/server.js

@@ -1,14 +1,48 @@
-const { VidaServer } = require('../../../lib/server');
+const { VidaServer }   = require('../../../lib/server');
+const   jestExpress    = require('jest-express');
+const { Response }     = require('jest-express/lib/response');
+
+
+// missing function in mock express
+Response.prototype.on = jest.fn();
+
+
+function buildServerEngineFactory() {
+    const instances = [];
+    const factory   = (...args) => {
+        const app = jestExpress(...args);
+        instances.push(app);
+        return app;
+    };
+    Object.assign(factory, jestExpress);
+    factory.raw         = jest.fn();
+    factory.__instances = instances;
+    return factory;
+}
+
+
+const serverEngineDouble = buildServerEngineFactory();
+const socketServerDouble = jest.fn();
+const httpServerDouble    = jest.fn();
 
 
 class TestServer extends VidaServer {
-    get controllerDirectories() {
-        return [`${__dirname}/controllers`];
-    }
+    get controllerDirectories() { return [`${__dirname}/controllers`]; }
+    get serverEngineFactory()   { return serverEngineDouble; }
+    get socketServerFactory()   { return socketServerDouble; }
+    get httpServerFactory()     { return httpServerDouble; }
 }
 
 
-module.exports = {
-    TestServer
+function lastApp() {
+    return serverEngineDouble.__instances[serverEngineDouble.__instances.length - 1];
 }
 
+
+module.exports = {
+    TestServer,
+    lastApp,
+    serverEngineDouble,
+    socketServerDouble,
+    httpServerDouble,
+}

package/test/server/server.test.js

@@ -3,42 +3,13 @@ const { BazController } = require('./helpers/controllers/sub/bazController');
 const { FooController } = require('./helpers/controllers/fooController');
 const { Request }       = require('jest-express/lib/request');
 const { Response }      = require('jest-express/lib/response');
-const { TestServer }    = require('./helpers/server');
+const {
+    TestServer,
+    lastApp,
+    socketServerDouble: IoServer,
+    httpServerDouble: HttpServer,
+} = 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   jestExpress = require('jest-express');
-    const { Response }  = require('jest-express/lib/response');
-
-    // missing functions in mock express
-    Response.prototype.on = jest.fn();
-
-    // 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() };
-});
 
 
 afterEach(() => {

package/test/server/serverController.test.js

@@ -1786,12 +1786,12 @@ describe('VidaServerController', () => {
                 .toThrow(NoActiveStreamError);
         });
 
-        it ('writes both event and data lines when an event name is provided', async () => {
+        it ('writes the event and data lines as a single atomic frame 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');
+                expect(response.write).toHaveBeenCalledTimes(1);
+                expect(response.write).toHaveBeenCalledWith('event: progress\ndata: halfway\n\n');
             }, jest.fn());
         });