@vida-global/core 1.4.5 → 2.0.0

package/test/jobQueue/worker.test.js

@@ -0,0 +1,526 @@
+const TestHelpers                          = require('@vida-global/test-helpers');
+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;
+
+beforeEach(() => {
+    jest.resetModules();
+    restoreEnv = setupJobQueueEnv(['WORKER_QUEUE_NAME', 'WORKER_CONCURRENCY']);
+
+    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'));
+});
+
+
+afterEach(() => {
+    restoreEnv();
+    jest.clearAllMocks();
+});
+
+
+describe('Worker', () => {
+    describe('constructor', () => {
+        it ('uses the queueName argument when provided', () => {
+            const name   = TestHelpers.Faker.Text.randomString();
+            const worker = new Worker(name);
+
+            expect(worker.queueName).toEqual(name);
+        });
+
+        it ('falls back to WORKER_QUEUE_NAME when argument is omitted', () => {
+            const name = TestHelpers.Faker.Text.randomString();
+            process.env.WORKER_QUEUE_NAME = name;
+
+            const worker = new Worker();
+
+            expect(worker.queueName).toEqual(name);
+        });
+
+        it ('leaves queueName undefined when neither the arg nor the env var is set', () => {
+            const worker = new Worker();
+
+            expect(worker.queueName).toBeUndefined();
+        });
+    });
+
+
+    describe('#concurrency', () => {
+        it ('defaults to 1', () => {
+            const worker = new Worker('q');
+
+            expect(worker.concurrency).toEqual(1);
+        });
+
+        it ('parses WORKER_CONCURRENCY from the environment', () => {
+            const value = TestHelpers.Faker.Math.randomNumber(50);
+            process.env.WORKER_CONCURRENCY = String(value);
+            const worker = new Worker('q');
+
+            expect(worker.concurrency).toEqual(value);
+        });
+    });
+
+
+    describe('#fullQueueName', () => {
+        it ('appends the current NODE_ENV', () => {
+            const name   = TestHelpers.Faker.Text.randomString();
+            const worker = new Worker(name);
+
+            expect(worker.fullQueueName).toEqual(`${name}-test`);
+        });
+    });
+
+
+    describe('#jobDirectories', () => {
+        it ('returns [cwd/jobs] by default', () => {
+            const worker = new Worker('q');
+
+            expect(worker.jobDirectories).toEqual([`${process.cwd()}/jobs`]);
+        });
+    });
+
+
+    describe('#logger', () => {
+        it ('returns the worker scope', () => {
+            const worker = new Worker('q');
+
+            expect(worker.logger).toBe(logger.worker);
+        });
+    });
+
+
+    describe('#workerOptions', () => {
+        it ('returns autorun: false, concurrency, and redis connection details', () => {
+            const value = TestHelpers.Faker.Math.randomNumber(20);
+            process.env.WORKER_CONCURRENCY = String(value);
+            const worker = new Worker('q');
+
+            expect(worker.workerOptions).toEqual({
+                autorun:     false,
+                concurrency: value,
+                connection:  {
+                    host:     process.env.REDIS_BULL_HOST,
+                    password: process.env.REDIS_BULL_PASSWORD,
+                    port:     process.env.REDIS_BULL_PORT,
+                },
+            });
+        });
+    });
+
+
+    describe('#listen', () => {
+        it ('constructs the BullMQ worker, and calls run()', async () => {
+            const worker = buildWorker(Worker, 'queueX');
+
+            await worker.listen();
+
+            expect(bullmqMock.instances.workers).toHaveLength(1);
+            const bullWorker = bullmqMock.instances.workers[0];
+            expect(bullWorker.name).toEqual('queueX-test');
+            expect(bullWorker.options.autorun).toBe(false);
+            expect(bullWorker.run).toHaveBeenCalledTimes(1);
+        });
+
+        it ('only constructs the BullMQ worker once across multiple listen calls', async () => {
+            const worker = buildWorker(Worker);
+
+            await worker.listen();
+            await worker.listen();
+
+            expect(bullmqMock.instances.workers).toHaveLength(1);
+        });
+
+        it ('registers completed, progress, failed, and error event handlers', async () => {
+            const worker = buildWorker(Worker);
+
+            await worker.listen();
+
+            const bullWorker = bullmqMock.instances.workers[0];
+            const events     = bullWorker.on.mock.calls.map(([event]) => event);
+            expect(events).toEqual(expect.arrayContaining(['completed', 'progress', 'failed', 'error']));
+        });
+    });
+
+
+    describe('#registerJobs', () => {
+        it ('imports AbstractJob subclasses from jobDirectories and ignores other classes', async () => {
+            const worker = buildWorker(Worker);
+
+            await worker.listen();
+
+            const bullWorker = bullmqMock.instances.workers[0];
+            const processor  = bullWorker.processor;
+            const fakeBull   = buildFakeBullJob({ name: 'TestJobA' });
+
+            await expect(processor(fakeBull)).resolves.toBeGreaterThanOrEqual(0);
+
+            const unknown = buildFakeBullJob({ name: 'NotAJob' });
+            await expect(processor(unknown)).rejects.toEqual('Unknown Job: NotAJob');
+        });
+
+        it ('short-circuits subsequent calls once registeredJobs is populated', async () => {
+            const worker = buildWorker(Worker);
+
+            await worker.listen();
+            const beforeCount = bullmqMock.instances.workers[0].on.mock.calls.length;
+            await worker.listen();
+            const afterCount  = bullmqMock.instances.workers[0].on.mock.calls.length;
+
+            expect(afterCount).toEqual(beforeCount);
+        });
+
+        it ('logs each registered job via verbose when NODE_ENV is not test', async () => {
+            process.env.NODE_ENV = 'development';
+            const worker = buildWorker(Worker);
+
+            await worker.listen();
+
+            expect(logger.worker.verbose).toHaveBeenCalledWith('JOB: TestJobA');
+            expect(logger.worker.verbose).toHaveBeenCalledWith('JOB: TestJobB');
+        });
+
+        it ('skips per-job verbose logging when NODE_ENV is test', async () => {
+            process.env.NODE_ENV = 'test';
+            const worker = buildWorker(Worker);
+
+            await worker.listen();
+
+            const verboseCalls = logger.worker.verbose.mock.calls.filter(
+                ([msg]) => typeof msg === 'string' && msg.startsWith('JOB:')
+            );
+            expect(verboseCalls).toHaveLength(0);
+        });
+    });
+
+
+    describe('#processJob', () => {
+        async function listenAndGetProcessor(worker) {
+            await worker.listen();
+            return bullmqMock.instances.workers[0].processor;
+        }
+
+
+        it ('instantiates the registered job and calls _run with id, args, and bound updateProgress', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            const runSpy    = jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const args      = [TestHelpers.Faker.Text.randomString()];
+            const id        = TestHelpers.Faker.Text.randomString();
+            const updateProgress = jest.fn();
+            const fakeBull  = buildFakeBullJob({ name: 'TestJobA', data: { id, args }, updateProgress });
+
+            await processor(fakeBull);
+
+            expect(runSpy).toHaveBeenCalledTimes(1);
+            expect(runSpy).toHaveBeenCalledWith(id, args, expect.any(Function));
+            runSpy.mockRestore();
+        });
+
+        it ('returns the elapsed milliseconds between start and finish', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const startedAt = 1000;
+            const finishedAt = 1750;
+            jest.spyOn(Date, 'now')
+                .mockReturnValueOnce(startedAt)
+                .mockReturnValueOnce(finishedAt);
+            const fakeBull = buildFakeBullJob({ name: 'TestJobA' });
+
+            const elapsed = await processor(fakeBull);
+
+            expect(elapsed).toEqual(finishedAt - startedAt);
+        });
+
+        it ('throws a string error when the job name is not registered', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            const fakeBull  = buildFakeBullJob({ name: 'NonexistentJob' });
+
+            await expect(processor(fakeBull)).rejects.toEqual('Unknown Job: NonexistentJob');
+        });
+
+        it ('propagates errors thrown from the job run method', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            const error     = new Error(TestHelpers.Faker.Text.randomString());
+            jest.spyOn(TestJobA.prototype, '_run').mockRejectedValue(error);
+            const fakeBull  = buildFakeBullJob({ name: 'TestJobA' });
+
+            await expect(processor(fakeBull)).rejects.toBe(error);
+        });
+
+
+        it ('wraps the job in a background transaction named after the job class', async () => {
+            const queueName = TestHelpers.Faker.Text.randomString();
+            const worker    = buildWorker(Worker, queueName);
+            const processor = await listenAndGetProcessor(worker);
+            jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const fakeBull = buildFakeBullJob({ name: 'TestJobA' });
+
+            await processor(fakeBull);
+
+            expect(APM.startBackgroundTransaction).toHaveBeenCalledTimes(1);
+            expect(APM.startBackgroundTransaction).toHaveBeenCalledWith(
+                'TestJobA',
+                `${queueName}-test`,
+                expect.any(Function),
+            );
+        });
+
+        it ('wraps job._run in a segment named "job:<jobName>"', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const fakeBull = buildFakeBullJob({ name: 'TestJobA' });
+
+            await processor(fakeBull);
+
+            expect(APM.startSegment).toHaveBeenCalledTimes(1);
+            expect(APM.startSegment).toHaveBeenCalledWith('job:TestJobA', true, expect.any(Function));
+        });
+
+        it ('adds jobId, jobName, queueName, attempt, and maxAttempts as custom attributes', async () => {
+            const queueName = TestHelpers.Faker.Text.randomString();
+            const worker    = buildWorker(Worker, queueName);
+            const processor = await listenAndGetProcessor(worker);
+            jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const id       = TestHelpers.Faker.Text.randomString();
+            const fakeBull = buildFakeBullJob({
+                name:         'TestJobA',
+                data:         { id, args: [] },
+                attemptsMade: 1,
+                opts:         { attempts: 5 },
+            });
+
+            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);
+        });
+
+        it ('records a JobCompleted custom event and a duration metric on success', async () => {
+            const queueName = TestHelpers.Faker.Text.randomString();
+            const worker    = buildWorker(Worker, queueName);
+            const processor = await listenAndGetProcessor(worker);
+            jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const startedAt  = 1000;
+            const finishedAt = 1500;
+            jest.spyOn(Date, 'now')
+                .mockReturnValueOnce(startedAt)
+                .mockReturnValueOnce(finishedAt);
+            const fakeBull = buildFakeBullJob({ name: 'TestJobA' });
+
+            await processor(fakeBull);
+
+            expect(APM.recordCustomEvent).toHaveBeenCalledWith('JobCompleted', {
+                jobName:    'TestJobA',
+                queueName,
+                durationMs: finishedAt - startedAt,
+                attempts:   1,
+            });
+            expect(APM.recordMetric).toHaveBeenCalledWith(
+                `Custom/Worker/${queueName}/TestJobA/duration`,
+                finishedAt - startedAt,
+            );
+        });
+
+        it ('reports errors to APM with job context and rethrows', async () => {
+            const queueName = TestHelpers.Faker.Text.randomString();
+            const worker    = buildWorker(Worker, queueName);
+            const processor = await listenAndGetProcessor(worker);
+            const err       = new Error(TestHelpers.Faker.Text.randomString());
+            jest.spyOn(TestJobA.prototype, '_run').mockRejectedValue(err);
+            const id       = TestHelpers.Faker.Text.randomString();
+            const fakeBull = buildFakeBullJob({
+                name:         'TestJobA',
+                data:         { id, args: [] },
+                attemptsMade: 0,
+                opts:         { attempts: 3 },
+            });
+
+            await expect(processor(fakeBull)).rejects.toBe(err);
+
+            expect(APM.reportError).toHaveBeenCalledTimes(1);
+            expect(APM.reportError).toHaveBeenCalledWith(err, {
+                jobId:        id,
+                jobName:      'TestJobA',
+                queueName,
+                attempt:      1,
+                maxAttempts:  3,
+                isFinalRetry: false,
+            });
+            expect(APM.recordCustomEvent).not.toHaveBeenCalledWith('JobFailed', expect.anything());
+        });
+
+        it ('records a JobFailed custom event on the final retry', async () => {
+            const queueName = TestHelpers.Faker.Text.randomString();
+            const worker    = buildWorker(Worker, queueName);
+            const processor = await listenAndGetProcessor(worker);
+            const err       = new Error(TestHelpers.Faker.Text.randomString());
+            jest.spyOn(TestJobA.prototype, '_run').mockRejectedValue(err);
+            const fakeBull = buildFakeBullJob({
+                name:         'TestJobA',
+                attemptsMade: 2,
+                opts:         { attempts: 3 },
+            });
+
+            await expect(processor(fakeBull)).rejects.toBe(err);
+
+            expect(APM.recordCustomEvent).toHaveBeenCalledWith('JobFailed', {
+                jobName:   'TestJobA',
+                queueName,
+                attempts:  3,
+                error:     err.message,
+            });
+            expect(APM.reportError).toHaveBeenCalledWith(err, expect.objectContaining({
+                isFinalRetry: true,
+            }));
+        });
+
+        it ('does not record JobCompleted or the duration metric when the job throws', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            const err       = new Error(TestHelpers.Faker.Text.randomString());
+            jest.spyOn(TestJobA.prototype, '_run').mockRejectedValue(err);
+            const fakeBull  = buildFakeBullJob({ name: 'TestJobA' });
+
+            await expect(processor(fakeBull)).rejects.toBe(err);
+
+            expect(APM.recordCustomEvent).not.toHaveBeenCalledWith('JobCompleted', expect.anything());
+            expect(APM.recordMetric).not.toHaveBeenCalled();
+        });
+
+/*
+        it ('registers a new logger scope for the job name', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const fakeBull  = buildFakeBullJob({ name: 'TestJobA' });
+
+            await processor(fakeBull);
+
+            expect(logger.addScope).toHaveBeenCalledWith('TestJobA');
+        });
+        */
+    });
+
+
+    describe('event handlers', () => {
+        async function listenAndGetWorker(worker) {
+            await worker.listen();
+            return bullmqMock.instances.workers[0];
+        }
+
+
+        it ('"completed" handler logs duration on the job-named child logger', async () => {
+            const worker     = buildWorker(Worker);
+            const bullWorker = await listenAndGetWorker(worker);
+            const handler    = bullmqMock.listenerFor(bullWorker, 'completed');
+            const id         = TestHelpers.Faker.Text.randomString();
+            const duration   = TestHelpers.Faker.Math.randomNumber(10000);
+
+            handler({ name: 'TestJobA', data: { id } }, duration);
+
+            const child = logger.worker.child.mock.results[0].value;
+            expect(child.debug).toHaveBeenCalledWith(`Completed in ${duration}ms`);
+        });
+
+        it ('"progress" handler logs the progress payload on the job-named child logger', async () => {
+            const worker     = buildWorker(Worker);
+            const bullWorker = await listenAndGetWorker(worker);
+            const handler    = bullmqMock.listenerFor(bullWorker, 'progress');
+            const id         = TestHelpers.Faker.Text.randomString();
+            const payload    = { step: TestHelpers.Faker.Text.randomString() };
+
+            handler({ name: 'TestJobA', data: { id } }, payload);
+
+            const child = logger.worker.child.mock.results[0].value;
+            expect(child.debug).toHaveBeenCalledWith(payload);
+        });
+
+        it ('"failed" handler logs and does NOT throw when attempts remain', async () => {
+            const worker     = buildWorker(Worker);
+            const bullWorker = await listenAndGetWorker(worker);
+            const handler    = bullmqMock.listenerFor(bullWorker, 'failed');
+            const job        = {
+                name: 'TestJobA',
+                data: { id: 't1' },
+                attemptsMade: 1,
+                opts: { attempts: 3 },
+            };
+            const err = new Error('boom');
+
+            expect(() => handler(job, err)).not.toThrow();
+            const child = logger.worker.child.mock.results[0].value;
+            expect(child.debug).toHaveBeenCalledWith('ERROR (1/3) Error: boom');
+        });
+
+        it ('"failed" handler re-throws on the final attempt', async () => {
+            const worker     = buildWorker(Worker);
+            const bullWorker = await listenAndGetWorker(worker);
+            const handler    = bullmqMock.listenerFor(bullWorker, 'failed');
+            const job        = {
+                name: 'TestJobA',
+                data: { id: 't1' },
+                attemptsMade: 3,
+                opts: { attempts: 3 },
+            };
+            const err = new Error('final');
+
+            expect(() => handler(job, err)).toThrow(err);
+        });
+
+        it ('"error" handler logs and rethrows in development', async () => {
+            process.env.NODE_ENV = 'development';
+            const worker     = buildWorker(Worker);
+            const bullWorker = await listenAndGetWorker(worker);
+            const handler    = bullmqMock.listenerFor(bullWorker, 'error');
+            const err = new Error(TestHelpers.Faker.Text.randomString());
+
+            expect(() => handler(err)).toThrow(err);
+            expect(logger.worker.error).toHaveBeenCalledWith(err);
+        });
+
+        it ('"error" handler logs and does NOT throw outside development', async () => {
+            const worker     = buildWorker(Worker);
+            const bullWorker = await listenAndGetWorker(worker);
+            const handler    = bullmqMock.listenerFor(bullWorker, 'error');
+            const err = new Error(TestHelpers.Faker.Text.randomString());
+
+            expect(() => handler(err)).not.toThrow();
+            expect(logger.worker.error).toHaveBeenCalledWith(err);
+        });
+    });
+});

