@vida-global/core 2.3.6 → 2.4.0

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');
+        });
     });
 });