@vida-global/core 1.4.5 → 2.0.0

package/test/jobQueue/queue.test.js

@@ -0,0 +1,320 @@
+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() };
+});
+
+
+let bullmqMock;
+let getQueue;
+let logger;
+let randomUUID;
+let restoreEnv;
+
+beforeEach(() => {
+    jest.resetModules();
+    restoreEnv = setupJobQueueEnv();
+
+    bullmqMock      = require('./helpers/bullmqMock');
+    ({ getQueue }   = require('../../lib/jobQueue/queue'));
+    ({ logger }     = require('../../lib/logger'));
+    ({ randomUUID } = require('crypto'));
+});
+
+
+afterEach(() => {
+    restoreEnv();
+    jest.clearAllMocks();
+});
+
+
+function expectedConnection() {
+    return {
+        host:     process.env.REDIS_BULL_HOST,
+        password: process.env.REDIS_BULL_PASSWORD,
+        port:     process.env.REDIS_BULL_PORT,
+    };
+}
+
+
+describe('getQueue', () => {
+    it ('returns a Queue with the given queueName', () => {
+        const name = TestHelpers.Faker.Text.randomString();
+
+        const queue = getQueue(name);
+
+        expect(queue.queueName).toEqual(name);
+    });
+
+    it ('memoizes by full queue name', () => {
+        const name = TestHelpers.Faker.Text.randomString();
+
+        const first  = getQueue(name);
+        const second = getQueue(name);
+
+        expect(second).toBe(first);
+    });
+
+    it ('returns different instances for different names', () => {
+        const queueA = getQueue(TestHelpers.Faker.Text.randomString());
+        const queueB = getQueue(TestHelpers.Faker.Text.randomString());
+
+        expect(queueB).not.toBe(queueA);
+    });
+
+    it ('treats the same raw name under different NODE_ENVs as different queues', () => {
+        const name = TestHelpers.Faker.Text.randomString();
+
+        process.env.NODE_ENV = 'test';
+        const inTest = getQueue(name);
+
+        process.env.NODE_ENV = 'staging';
+        const inStaging = getQueue(name);
+
+        expect(inStaging).not.toBe(inTest);
+    });
+});
+
+
+describe('Queue', () => {
+    let queueName;
+    let queue;
+
+    beforeEach(() => {
+        queueName = TestHelpers.Faker.Text.randomString();
+        queue     = getQueue(queueName);
+    });
+
+
+    describe('#queueName', () => {
+        it ('returns the raw queue name', () => {
+            expect(queue.queueName).toEqual(queueName);
+        });
+    });
+
+
+    describe('#fullQueueName', () => {
+        it ('appends the current NODE_ENV', () => {
+            expect(queue.fullQueueName).toEqual(`${queueName}-test`);
+        });
+    });
+
+
+    describe('#logger', () => {
+        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);
+        });
+    });
+
+
+    describe('lazy BullMQ.Queue construction', () => {
+        it ('does not construct the BullMQ queue until a method needs it', () => {
+            expect(bullmqMock.instances.queues).toHaveLength(0);
+        });
+
+        it ('constructs the BullMQ queue with fullQueueName and connection options on first use', async () => {
+            await queue.numQueuedJobs();
+
+            expect(bullmqMock.instances.queues).toHaveLength(1);
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.name).toEqual(`${queueName}-test`);
+            expect(instance.options).toEqual({ connection: expectedConnection() });
+        });
+
+        it ('reuses the same BullMQ queue across multiple method calls', async () => {
+            await queue.numQueuedJobs();
+            await queue.numActiveJobs();
+            await queue.close();
+
+            expect(bullmqMock.instances.queues).toHaveLength(1);
+        });
+
+        it ('registers an error handler on the BullMQ queue', async () => {
+            await queue.numQueuedJobs();
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.on).toHaveBeenCalledWith('error', expect.any(Function));
+        });
+    });
+
+
+    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);
+            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() };
+
+            await queue.queueJob(jobClass, args, settings);
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.add).toHaveBeenCalledTimes(1);
+            expect(instance.add).toHaveBeenCalledWith(jobClass.name, { id, args }, settings);
+        });
+    });
+
+
+    describe.each([
+        ['close',  'close',  []],
+        ['pause',  'pause',  []],
+        ['resume', 'resume', []],
+    ])('#%s', (method, bullMethod, expectedArgs) => {
+        it (`calls bullmq queue.${bullMethod}`, async () => {
+            await queue[method]();
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance[bullMethod]).toHaveBeenCalledWith(...expectedArgs);
+        });
+    });
+
+
+    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);
+
+            const result = await queue[method]();
+
+            expect(result).toEqual(expectedCount);
+        });
+    });
+
+
+    describe('#numWorkers', () => {
+        it ('returns the length of bullmq queue.getWorkers()', async () => {
+            await queue.numQueuedJobs();
+            const instance = bullmqMock.instances.queues[0];
+            const workers  = Array.from({ length: TestHelpers.Faker.Math.randomNumber(10) }, () => ({}));
+            instance.getWorkers.mockResolvedValue(workers);
+
+            await expect(queue.numWorkers()).resolves.toEqual(workers.length);
+        });
+    });
+
+
+    describe('clear methods', () => {
+        it ('#clearFailedJobs calls bullmq clean(0, null, "failed")', async () => {
+            await queue.clearFailedJobs();
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.clean).toHaveBeenCalledWith(0, null, 'failed');
+        });
+
+        it ('#clearCompletedJobs calls bullmq clean(0, null, "completed")', async () => {
+            await queue.clearCompletedJobs();
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.clean).toHaveBeenCalledWith(0, null, 'completed');
+        });
+
+        it ('#clearQueuedJobs calls bullmq drain()', async () => {
+            await queue.clearQueuedJobs();
+
+            const instance = bullmqMock.instances.queues[0];
+            expect(instance.drain).toHaveBeenCalled();
+        });
+    });
+
+
+    describe('job-list queries', () => {
+        function buildBullJob(overrides = {}) {
+            return {
+                queue:           { name: TestHelpers.Faker.Text.randomString() },
+                name:            TestHelpers.Faker.Text.randomString(),
+                data:            { args: [TestHelpers.Faker.Text.randomString()] },
+                id:              TestHelpers.Faker.Text.randomString(),
+                attemptsMade:    TestHelpers.Faker.Math.randomNumber(10),
+                attemptsStarted: TestHelpers.Faker.Math.randomNumber(10),
+                progress:        TestHelpers.Faker.Math.randomNumber(100),
+                failedReason:    TestHelpers.Faker.Text.randomString(),
+                ...overrides,
+            };
+        }
+
+        function expectedShape(bullJob) {
+            return {
+                queueName:       bullJob.queue.name,
+                name:            bullJob.name,
+                args:            bullJob.data,
+                id:              bullJob.id,
+                attemptsMade:    bullJob.attemptsMade,
+                attemptsStarted: bullJob.attemptsStarted,
+                progress:        bullJob.progress,
+                failedReason:    bullJob.failedReason,
+            };
+        }
+
+
+        it ('#getQueuedJobs maps getJobs(["paused","wait","prioritized","delayed"]) to formatted shape', async () => {
+            const bullJob1 = buildBullJob();
+            const bullJob2 = buildBullJob();
+            await queue.numQueuedJobs();
+            const instance = bullmqMock.instances.queues[0];
+            instance.getJobs.mockResolvedValue([bullJob1, bullJob2]);
+
+            const result = await queue.getQueuedJobs();
+
+            expect(instance.getJobs).toHaveBeenCalledWith(['paused', 'wait', 'prioritized', 'delayed']);
+            expect(result).toEqual([expectedShape(bullJob1), expectedShape(bullJob2)]);
+        });
+
+        it ('#getActiveJobs maps getActive() to formatted shape', async () => {
+            const bullJob = buildBullJob();
+            await queue.numQueuedJobs();
+            const instance = bullmqMock.instances.queues[0];
+            instance.getActive.mockResolvedValue([bullJob]);
+
+            const result = await queue.getActiveJobs();
+
+            expect(result).toEqual([expectedShape(bullJob)]);
+        });
+
+        it ('#getFailedJobs maps getFailed() to formatted shape', async () => {
+            const bullJob = buildBullJob();
+            await queue.numQueuedJobs();
+            const instance = bullmqMock.instances.queues[0];
+            instance.getFailed.mockResolvedValue([bullJob]);
+
+            const result = await queue.getFailedJobs();
+
+            expect(result).toEqual([expectedShape(bullJob)]);
+        });
+    });
+
+
+    describe('error handler', () => {
+        it ('forwards arguments from the bullmq error event to logger.error', async () => {
+            await queue.numQueuedJobs();
+            const instance      = bullmqMock.instances.queues[0];
+            const errorListener = bullmqMock.listenerFor(instance, 'error');
+            const err           = new Error(TestHelpers.Faker.Text.randomString());
+
+            errorListener(err);
+
+            const child = logger.queue.child.mock.results[0].value;
+            expect(child.error).toHaveBeenCalledWith(err);
+        });
+    });
+});