package/test/logger/index.test.js

@@ -0,0 +1,61 @@
+const TestHelpers = require('@vida-global/test-helpers');
+const { Logger }  = require('../../lib/logger');
+
+
+// Faker can return random strings that collide with Logger's own properties (`scopes`, `id`,
+// `debug`, etc.). Prefixing keeps generated scope names in their own namespace.
+function randomScope() {
+    return `s_${TestHelpers.Faker.Text.randomString()}`.toLowerCase();
+}
+
+
+describe('Logger', () => {
+    describe('#addScope', () => {
+        it ('nests the new scope under the parent logger\'s scopes', () => {
+            const parentScope = randomScope();
+            const childScope  = randomScope();
+            const root        = new Logger(parentScope);
+
+            root.addScope(childScope);
+
+            expect(root[childScope].scopes).toEqual([parentScope, childScope]);
+        });
+
+        it ('chains scope nesting through multiple levels', () => {
+            const scopeA = randomScope();
+            const scopeB = randomScope();
+            const scopeC = randomScope();
+            const root   = new Logger(scopeA);
+
+            root.addScope(scopeB);
+            root[scopeB].addScope(scopeC);
+
+            expect(root[scopeB][scopeC].scopes).toEqual([scopeA, scopeB, scopeC]);
+        });
+
+        it ('preserves the parent\'s id on the nested logger', () => {
+            const id          = TestHelpers.Faker.Text.randomString();
+            const parentScope = randomScope();
+            const childScope  = randomScope();
+            const root        = new Logger(parentScope, id);
+
+            root.addScope(childScope);
+
+            expect(root[childScope].id).toEqual(id);
+        });
+    });
+
+
+    describe('#messageFormatter', () => {
+        it ('renders every nested scope in the prefix in order', () => {
+            const scopeA = randomScope();
+            const scopeB = randomScope();
+            const logger = new Logger([scopeA, scopeB]);
+            const info   = { level: 'info', timestamp: 'TS', message: 'hello' };
+
+            const result = logger.messageFormatter(info);
+
+            expect(result.message).toEqual(`[TS][INFO][${scopeA.toUpperCase()}][${scopeB.toUpperCase()}] hello`);
+        });
+    });
+});

