@onify/fake-amqplib 3.4.0 → 3.6.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,104 @@
-/// <reference types="amqplib" />
 /// <reference types="node" />
 
 declare module '@onify/fake-amqplib' {
-  import { Options, Connection, Channel, ChannelModel } from 'amqplib';
+  import { Options, Channel, ChannelModel, Replies, RecoveryOptions, SocketOptions } from 'amqplib';
   import { Broker } from 'smqp';
 
+  export { RecoveryOptions, SocketOptions };
+
   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;
-    get _closed(): boolean;
+  };
+
+  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 interface FakeAmqplibConnection extends Connection, ChannelModel {
+  export const FakeAmqplibConfirmChannel: {
+    new (broker: Broker, connection: FakeAmqplibConnection): FakeAmqplibConfirmChannel;
+  };
+
+  export interface FakeAmqplibConnection extends 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;
+    readonly _closed: boolean;
   }
 
-  interface SocketOptions {
-    host?: string;
-    keepAlive?: boolean;
-    keepAliveDelay?: number;
-    noDelay?: boolean;
-    port?: number;
-    serverName?: string;
-    timeout?: number;
-    [x: string]: any;
-  }
+  export const FakeAmqplibConnection: {
+    new (broker: Broker, version: number, amqpUrl: string, options?: SocketOptions): FakeAmqplibConnection;
+  };
 
-  type connectCallback = (err: Error, connection: FakeAmqplibConnection) => void;
+  export type ConnectCallback = (err: Error | null, connection: FakeAmqplibConnection) => void;
 
-  export class FakeAmqplib {
+  export interface 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;
+    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;
+    connectWithRecoveryPromise(
+      url: string | Options.Connect,
+      recoveryOptions?: RecoveryOptions,
+      socketOptions?: SocketOptions
+    ): Promise<FakeAmqplibConnection>;
+    connectWithRecoveryCallback(
+      url: string | Options.Connect,
+      recoveryOptions: RecoveryOptions,
+      socketOptions: SocketOptions,
+      callback: ConnectCallback
+    ): void;
     resetMock(): void;
-    setVersion(minorVersion: number): 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 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 connectWithRecoveryPromise(
+    url: string | Options.Connect,
+    recoveryOptions?: RecoveryOptions,
+    socketOptions?: SocketOptions
+  ): Promise<FakeAmqplibConnection>;
+  export function connectWithRecoveryCallback(
+    url: string | Options.Connect,
+    recoveryOptions: RecoveryOptions,
+    socketOptions: SocketOptions,
+    callback: ConnectCallback
+  ): void;
   export function resetMock(): void;
-  export function setVersion(minorVersion: number): 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,21 @@ export class FakeAmqplibChannel extends EventEmitter {
       brokerMessage.reject(requeue);
     }
   }
