@autofleet/rabbit 1.5.1 → 1.5.3

package/dist/example.js

@@ -10,10 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
-// process.env.RABBITMQ_SERVICE_HOST = '34.76.123.137:5672';
+process.env.RABBITMQ_SERVICE_HOST = '34.76.123.137:5672';
 const init = () => __awaiter(void 0, void 0, void 0, function* () {
     const rabbit = new index_1.default();
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     yield rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
         console.log('consumeFromExchange: msg2', msg.content);
         ack(msg);
@@ -29,5 +28,7 @@ const init = () => __awaiter(void 0, void 0, void 0, function* () {
         ack(msg);
     });
     yield rabbit.sendToQueue('test-q-2', 'hey-q');
+    const getQueueLength = yield rabbit.getQueueLength('test-q2');
+    console.log(`getQueueLength:${getQueueLength}`);
 });
 init();

package/dist/index.d.ts

@@ -1,10 +1,11 @@
 /// <reference types="node" />
 import { AmqpConnectionManager, ChannelWrapper } from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
+import RabbitWrapperInterface from './interfaces/RabbitWrapperInterface';
 interface ExchangesCache {
     [key: string]: any;
 }
-declare class RabbitMq {
+declare class RabbitMq implements RabbitWrapperInterface {
     static parseMsg(msg: any): any;
     static validateName(type: string, name: string): void;
     PUBLISH_TIMEOUT: number;
@@ -15,12 +16,19 @@ declare class RabbitMq {
     em: EventEmitter;
     creatingConnection: boolean;
     exchanges: ExchangesCache;
-    constructor();
+    isTestEnv: boolean;
+    constructor({ isTestEnv }?: {
+        isTestEnv?: boolean | undefined;
+    });
+    private getConnectFunc;
+    private connect;
     ack: (msg: any) => Promise<void>;
     nack: (queue: string) => (msg: any, retries: number) => Promise<void>;
     getConnection(): Promise<AmqpConnectionManager>;
     assertChannel(): Promise<ChannelWrapper>;
     assertExchange(exchangeName: string, options?: any): Promise<any>;
+    getQueueLength(queue: string): Promise<any>;
+    bindQueue(queue: string, exchange: string): Promise<any>;
     assertQueue(queue: string, options?: any): Promise<void>;
     consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any): Promise<void>;
     consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any): Promise<void>;

package/dist/index.js

@@ -9,18 +9,22 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/ban-types,@typescript-eslint/no-unused-vars,consistent-return,no-async-promise-executor,no-param-reassign,no-empty */
 // eslint-disable-next-line max-classes-per-file
 const bluebird = require("bluebird");
 const amqp_connection_manager_1 = require("amqp-connection-manager");
 const events_1 = require("events");
+const mockImpl_1 = require("./mockImpl");
 const rabbitError_1 = require("./rabbitError");
 const assertExchangeFanout = (c, exchangeName) => c.assertExchange(exchangeName, 'fanout');
 const connectionCreatedConst = 'connectionCreated';
 class RabbitMq {
-    constructor() {
+    constructor({ isTestEnv = false } = {}) {
         this.PUBLISH_TIMEOUT = Number(process.env.RABBITMQ_PUBLISH_TIMEOUT) || 60000;
         this.PUBLISH_ERROR_MSG = `rabbit: publish timeout(${this.PUBLISH_TIMEOUT}ms) has pass, exchange: `;
         this.DISCONNECT_MSG = 'rabbit: connection disconnect';
+        this.getConnectFunc = () => (this.isTestEnv ? mockImpl_1.connect : amqp_connection_manager_1.connect);
+        this.connect = (urls = []) => this.getConnectFunc()(urls);
         this.ack = (msg) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
                 yield this.channel.ack(msg);
@@ -29,7 +33,6 @@ class RabbitMq {
         this.nack = (queue) => (msg, retries) => __awaiter(this, void 0, void 0, function* () {
             if (this.channel) {
                 if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
-                    // eslint-disable-next-line no-param-reassign
                     msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
                     yield this.sendToQueue(queue, msg.content);
                 }
@@ -46,6 +49,7 @@ class RabbitMq {
         this.connection = null;
         this.creatingConnection = false;
         this.exchanges = {};
+        this.isTestEnv = isTestEnv;
     }
     static parseMsg(msg) {
         let { content } = msg;
@@ -53,7 +57,7 @@ class RabbitMq {
         try {
             content = JSON.parse(content);
         }
-        catch (e) { } // eslint-disable-line no-empty
+        catch (e) { }
         return Object.assign(Object.assign({}, msg), { content });
     }
     static validateName(type, name) {
@@ -63,19 +67,17 @@ class RabbitMq {
     }
     getConnection() {
         return __awaiter(this, void 0, void 0, function* () {
-            // eslint-disable-next-line no-async-promise-executor
             return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
                 if (this.creatingConnection) {
                     this.em.on(connectionCreatedConst, resolve);
                     return;
                 }
                 if (this.connection !== null) {
-                    // eslint-disable-next-line consistent-return
                     return this.connection;
                 }
                 this.creatingConnection = true;
                 const host = process.env.RABBITMQ_SERVICE_HOST || '';
-                const connection = yield amqp_connection_manager_1.connect([`amqp://${host}`]);
+                const connection = yield this.connect([`amqp://${host}`]);
                 this.connection = connection;
                 this.connection.on('disconnect', ({ err }) => console.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`));
                 this.creatingConnection = false;
@@ -86,7 +88,6 @@ class RabbitMq {
     }
     assertChannel() {
         return __awaiter(this, void 0, void 0, function* () {
-            // eslint-disable-next-line no-async-promise-executor,consistent-return
             return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
                 if (this.channel) {
                     return resolve(this.channel);
@@ -94,7 +95,7 @@ class RabbitMq {
                 const connection = yield this.getConnection();
                 try {
                     if (this.channel === null) {
-                        this.channel = connection.createChannel({});
+                        this.channel = yield connection.createChannel({});
                     }
                     resolve(this.channel);
                 }
@@ -104,7 +105,6 @@ class RabbitMq {
             }));
         });
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     assertExchange(exchangeName, options) {
         return __awaiter(this, void 0, void 0, function* () {
             const channel = yield this.assertChannel();
@@ -118,7 +118,21 @@ class RabbitMq {
             }));
         });
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    getQueueLength(queue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            RabbitMq.validateName('queue', queue);
+            const channel = yield this.assertChannel();
+            // @ts-ignore
+            return channel.checkQueue(queue);
+        });
+    }
+    bindQueue(queue, exchange) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const channel = yield this.assertChannel();
+            // @ts-ignore
+            return channel.bindQueue(queue, exchange, '');
+        });
+    }
     assertQueue(queue, options) {
         return __awaiter(this, void 0, void 0, function* () {
             RabbitMq.validateName('queue', queue);
@@ -126,7 +140,6 @@ class RabbitMq {
             return channel.addSetup((c) => c.assertQueue(queue));
         });
     }
-    // eslint-disable-next-line @typescript-eslint/ban-types
     consume(queue, callback, options) {
         return __awaiter(this, void 0, void 0, function* () {
             RabbitMq.validateName('queue', queue);
@@ -141,7 +154,6 @@ class RabbitMq {
             }));
         });
     }
-    // eslint-disable-next-line @typescript-eslint/ban-types
     consumeFromExchange(queue, exchange, callback, options) {
         return __awaiter(this, void 0, void 0, function* () {
             RabbitMq.validateName('queue', queue);

package/dist/index.test.js

@@ -9,8 +9,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/no-unused-vars */
 const index_1 = require("./index");
-// import RabbitError from './rabbitError';
 jest.setTimeout(120000);
 const rabbit = new index_1.default();
 const delay = () => new Promise((resolve) => setTimeout(() => resolve(), 500));
@@ -48,7 +48,6 @@ describe('RabbitMQ', () => {
         expect(err).toBeDefined();
     }));
     it('cant publish due timeout', () => __awaiter(void 0, void 0, void 0, function* () {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         process.env.RABBITMQ_PUBLISH_TIMEOUT = 1;
         const rabbit2 = new index_1.default();
@@ -61,4 +60,25 @@ describe('RabbitMQ', () => {
         }
         expect(err).toBeDefined();
     }));
+    it('get queue length', () => __awaiter(void 0, void 0, void 0, function* () {
+        const queueName = 'test-queue-length';
+        const exchangeName = 'test-e2';
+        yield rabbit.assertQueue(queueName);
+        yield rabbit.assertExchange(exchangeName);
+        yield rabbit.bindQueue(queueName, exchangeName);
+        yield rabbit.publish(exchangeName, 'hey');
+        let messageCount;
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(1);
+        yield rabbit.publish(exchangeName, 'hey');
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(2);
+        yield rabbit.consumeFromExchange(queueName, exchangeName, (msg, ack) => __awaiter(void 0, void 0, void 0, function* () {
+            expect(msg.content).toEqual('hey');
+            ack(msg);
+        }));
+        yield delay();
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(0);
+    }));
 });

package/dist/interfaces/RabbitWrapperInterface.d.ts

@@ -0,0 +1,15 @@
+interface RabbitWrapperInterface {
+    ack: any;
+    nack: any;
+    getConnection: any;
+    assertChannel: any;
+    assertExchange: any;
+    getQueueLength: any;
+    bindQueue: any;
+    assertQueue: any;
+    consume: any;
+    consumeFromExchange: any;
+    publish: any;
+    sendToQueue: any;
+}
+export default RabbitWrapperInterface;

package/dist/interfaces/RabbitWrapperInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mockImpl/index.d.ts

@@ -0,0 +1,25 @@
+export interface channel {
+    assertQueue: any;
+    assertExchange: any;
+    bindQueue: any;
+    publish: any;
+    consume: any;
+    deleteQueue: any;
+    ack: any;
+    nack: any;
+    prefetch: any;
+    on: any;
+    once: any;
+    close: any;
+    addSetup: any;
+    checkQueue: any;
+    sendToQueue: any;
+}
+export interface connection {
+    createChannel: any;
+    createConfirmChannel: any;
+    on: any;
+    once: any;
+    close: any;
+}
+export declare const connect: () => any;

package/dist/mockImpl/index.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connect = void 0;
+const Bluebird = require("bluebird");
+let exchanges = {};
+let queues = {};
+const setIfUndef = (object, prop, value) => {
+    if (!object[prop]) {
+        // eslint-disable-next-line no-param-reassign
+        object[prop] = value;
+    }
+};
+class ChannelImpl {
+    constructor() {
+        this.assertQueue = (queue, qOptions) => new Bluebird((resolve) => {
+            setIfUndef(queues, queue, { messages: [], subscribers: [], options: qOptions });
+            return resolve();
+        });
+        this.assertExchange = (exchange, type, exchOptions = {}) => new Bluebird((resolve) => {
+            setIfUndef(exchanges, exchange, { bindings: [], options: exchOptions, type });
+            return resolve();
+        });
+        this.bindQueue = (queue, exchange, key) => new Bluebird((resolve, reject) => {
+            if (!exchanges[exchange])
+                return reject(`Bind to non-existing exchange ${exchange}`);
+            const re = `^${key.replace('.', '\\.').replace('#', '(\\w|\\.)+').replace('*', '\\w+')}$`;
+            exchanges[exchange].bindings.push({ regex: new RegExp(re), queueName: queue });
+            return resolve();
+        });
+        this.publish = (exchange, routingKey, content, props) => new Bluebird((resolve, reject) => {
+            if (!exchanges[exchange])
+                return reject(`Publish to non-existing exchange ${exchange}`);
+            const { bindings } = exchanges[exchange];
+            const matchingBindings = bindings.filter((b) => b.regex.test(routingKey));
+            matchingBindings.forEach((binding) => {
+                const subscribers = queues[binding.queueName] ? queues[binding.queueName].subscribers : [];
+                subscribers.forEach((sub) => {
+                    const message = { fields: { routingKey }, properties: props, content };
+                    sub(message);
+                });
+            });
+            return resolve();
+        });
+        this.consume = (queue, handler) => {
+            queues[queue].subscribers.push(handler);
+        };
+        this.sendToQueue = (queue, content, routingKey = '', props = {}) => {
+            const subscribers = queues[queue] ? queues[queue].subscribers : [];
+            subscribers.forEach((sub) => {
+                const message = { fields: { routingKey }, properties: props, content };
+                sub(message);
+            });
+        };
+        this.deleteQueue = (queue) => {
+            setImmediate(() => {
+                delete queues[queue];
+            });
+        };
+        this.checkQueue = () => ({ messageCount: 0 });
+        this.ack = () => null;
+        this.nack = () => null;
+        this.prefetch = () => null;
+        this.on = () => null;
+        this.once = () => null;
+        this.close = () => Bluebird.resolve();
+    }
+    addSetup(funcToRun) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const val = yield funcToRun(this);
+            return val;
+        });
+    }
+}
+const createChannel = () => new Bluebird((resolve) => resolve(new ChannelImpl()));
+exports.connect = () => new Bluebird((resolve) => {
+    const connectionImpl = {
+        createChannel,
+        createConfirmChannel: createChannel,
+        on: () => null,
+        once: () => null,
+        close: () => Bluebird.resolve(),
+    };
+    return resolve(connectionImpl);
+});
+const resetMock = () => {
+    queues = {};
+    exchanges = {};
+};
+module.exports = { connect: exports.connect, resetMock };

package/dist/mockImpl/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/mockImpl/index.test.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/no-unused-vars */
+const index_1 = require("../index");
+jest.setTimeout(120000);
+const rabbit = new index_1.default({ isTestEnv: true });
+describe('RabbitMQ', () => {
+    it('check exchange', () => __awaiter(void 0, void 0, void 0, function* () {
+        const callback = (msg, ack) => {
+            expect(msg.content).toEqual('hey');
+            ack(msg);
+        };
+        const mockFn = jest.fn(callback);
+        yield rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
+        yield rabbit.publish('test-e', 'hey');
+        expect(mockFn).toBeCalled();
+    }));
+    it('check queue', () => __awaiter(void 0, void 0, void 0, function* () {
+        const callback = (msg, ack) => {
+            expect(msg.content).toEqual('hey-q');
+            ack(msg);
+        };
+        const mockFn = jest.fn(callback);
+        yield rabbit.consume('test-q-2', mockFn);
+        yield rabbit.sendToQueue('test-q-2', 'hey-q');
+        expect(mockFn).toBeCalled();
+    }));
+    it('cant publish to unknown exchange', () => __awaiter(void 0, void 0, void 0, function* () {
+        let err;
+        try {
+            yield rabbit.publish('', 'hey');
+        }
+        catch (e) {
+            err = e;
+        }
+        expect(err).toBeDefined();
+    }));
+    it('get queue length', () => __awaiter(void 0, void 0, void 0, function* () {
+        const queueName = 'test-queue-length';
+        const exchangeName = 'test-e2';
+        yield rabbit.assertQueue(queueName);
+        yield rabbit.assertExchange(exchangeName);
+        yield rabbit.bindQueue(queueName, exchangeName);
+        yield rabbit.publish(exchangeName, 'hey');
+        let messageCount;
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(0);
+        yield rabbit.publish(exchangeName, 'hey');
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(0);
+        yield rabbit.consumeFromExchange(queueName, exchangeName, (msg, ack) => __awaiter(void 0, void 0, void 0, function* () {
+            expect(msg.content).toEqual('hey');
+            ack(msg);
+        }));
+        ({ messageCount } = yield rabbit.getQueueLength(queueName));
+        expect(messageCount).toEqual(0);
+    }));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/rabbit",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -14,9 +14,9 @@
     "dev": "nodemon"
   },
   "dependencies": {
+    "@types/amqp-connection-manager": "^2.0.10",
+    "@types/amqplib": "^0.5.16",
     "@types/jest": "^22.0.0",
-    "@types/amqp-connection-manager": "^2.0.2",
-    "@types/amqplib": "^0.5.9",
     "amqp-connection-manager": "^3.2.1",
     "amqplib": "^0.6.0",
     "bluebird": "^3.7.2",

package/src/example.ts

@@ -1,10 +1,10 @@
 import RabbitMq from './index';
 
-// process.env.RABBITMQ_SERVICE_HOST = '34.76.123.137:5672';
+process.env.RABBITMQ_SERVICE_HOST = '34.76.123.137:5672';
 
 const init = async () => {
   const rabbit = new RabbitMq();
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
   await rabbit.consumeFromExchange('test-q2', 'test-e', (msg, ack) => {
     console.log('consumeFromExchange: msg2', msg.content);
     ack(msg);
@@ -21,7 +21,11 @@ const init = async () => {
     console.log('consume: msg-q', msg.content);
     ack(msg);
   });
+
   await rabbit.sendToQueue('test-q-2', 'hey-q');
+
+  const getQueueLength = await rabbit.getQueueLength('test-q2');
+  console.log(`getQueueLength:${getQueueLength}`);
 };
 
 init();

package/src/index.test.ts

@@ -1,5 +1,5 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/no-unused-vars */
 import RabbitMq from './index';
-// import RabbitError from './rabbitError';
 
 jest.setTimeout(120000);
 
@@ -43,7 +43,6 @@ describe('RabbitMQ', () => {
   });
 
   it('cant publish due timeout', async () => {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore
     process.env.RABBITMQ_PUBLISH_TIMEOUT = 1;
     const rabbit2 = new RabbitMq();
@@ -56,4 +55,28 @@ describe('RabbitMQ', () => {
     }
     expect(err).toBeDefined();
   });
+
+  it('get queue length', async () => {
+    const queueName = 'test-queue-length';
+    const exchangeName = 'test-e2';
+
+    await rabbit.assertQueue(queueName);
+    await rabbit.assertExchange(exchangeName);
+    await rabbit.bindQueue(queueName, exchangeName);
+
+    await rabbit.publish(exchangeName, 'hey');
+    let messageCount: any;
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(1);
+    await rabbit.publish(exchangeName, 'hey');
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(2);
+    await rabbit.consumeFromExchange(queueName, exchangeName, async (msg: any, ack: any) => {
+      expect(msg.content).toEqual('hey');
+      ack(msg);
+    });
+    await delay();
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(0);
+  });
 });

package/src/index.ts

@@ -1,8 +1,14 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/ban-types,@typescript-eslint/no-unused-vars,consistent-return,no-async-promise-executor,no-param-reassign,no-empty */
 // eslint-disable-next-line max-classes-per-file
 import * as bluebird from 'bluebird';
 import { ConfirmChannel } from 'amqplib';
-import { AmqpConnectionManager, ChannelWrapper, connect } from 'amqp-connection-manager';
+import {
+  AmqpConnectionManager, ChannelWrapper,
+  connect as connectAmqp,
+} from 'amqp-connection-manager';
 import { EventEmitter } from 'events';
+import { connect as connectMock } from './mockImpl';
+import RabbitWrapperInterface from './interfaces/RabbitWrapperInterface';
 import RabbitError from './rabbitError';
 
 interface ExchangesCache {
@@ -12,14 +18,14 @@ interface ExchangesCache {
 const assertExchangeFanout = (c: any, exchangeName: string) => c.assertExchange(exchangeName, 'fanout');
 
 const connectionCreatedConst = 'connectionCreated';
-class RabbitMq {
+class RabbitMq implements RabbitWrapperInterface {
   static parseMsg(msg: any) {
     let { content } = msg;
     content = content.toString();
 
     try {
       content = JSON.parse(content);
-    } catch (e) { } // eslint-disable-line no-empty
+    } catch (e) { }
 
     return {
       ...msg,
@@ -49,14 +55,21 @@ class RabbitMq {
 
   exchanges: ExchangesCache;
 
-  constructor() {
+  isTestEnv: boolean;
+
+  constructor({ isTestEnv = false } = {}) {
     this.em = new EventEmitter();
     this.channel = null;
     this.connection = null;
     this.creatingConnection = false;
     this.exchanges = {};
+    this.isTestEnv = isTestEnv;
   }
 
+  private getConnectFunc = () => (this.isTestEnv ? connectMock : connectAmqp)
+
+  private connect = (urls:any[] = []) => this.getConnectFunc()(urls);
+
   public ack = async (msg: any) => {
     if (this.channel) {
       await this.channel.ack(msg);
@@ -66,7 +79,6 @@ class RabbitMq {
   public nack = (queue: string) => async (msg: any, retries: number) => {
     if (this.channel) {
       if (!msg.content['x-retry-count'] || msg.content['x-retry-count'] <= retries) {
-        // eslint-disable-next-line no-param-reassign
         msg.content['x-retry-count'] = msg.content['x-retry-count'] ? msg.content['x-retry-count'] + 1 : 1;
         await this.sendToQueue(queue, msg.content);
       } else {
@@ -79,19 +91,17 @@ class RabbitMq {
   }
 
   async getConnection() {
-    // eslint-disable-next-line no-async-promise-executor
     return new Promise<AmqpConnectionManager>(async (resolve) => {
       if (this.creatingConnection) {
         this.em.on(connectionCreatedConst, resolve);
         return;
       }
       if (this.connection !== null) {
-        // eslint-disable-next-line consistent-return
         return this.connection;
       }
       this.creatingConnection = true;
       const host: string = process.env.RABBITMQ_SERVICE_HOST || '';
-      const connection: AmqpConnectionManager = await connect([`amqp://${host}`]);
+      const connection: AmqpConnectionManager = await this.connect([`amqp://${host}`]);
       this.connection = connection;
       this.connection.on('disconnect',
         ({ err }) => console.error(`${this.DISCONNECT_MSG}${err && ` - ${err}`}`));
@@ -102,7 +112,6 @@ class RabbitMq {
   }
 
   async assertChannel() {
-    // eslint-disable-next-line no-async-promise-executor,consistent-return
     return new Promise<ChannelWrapper>(async (resolve, reject) => {
       if (this.channel) {
         return resolve(this.channel);
@@ -112,7 +121,7 @@ class RabbitMq {
 
       try {
         if (this.channel === null) {
-          this.channel = connection.createChannel({});
+          this.channel = await connection.createChannel({});
         }
         resolve(this.channel);
       } catch (e) {
@@ -121,7 +130,6 @@ class RabbitMq {
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async assertExchange(exchangeName: string, options?: any) {
     const channel: ChannelWrapper = await this.assertChannel();
     if (this.exchanges[exchangeName]) {
@@ -134,14 +142,25 @@ class RabbitMq {
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async getQueueLength(queue: string) {
+    RabbitMq.validateName('queue', queue);
+    const channel: ChannelWrapper = await this.assertChannel();
+    // @ts-ignore
+    return channel.checkQueue(queue);
+  }
+
+  async bindQueue(queue: string, exchange: string) {
+    const channel: ChannelWrapper = await this.assertChannel();
+    // @ts-ignore
+    return channel.bindQueue(queue, exchange, '');
+  }
+
   async assertQueue(queue: string, options?: any) {
     RabbitMq.validateName('queue', queue);
     const channel: ChannelWrapper = await this.assertChannel();
     return channel.addSetup((c: ConfirmChannel) => c.assertQueue(queue));
   }
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
   async consume(queue: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
     RabbitMq.validateName('queue', queue);
     const { limit } = (options && options.limit) ? options : { limit: 1 };
@@ -155,7 +174,6 @@ class RabbitMq {
     });
   }
 
-  // eslint-disable-next-line @typescript-eslint/ban-types
   async consumeFromExchange(queue: string, exchange: string, callback: (msg: any, ack: Function, nack: Function) => any, options?: any) {
     RabbitMq.validateName('queue', queue);
     RabbitMq.validateName('exchange', exchange);

package/src/interfaces/RabbitWrapperInterface.ts

@@ -0,0 +1,17 @@
+interface RabbitWrapperInterface {
+    ack:any;
+    nack: any;
+    getConnection: any;
+    assertChannel: any;
+    assertExchange: any;
+    getQueueLength: any;
+    bindQueue: any;
+    assertQueue: any;
+    consume: any;
+    consumeFromExchange: any;
+    publish: any;
+    sendToQueue: any;
+
+}
+
+export default RabbitWrapperInterface;

package/src/mockImpl/index.test.ts

@@ -0,0 +1,63 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment,@typescript-eslint/no-unused-vars */
+import RabbitMq from '../index';
+
+jest.setTimeout(120000);
+
+const rabbit = new RabbitMq({ isTestEnv: true });
+
+describe('RabbitMQ', () => {
+  it('check exchange', async () => {
+    const callback = (msg: any, ack: any) => {
+      expect(msg.content).toEqual('hey');
+      ack(msg);
+    };
+    const mockFn = jest.fn(callback);
+    await rabbit.consumeFromExchange('test-q2', 'test-e', mockFn);
+    await rabbit.publish('test-e', 'hey');
+    expect(mockFn).toBeCalled();
+  });
+
+  it('check queue', async () => {
+    const callback = (msg: any, ack: any) => {
+      expect(msg.content).toEqual('hey-q');
+      ack(msg);
+    };
+    const mockFn = jest.fn(callback);
+    await rabbit.consume('test-q-2', mockFn);
+    await rabbit.sendToQueue('test-q-2', 'hey-q');
+    expect(mockFn).toBeCalled();
+  });
+
+  it('cant publish to unknown exchange', async () => {
+    let err;
+    try {
+      await rabbit.publish('', 'hey');
+    } catch (e) {
+      err = e;
+    }
+    expect(err).toBeDefined();
+  });
+
+  it('get queue length', async () => {
+    const queueName = 'test-queue-length';
+    const exchangeName = 'test-e2';
+
+    await rabbit.assertQueue(queueName);
+    await rabbit.assertExchange(exchangeName);
+    await rabbit.bindQueue(queueName, exchangeName);
+
+    await rabbit.publish(exchangeName, 'hey');
+    let messageCount: any;
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(0);
+    await rabbit.publish(exchangeName, 'hey');
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(0);
+    await rabbit.consumeFromExchange(queueName, exchangeName, async (msg: any, ack: any) => {
+      expect(msg.content).toEqual('hey');
+      ack(msg);
+    });
+    ({ messageCount } = await rabbit.getQueueLength(queueName));
+    expect(messageCount).toEqual(0);
+  });
+});

package/src/mockImpl/index.ts

@@ -0,0 +1,132 @@
+import * as Bluebird from 'bluebird';
+
+let exchanges: any = {};
+let queues: any = {};
+
+export interface channel {
+  assertQueue: any;
+  assertExchange: any;
+  bindQueue: any;
+  publish: any;
+  consume: any;
+  deleteQueue: any;
+  ack: any;
+  nack: any;
+  prefetch: any;
+  on: any;
+  once: any;
+  close: any;
+  addSetup: any;
+  checkQueue: any;
+  sendToQueue: any;
+}
+export interface connection {
+  createChannel: any;
+  createConfirmChannel: any;
+  on: any;
+  once: any;
+  close: any;
+}
+
+const setIfUndef = (object: any, prop: any, value: any) => {
+  if (!object[prop]) {
+    // eslint-disable-next-line no-param-reassign
+    object[prop] = value;
+  }
+};
+
+class ChannelImpl implements channel {
+  public assertQueue = (queue: any, qOptions: any) => new Bluebird((resolve: () => any) => {
+    setIfUndef(queues, queue, { messages: [], subscribers: [], options: qOptions });
+    return resolve();
+  });
+
+  public assertExchange = (exchange: any, type: any, exchOptions: any = {}) => new Bluebird((resolve: () => any) => {
+    setIfUndef(exchanges, exchange, { bindings: [], options: exchOptions, type });
+
+    return resolve();
+  });
+
+  public bindQueue = (queue: any, exchange: string, key: string) => new Bluebird((resolve: () => any, reject: (arg0: string) => any) => {
+    if (!exchanges[exchange]) return reject(`Bind to non-existing exchange ${exchange}`);
+
+    const re = `^${key.replace('.', '\\.').replace('#', '(\\w|\\.)+').replace('*', '\\w+')}$`;
+    exchanges[exchange].bindings.push({ regex: new RegExp(re), queueName: queue });
+
+    return resolve();
+  });
+
+  public publish = (exchange: string, routingKey: any, content: any, props: any) => new Bluebird((resolve: () => any, reject: (arg0: string) => any) => {
+    if (!exchanges[exchange]) return reject(`Publish to non-existing exchange ${exchange}`);
+
+    const { bindings } = exchanges[exchange];
+    const matchingBindings = bindings.filter((b: any) => b.regex.test(routingKey));
+
+    matchingBindings.forEach((binding: { queueName: string | number; }) => {
+      const subscribers = queues[binding.queueName] ? queues[binding.queueName].subscribers : [];
+      subscribers.forEach((sub: (arg0: { fields: { routingKey: any; }; properties: any; content: any; }) => void) => {
+        const message = { fields: { routingKey }, properties: props, content };
+        sub(message);
+      });
+    });
+
+    return resolve();
+  });
+
+  public consume = (queue: string | number, handler: any) => {
+    queues[queue].subscribers.push(handler);
+  };
+
+  public sendToQueue = (queue: string, content: any, routingKey = '', props: any = {}) => {
+    const subscribers = queues[queue] ? queues[queue].subscribers : [];
+    subscribers.forEach((sub: (arg0: { fields: { routingKey: any; }; properties: any; content: any; }) => void) => {
+      const message = { fields: { routingKey }, properties: props, content };
+      sub(message);
+    });
+  };
+
+  public deleteQueue = (queue: string | number) => {
+    setImmediate(() => {
+      delete queues[queue];
+    });
+  };
+
+  public async addSetup(funcToRun: any) {
+    const val = await funcToRun(this);
+    return val;
+  }
+
+  public checkQueue = () => ({ messageCount: 0 });
+
+  public ack = () => null;
+
+  public nack = () => null;
+
+  public prefetch = () => null;
+
+  public on = () => null;
+
+  public once = () => null;
+
+  public close = () => Bluebird.resolve();
+}
+
+const createChannel = () => new Bluebird((resolve: any) => resolve(new ChannelImpl()));
+export const connect = (): any => new Bluebird((resolve: any) => {
+  const connectionImpl: connection = {
+    createChannel,
+    createConfirmChannel: createChannel,
+    on: () => null,
+    once: () => null,
+    close: () => Bluebird.resolve(),
+  };
+
+  return resolve(connectionImpl);
+});
+
+const resetMock = () => {
+  queues = {};
+  exchanges = {};
+};
+
+module.exports = { connect, resetMock };