@onify/fake-amqplib 3.3.0 → 3.5.0

package/README.md

@@ -4,6 +4,18 @@
 
 Mocked version of https://www.npmjs.com/package/amqplib.
 
+<!-- toc -->
+
+- [Fake api](#fake-api)
+- [RabbitMQ versions](#rabbitmq-versions)
+- [Mocking amqplib](#mocking-amqplib)
+  - [ESM](#esm)
+    - [Node 20+ — `node:test` `mock.module` (recommended)](#node-20-nodetest-mockmodule-recommended)
+    - [Alternative — Quibble](#alternative-quibble)
+  - [CommonJS](#commonjs)
+
+<!-- /toc -->
+
 ## Fake api
 
 - `async connect(amqpurl[, ...otherOptions, callback])`: wait for a fake connection or expect one in the callback
@@ -38,46 +50,62 @@ var fakeAmqp = require('@onify/fake-amqplib');
 
 You might want to override `amqplib` with `@onify/fake-amqplib` in tests. This can be done in a number of ways.
 
-### CommonJS
+### ESM
 
-Example on how to mock amqplib when working with commonjs.
+Example on how to mock the `amqplib` import when working with modules.
 
-```js
-const amqplib = require('amqplib');
-const fakeAmqp = require('@onify/fake-amqplib');
+#### Node 20+ — `node:test` `mock.module` (recommended)
 
-amqplib.connect = fakeAmqp.connect;
+Node's built-in test runner ships an experimental module-mocking API that needs no extra dependency. Set it up at the top of the test file (or in a setup file), then dynamically import `amqplib`.
+
+_.mocharc.json_
+
+```json
+{
+  "recursive": true,
+  "require": ["chai/register-expect.js"],
+  "node-option": ["experimental-test-module-mocks", "no-warnings"]
+}
 ```
 
-or:
+The `experimental-test-module-mocks` flag enables `mock.module`; `no-warnings` silences the "experimental feature" notice. Drop it if you'd rather see the warning.
 
-```js
-const mock = require('mock-require');
-const fakeAmqp = require('@onify/fake-amqplib');
+_test/amqplib-connection-test.js_
 
-mock('amqplib/callback_api', fakeAmqp);
-```
+```javascript
+import { mock } from 'node:test';
+import { connect as fakeConnect, resetMock } from '@onify/fake-amqplib';
 
-or just mock the entire amqplib with:
+describe('connection', () => {
+  let connect;
+  let ctx;
 
-```js
-const mock = require('mock-require');
-const fakeAmqp = require('@onify/fake-amqplib');
+  before(async () => {
+    ctx = mock.module('amqplib', { namedExports: { connect: fakeConnect } });
+    ({ connect } = await import('amqplib'));
+  });
 
-mock('amqplib', fakeAmqp);
-```
+  after(() => {
+    ctx.restore();
+    resetMock();
+  });
 
-### ESM
+  it('connects to the fake', async () => {
+    const connection = await connect('amqp://host');
+    expect(connection.connection.serverProperties).to.have.property('product', 'RabbitMQ');
+  });
+});
+```
 
-Example on how to mock amqplib import when working with modules.
+If you also use `mocha --parallel` or run tests via `node --test`, the same setup works — `mock.module` is process-global, so register it before the first dynamic import in each test file.
 
-**[Quibble](https://www.npmjs.com/package/quibble) mocha example**
+#### Alternative — Quibble
 
-Both amqplib and fake-amqplib have to be quibbled if reset mock is used during testing.
+[Quibble](https://www.npmjs.com/package/quibble) is useful if you're on a Node version older than 20, or prefer not to rely on an experimental flag.
 
 _test/setup.js_
 
-```javascript
+```js
 import * as fakeAmqpLib from '@onify/fake-amqplib';
 import { connect as fakeConnect } from '@onify/fake-amqplib';
 import quibble from 'quibble';
@@ -88,7 +116,7 @@ import quibble from 'quibble';
 })();
 ```
 
-_.mocharc.json_ (true for node version < 20)
+_.mocharc.json_ (the `loader=quibble` option is only needed on Node < 20)
 
 ```json
 {
@@ -98,29 +126,33 @@ _.mocharc.json_ (true for node version < 20)
 }
 ```
 
-_test/amqplib-connection-test.js_
+Then import `amqplib` normally in your tests; quibble rewires the import.
 
-```javascript
-import assert from 'node:assert';
-import { connect } from 'amqplib';
-import { connect as connectCb } from 'amqplib';
+### CommonJS
 
-import { resetMock } from '@onify/fake-amqplib';
+Example on how to mock amqplib when working with commonjs.
 
-describe('connection', () => {
-  afterEach(resetMock);
+```js
+const amqplib = require('amqplib');
+const fakeAmqp = require('@onify/fake-amqplib');
 
-  it('connect promise', async () => {
-    const connection = await connect('amqp://host');
-    assert.equal(connection.connection.serverProperties.version, '3.5.0');
-  });
+amqplib.connect = fakeAmqp.connect;
+```
 
-  it('connect callback', (done) => {
-    connectCb('amqp://host', (err, connection) => {
-      if (err) return done(err);
-      assert.equal(connection.connection.serverProperties.version, '3.5.0');
-      done();
-    });
-  });
-});
+or:
+
+```js
+const mock = require('mock-require');
+const fakeAmqp = require('@onify/fake-amqplib');
+
+mock('amqplib/callback_api', fakeAmqp);
+```
+
+or just mock the entire amqplib with:
+
+```js
+const mock = require('mock-require');
+const fakeAmqp = require('@onify/fake-amqplib');
+
+mock('amqplib', fakeAmqp);
 ```

package/index.d.ts

@@ -1,59 +1,90 @@
 /// <reference types="amqplib" />
 /// <reference types="node" />
 
-declare module '@onify/fake-amqplib' {
-  import { Options, Connection, Channel, ChannelModel } from 'amqplib';
-  import { Broker } from 'smqp';
-
-  export interface FakeAmqplibChannel extends Channel {
-    /** Channel name and identifier, for faking purposes */
-    _channelName: string;
-    _broker: Broker;
-    _version: number;
-    new (broker: Broker, connection: FakeAmqplibConnection): FakeAmqplibChannel;
-    get _closed(): boolean;
-  }
-
-  export interface FakeAmqplibConnection extends Connection, ChannelModel {
-    _channels: FakeAmqplibChannel[];
-    _url: URL;
-    /** Connection identifier, for faking purposes */
-    _id: string;
-    _broker: Broker;
-    _version: number;
-    new (broker: Broker, version: number, amqpUrl: string, options?: any): FakeAmqplibConnection;
-    get _closed(): boolean;
-  }
-
-  interface SocketOptions {
-    host?: string;
-    keepAlive?: boolean;
-    keepAliveDelay?: number;
-    noDelay?: boolean;
-    port?: number;
-    serverName?: string;
-    timeout?: number;
-    [x: string]: any;
-  }
-
-  type connectCallback = (err: Error, connection: FakeAmqplibConnection) => void;
-
-  export class FakeAmqplib {
-    version: number;
-    connections: FakeAmqplibConnection[];
-    constructor(version?: number);
-    connect(url: string | Options.Connect, socketOptions?: SocketOptions): Promise<FakeAmqplibConnection>;
-    connect(url: string | Options.Connect, socketOptions: SocketOptions, callback: connectCallback): void;
-    connect(url: string | Options.Connect, callback: (err: Error, connection: FakeAmqplibConnection) => void): void;
-    connectSync(url: string | Options.Connect, socketOptions?: SocketOptions): FakeAmqplibConnection;
-    resetMock(): void;
-    setVersion(minorVersion: number): void;
-  }
-
-  export function connect(url: string | Options.Connect, socketOptions?: SocketOptions): Promise<FakeAmqplibConnection>;
-  export function connect(url: string | Options.Connect, socketOptions: SocketOptions, callback: connectCallback): void;
-  export function connect(url: string | Options.Connect, callback: connectCallback): void;
-  export function connectSync(url: string | Options.Connect, socketOptions?: SocketOptions): FakeAmqplibConnection;
-  export function resetMock(): void;
-  export function setVersion(minorVersion: number): void;
+import { Options, Connection, Channel, ChannelModel, Replies } from 'amqplib';
+import { Broker } from 'smqp';
+
+export interface FakeAmqplibChannel extends Channel {
+  /** Channel name and identifier, for faking purposes */
+  _channelName: string;
+  _broker: Broker;
+  _version: number;
+  readonly _closed: boolean;
+}
+
+export const FakeAmqplibChannel: {
+  new (broker: Broker, connection: FakeAmqplibConnection): FakeAmqplibChannel;
+};
+
+export interface FakeAmqplibConfirmChannel extends FakeAmqplibChannel {
+  publish(
+    exchange: string,
+    routingKey: string,
+    content: Buffer,
+    options?: Options.Publish,
+    callback?: (err: Error | null, ok: Replies.Empty) => void
+  ): boolean;
+  sendToQueue(
+    queue: string,
+    content: Buffer,
+    options?: Options.Publish,
+    callback?: (err: Error | null, ok: Replies.Empty) => void
+  ): boolean;
+  waitForConfirms(callback?: (err: Error | null) => void): Promise<void>;
+}
+
+export const FakeAmqplibConfirmChannel: {
+  new (broker: Broker, connection: FakeAmqplibConnection): FakeAmqplibConfirmChannel;
+};
+
+export interface FakeAmqplibConnection extends Connection, ChannelModel {
+  _channels: FakeAmqplibChannel[];
+  _url: URL;
+  /** Connection identifier, for faking purposes */
+  _id: string;
+  _broker: Broker;
+  _version: number;
+  readonly _closed: boolean;
+}
+
+export const FakeAmqplibConnection: {
+  new (broker: Broker, version: number, amqpUrl: string, options?: SocketOptions): FakeAmqplibConnection;
+};
+
+export interface SocketOptions {
+  host?: string;
+  keepAlive?: boolean;
+  keepAliveDelay?: number;
+  noDelay?: boolean;
+  port?: number;
+  serverName?: string;
+  timeout?: number;
+  [x: string]: any;
+}
+
+export type ConnectCallback = (err: Error | null, connection: FakeAmqplibConnection) => void;
+
+export interface FakeAmqplib {
+  version: number;
+  connections: FakeAmqplibConnection[];
+  connect(url: string | Options.Connect, socketOptions?: SocketOptions): Promise<FakeAmqplibConnection>;
+  connect(url: string | Options.Connect, socketOptions: SocketOptions, callback: ConnectCallback): void;
+  connect(url: string | Options.Connect, callback: ConnectCallback): void;
+  connectSync(url: string | Options.Connect, socketOptions?: SocketOptions): FakeAmqplibConnection;
+  resetMock(): void;
+  setVersion(minorVersion: number | string): void;
 }
+
+export const FakeAmqplib: {
+  new (minorVersion?: number | string): FakeAmqplib;
+  (minorVersion?: number | string): FakeAmqplib;
+};
+
+export const connections: FakeAmqplibConnection[];
+
+export function connect(url: string | Options.Connect, socketOptions?: SocketOptions): Promise<FakeAmqplibConnection>;
+export function connect(url: string | Options.Connect, socketOptions: SocketOptions, callback: ConnectCallback): void;
+export function connect(url: string | Options.Connect, callback: ConnectCallback): void;
+export function connectSync(url: string | Options.Connect, socketOptions?: SocketOptions): FakeAmqplibConnection;
+export function resetMock(): void;
+export function setVersion(minorVersion: number | string): void;

package/index.js

@@ -7,6 +7,9 @@ const kClosed = Symbol.for('closed');
 const kDeliveryTag = Symbol.for('channel delivery tag');
 const kPrefetch = Symbol.for('prefetch');
 const kChannelPrefetch = Symbol.for('channel prefetch');
+const kPendingConfirms = Symbol.for('pending confirms');
+
+const CHANNEL_CLOSED_ERROR = 'Channel is closed';
 
 class AmqplibBroker extends Broker {
   constructor(...args) {
@@ -429,6 +432,19 @@ export class FakeAmqplibChannel extends EventEmitter {
       brokerMessage.reject(requeue);
     }
   }
+  recover(...args) {
+    const channelQ = this._channelQueue;
+    return this._callBroker(recoverChannel, ...args);
+
+    function recoverChannel() {
+      let msg;
+      while ((msg = channelQ.get())) {
+        msg.content[kSmqp].reject(true);
+        msg.reject(false);
+      }
+      return {};
+    }
+  }
   prefetch(val, isChannelPrefetch) {
     if (this.connection._version < 3.3) {
       if (isChannelPrefetch !== undefined) {
@@ -449,7 +465,7 @@ export class FakeAmqplibChannel extends EventEmitter {
     else poppedCb = null;
 
     if (this.connection._closed) throw new FakeAmqpError('Connection is closed', 504);
-    if (this[kClosed]) throw new Error('Channel is closed');
+    if (this[kClosed]) throw new Error(CHANNEL_CLOSED_ERROR);
 
     return new Promise((resolve, reject) => {
       try {
@@ -509,19 +525,25 @@ export class FakeAmqplibChannel extends EventEmitter {
 }
 
 export class FakeAmqplibConfirmChannel extends FakeAmqplibChannel {
+  constructor(broker, connection) {
+    super(broker, connection);
+    this[kPendingConfirms] = new Set();
+  }
   publish(exchange, routingKey, content, options, callback) {
     if (!Buffer.isBuffer(content)) throw new TypeError('content is not a buffer');
     if (exchange === '') return this.sendToQueue(routingKey, content, options, callback);
+    if (this[kClosed]) throw new Error(CHANNEL_CLOSED_ERROR);
 
     const args = [this._broker.publish, exchange, routingKey, content];
 
-    args.push(...addConfirmCallback(this._broker, options, callback));
+    args.push(...addConfirmCallback(this._broker, options, this._trackConfirm(callback)));
 
     this.checkExchange(exchange)
       .then(() => {
         return this._callBroker(...args);
       })
       .catch((err) => {
+        if (err.message === CHANNEL_CLOSED_ERROR) return;
         this.emit('error', err);
       });
 
@@ -529,21 +551,61 @@ export class FakeAmqplibConfirmChannel extends FakeAmqplibChannel {
   }
   sendToQueue(queue, content, options, callback) {
     if (!Buffer.isBuffer(content)) throw new TypeError('content is not a buffer');
+    if (this[kClosed]) throw new Error(CHANNEL_CLOSED_ERROR);
 
     const args = [this._broker.sendToQueue, queue, content];
 
-    args.push(...addConfirmCallback(this._broker, options, callback));
+    args.push(...addConfirmCallback(this._broker, options, this._trackConfirm(callback)));
 
     this.checkQueue(queue)
       .then(() => {
         return this._callBroker(...args);
       })
       .catch((err) => {
+        if (err.message === CHANNEL_CLOSED_ERROR) return;
         this.emit('error', err);
       });
 
     return true;
   }
+  _trackConfirm(userCallback) {
+    let resolveSettled;
+    const settled = new Promise((resolve) => {
+      resolveSettled = resolve;
+    });
+    const entry = { settled, resolveSettled, userCallback };
+    this[kPendingConfirms].add(entry);
+
+    return (err, ok) => {
+      this[kPendingConfirms].delete(entry);
+      resolveSettled(err || null);
+      if (typeof userCallback === 'function') userCallback(err, ok);
+    };
+  }
+  waitForConfirms(callback) {
+    const snapshot = [...this[kPendingConfirms]].map((entry) => entry.settled);
+    const promise = Promise.all(snapshot).then((errs) => {
+      const firstErr = errs.find((e) => e !== null);
+      if (firstErr) throw firstErr;
+    });
+    if (typeof callback === 'function') {
+      promise.then(
+        () => callback(null),
+        (err) => callback(err)
+      );
+    }
+    return promise;
+  }
+  _teardown() {
+    super._teardown();
+    if (!this[kPendingConfirms] || this[kPendingConfirms].size === 0) return;
+    const err = new Error(CHANNEL_CLOSED_ERROR);
+    for (const entry of [...this[kPendingConfirms]]) {
+      this[kPendingConfirms].delete(entry);
+      entry.resolveSettled(err);
+      if (typeof entry.userCallback === 'function') entry.userCallback(err);
+    }
+  }
 }
 
 export class FakeAmqplibConnection extends EventEmitter {
@@ -586,6 +648,10 @@ export class FakeAmqplibConnection extends EventEmitter {
     this._channels.push(channel);
     return resolveOrCallback(args.slice(-1)[0], null, channel);
   }
+  updateSecret(...args) {
+    process.nextTick(() => this.emit('update-secret-ok'));
+    return resolveOrCallback(args.slice(-1)[0]);
+  }
   close(...args) {
     if (this[kClosed]) return resolveOrCallback(args.slice(-1)[0]);
     this[kClosed] = true;

package/main.cjs

@@ -9,6 +9,9 @@ const kClosed = Symbol.for('closed');
 const kDeliveryTag = Symbol.for('channel delivery tag');
 const kPrefetch = Symbol.for('prefetch');
 const kChannelPrefetch = Symbol.for('channel prefetch');
+const kPendingConfirms = Symbol.for('pending confirms');
+
+const CHANNEL_CLOSED_ERROR = 'Channel is closed';
 
 class AmqplibBroker extends smqp.Broker {
   constructor(...args) {
@@ -431,6 +434,19 @@ class FakeAmqplibChannel extends events.EventEmitter {
       brokerMessage.reject(requeue);
     }
   }
+  recover(...args) {
+    const channelQ = this._channelQueue;
+    return this._callBroker(recoverChannel, ...args);
+
+    function recoverChannel() {
+      let msg;
+      while ((msg = channelQ.get())) {
+        msg.content[kSmqp].reject(true);
+        msg.reject(false);
+      }
+      return {};
+    }
+  }
   prefetch(val, isChannelPrefetch) {
     if (this.connection._version < 3.3) {
       if (isChannelPrefetch !== undefined) {
@@ -451,7 +467,7 @@ class FakeAmqplibChannel extends events.EventEmitter {
     else poppedCb = null;
 
     if (this.connection._closed) throw new FakeAmqpError('Connection is closed', 504);
-    if (this[kClosed]) throw new Error('Channel is closed');
+    if (this[kClosed]) throw new Error(CHANNEL_CLOSED_ERROR);
 
     return new Promise((resolve, reject) => {
       try {
@@ -511,19 +527,25 @@ class FakeAmqplibChannel extends events.EventEmitter {
 }
 
 class FakeAmqplibConfirmChannel extends FakeAmqplibChannel {
+  constructor(broker, connection) {
+    super(broker, connection);
+    this[kPendingConfirms] = new Set();
+  }
   publish(exchange, routingKey, content, options, callback) {
     if (!Buffer.isBuffer(content)) throw new TypeError('content is not a buffer');
     if (exchange === '') return this.sendToQueue(routingKey, content, options, callback);
+    if (this[kClosed]) throw new Error(CHANNEL_CLOSED_ERROR);
 
     const args = [this._broker.publish, exchange, routingKey, content];
 
-    args.push(...addConfirmCallback(this._broker, options, callback));
+    args.push(...addConfirmCallback(this._broker, options, this._trackConfirm(callback)));
 
     this.checkExchange(exchange)
       .then(() => {
         return this._callBroker(...args);
       })
       .catch((err) => {
+        if (err.message === CHANNEL_CLOSED_ERROR) return;
         this.emit('error', err);
       });
 
@@ -531,21 +553,61 @@ class FakeAmqplibConfirmChannel extends FakeAmqplibChannel {
   }
   sendToQueue(queue, content, options, callback) {
     if (!Buffer.isBuffer(content)) throw new TypeError('content is not a buffer');
+    if (this[kClosed]) throw new Error(CHANNEL_CLOSED_ERROR);
 
     const args = [this._broker.sendToQueue, queue, content];
 
-    args.push(...addConfirmCallback(this._broker, options, callback));
+    args.push(...addConfirmCallback(this._broker, options, this._trackConfirm(callback)));
 
     this.checkQueue(queue)
       .then(() => {
         return this._callBroker(...args);
       })
       .catch((err) => {
+        if (err.message === CHANNEL_CLOSED_ERROR) return;
         this.emit('error', err);
       });
 
     return true;
   }
+  _trackConfirm(userCallback) {
+    let resolveSettled;
+    const settled = new Promise((resolve) => {
+      resolveSettled = resolve;
+    });
+    const entry = { settled, resolveSettled, userCallback };
+    this[kPendingConfirms].add(entry);
+
+    return (err, ok) => {
+      this[kPendingConfirms].delete(entry);
+      resolveSettled(err || null);
+      if (typeof userCallback === 'function') userCallback(err, ok);
+    };
+  }
+  waitForConfirms(callback) {
+    const snapshot = [...this[kPendingConfirms]].map((entry) => entry.settled);
+    const promise = Promise.all(snapshot).then((errs) => {
+      const firstErr = errs.find((e) => e !== null);
+      if (firstErr) throw firstErr;
+    });
+    if (typeof callback === 'function') {
+      promise.then(
+        () => callback(null),
+        (err) => callback(err)
+      );
+    }
+    return promise;
+  }
+  _teardown() {
+    super._teardown();
+    if (!this[kPendingConfirms] || this[kPendingConfirms].size === 0) return;
+    const err = new Error(CHANNEL_CLOSED_ERROR);
+    for (const entry of [...this[kPendingConfirms]]) {
+      this[kPendingConfirms].delete(entry);
+      entry.resolveSettled(err);
+      if (typeof entry.userCallback === 'function') entry.userCallback(err);
+    }
+  }
 }
 
 class FakeAmqplibConnection extends events.EventEmitter {
@@ -588,6 +650,10 @@ class FakeAmqplibConnection extends events.EventEmitter {
     this._channels.push(channel);
     return resolveOrCallback(args.slice(-1)[0], null, channel);
   }
+  updateSecret(...args) {
+    process.nextTick(() => this.emit('update-secret-ok'));
+    return resolveOrCallback(args.slice(-1)[0]);
+  }
   close(...args) {
     if (this[kClosed]) return resolveOrCallback(args.slice(-1)[0]);
     this[kClosed] = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onify/fake-amqplib",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "Fake amqplib",
   "type": "module",
   "exports": {
@@ -13,19 +13,21 @@
   "main": "./main.cjs",
   "scripts": {
     "test": "mocha",
-    "posttest": "npm run lint && npm run dist",
+    "posttest": "npm run lint && npm run dist && npm run test:md",
     "lint": "eslint . --cache && prettier . -c --cache",
     "dist": "rollup -c",
     "prepack": "npm run dist",
     "cov:html": "c8 -r html -r text mocha",
-    "test:lcov": "c8 -r lcov mocha && npm run lint"
+    "test:lcov": "c8 -r lcov mocha && npm run lint",
+    "test:md": "texample ./README.md -c ./.mocharc.json -r scripts/texample-mocha.js",
+    "toc": "node scripts/toc.js"
   },
   "author": {
     "name": "Onify",
     "url": "https://github.com/onify"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=18"
   },
   "repository": {
     "type": "git",
@@ -33,21 +35,30 @@
   },
   "license": "MIT",
   "dependencies": {
-    "smqp": "^10.0.0"
+    "smqp": "^12.0.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@rollup/plugin-commonjs": "^29.0.0",
     "@types/amqplib": "^0.10.2",
-    "amqplib": "^0.10.4",
-    "c8": "^10.1.2",
+    "amqplib": "^1.0.3",
+    "c8": "^11.0.0",
     "chai": "^6.2.1",
-    "eslint": "^9.0.0",
-    "globals": "^16.0.0",
+    "eslint": "^10.3.0",
+    "globals": "^17.0.0",
     "mocha": "^11.0.1",
     "prettier": "^3.2.5",
     "quibble": "^0.9.2",
     "rollup": "^4.0.2",
-    "texample": "^0.1.0"
+    "texample": "^1.0.2"
+  },
+  "overrides": {
+    "c8": {
+      "yargs": "^18.0.0"
+    },
+    "mocha": {
+      "yargs": "^18.0.0"
+    }
   },
   "keywords": [
     "fake",