@vida-global/core 2.3.6 → 2.4.1

package/test/jobQueue/queue.test.js

@@ -110,7 +110,7 @@ describe('Queue', () => {
         });
 
         it ('constructs the BullMQ queue with fullQueueName and connection options on first use', async () => {
-            await queue.numQueuedJobs();
+            await queue.getJobCounts();
 
             expect(bullmqMock.instances.queues).toHaveLength(1);
             const instance = bullmqMock.instances.queues[0];
@@ -119,15 +119,15 @@ describe('Queue', () => {
         });
 
         it ('reuses the same BullMQ queue across multiple method calls', async () => {
-            await queue.numQueuedJobs();
-            await queue.numActiveJobs();
+            await queue.getJobCounts();
+            await queue.pause();
             await queue.close();
 
             expect(bullmqMock.instances.queues).toHaveLength(1);
         });
 
         it ('registers an error handler on the BullMQ queue', async () => {
-            await queue.numQueuedJobs();
+            await queue.getJobCounts();
 
             const instance = bullmqMock.instances.queues[0];
             expect(instance.on).toHaveBeenCalledWith('error', expect.any(Function));
@@ -136,9 +136,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();
-            queue.idGenerator.mockReturnValue(id);
+        it ('adds the job to the BullMQ queue with its args and settings', async () => {
             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() };
@@ -147,7 +145,7 @@ describe('Queue', () => {
 
             const instance = bullmqMock.instances.queues[0];
             expect(instance.add).toHaveBeenCalledTimes(1);
-            expect(instance.add).toHaveBeenCalledWith(jobClass.name, { id, args }, settings);
+            expect(instance.add).toHaveBeenCalledWith(jobClass.name, { args }, settings);
         });
     });
 
@@ -166,26 +164,20 @@ describe('Queue', () => {
     });
 
 
-    describe('count-style queries', () => {
-        it.each([
-            ['numQueuedJobs', 'count'],
-            ['numActiveJobs', 'getActiveCount'],
-            ['numFailedJobs', 'getFailedCount'],
-        ])('#%s delegates to bullmq queue.%s and returns its value', async (method, bullMethod) => {
-            const expectedCount = TestHelpers.Faker.Math.randomNumber();
-            const queueInstance = (() => { queue[method](); return bullmqMock.instances.queues[0]; })();
-            queueInstance[bullMethod].mockResolvedValue(expectedCount);
+    describe('#getJobCounts', () => {
+        it ('returns what bullmq reports', async () => {
+            const counts        = { waiting: 1, active: 2, completed: 3, failed: 4, delayed: 5, paused: 6 };
+            const queueInstance = (() => { queue.getJobCounts(); return bullmqMock.instances.queues[0]; })();
+            queueInstance.getJobCounts.mockResolvedValue(counts);
 
-            const result = await queue[method]();
-
-            expect(result).toEqual(expectedCount);
+            await expect(queue.getJobCounts()).resolves.toEqual(counts);
         });
     });
 
 
     describe('#numWorkers', () => {
         it ('returns the length of bullmq queue.getWorkers()', async () => {
-            await queue.numQueuedJobs();
+            await queue.getJobCounts();
             const instance = bullmqMock.instances.queues[0];
             const workers  = Array.from({ length: TestHelpers.Faker.Math.randomNumber(10) }, () => ({}));
             instance.getWorkers.mockResolvedValue(workers);
@@ -195,22 +187,29 @@ describe('Queue', () => {
     });
 
 
-    describe('clear methods', () => {
-        it ('#clearFailedJobs calls bullmq clean(0, null, "failed")', async () => {
-            await queue.clearFailedJobs();
+    describe('#clean', () => {
+        it ('passes the grace period, limit and type through in bullmq order', async () => {
+            const grace = TestHelpers.Faker.Math.randomNumber(100000);
+            const limit = TestHelpers.Faker.Math.randomNumber(100);
+
+            await queue.clean(grace, limit, 'failed');
 
             const instance = bullmqMock.instances.queues[0];
-            expect(instance.clean).toHaveBeenCalledWith(0, null, 'failed');
+            expect(instance.clean).toHaveBeenCalledWith(grace, limit, 'failed');
         });
 
-        it ('#clearCompletedJobs calls bullmq clean(0, null, "completed")', async () => {
-            await queue.clearCompletedJobs();
+        it ('returns the jobs bullmq removed', async () => {
+            const removed       = [TestHelpers.Faker.Text.randomString()];
+            const queueInstance = (() => { queue.clean(0, 1, 'failed'); return bullmqMock.instances.queues[0]; })();
+            queueInstance.clean.mockResolvedValue(removed);
 
-            const instance = bullmqMock.instances.queues[0];
-            expect(instance.clean).toHaveBeenCalledWith(0, null, 'completed');
+            await expect(queue.clean(0, 1, 'failed')).resolves.toEqual(removed);
         });
+    });
 
-        it ('#clearQueuedJobs calls bullmq drain()', async () => {
+
+    describe('#clearQueuedJobs', () => {
+        it ('calls bullmq drain()', async () => {
             await queue.clearQueuedJobs();
 
             const instance = bullmqMock.instances.queues[0];
@@ -219,6 +218,33 @@ describe('Queue', () => {
     });
 
 
+    describe('maximum concurrency', () => {
+        it ('sets the queue maximum', async () => {
+            const maximum = TestHelpers.Faker.Math.randomNumber(20);
+
+            await queue.setMaximumConcurrency(maximum);
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.setGlobalConcurrency).toHaveBeenCalledWith(maximum);
+        });
+
+        it ('reads the queue maximum back', async () => {
+            const maximum       = TestHelpers.Faker.Math.randomNumber(20);
+            const queueInstance = (() => { queue.maximumConcurrency(); return bullmqMock.instances.queues[0]; })();
+            queueInstance.getGlobalConcurrency.mockResolvedValue(maximum);
+
+            await expect(queue.maximumConcurrency()).resolves.toEqual(maximum);
+        });
+
+        it ('removes the queue maximum', async () => {
+            await queue.removeMaximumConcurrency();
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.removeGlobalConcurrency).toHaveBeenCalled();
+        });
+    });
+
+
     describe('job-list queries', () => {
         function buildBullJob(overrides = {}) {
             return {
@@ -251,7 +277,7 @@ describe('Queue', () => {
         it ('#getQueuedJobs maps getJobs(["paused","wait","prioritized","delayed"]) to formatted shape', async () => {
             const bullJob1 = buildBullJob();
             const bullJob2 = buildBullJob();
-            await queue.numQueuedJobs();
+            await queue.getJobCounts();
             const instance = bullmqMock.instances.queues[0];
             instance.getJobs.mockResolvedValue([bullJob1, bullJob2]);
 
@@ -263,7 +289,7 @@ describe('Queue', () => {
 
         it ('#getActiveJobs maps getActive() to formatted shape', async () => {
             const bullJob = buildBullJob();
-            await queue.numQueuedJobs();
+            await queue.getJobCounts();
             const instance = bullmqMock.instances.queues[0];
             instance.getActive.mockResolvedValue([bullJob]);
 
@@ -274,7 +300,7 @@ describe('Queue', () => {
 
         it ('#getFailedJobs maps getFailed() to formatted shape', async () => {
             const bullJob = buildBullJob();
-            await queue.numQueuedJobs();
+            await queue.getJobCounts();
             const instance = bullmqMock.instances.queues[0];
             instance.getFailed.mockResolvedValue([bullJob]);
 
@@ -282,12 +308,32 @@ describe('Queue', () => {
 
             expect(result).toEqual([expectedShape(bullJob)]);
         });
+
+        // The way a single failed job gets fetched for inspection or replay.
+        it ('#getJob maps one job by id to the formatted shape', async () => {
+            const bullJob = buildBullJob();
+            await queue.getJobCounts();
+            const instance = bullmqMock.instances.queues[0];
+            instance.getJob.mockResolvedValue(bullJob);
+
+            const result = await queue.getJob(bullJob.id);
+
+            expect(instance.getJob).toHaveBeenCalledWith(bullJob.id);
+            expect(result).toEqual(expectedShape(bullJob));
+        });
+
+        it ('#getJob returns null when there is no such job', async () => {
+            await queue.getJobCounts();
+            bullmqMock.instances.queues[0].getJob.mockResolvedValue(undefined);
+
+            await expect(queue.getJob('nope')).resolves.toBeNull();
+        });
     });
 
 
     describe('error handler', () => {
         it ('forwards arguments from the bullmq error event to logger.error', async () => {
-            await queue.numQueuedJobs();
+            await queue.getJobCounts();
             const instance      = bullmqMock.instances.queues[0];
             const errorListener = bullmqMock.listenerFor(instance, 'error');
             const err           = new Error(TestHelpers.Faker.Text.randomString());

package/test/jobQueue/worker.test.js

@@ -66,9 +66,32 @@ describe('Worker', () => {
 
             expect(worker.concurrency).toEqual(value);
         });
+
+        it ('takes the constructor option over the environment', () => {
+            process.env.WORKER_CONCURRENCY = '2';
+            const value  = TestHelpers.Faker.Math.randomNumber(50);
+            const worker = new Worker('q', { concurrency: value });
+
+            expect(worker.concurrency).toEqual(value);
+        });
+    });
+
+
+    describe('#rateLimit', () => {
+        it ('is null when the option is absent', () => {
+            expect(new Worker('q').rateLimit).toBeNull();
+        });
+
+        it ('returns the configured limit', () => {
+            const rateLimit = { max: 100, duration: 60000 };
+
+            expect(new Worker('q', { rateLimit }).rateLimit).toBe(rateLimit);
+        });
     });
 
 
+
+
     describe('#fullQueueName', () => {
         it ('appends the current NODE_ENV', () => {
             const name   = TestHelpers.Faker.Text.randomString();
@@ -113,6 +136,17 @@ describe('Worker', () => {
                 },
             });
         });
+
+        it ('passes a configured rate limit to BullMQ as its limiter', () => {
+            const rateLimit = { max: 100, duration: 60000 };
+            const worker    = new Worker('q', { rateLimit });
+
+            expect(worker.workerOptions.limiter).toBe(rateLimit);
+        });
+
+        it ('omits the limiter when no rate limit is configured', () => {
+            expect(new Worker('q').workerOptions).not.toHaveProperty('limiter');
+        });
     });
 
 
@@ -147,6 +181,52 @@ describe('Worker', () => {
             const events     = bullWorker.on.mock.calls.map(([event]) => event);
             expect(events).toEqual(expect.arrayContaining(['completed', 'progress', 'failed', 'error']));
         });
+
+        it ('applies a configured maximum concurrency to the queue', async () => {
+            const maximumConcurrency = TestHelpers.Faker.Math.randomNumber(20);
+            const worker             = buildWorker(Worker, 'queueX', { maximumConcurrency });
+
+            await worker.listen();
+
+            expect(worker.queue.setMaximumConcurrency).toHaveBeenCalledWith(maximumConcurrency);
+            expect(worker.queue.removeMaximumConcurrency).not.toHaveBeenCalled();
+        });
+
+        it ('removes the queue maximum concurrency when none is configured', async () => {
+            const worker = buildWorker(Worker, 'queueX');
+
+            await worker.listen();
+
+            expect(worker.queue.removeMaximumConcurrency).toHaveBeenCalled();
+            expect(worker.queue.setMaximumConcurrency).not.toHaveBeenCalled();
+        });
+
+        it ('logs the maximum concurrency and the rate limit it applied', async () => {
+            const worker = buildWorker(Worker, 'queueX', {
+                maximumConcurrency: 8,
+                rateLimit:          { max: 100, duration: 60000 },
+            });
+
+            await worker.listen();
+
+            const info = worker.loggerLibrary.worker.info.mock.calls.map(([message]) => message);
+            expect(info).toEqual(expect.arrayContaining([
+                'Queue queueX-test maximum concurrency is 8',
+                'Queue queueX-test rate limit is 100 per 60000ms',
+            ]));
+        });
+    });
+
+
+    describe('#close', () => {
+        it ('closes the BullMQ worker', async () => {
+            const worker = buildWorker(Worker);
+            await worker.listen();
+
+            await worker.close();
+
+            expect(bullmqMock.instances.workers[0].close).toHaveBeenCalled();
+        });
     });
 
 
@@ -177,6 +257,46 @@ describe('Worker', () => {
             expect(afterCount).toEqual(beforeCount);
         });
 
+
+        it ('falls back to the job that opted in as default for its queue', async () => {
+            const worker    = buildWorker(Worker, 'beta');
+            await worker.listen();
+            const processor = bullmqMock.instances.workers[0].processor;
+
+            // The name bull writes for an unnamed job, which matches no registered job class.
+            const legacy = buildFakeBullJob({ name: '__default__', data: 'raw payload' });
+
+            await expect(processor(legacy)).resolves.toBeGreaterThanOrEqual(0);
+        });
+
+
+        // The job scan is memoized for the process, but the default job is per worker. Assigning it
+        // inside the memo left every worker after the first without one, so only the first queue in
+        // a process could consume a legacy payload.
+        it ('gives a second worker in the process its own default job', async () => {
+            const first = buildWorker(Worker, 'alpha');
+            await first.listen();
+
+            const second = buildWorker(Worker, 'beta');
+            await second.listen();
+            const processor = bullmqMock.instances.workers[1].processor;
+
+            const legacy = buildFakeBullJob({ name: '__default__', data: 'raw payload' });
+
+            await expect(processor(legacy)).resolves.toBeGreaterThanOrEqual(0);
+        });
+
+
+        it ('leaves a worker whose queue has no default job rejecting unknown names', async () => {
+            const worker = buildWorker(Worker, 'alpha');
+            await worker.listen();
+            const processor = bullmqMock.instances.workers[0].processor;
+
+            const legacy = buildFakeBullJob({ name: '__default__', data: 'raw payload' });
+
+            await expect(processor(legacy)).rejects.toEqual('Unknown Job: __default__');
+        });
+
         it ('logs each registered job via verbose when NODE_ENV is not test', async () => {
             process.env.NODE_ENV = 'development';
             const worker = buildWorker(Worker);
@@ -215,12 +335,29 @@ describe('Worker', () => {
             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 });
+            const fakeBull  = buildFakeBullJob({ name: 'TestJobA', id, data: { args }, updateProgress });
 
             await processor(fakeBull);
 
             expect(runSpy).toHaveBeenCalledTimes(1);
-            expect(runSpy).toHaveBeenCalledWith(id, args, expect.any(Function));
+            expect(runSpy).toHaveBeenCalledWith(id, args, expect.any(Function), expect.any(Object));
+            runSpy.mockRestore();
+        });
+
+        it ('tells the job which attempt it is on', async () => {
+            const worker    = buildWorker(Worker);
+            const processor = await listenAndGetProcessor(worker);
+            const runSpy    = jest.spyOn(TestJobA.prototype, '_run').mockResolvedValue(undefined);
+            const fakeBull  = buildFakeBullJob({ attemptsMade: 2, opts: { attempts: 3 } });
+
+            await processor(fakeBull);
+
+            expect(runSpy).toHaveBeenCalledWith(
+                expect.anything(),
+                expect.anything(),
+                expect.any(Function),
+                { attempt: 3, maxAttempts: 3 },
+            );
             runSpy.mockRestore();
         });
 
@@ -296,7 +433,8 @@ describe('Worker', () => {
             const id       = TestHelpers.Faker.Text.randomString();
             const fakeBull = buildFakeBullJob({
                 name:         'TestJobA',
-                data:         { id, args: [] },
+                id,
+                data:         { args: [] },
                 attemptsMade: 1,
                 opts:         { attempts: 5 },
             });
@@ -345,7 +483,8 @@ describe('Worker', () => {
             const id       = TestHelpers.Faker.Text.randomString();
             const fakeBull = buildFakeBullJob({
                 name:         'TestJobA',
-                data:         { id, args: [] },
+                id,
+                data:         { args: [] },
                 attemptsMade: 0,
                 opts:         { attempts: 3 },
             });
@@ -401,19 +540,6 @@ describe('Worker', () => {
             expect(worker.apm.recordCustomEvent).not.toHaveBeenCalledWith('JobCompleted', expect.anything());
             expect(worker.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');
-        });
-        */
     });
 
 
@@ -431,7 +557,7 @@ describe('Worker', () => {
             const id         = TestHelpers.Faker.Text.randomString();
             const duration   = TestHelpers.Faker.Math.randomNumber(10000);
 
-            handler({ name: 'TestJobA', data: { id } }, duration);
+            handler({ name: 'TestJobA', id }, duration);
 
             const child = worker.loggerLibrary.worker.child.mock.results[0].value;
             expect(child.debug).toHaveBeenCalledWith(`Completed in ${duration}ms`);
@@ -444,7 +570,7 @@ describe('Worker', () => {
             const id         = TestHelpers.Faker.Text.randomString();
             const payload    = { step: TestHelpers.Faker.Text.randomString() };
 
-            handler({ name: 'TestJobA', data: { id } }, payload);
+            handler({ name: 'TestJobA', id }, payload);
 
             const child = worker.loggerLibrary.worker.child.mock.results[0].value;
             expect(child.debug).toHaveBeenCalledWith(payload);
@@ -456,7 +582,7 @@ describe('Worker', () => {
             const handler    = bullmqMock.listenerFor(bullWorker, 'failed');
             const job        = {
                 name: 'TestJobA',
-                data: { id: 't1' },
+                id:   't1',
                 attemptsMade: 1,
                 opts: { attempts: 3 },
             };
@@ -473,7 +599,7 @@ describe('Worker', () => {
             const handler    = bullmqMock.listenerFor(bullWorker, 'failed');
             const job        = {
                 name: 'TestJobA',
-                data: { id: 't1' },
+                id:   't1',
                 attemptsMade: 3,
                 opts: { attempts: 3 },
             };

package/test/logger/index.test.js

@@ -43,6 +43,69 @@ describe('Logger', () => {
 
             expect(root[childScope].id).toEqual(id);
         });
+
+        it ('returns the scoped logger it registered', () => {
+            const childScope = randomScope();
+            const root       = new Logger(randomScope());
+
+            expect(root.addScope(childScope)).toBe(root[childScope]);
+        });
+
+        it ('returns the same logger when the scope is already registered', () => {
+            const childScope = randomScope();
+            const root       = new Logger(randomScope());
+
+            expect(root.addScope(childScope)).toBe(root.addScope(childScope));
+        });
+
+        it ('throws when the name is already taken by something that is not a logger', () => {
+            const root = new Logger(randomScope());
+
+            expect(() => root.addScope('child')).toThrow(/child/);
+        });
+    });
+
+
+    describe('#scope', () => {
+        it ('registers and returns a scope whose name is not lowercase', () => {
+            const root = new Logger(randomScope());
+            const name = `S_${TestHelpers.Faker.Text.randomString()}`;
+
+            const scoped = root.scope(name);
+
+            expect(scoped.scopes).toContain(name.toLowerCase());
+        });
+
+        it ('reaches the scope by the name it was given and by the lowercased one', () => {
+            const root = new Logger(randomScope());
+            const name = `S_${TestHelpers.Faker.Text.randomString()}`;
+
+            const scoped = root.scope(name);
+
+            expect(root[name]).toBe(scoped);
+            expect(root[name.toLowerCase()]).toBe(scoped);
+        });
+
+        it ('returns the same logger on every call', () => {
+            const root = new Logger(randomScope());
+            const name = `S_${TestHelpers.Faker.Text.randomString()}`;
+
+            expect(root.scope(name)).toBe(root.scope(name));
+        });
+
+        it ('returns the existing scope when the same name arrives in another casing', () => {
+            const root = new Logger(randomScope());
+            const name = `S_${TestHelpers.Faker.Text.randomString()}`;
+
+            expect(root.scope(name.toUpperCase())).toBe(root.scope(name));
+        });
+
+        it ('tags the scope lowercased whichever spelling registered it', () => {
+            const name = `S_${TestHelpers.Faker.Text.randomString()}`;
+            const root = new Logger(randomScope());
+
+            expect(root.scope(name).scopes).not.toContain(name);
+        });
     });
 
 
@@ -83,5 +146,55 @@ describe('Logger', () => {
 
             expect(result.message).toEqual(`[TS][INFO][${scopeA.toUpperCase()}][${scopeB.toUpperCase()}] hello`);
         });
+
+
+        // Winston hands a logged Error through as `info`, so assigning onto it rewrote the caller's
+        // error with the whole formatted line.
+        it ('leaves the object it was given untouched', () => {
+            const logger = new Logger(randomScope());
+            const info   = { level: 'info', timestamp: 'TS', message: 'hello' };
+
+            logger.messageFormatter(info);
+
+            expect(info.message).toEqual('hello');
+        });
+
+        it ('does not rewrite the message of an error it formats', () => {
+            const logger = new Logger(randomScope());
+            const error  = new Error('boom');
+            error.level     = 'error';
+            error.timestamp = 'TS';
+
+            const result = logger.messageFormatter(error);
+
+            expect(error.message).toEqual('boom');
+            expect(result.message).toContain('boom');
+        });
+
+        // Formatting the same error twice used to compound the prefix, because the first call had
+        // already written its output back onto the error.
+        it ('formats the same error the same way every time', () => {
+            const logger = new Logger(randomScope());
+            const error  = new Error('boom');
+            error.level     = 'error';
+            error.timestamp = 'TS';
+
+            const first  = logger.messageFormatter(error);
+            const second = logger.messageFormatter(error);
+
+            expect(second.message).toEqual(first.message);
+        });
+
+        // The transports read these, so a copy that dropped them would stop formatting output.
+        it ("carries winston's own symbol properties onto the copy", () => {
+            const logger  = new Logger(randomScope());
+            const marker  = Symbol.for('level');
+            const info    = { level: 'info', timestamp: 'TS', message: 'hello' };
+            info[marker]  = 'info';
+
+            const result = logger.messageFormatter(info);
+
+            expect(result[marker]).toEqual('info');
+        });
     });
 });

package/test/server/controllerMixins/renderer.test.js

@@ -751,6 +751,65 @@ describe('VidaServerController', () => {
     });
 
 
+    describe('#renderBinary', () => {
+        let request;
+        let response;
+        let controller;
+
+
+        beforeEach(() => {
+            request    = {};
+            response   = {
+                setHeader:  jest.fn(),
+                attachment: jest.fn(),
+                send:       jest.fn(),
+            };
+            controller = new FooController(request, response);
+        });
+
+
+        it ('sends the body untouched with the given content type', () => {
+            const body = Buffer.from([0x00, 0x01, 0x02]);
+
+            controller.renderBinary(body, { contentType: 'audio/wav' });
+
+            expect(response.setHeader).toHaveBeenCalledWith('Content-Type', 'audio/wav');
+            expect(response.send).toHaveBeenCalledWith(body);
+        });
+
+
+        it ('marks the response rendered', () => {
+            controller.renderBinary(Buffer.from('x'), { contentType: 'audio/wav' });
+
+            expect(controller.rendered).toBe(true);
+        });
+
+
+        it ('sets a download filename when one is given', () => {
+            controller.renderBinary(Buffer.from('x'), { contentType: 'audio/wav', filename: 'call.wav' });
+
+            expect(response.attachment).toHaveBeenCalledWith('call.wav');
+        });
+
+
+        // Without a filename the body is displayed rather than downloaded.
+        it ('sets no filename when none is given', () => {
+            controller.renderBinary(Buffer.from('x'), { contentType: 'audio/wav' });
+
+            expect(response.attachment).not.toHaveBeenCalled();
+        });
+
+
+        it ('is a no-op once something has already been rendered', () => {
+            controller.markRendered();
+
+            controller.renderBinary(Buffer.from('x'), { contentType: 'audio/wav' });
+
+            expect(response.send).not.toHaveBeenCalled();
+        });
+    });
+
+
     describe('#renderFile', () => {
         let request;
         let response;