consumer-pgmq 2.0.1 → 3.1.0

package/tests/consumer.spec.ts

@@ -1,6 +1,5 @@
 import Consumer from '../src/consumer'
 import { Message, QueueDriver, Options } from '../src/type'
-import timersPromises from 'node:timers/promises'
 
 describe('Consumer', () => {
     let queueDriver: jest.Mocked<QueueDriver>
@@ -18,6 +17,9 @@ describe('Consumer', () => {
             get: jest.fn(),
             pop: jest.fn(),
             delete: jest.fn(),
+            send: jest.fn(),
+            allocateConsumer: jest.fn(),
+            freeConsumer: jest.fn()
         }
         jest.useFakeTimers();
     })
@@ -28,6 +30,165 @@ describe('Consumer', () => {
     })
 
 
+    it('Should throw error if set dead letter queue and no set total retries before send to dlq', async () => {
+        try {
+            queueDriver.get.mockResolvedValueOnce({ data: [message], error: null })
+            queueDriver.delete.mockResolvedValueOnce({ error: null })
+            queueDriver.get.mockResolvedValueOnce({ data: [], error: null })
+
+            const handler = jest.fn(async () => { })
+            const consumer = new Consumer(
+                {
+                    queueName: 'q',
+                    consumeType: 'read',
+                    visibilityTime: 1,
+                    poolSize: 1,
+                    timeMsWaitBeforeNextPolling: 1,
+                    enabledPolling: true,
+                    queueNameDlq: 'q_dlq',
+                },
+                handler,
+                queueDriver
+            )
+
+            const onFinish = jest.fn()
+            consumer.on('finish', onFinish)
+            await consumer.start()
+        } catch (error: any) {
+            expect(error).toBeInstanceOf(Error)
+            expect(error.message).toBe('The option totalRetriesBeforeSendToDlq is required when queueNameDlq is set')
+        }
+    })
+
+
+    it('Should send message to dlq if read count is greater than total retries before send to dlq', async () => {
+        const messageToSendDlq = { ...message }
+        messageToSendDlq.read_ct = 3
+        messageToSendDlq.msg_id = 2
+        queueDriver.get.mockResolvedValueOnce({ data: [messageToSendDlq], error: null })
+        queueDriver.delete.mockResolvedValueOnce({ error: null })
+        queueDriver.get.mockResolvedValueOnce({ data: [], error: null })
+        queueDriver.send.mockResolvedValueOnce({ error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'read',
+                visibilityTime: 1,
+                poolSize: 1,
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true,
+                queueNameDlq: 'q_dlq',
+                totalRetriesBeforeSendToDlq: 2
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledTimes(0)
+        expect(onFinish).toHaveBeenCalledTimes(0)
+        expect(queueDriver.delete).toHaveBeenCalledTimes(1)
+        expect(queueDriver.send).toHaveBeenCalledTimes(1)
+        expect(queueDriver.send).toHaveBeenCalledWith(
+            'q_dlq', messageToSendDlq.message, expect.any(AbortSignal)
+        )
+    })
+
+    it('Should send 2 messages to dlq if read count is greater than total retries before send to dlq', async () => {
+        const messageToSendDlq = { ...message }
+        messageToSendDlq.read_ct = 3
+        messageToSendDlq.msg_id = 2
+        queueDriver.get.mockResolvedValueOnce({
+            data: [
+                messageToSendDlq, messageToSendDlq
+            ], error: null
+        })
+        queueDriver.delete.mockResolvedValueOnce({ error: null })
+        queueDriver.get.mockResolvedValueOnce({ data: [], error: null })
+        queueDriver.send.mockResolvedValue({ error: null })
+
+        const handler = jest.fn(async () => { })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'read',
+                visibilityTime: 1,
+                poolSize: 2,
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true,
+                queueNameDlq: 'q_dlq',
+                totalRetriesBeforeSendToDlq: 2
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledTimes(0)
+        expect(onFinish).toHaveBeenCalledTimes(0)
+        expect(queueDriver.delete).toHaveBeenCalledTimes(2)
+        expect(queueDriver.send).toHaveBeenCalledTimes(2)
+        expect(queueDriver.send).toHaveBeenCalledWith(
+            'q_dlq', messageToSendDlq.message, expect.any(AbortSignal)
+        )
+    })
+
+
+    it('Should send only 1 message to dlq if read count is greater than total retries before send to dlq', async () => {
+        const messageToSendDlq = { ...message }
+        messageToSendDlq.read_ct = 3
+        messageToSendDlq.msg_id = 2
+
+        const messageToSendDlq2 = { ...message }
+        messageToSendDlq2.read_ct = 1
+        messageToSendDlq2.msg_id = 3
+        queueDriver.get.mockResolvedValueOnce({
+            data: [
+                messageToSendDlq, messageToSendDlq2
+            ], error: null
+        })
+        queueDriver.delete.mockResolvedValue({ error: null })
+        queueDriver.get.mockResolvedValueOnce({ data: [], error: null })
+        queueDriver.send.mockResolvedValue({ error: null })
+
+        const handler = jest.fn(async () => {
+            return Promise.resolve()
+        })
+        const consumer = new Consumer(
+            {
+                queueName: 'q',
+                consumeType: 'read',
+                visibilityTime: 1,
+                poolSize: 2,
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true,
+                queueNameDlq: 'q_dlq',
+                totalRetriesBeforeSendToDlq: 2
+            },
+            handler,
+            queueDriver
+        )
+
+        const onFinish = jest.fn()
+        consumer.on('finish', onFinish)
+        await consumer.start()
+
+        expect(handler).toHaveBeenCalledTimes(1)
+        expect(onFinish).toHaveBeenCalledTimes(1)
+        expect(queueDriver.delete).toHaveBeenCalledTimes(2)
+        expect(queueDriver.send).toHaveBeenCalledTimes(1)
+        expect(queueDriver.send).toHaveBeenCalledWith(
+            'q_dlq', messageToSendDlq.message, expect.any(AbortSignal)
+        )
+    })
 
     it('Should not process message if read method does not return any message second polling', async () => {
         queueDriver.get.mockResolvedValueOnce({ data: [message], error: null })
@@ -41,7 +202,8 @@ describe('Consumer', () => {
                 consumeType: 'read',
                 visibilityTime: 1,
                 poolSize: 1,
-                timeMsWaitBeforeNextPolling: 1
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true
             },
             handler,
             queueDriver
@@ -69,7 +231,8 @@ describe('Consumer', () => {
                 consumeType: 'pop',
                 visibilityTime: 1,
                 poolSize: 1,
-                timeMsWaitBeforeNextPolling: 1
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true
             },
             handler,
             queueDriver
@@ -95,7 +258,8 @@ describe('Consumer', () => {
                 consumeType: 'pop',
                 visibilityTime: 1,
                 poolSize: 1,
-                timeMsWaitBeforeNextPolling: 1
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true
             },
             handler,
             queueDriver
@@ -121,7 +285,8 @@ describe('Consumer', () => {
                 consumeType: 'read',
                 visibilityTime: 1,
                 poolSize: 1,
-                timeMsWaitBeforeNextPolling: 1
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true
             },
             handler,
             queueDriver
@@ -150,7 +315,8 @@ describe('Consumer', () => {
                 consumeType: 'read',
                 visibilityTime: 1,
                 poolSize: 1,
-                timeMsWaitBeforeNextPolling: 1
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true
             },
             handler,
             queueDriver
@@ -179,7 +345,8 @@ describe('Consumer', () => {
                 consumeType: 'read',
                 visibilityTime: 1,
                 poolSize: 4,
-                timeMsWaitBeforeNextPolling: 1
+                timeMsWaitBeforeNextPolling: 1,
+                enabledPolling: true
             },
             handler,
             queueDriver
@@ -230,8 +397,35 @@ describe('Consumer', () => {
 
         await consumer.start()
 
+        expect(queueDriver.allocateConsumer).toHaveBeenCalledTimes(0)
         expect(onError).toHaveBeenCalled()
         expect((onError.mock.calls[0][0] as Error).message)
             .toBe('visibilityTime is required for read')
     })
+
+
+    it('Should call allocateConsumer when option enableControlConsumer is true', async () => {
+        queueDriver.allocateConsumer.mockResolvedValue({ id: '1' })
+        const consumer = new Consumer(
+            { queueName: 'q', consumeType: 'read', enableControlConsumer: true } as Options,
+            async () => { },
+            queueDriver
+        )
+
+        await consumer.start()
+
+        expect(queueDriver.allocateConsumer).toHaveBeenCalled()
+    })
+
+
+    it('Should call freeConsumer when option enableControlConsumer is true and process exit', async () => {
+        queueDriver.allocateConsumer.mockResolvedValue({ id: '1' })
+        const consumer = new Consumer(
+            { queueName: 'q', consumeType: 'read', enableControlConsumer: true } as Options,
+            async () => { },
+            queueDriver
+        )
+
+        await consumer.start()
+    })
 })