package/test/logger/serverMiddleware.test.js

@@ -0,0 +1,72 @@
+jest.mock('express-winston', () => {
+    return {
+        logger: jest.fn(() => jest.fn()) // returns a noop middleware
+    };
+});
+
+const expressWinston = require('express-winston');
+
+// 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;
+
+
+describe('logger/serverMiddleware', () => {
+    describe('msgFormatter', () => {
+        const baseRes = (overrides = {}) => ({
+            statusCode:   200,
+            responseTime: 12,
+            ...overrides
+        });
+
+        const baseReq = (overrides = {}) => ({
+            method: 'GET',
+            url:    '/api/things',
+            ip:     '127.0.0.1',
+            ...overrides
+        });
+
+        it ('uses Controller#action when req.controller is set', () => {
+            class FooController {}
+            const req = baseReq({ controller: new FooController(), action: 'getIndex' });
+            const res = baseRes();
+            const msg = msgFormatter(req, res);
+            expect(msg).toContain('FooController#getIndex');
+            expect(msg).toContain('req: GET /api/things for 127.0.0.1');
+            expect(msg).toContain('res: statusCode=200 responseTime=12ms');
+        });
+
+        it ('uses "request completed" when no controller and statusCode < 500', () => {
+            const msg = msgFormatter(baseReq(), baseRes({ statusCode: 200 }));
+            expect(msg).toContain('request completed');
+        });
+
+        it ('uses "request errored" when no controller and statusCode >= 500', () => {
+            const msg = msgFormatter(baseReq(), baseRes({ statusCode: 503 }));
+            expect(msg).toContain('request errored');
+        });
+
+        it ('strips the query string from the request URL', () => {
+            const req = baseReq({ url: '/api/things?limit=10&q=foo' });
+            const msg = msgFormatter(req, baseRes());
+            expect(msg).toContain('req: GET /api/things for 127.0.0.1');
+            expect(msg).not.toContain('limit=10');
+        });
+
+        it ('appends the error stack when res.error is present', () => {
+            const err = new Error('boom');
+            err.stack = 'Error: boom\n    at somewhere';
+            const msg = msgFormatter(baseReq(), baseRes({ error: err }));
+            expect(msg).toContain('Error: boom\n    at somewhere');
+        });
+
+        it ('does not append a stack when there is no res.error', () => {
+            const msg = msgFormatter(baseReq(), baseRes());
+            expect(msg).not.toContain('Error:');
+        });
+    });
+});