@quatrain/queue-amqp 1.3.3 → 1.3.4

package/dist/AmqpQueueAdapter.test.js

@@ -8,36 +8,37 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const AmqpQueueAdapter_1 = require("./AmqpQueueAdapter");
-const amqp_client_1 = require("@cloudamqp/amqp-client");
+const amqplib_1 = __importDefault(require("amqplib"));
 const queue_1 = require("@quatrain/queue");
-// Mock the @cloudamqp/amqp-client library
-jest.mock('@cloudamqp/amqp-client');
-// Mock @quatrain/queue to spy on Queue.info
-jest.mock('@quatrain/queue', () => (Object.assign(Object.assign({}, jest.requireActual('@quatrain/queue')), { Queue: {
-        info: jest.fn(),
-    } })));
-const mockPublish = jest
-    .fn()
-    .mockResolvedValue({ confirmId: 'mock-confirm-id' });
-const mockSubscribe = jest.fn();
-const mockQueue = jest.fn().mockResolvedValue({
-    publish: mockPublish,
-    subscribe: mockSubscribe,
-});
-const mockChannel = jest.fn().mockResolvedValue({
-    queue: mockQueue,
+// Mock the amqplib library
+jest.mock('amqplib');
+const mockSendToQueue = jest.fn();
+const mockAck = jest.fn();
+const mockNack = jest.fn();
+const mockAssertQueue = jest.fn().mockResolvedValue({});
+const mockPrefetch = jest.fn().mockResolvedValue({});
+const mockConsume = jest.fn().mockResolvedValue({});
+const mockCloseChannel = jest.fn().mockResolvedValue({});
+const mockCreateChannel = jest.fn().mockResolvedValue({
+    sendToQueue: mockSendToQueue,
+    assertQueue: mockAssertQueue,
+    prefetch: mockPrefetch,
+    consume: mockConsume,
+    ack: mockAck,
+    nack: mockNack,
+    close: mockCloseChannel,
 });
+const mockCloseConnection = jest.fn().mockResolvedValue({});
 const mockConnect = jest.fn().mockResolvedValue({
-    channel: mockChannel,
-});
-const AMQPClientMock = amqp_client_1.AMQPClient;
-AMQPClientMock.mockImplementation(() => {
-    return {
-        connect: mockConnect,
-    };
+    createChannel: mockCreateChannel,
+    close: mockCloseConnection,
 });
+amqplib_1.default.connect.mockImplementation(mockConnect);
 describe('AmqpQueueAdapter', () => {
     const params = {
         config: {
@@ -48,21 +49,48 @@ describe('AmqpQueueAdapter', () => {
         },
         topic: 'default-topic',
     };
+    let mockProcessExit;
+    let mockLogger;
+    beforeAll(() => {
+        mockLogger = {
+            info: jest.fn(),
+            debug: jest.fn(),
+            warn: jest.fn(),
+            error: jest.fn(),
+        };
+        jest.spyOn(queue_1.Queue.logger, 'clone').mockReturnValue(mockLogger);
+    });
     beforeEach(() => {
-        // Clear all instances and calls to constructor and all methods:
-        AMQPClientMock.mockClear();
+        mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
         mockConnect.mockClear();
-        mockChannel.mockClear();
-        mockQueue.mockClear();
-        mockPublish.mockClear();
-        mockSubscribe.mockClear();
-        queue_1.Queue.info.mockClear();
+        mockCreateChannel.mockClear();
+        mockCloseConnection.mockClear();
+        mockSendToQueue.mockClear();
+        mockAssertQueue.mockClear();
+        mockPrefetch.mockClear();
+        mockConsume.mockClear();
+        mockAck.mockClear();
+        mockNack.mockClear();
+        mockCloseChannel.mockClear();
+        mockLogger.info.mockClear();
+        mockLogger.debug.mockClear();
+        mockLogger.warn.mockClear();
+        mockLogger.error.mockClear();
     });
-    it('should construct with default and custom parameters', () => {
-        new AmqpQueueAdapter_1.AmqpQueueAdapter({ config: {} });
-        expect(AMQPClientMock).toHaveBeenCalledWith('amqp://guest:guest@localhost:5672?frameMax=0');
-        new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
-        expect(AMQPClientMock).toHaveBeenCalledWith('amqp://test-user:test-password@test-host:1234?frameMax=0');
+    afterEach(() => {
+        mockProcessExit.mockRestore();
+    });
+    describe('connection parameters', () => {
+        it('should connect with default parameters', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter({ config: {} });
+            yield adapter._connect();
+            expect(mockConnect).toHaveBeenCalledWith('amqp://guest:guest@localhost:5672');
+        }));
+        it('should connect with custom parameters', () => __awaiter(void 0, void 0, void 0, function* () {
+            const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
+            yield adapter._connect();
+            expect(mockConnect).toHaveBeenCalledWith('amqp://test-user:test-password@test-host:1234');
+        }));
     });
     describe('send', () => {
         it('should send a message to the specified topic', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -71,12 +99,11 @@ describe('AmqpQueueAdapter', () => {
             const topic = 'test-topic';
             const confirmId = yield adapter.send(data, topic);
             expect(mockConnect).toHaveBeenCalledTimes(1);
-            expect(mockChannel).toHaveBeenCalledTimes(1);
-            expect(mockQueue).toHaveBeenCalledWith(topic);
-            expect(mockPublish).toHaveBeenCalledWith(Buffer.from(JSON.stringify(data)), { deliveryMode: 2 });
-            expect(queue_1.Queue.info).toHaveBeenCalledWith(`[AMQP] Sending message to ${topic}`);
-            expect(queue_1.Queue.info).toHaveBeenCalledWith(`[AMQP] Message send with id mock-confirm-id`);
-            expect(confirmId).toBe('mock-confirm-id');
+            expect(mockCreateChannel).toHaveBeenCalledTimes(1);
+            expect(mockSendToQueue).toHaveBeenCalledWith(topic, Buffer.from(JSON.stringify(data)));
+            expect(mockCloseChannel).toHaveBeenCalledTimes(1);
+            expect(mockLogger.info).toHaveBeenCalledWith(`Sending message to ${topic}`);
+            expect(confirmId).toBeDefined();
         }));
     });
     describe('listen', () => {
@@ -85,16 +112,17 @@ describe('AmqpQueueAdapter', () => {
             const handler = jest.fn();
             yield adapter.listen(undefined, handler);
             expect(mockConnect).toHaveBeenCalledTimes(1);
-            expect(mockChannel).toHaveBeenCalledTimes(1);
-            expect(mockQueue).toHaveBeenCalledWith(params.topic);
-            expect(mockSubscribe).toHaveBeenCalledWith({ noAck: true }, expect.any(Function));
+            expect(mockCreateChannel).toHaveBeenCalledTimes(1);
+            expect(mockAssertQueue).toHaveBeenCalledWith(params.topic, { durable: true, autoDelete: false });
+            expect(mockPrefetch).toHaveBeenCalledWith(0);
+            expect(mockConsume).toHaveBeenCalledWith(params.topic, expect.any(Function), { noAck: false });
         }));
         it('should listen to a specific topic', () => __awaiter(void 0, void 0, void 0, function* () {
             const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter(params);
             const handler = jest.fn();
             const topic = 'specific-topic';
             yield adapter.listen(topic, handler);
-            expect(mockQueue).toHaveBeenCalledWith(topic);
+            expect(mockAssertQueue).toHaveBeenCalledWith(topic, { durable: true, autoDelete: false });
         }));
         it('should throw an error if no topic is available', () => __awaiter(void 0, void 0, void 0, function* () {
             const adapter = new AmqpQueueAdapter_1.AmqpQueueAdapter({ config: {} });
@@ -106,13 +134,14 @@ describe('AmqpQueueAdapter', () => {
             const handler = jest.fn();
             const messageContent = { data: 'test message' };
             const message = {
-                bodyToString: () => JSON.stringify(messageContent),
+                content: Buffer.from(JSON.stringify(messageContent)),
             };
-            mockSubscribe.mockImplementation((options, callback) => __awaiter(void 0, void 0, void 0, function* () {
+            mockConsume.mockImplementation((topic, callback, options) => __awaiter(void 0, void 0, void 0, function* () {
                 yield callback(message);
             }));
             yield adapter.listen('any-topic', handler);
-            expect(handler).toHaveBeenCalledWith(JSON.stringify(messageContent));
+            expect(handler).toHaveBeenCalledWith(JSON.stringify(messageContent), undefined);
+            expect(mockAck).toHaveBeenCalledWith(message);
         }));
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quatrain/queue-amqp",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "Queue adapter for AMQP compatible queue",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "@cloudamqp/amqp-client": "^3.4.1",
-    "@quatrain/core": "^1.2.6",
+    "@quatrain/core": "^1.2.9",
     "@quatrain/queue": "^1.2.3",
     "amqplib": "^0.10.9"
   },

package/src/AmqpQueueAdapter.test.ts

@@ -1,41 +1,37 @@
 import { AmqpQueueAdapter } from './AmqpQueueAdapter'
-import { AMQPClient, AMQPMessage } from '@cloudamqp/amqp-client'
+import amqplib from 'amqplib'
 import { Queue } from '@quatrain/queue'
 
-// Mock the @cloudamqp/amqp-client library
-jest.mock('@cloudamqp/amqp-client')
-
-// Mock @quatrain/queue to spy on Queue.info
-jest.mock('@quatrain/queue', () => ({
-   ...jest.requireActual('@quatrain/queue'),
-   Queue: {
-      info: jest.fn(),
-   },
-}))
-
-const mockPublish = jest
-   .fn()
-   .mockResolvedValue({ confirmId: 'mock-confirm-id' })
-const mockSubscribe = jest.fn()
-const mockQueue = jest.fn().mockResolvedValue({
-   publish: mockPublish,
-   subscribe: mockSubscribe,
-})
-const mockChannel = jest.fn().mockResolvedValue({
-   queue: mockQueue,
-})
-const mockConnect = jest.fn().mockResolvedValue({
-   channel: mockChannel,
+// Mock the amqplib library
+jest.mock('amqplib')
+
+const mockSendToQueue = jest.fn()
+const mockAck = jest.fn()
+const mockNack = jest.fn()
+const mockAssertQueue = jest.fn().mockResolvedValue({})
+const mockPrefetch = jest.fn().mockResolvedValue({})
+const mockConsume = jest.fn().mockResolvedValue({})
+const mockCloseChannel = jest.fn().mockResolvedValue({})
+
+const mockCreateChannel = jest.fn().mockResolvedValue({
+   sendToQueue: mockSendToQueue,
+   assertQueue: mockAssertQueue,
+   prefetch: mockPrefetch,
+   consume: mockConsume,
+   ack: mockAck,
+   nack: mockNack,
+   close: mockCloseChannel,
 })
 
-const AMQPClientMock = AMQPClient as jest.Mock
+const mockCloseConnection = jest.fn().mockResolvedValue({})
 
-AMQPClientMock.mockImplementation(() => {
-   return {
-      connect: mockConnect,
-   }
+const mockConnect = jest.fn().mockResolvedValue({
+   createChannel: mockCreateChannel,
+   close: mockCloseConnection,
 })
 
+;(amqplib.connect as jest.Mock).mockImplementation(mockConnect)
+
 describe('AmqpQueueAdapter', () => {
    const params = {
       config: {
@@ -47,27 +43,53 @@ describe('AmqpQueueAdapter', () => {
       topic: 'default-topic',
    }
 
+   let mockProcessExit: jest.SpyInstance
+   let mockLogger: any
+
+   beforeAll(() => {
+      mockLogger = {
+         info: jest.fn(),
+         debug: jest.fn(),
+         warn: jest.fn(),
+         error: jest.fn(),
+      }
+      jest.spyOn(Queue.logger, 'clone').mockReturnValue(mockLogger)
+   })
+
    beforeEach(() => {
-      // Clear all instances and calls to constructor and all methods:
-      AMQPClientMock.mockClear()
+      mockProcessExit = jest.spyOn(process, 'exit').mockImplementation(() => undefined as never)
       mockConnect.mockClear()
-      mockChannel.mockClear()
-      mockQueue.mockClear()
-      mockPublish.mockClear()
-      mockSubscribe.mockClear()
-      ;(Queue.info as jest.Mock).mockClear()
+      mockCreateChannel.mockClear()
+      mockCloseConnection.mockClear()
+      mockSendToQueue.mockClear()
+      mockAssertQueue.mockClear()
+      mockPrefetch.mockClear()
+      mockConsume.mockClear()
+      mockAck.mockClear()
+      mockNack.mockClear()
+      mockCloseChannel.mockClear()
+      mockLogger.info.mockClear()
+      mockLogger.debug.mockClear()
+      mockLogger.warn.mockClear()
+      mockLogger.error.mockClear()
    })
 
-   it('should construct with default and custom parameters', () => {
-      new AmqpQueueAdapter({ config: {} })
-      expect(AMQPClientMock).toHaveBeenCalledWith(
-         'amqp://guest:guest@localhost:5672?frameMax=0'
-      )
+   afterEach(() => {
+      mockProcessExit.mockRestore()
+   })
+
+   describe('connection parameters', () => {
+      it('should connect with default parameters', async () => {
+         const adapter = new AmqpQueueAdapter({ config: {} })
+         await (adapter as any)._connect()
+         expect(mockConnect).toHaveBeenCalledWith('amqp://guest:guest@localhost:5672')
+      })
 
-      new AmqpQueueAdapter(params)
-      expect(AMQPClientMock).toHaveBeenCalledWith(
-         'amqp://test-user:test-password@test-host:1234?frameMax=0'
-      )
+      it('should connect with custom parameters', async () => {
+         const adapter = new AmqpQueueAdapter(params)
+         await (adapter as any)._connect()
+         expect(mockConnect).toHaveBeenCalledWith('amqp://test-user:test-password@test-host:1234')
+      })
    })
 
    describe('send', () => {
@@ -79,19 +101,16 @@ describe('AmqpQueueAdapter', () => {
          const confirmId = await adapter.send(data, topic)
 
          expect(mockConnect).toHaveBeenCalledTimes(1)
-         expect(mockChannel).toHaveBeenCalledTimes(1)
-         expect(mockQueue).toHaveBeenCalledWith(topic)
-         expect(mockPublish).toHaveBeenCalledWith(
-            Buffer.from(JSON.stringify(data)),
-            { deliveryMode: 2 }
+         expect(mockCreateChannel).toHaveBeenCalledTimes(1)
+         expect(mockSendToQueue).toHaveBeenCalledWith(
+            topic,
+            Buffer.from(JSON.stringify(data))
          )
-         expect(Queue.info).toHaveBeenCalledWith(
-            `[AMQP] Sending message to ${topic}`
+         expect(mockCloseChannel).toHaveBeenCalledTimes(1)
+         expect(mockLogger.info).toHaveBeenCalledWith(
+            `Sending message to ${topic}`
          )
-         expect(Queue.info).toHaveBeenCalledWith(
-            `[AMQP] Message send with id mock-confirm-id`
-         )
-         expect(confirmId).toBe('mock-confirm-id')
+         expect(confirmId).toBeDefined()
       })
    })
 
@@ -103,11 +122,13 @@ describe('AmqpQueueAdapter', () => {
          await adapter.listen(undefined, handler)
 
          expect(mockConnect).toHaveBeenCalledTimes(1)
-         expect(mockChannel).toHaveBeenCalledTimes(1)
-         expect(mockQueue).toHaveBeenCalledWith(params.topic)
-         expect(mockSubscribe).toHaveBeenCalledWith(
-            { noAck: true },
-            expect.any(Function)
+         expect(mockCreateChannel).toHaveBeenCalledTimes(1)
+         expect(mockAssertQueue).toHaveBeenCalledWith(params.topic, { durable: true, autoDelete: false })
+         expect(mockPrefetch).toHaveBeenCalledWith(0)
+         expect(mockConsume).toHaveBeenCalledWith(
+            params.topic,
+            expect.any(Function),
+            { noAck: false }
          )
       })
 
@@ -118,7 +139,7 @@ describe('AmqpQueueAdapter', () => {
 
          await adapter.listen(topic, handler)
 
-         expect(mockQueue).toHaveBeenCalledWith(topic)
+         expect(mockAssertQueue).toHaveBeenCalledWith(topic, { durable: true, autoDelete: false })
       })
 
       it('should throw an error if no topic is available', async () => {
@@ -135,16 +156,20 @@ describe('AmqpQueueAdapter', () => {
          const handler = jest.fn()
          const messageContent = { data: 'test message' }
          const message = {
-            bodyToString: () => JSON.stringify(messageContent),
-         } as AMQPMessage
+            content: Buffer.from(JSON.stringify(messageContent)),
+         } as any
 
-         mockSubscribe.mockImplementation(async (options, callback) => {
+         mockConsume.mockImplementation(async (topic, callback, options) => {
             await callback(message)
          })
 
          await adapter.listen('any-topic', handler)
 
-         expect(handler).toHaveBeenCalledWith(JSON.stringify(messageContent))
+         expect(handler).toHaveBeenCalledWith(
+            JSON.stringify(messageContent),
+            undefined
+         )
+         expect(mockAck).toHaveBeenCalledWith(message)
       })
    })
 })