+  recover(...args) {
+    const channelQ = this._channelQueue;
+    return this._callBroker(recoverChannel, ...args);
+
+    function recoverChannel() {
+      const snapshot = [];
+      let msg;
+      while ((msg = channelQ.get())) snapshot.push(msg);
+      for (const m of snapshot) {
+        m.content[kSmqp].reject(true);
+        m.reject(false);
+      }
+      return {};
+    }
+  }
   prefetch(val, isChannelPrefetch) {
     if (this.connection._version < 3.3) {
       if (isChannelPrefetch !== undefined) {
@@ -449,7 +467,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 +527,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 +553,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 +650,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;
@@ -608,6 +676,8 @@ export function FakeAmqplib(minorVersion = '3.5') {
 
   this.connect = this.connect.bind(this);
   this.connectSync = this.connectSync.bind(this);
+  this.connectWithRecoveryPromise = this.connectWithRecoveryPromise.bind(this);
+  this.connectWithRecoveryCallback = this.connectWithRecoveryCallback.bind(this);
   this.resetMock = this.resetMock.bind(this);
   this.setVersion = this.setVersion.bind(this);
 }
@@ -617,6 +687,19 @@ FakeAmqplib.prototype.connect = function fakeConnect(amqpUrl, ...args) {
   return resolveOrCallback(args.slice(-1)[0], null, connection);
 };
 
+FakeAmqplib.prototype.connectWithRecoveryPromise = function fakeConnectWithRecoveryPromise(amqpUrl, recoveryOptions, socketOptions) {
+  return this.connect(amqpUrl, socketOptions);
+};
+
+FakeAmqplib.prototype.connectWithRecoveryCallback = function fakeConnectWithRecoveryCallback(
+  amqpUrl,
+  recoveryOptions,
+  socketOptions,
+  callback
+) {
+  return this.connect(amqpUrl, socketOptions, callback);
+};
+
 FakeAmqplib.prototype.connectSync = function fakeConnectSync(amqpUrl, ...args) {
   const { _broker } = this.connections.find((conn) => compareConnectionString(conn._url, amqpUrl)) || {};
   const broker = _broker || new AmqplibBroker(this);
@@ -762,6 +845,14 @@ export function connectSync(amqpUrl, ...args) {
   return defaultFake.connectSync(amqpUrl, ...args);
 }
 
+export function connectWithRecoveryPromise(amqpUrl, recoveryOptions, socketOptions) {
+  return defaultFake.connectWithRecoveryPromise(amqpUrl, recoveryOptions, socketOptions);
+}
+
+export function connectWithRecoveryCallback(amqpUrl, recoveryOptions, socketOptions, callback) {
+  return defaultFake.connectWithRecoveryCallback(amqpUrl, recoveryOptions, socketOptions, callback);
+}
+
 export function resetMock() {
   return defaultFake.resetMock();
 }

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,21 @@ class FakeAmqplibChannel extends events.EventEmitter {
       brokerMessage.reject(requeue);
     }
   }
+  recover(...args) {
+    const channelQ = this._channelQueue;
+    return this._callBroker(recoverChannel, ...args);
+
+    function recoverChannel() {
+      const snapshot = [];
+      let msg;
+      while ((msg = channelQ.get())) snapshot.push(msg);
+      for (const m of snapshot) {
+        m.content[kSmqp].reject(true);
+        m.reject(false);
+      }
+      return {};
+    }
+  }
   prefetch(val, isChannelPrefetch) {
     if (this.connection._version < 3.3) {
       if (isChannelPrefetch !== undefined) {
@@ -451,7 +469,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 +529,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 +555,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 +652,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;
@@ -610,6 +678,8 @@ function FakeAmqplib(minorVersion = '3.5') {
 
   this.connect = this.connect.bind(this);
   this.connectSync = this.connectSync.bind(this);
+  this.connectWithRecoveryPromise = this.connectWithRecoveryPromise.bind(this);
+  this.connectWithRecoveryCallback = this.connectWithRecoveryCallback.bind(this);
   this.resetMock = this.resetMock.bind(this);
   this.setVersion = this.setVersion.bind(this);
 }
@@ -619,6 +689,19 @@ FakeAmqplib.prototype.connect = function fakeConnect(amqpUrl, ...args) {
   return resolveOrCallback(args.slice(-1)[0], null, connection);
 };
 
+FakeAmqplib.prototype.connectWithRecoveryPromise = function fakeConnectWithRecoveryPromise(amqpUrl, recoveryOptions, socketOptions) {
+  return this.connect(amqpUrl, socketOptions);
+};
+
+FakeAmqplib.prototype.connectWithRecoveryCallback = function fakeConnectWithRecoveryCallback(
+  amqpUrl,
+  recoveryOptions,
+  socketOptions,
+  callback
+) {
+  return this.connect(amqpUrl, socketOptions, callback);
+};
+
 FakeAmqplib.prototype.connectSync = function fakeConnectSync(amqpUrl, ...args) {
   const { _broker } = this.connections.find((conn) => compareConnectionString(conn._url, amqpUrl)) || {};
   const broker = _broker || new AmqplibBroker(this);
@@ -764,6 +847,14 @@ function connectSync(amqpUrl, ...args) {
   return defaultFake.connectSync(amqpUrl, ...args);
 }
 
+function connectWithRecoveryPromise(amqpUrl, recoveryOptions, socketOptions) {
+  return defaultFake.connectWithRecoveryPromise(amqpUrl, recoveryOptions, socketOptions);
+}
+
+function connectWithRecoveryCallback(amqpUrl, recoveryOptions, socketOptions, callback) {
+  return defaultFake.connectWithRecoveryCallback(amqpUrl, recoveryOptions, socketOptions, callback);
+}
+
 function resetMock() {
   return defaultFake.resetMock();
 }
@@ -778,6 +869,8 @@ exports.FakeAmqplibConfirmChannel = FakeAmqplibConfirmChannel;
 exports.FakeAmqplibConnection = FakeAmqplibConnection;
 exports.connect = connect;
 exports.connectSync = connectSync;
+exports.connectWithRecoveryCallback = connectWithRecoveryCallback;
+exports.connectWithRecoveryPromise = connectWithRecoveryPromise;
 exports.connections = connections;
 exports.resetMock = resetMock;
 exports.setVersion = setVersion;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onify/fake-amqplib",
-  "version": "3.4.0",
+  "version": "3.6.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": "^11.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",
+    "@types/node": "^20.19.40",
+    "amqplib": "^1.2.0",
+    "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",