@onify/fake-amqplib 0.8.2

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Onify
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,67 @@
+Onify fake-amqplib
+==================
+
+[![Built latest](https://github.com/onify/fake-amqplib/actions/workflows/build-latest.yaml/badge.svg)](https://github.com/onify/fake-amqplib/actions/workflows/build-latest.yaml)
+
+Mocked version of https://www.npmjs.com/package/amqplib.
+
+### Overriding amqplib
+
+You might want to override `amqplib` with `@onify/fake-amqplib` in tests. This can be done this way:
+
+```javascript
+const amqplib = require('amqplib');
+const fakeAmqp = require('@onify/fake-amqplib');
+
+amqplib.connect = fakeAmqp.connect;
+```
+
+If you are using version 2 or higher of [exp-amqp-connection](https://www.npmjs.com/package/exp-amqp-connection)
+you can use [mock-require](https://www.npmjs.com/package/mock-require) to replace `amqplib` with `@onify/fake-amqplib` in your tests like this:
+
+```javascript
+const mock = require('mock-require');
+const fakeAmqp = require('@onify/fake-amqplib');
+
+mock('amqplib/callback_api', fakeAmqp);
+```
+
+or just mock the entire amqplib with
+
+```javascript
+const mock = require('mock-require');
+const fakeAmqp = require('@onify/fake-amqplib');
+
+mock('amqplib', fakeAmqp);
+```
+
+### RabbitMQ versions
+
+Some behaviour differs between versions. To specify your version of RabbitMQ you can call `setVersion(minorVersionFloatOrString)`. Default version is 3.5.
+
+Example:
+```js
+var fakeAmqp = require('@onify/fake-amqplib');
+
+// prepare your connections
+(async () => {
+  fakeAmqp.setVersion('2.2');
+  const conn2 = await fakeAmqp.connect('amqp://rabbit2-2');
+
+  fakeAmqp.setVersion('3.2');
+  const conn3 = await fakeAmqp.connect('amqp://rabbit3-1');
+
+  fakeAmqp.setVersion('3.7');
+  const conn37 = await fakeAmqp.connect('amqp://rabbit3-7');
+})()
+```
+
+### Fake api
+
+List of available methods and a property
+
+- `connections`: property with all faked connections
+- `connectSync(amqpurl[, ...otherOptions])`: helper method to create a connection without waiting for promise to resolve - synchronous
+- `resetMock()`: reset all connections and brokers
+- `setVersion(minor)`: next connection will be to a amqp of a specific version
+- `async connect(amqpurl[, ...otherOptions, callback])`: make a fake connection

package/index.js

@@ -0,0 +1,410 @@
+'use strict';
+
+const {Broker} = require('smqp');
+const {EventEmitter} = require('events');
+const {URL} = require('url');
+
+class FakeAmqpError extends Error {
+  constructor(message, code, killChannel, killConnection) {
+    super(message);
+    this.code = code;
+    this._killChannel = killChannel;
+    this._killConnection  = killConnection;
+  }
+}
+
+class FakeAmqpNotFoundError extends FakeAmqpError {
+  constructor(type, name, killConnection = false) {
+    super(`Channel closed by server: 404 (NOT-FOUND) with message "NOT_FOUND - no ${type} '${name}' in vhost '/'`, 404, true, killConnection);
+  }
+}
+
+const connections = [];
+
+module.exports = Fake('3.5');
+
+function Fake(minorVersion) {
+  let defaultVersion = Number(minorVersion);
+  return {
+    connections,
+    resetMock,
+    connectSync,
+    setVersion(minor) {
+      const n = Number(minor);
+      if (!isNaN(n)) defaultVersion = n;
+    },
+    connect,
+  };
+
+  function connect(amqpUrl, ...args) {
+    const connection = connectSync(amqpUrl, ...args);
+    return resolveOrCallback(args.slice(-1)[0], null, connection);
+  }
+
+  function connectSync(amqpUrl, ...args) {
+    const {_broker} = connections.find((conn) => compareConnectionString(conn.options[0], amqpUrl)) || {};
+    const broker = _broker || Broker();
+    const connection = Connection(broker, defaultVersion, amqpUrl, ...args);
+    connections.push(connection);
+    return connection;
+  }
+
+  function resetMock() {
+    for (const connection of connections.splice(0)) {
+      connection._broker.reset();
+    }
+  }
+
+  function Connection(broker, version, ...connArgs) {
+    const emitter = new EventEmitter();
+    const options = connArgs.filter((a) => typeof a !== 'function');
+    let closed = false;
+    const channels = [];
+
+    return {
+      _id: generateId(),
+      _broker: broker,
+      _version: version,
+      get _closed() {
+        return closed;
+      },
+      get _emitter() {
+        return emitter;
+      },
+      options,
+      createChannel(...args) {
+        if (closed) return resolveOrCallback(args.slice(-1)[0], unavailable());
+
+        const channel = Channel(broker, this);
+        channels.push(channel);
+        return resolveOrCallback(args.slice(-1)[0], null, channel);
+      },
+      createConfirmChannel(...args) {
+        if (closed) return resolveOrCallback(args.slice(-1)[0], unavailable());
+
+        const channel = Channel(broker, this, true);
+        channels.push(channel);
+        return resolveOrCallback(args.slice(-1)[0], null, channel);
+      },
+      async close(...args) {
+        closed = true;
+
+        const idx = connections.indexOf(this);
+        if (idx > -1) connections.splice(idx, 1);
+        channels.splice(0).forEach((channel) => channel.close());
+
+        emitter.emit('close');
+
+        return resolveOrCallback(args.slice(-1)[0]);
+      },
+      on(...args) {
+        return emitter.on(...args);
+      },
+      once(...args) {
+        return emitter.once(...args);
+      },
+    };
+
+    function unavailable() {
+      return new FakeAmqpError('Connection closed: 504', 504);
+    }
+  }
+
+  function Channel(broker, connection, confirmChannel) {
+    let closed = false, prefetch = 10000;
+    const emitter = new EventEmitter();
+    const channelName = 'channel-' + generateId();
+    const version = connection._version;
+
+    broker.on('return', emitReturn);
+
+    return {
+      _broker: broker,
+      _version: version,
+      get _emitter() {
+        return emitter;
+      },
+      get _closed() {
+        return closed;
+      },
+      assertExchange(...args) {
+        return callBroker(assertExchange, ...args);
+
+        function assertExchange(exchange, ...args) {
+          broker.assertExchange(exchange, ...args);
+          return {
+            exchange,
+          };
+        }
+      },
+      assertQueue(...args) {
+        return callBroker(assertQueue, ...args);
+
+        function assertQueue(queueName, ...args) {
+          const name = queueName ? queueName : 'amqp.gen-' + generateId();
+          const options = typeof args[0] === 'object' ? args.shift() : {};
+          const queue = broker.assertQueue(queueName, {...options, _connectionId: connection._id}, ...args);
+          return {
+            ...(!queueName ? {queue: name} : undefined),
+            messageCount: queue.messageCount,
+            consumerCount: queue.consumerCount,
+          };
+        }
+      },
+      bindExchange(destination, source, ...args) {
+        return Promise.all([this.checkExchange(source), this.checkExchange(destination)]).then(() => {
+          return callBroker(broker.bindExchange, source, destination, ...args);
+        });
+      },
+      bindQueue(queue, source, ...args) {
+        return Promise.all([this.checkQueue(queue), this.checkExchange(source)]).then(() => {
+          return callBroker(broker.bindQueue, queue, source, ...args);
+        });
+      },
+      checkExchange(name, ...args) {
+        return callBroker(check, ...args);
+
+        function check() {
+          if (!broker.getExchange(name)) throw new FakeAmqpError(`Channel closed by server: 404 (NOT-FOUND) with message "NOT_FOUND - no exchange '${name}' in vhost '/'`, 404, true);
+          return true;
+        }
+      },
+      checkQueue(name, ...args) {
+        return callBroker(check, ...args);
+
+        function check() {
+          let queue;
+          if (!(queue = broker.getQueue(name))) {
+            throw new FakeAmqpNotFoundError('queue', name);
+          }
+
+          return {
+            messageCount: queue.messageCount,
+            consumerCount: queue.consumerCount,
+          };
+        }
+      },
+      get(queue, ...args) {
+        return callBroker(getMessage, ...args);
+
+        function getMessage(...getargs) {
+          const q = broker.getQueue(queue);
+          if (!q) throw new FakeAmqpNotFoundError('queue');
+          return q.get(...getargs) || false;
+        }
+      },
+      deleteExchange(exchange, ...args) {
+        return callBroker(check, ...args);
+
+        function check() {
+          const result = broker.deleteExchange(exchange, ...args);
+          if (!result && version < 3.2) throw new FakeAmqpNotFoundError('exchange', exchange);
+          return result;
+        }
+      },
+      deleteQueue(queue, ...args) {
+        return callBroker(check, ...args);
+
+        function check() {
+          const result = broker.deleteQueue(queue, ...args);
+          if (!result && version < 3.2) throw new FakeAmqpNotFoundError('queue', queue);
+          return result;
+        }
+      },
+      publish(exchange, routingKey, content, options, callback) {
+        if (!Buffer.isBuffer(content)) throw new TypeError('content is not a buffer');
+        if (confirmChannel) {
+          options = {...options, confirm: makeConfirmCallback(callback)};
+        }
+
+        this.checkExchange(exchange).then(() => {
+          return callBroker(broker.publish, exchange, routingKey, content, options);
+        }).catch((err) => {
+          emitter.emit('error', err);
+        });
+
+        return true;
+      },
+      purgeQueue(queue, ...args) {
+        return callBroker(check, ...args);
+
+        function check() {
+          const result = broker.purgeQueue(queue);
+          if (!result && version < 3.2) throw new FakeAmqpNotFoundError('queue', queue);
+          return result === undefined ? undefined : {messageCount: result};
+        }
+      },
+      sendToQueue(queue, content, options, callback) {
+        if (!Buffer.isBuffer(content)) throw new TypeError('content is not a buffer');
+        if (confirmChannel) {
+          options = {...options, confirm: makeConfirmCallback(callback)};
+        }
+
+        this.checkQueue(queue).then(() => {
+          return callBroker(broker.sendToQueue, queue, content, options);
+        }).catch((err) => {
+          emitter.emit('error', err);
+        });
+
+        return true;
+      },
+      unbindExchange(destination, source, pattern, ...args) {
+        return callBroker(check, ...args);
+
+        function check() {
+          const q = broker.getExchange(destination);
+          if (!q) throw new FakeAmqpNotFoundError('exchange', destination);
+
+          const exchange = broker.getExchange(source);
+          if (!exchange) throw new FakeAmqpNotFoundError('exchange', source);
+
+          const result = broker.unbindExchange(source, destination, pattern);
+          if (!result && version <= 3.2) throw new FakeAmqpNotFoundError('binding', pattern);
+
+          return true;
+        }
+      },
+      unbindQueue(queue, source, pattern, ...args) {
+        return callBroker(check, ...args);
+
+        function check() {
+          const q = broker.getQueue(queue);
+          if (!q) throw new FakeAmqpNotFoundError('queue', queue);
+
+          const exchange = broker.getExchange(source);
+          if (!exchange) throw new FakeAmqpNotFoundError('exchange', source);
+
+          const binding = exchange.getBinding(queue, pattern);
+          if (!binding && version <= 3.2) throw new FakeAmqpNotFoundError('binding', pattern, version < 3.2);
+
+          broker.unbindQueue(queue, source, pattern);
+          return true;
+        }
+      },
+      consume(queue, onMessage, options = {}, callback) {
+        return callBroker(check, callback);
+
+        function check() {
+          const q = queue && broker.getQueue(queue);
+          if (queue && !q) {
+            throw new FakeAmqpNotFoundError('queue', queue);
+          }
+
+          if (q) {
+            if (q.exclusive || (q.options.exclusive && q.options._connectionId !== connection._id)) {
+              throw new FakeAmqpError(`Channel closed by server: 403 (ACCESS-REFUSED) with message "ACCESS_REFUSED - queue '${queue}' in vhost '/' in exclusive use"`, 403, true, true);
+            }
+          }
+
+          const {consumerTag} = broker.consume(queue, onMessage && handler, {...options, channelName, prefetch});
+          return {consumerTag};
+        }
+
+        function handler(_, msg) {
+          onMessage(msg);
+        }
+      },
+      cancel(consumerTag, ...args) {
+        return callBroker(broker.cancel, consumerTag, ...args);
+      },
+      close(callback) {
+        if (closed) return;
+        broker.off('return', emitReturn);
+        const channelConsumers = broker.getConsumers().filter((f) => f.options.channelName === channelName);
+        channelConsumers.forEach((c) => broker.cancel(c.consumerTag));
+        closed = true;
+        emitter.emit('close');
+        return resolveOrCallback(callback);
+      },
+      ack: broker.ack,
+      ackAll: broker.ackAll,
+      ...(version >= 2.3 ? {
+        nack(message, ...args) {
+          return broker.nack(message, ...args);
+        }
+      } : undefined),
+      reject: broker.reject,
+      nackAll: broker.nackAll,
+      prefetch(val) {
+        prefetch = val;
+      },
+      on(...args) {
+        return emitter.on(...args);
+      },
+      once(...args) {
+        return emitter.once(...args);
+      },
+    };
+
+    function makeConfirmCallback(callback) {
+      const confirm = 'msg.' + generateId();
+      const consumerTag = 'ct-' + confirm;
+      broker.on('message.*', onConsumeMessage, {consumerTag});
+
+      function onConsumeMessage(event) {
+        if (event.properties.confirm !== confirm) return;
+
+        switch(event.name) {
+          case 'message.nack':
+            return confirmCallback(new Error('message nacked'));
+          case 'message.undelivered':
+            return confirmCallback(new Error('message undelivered'));
+          case 'message.ack':
+            return confirmCallback(null, true);
+        }
+
+        function confirmCallback(err, ok) {
+          broker.off('message.*', {consumerTag});
+          callback(err, ok);
+        }
+      }
+
+      return confirm;
+    }
+
+    function callBroker(fn, ...args) {
+      let [poppedCb] = args.slice(-1);
+      if (typeof poppedCb === 'function') args.splice(-1);
+      else poppedCb = null;
+
+      if (connection._closed) throw new FakeAmqpError('Connection is closed', 504);
+      if (closed) throw new Error('Channel is closed');
+
+      return new Promise((resolve, reject) => {
+        try {
+          const result = fn.call(broker, ...args);
+          if (poppedCb) poppedCb(null, result);
+          return resolve(result);
+        } catch (err) {
+          if (err._killConnection) connection.close();
+          else if (err._killChannel) closed = true;
+          if (!poppedCb) return reject(err);
+          poppedCb(err);
+          return resolve();
+        }
+      });
+    }
+
+    function emitReturn({fields, content, properties}) {
+      process.nextTick(() => {
+        emitter.emit('return', {fields, content, properties});
+      });
+    }
+  }
+}
+
+function resolveOrCallback(optionalCb, err, ...args) {
+  if (typeof optionalCb === 'function') optionalCb(err, ...args);
+  if (err) return Promise.reject(err);
+  return Promise.resolve(...args);
+}
+
+function generateId() {
+  return Math.random().toString(16).substring(2, 12);
+}
+
+function compareConnectionString(url1, url2) {
+  const parsedUrl1 = new URL(url1);
+  const parsedUrl2 = new URL(url2);
+  return parsedUrl1.host === parsedUrl2.host && parsedUrl1.pathname === parsedUrl2.pathname;
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@onify/fake-amqplib",
+  "version": "0.8.2",
+  "description": "Fake amqplib",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha",
+    "posttest": "eslint . --cache",
+    "cov:html": "nyc mocha && nyc report --reporter=html"
+  },
+  "author": {
+    "name": "Onify",
+    "url": "https://github.com/onify"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/onify/fake-amqplib.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "smqp": "^5.0.0"
+  },
+  "keywords": [
+    "fake",
+    "mock",
+    "amqp",
+    "amqplib",
+    "rabbitmq"
+  ],
+  "devDependencies": {
+    "chai": "^4.2.0",
+    "eslint": "^7.32.0",
+    "mocha": "^9.1.1",
+    "nyc": "^15.1.0"
+  },
+  "files": [
+    "index.js"
+  ],
+  "directories": {
+    "test": "test"
+  }
+}