amqplib 2.1.0 → 2.2.1

package/test/mux.test.js

@@ -1,258 +0,0 @@
-const { describe, it } = require('node:test');
-const assert = require('node:assert');
-const Mux = require('../lib/mux').Mux;
-const PassThrough = require('node:stream').PassThrough;
-
-const latch = require('./lib/util').latch;
-const schedule = require('./lib/util').schedule;
-
-function stream() {
-  return new PassThrough({ objectMode: true });
-}
-
-function readAllObjects(s, cb) {
-  const objs = [];
-
-  function read() {
-    let v = s.read();
-    while (v !== null) {
-      objs.push(v);
-      v = s.read();
-    }
-  }
-
-  s.on('end', () => {
-    cb(objs);
-  });
-  s.on('readable', read);
-
-  read();
-}
-
-describe('mux', () => {
-
-  it('single input', (_t, done) => {
-    const input = stream();
-    const output = stream();
-    input.on('end', () => output.end());
-
-    const mux = new Mux(output);
-    mux.pipeFrom(input);
-
-    const data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    // not 0, it's treated specially by PassThrough for some reason. By
-    // 'specially' I mean it breaks the stream. See e.g.,
-    // https://github.com/isaacs/readable-stream/pull/55
-    data.forEach((chunk) => input.write(chunk));
-
-    readAllObjects(output, (vals) => {
-      assert.deepEqual(data, vals);
-      done();
-    });
-
-    input.end();
-  });
-
-  it('single input, resuming stream', (_t, done) => {
-    const input = stream();
-    const output = stream();
-    input.on('end', () => output.end());
-
-    const mux = new Mux(output);
-    mux.pipeFrom(input);
-
-    // Streams might be blocked and become readable again, simulate this
-    // using a special read function and a marker
-    const data = [1, 2, 3, 4, 'skip', 6, 7, 8, 9];
-
-    const oldRead = input.read;
-    input.read = (size) => {
-      const val = oldRead.call(input, size);
-
-      if (val === 'skip') {
-        input.emit('readable');
-        return null;
-      }
-
-      return val;
-    };
-
-    data.forEach((chunk) => input.write(chunk));
-
-    readAllObjects(output, (vals) => {
-      assert.deepEqual([1, 2, 3, 4, 6, 7, 8, 9], vals);
-      done();
-    });
-
-    input.end();
-  });
-
-  it('two sequential inputs', (_t, done) => {
-    const input1 = stream();
-    const input2 = stream();
-    const output = stream();
-    const mux = new Mux(output);
-    mux.pipeFrom(input1);
-    mux.pipeFrom(input2);
-
-    const data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    data.forEach((v) => {
-      input1.write(v);
-    });
-
-    input1.on('end', () => {
-      data.forEach((v) => {
-        input2.write(v);
-      });
-      input2.end();
-    });
-    input2.on('end', () => output.end());
-
-    input1.end();
-    readAllObjects(output, (vs) => {
-      assert.equal(2 * data.length, vs.length);
-      done();
-    });
-  });
-
-  it('two interleaved inputs', (_t, done) => {
-    const input1 = stream();
-    const input2 = stream();
-    const output = stream();
-    const mux = new Mux(output);
-    mux.pipeFrom(input1);
-    mux.pipeFrom(input2);
-
-    const decrementLatch = latch(2, () => output.end());
-    input1.on('end', decrementLatch);
-    input2.on('end', decrementLatch);
-
-    const data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-    data.forEach((v) => {
-      input1.write(v);
-    });
-    input1.end();
-
-    data.forEach((v) => input2.write(v));
-    input2.end();
-
-    readAllObjects(output, (vs) => {
-      assert.equal(2 * data.length, vs.length);
-      done();
-    });
-  });
-
-  it('unpipe', (_t, done) => {
-    const input = stream();
-    const output = stream();
-    const mux = new Mux(output);
-
-    const pipedData = [1, 2, 3, 4, 5];
-    const unpipedData = [6, 7, 8, 9];
-
-    mux.pipeFrom(input);
-
-    schedule(() => {
-      pipedData.forEach((chunk) => input.write(chunk));
-
-      schedule(() => {
-        mux.unpipeFrom(input);
-
-        schedule(() => {
-          unpipedData.forEach((chunk) => input.write(chunk));
-          input.end();
-          schedule(() => {
-            // exhaust so that 'end' fires
-            let v;
-            do {
-              v = input.read();
-            } while (v);
-          });
-        });
-      });
-    });
-
-    input.on('end', () => output.end());
-
-    readAllObjects(output, (vals) => {
-      try {
-        assert.deepEqual(pipedData, vals);
-        done();
-      } catch (e) {
-        done(e);
-      }
-    });
-  });
-
-  it('backpressure does not crash when newStreams is drained', () => {
-    // Regression test: out.write() returns false (backpressure) while
-    // draining newStreams. The buggy code does an unconditional shift at the
-    // bottom of the loop, so if the next stream reads null (empty) it gets
-    // discarded without being pushed back, leaving newStreams empty and
-    // triggering assert(this.newStreams.length > 0) in the else-branch.
-    //
-    // Scenario: newStreams = [input1, input2], input1 has data, input2 empty.
-    // - shift input1, read 1, write → backpressure (false), push input1 back
-    // - (buggy) unconditional shift takes input2, loop condition false → exit
-    // - newStreams = [input1], length > 0, assert passes  ← not the bug path
-    //
-    // The crash path requires backpressure AND the shifted stream reading null
-    // with no other streams remaining. Use a single stream that has data, then
-    // engineer a second read() on the same stream returning null after the
-    // write so the stream is not pushed back, emptying newStreams entirely.
-    const input1 = stream();
-    const output = stream();
-    const mux = new Mux(output);
-
-    mux.newStreams.push(input1);
-    input1.write(1);
-
-    // After the first write (which triggers backpressure), wrap read() so
-    // the stream appears empty on the next call — simulating a stream that
-    // had one item buffered and is now drained within the same roundrobin pass.
-    const originalRead = input1.read.bind(input1);
-    let readCount = 0;
-    input1.read = (size) => {
-      readCount++;
-      if (readCount > 1) return null; // appear empty after first read
-      return originalRead(size);
-    };
-
-    const originalWrite = output.write.bind(output);
-    output.write = (...args) => {
-      originalWrite(...args);
-      return false; // signal backpressure immediately
-    };
-
-    assert.doesNotThrow(() => mux._readIncoming());
-  });
-
-  it('roundrobin', (_t, done) => {
-    const input1 = stream();
-    const input2 = stream();
-    const output = stream();
-    const mux = new Mux(output);
-
-    mux.pipeFrom(input1);
-    mux.pipeFrom(input2);
-
-    const decrementLatch = latch(2, () => output.end());
-    input1.on('end', decrementLatch);
-    input2.on('end', decrementLatch);
-
-    const ones = [1, 1, 1, 1, 1];
-    ones.forEach((v) => {
-      input1.write(v);
-    });
-    input1.end();
-
-    const twos = [2, 2, 2, 2, 2];
-    twos.forEach((v) => input2.write(v));
-    input2.end();
-
-    readAllObjects(output, (vs) => {
-      assert.deepEqual([1, 2, 1, 2, 1, 2, 1, 2, 1, 2], vs);
-      done();
-    });
-  });
-});

package/test/recovery.test.js

@@ -1,402 +0,0 @@
-
-
-const { describe, it } = require('node:test');
-const assert = require('node:assert');
-const EventEmitter = require('node:events');
-const recovery = require('../lib/recovery');
-
-class FakePromiseModel extends EventEmitter {
-  constructor(id) {
-    super();
-    this.id = id;
-  }
-
-  close() {
-    return Promise.resolve();
-  }
-
-  createChannel(options) {
-    return Promise.resolve({kind: 'channel', id: this.id, options});
-  }
-
-  createConfirmChannel(options) {
-    return Promise.resolve({kind: 'confirm', id: this.id, options});
-  }
-
-  updateSecret(_newSecret, _reason) {
-    return Promise.resolve();
-  }
-}
-
-class FakeCallbackModel extends EventEmitter {
-  constructor(id) {
-    super();
-    this.id = id;
-  }
-
-  close(cb) {
-    cb && cb(null);
-  }
-
-  createChannel(options, cb) {
-    if (typeof options === 'function') {
-      cb = options;
-      options = undefined;
-    }
-    cb && cb(null, {kind: 'channel', id: this.id, options});
-  }
-
-  createConfirmChannel(options, cb) {
-    if (typeof options === 'function') {
-      cb = options;
-      options = undefined;
-    }
-    cb && cb(null, {kind: 'confirm', id: this.id, options});
-  }
-
-  updateSecret(_newSecret, _reason, cb) {
-    cb && cb(null);
-  }
-}
-
-describe('recovery', () => {
-  it('promise recovery reconnects after close', async () => {
-    const models = [];
-    let opened = 0;
-
-    function openModel() {
-      const model = new FakePromiseModel(++opened);
-      models.push(model);
-      return Promise.resolve(model);
-    }
-
-    const client = await recovery.connectWithRecoveryPromise(openModel, {
-      initialDelay: 1,
-      maxDelay: 1,
-      jitter: 0,
-      maxRetries: 3,
-    });
-
-    assert.equal(1, opened);
-
-    await new Promise((resolve) => {
-      client.once('connect', () => {
-        assert.equal(2, opened);
-        resolve();
-      });
-
-      models[0].emit('close', new Error('socket closed'));
-    });
-
-    await client.close();
-  });
-
-  it('promise recovery runs setup on every connect', async () => {
-    const models = [];
-    let setupCalls = 0;
-    let opened = 0;
-
-    function openModel() {
-      const model = new FakePromiseModel(++opened);
-      models.push(model);
-      return Promise.resolve(model);
-    }
-
-    const client = await recovery.connectWithRecoveryPromise(openModel, {
-      initialDelay: 1,
-      maxDelay: 1,
-      jitter: 0,
-      maxRetries: 3,
-      setup() {
-        setupCalls++;
-      },
-    });
-
-    assert.equal(1, setupCalls);
-
-    await new Promise((resolve) => {
-      client.once('connect', () => {
-        assert.equal(2, setupCalls);
-        resolve();
-      });
-
-      models[0].emit('close', new Error('socket closed'));
-    });
-
-    await client.close();
-  });
-
-  it('callback recovery reconnects and creates channels after reconnect', (done) => {
-    const models = [];
-    let opened = 0;
-
-    function openModel() {
-      const model = new FakeCallbackModel(++opened);
-      models.push(model);
-      return Promise.resolve(model);
-    }
-
-    const client = recovery.connectWithRecoveryCallback(
-      openModel,
-      {
-        initialDelay: 1,
-        maxDelay: 1,
-        jitter: 0,
-        maxRetries: 3,
-      },
-      (err, c) => {
-        if (err) return done(err);
-
-        c.createChannel((createErr, ch) => {
-          if (createErr) return done(createErr);
-          assert.equal(1, ch.id);
-
-          c.once('connect', () => {
-            c.createChannel((reconnectErr, reconnectedChannel) => {
-              if (reconnectErr) return done(reconnectErr);
-              assert.equal(2, reconnectedChannel.id);
-              c.close(done);
-            });
-          });
-
-          models[0].emit('close', new Error('socket closed'));
-        });
-      },
-    );
-
-    assert(client);
-  });
-
-  it('handler-error from underlying model is forwarded to recovery wrapper', async () => {
-    const models = [];
-    let opened = 0;
-
-    function openModel() {
-      const model = new FakePromiseModel(++opened);
-      models.push(model);
-      return Promise.resolve(model);
-    }
-
-    const client = await recovery.connectWithRecoveryPromise(openModel, {
-      initialDelay: 1,
-      maxDelay: 1,
-      jitter: 0,
-    });
-
-    const expectedErr = new Error('user close handler explodes');
-
-    await new Promise((resolve) => {
-      client.on('handler-error', (err, event) => {
-        assert.strictEqual(err, expectedErr);
-        assert.strictEqual(event, 'close');
-        resolve();
-      });
-
-      // Simulate a handler throwing in a 'close' listener on the underlying model
-      models[0].emit('handler-error', expectedErr, 'close');
-    });
-
-    await client.close();
-  });
-
-  it('promise recovery fails after max retries', async () => {
-    let attempts = 0;
-
-    function openModel() {
-      attempts++;
-      return Promise.reject(new Error('connect failed'));
-    }
-
-    let failed = false;
-    try {
-      await recovery.connectWithRecoveryPromise(openModel, {
-        initialDelay: 1,
-        maxDelay: 1,
-        jitter: 0,
-        maxRetries: 1,
-      });
-    } catch (err) {
-      failed = true;
-      assert.equal('connect failed', err.message);
-    }
-
-    assert(failed);
-    assert.equal(2, attempts);
-  });
-
-  describe('waitForConnect: false', () => {
-    function watchUnhandledRejections(t) {
-      const rejections = [];
-      const onRejection = (err) => rejections.push(err);
-      process.on('unhandledRejection', onRejection);
-      t.after(() => process.removeListener('unhandledRejection', onRejection));
-      return rejections;
-    }
-
-    it('promise connect resolves before the first connection and later emits connect', async () => {
-      let opened = 0;
-
-      function openModel() {
-        return Promise.resolve(new FakePromiseModel(++opened));
-      }
-
-      const client = await recovery.connectWithRecoveryPromise(openModel, {waitForConnect: false});
-
-      assert.equal(0, opened);
-
-      const model = await new Promise((resolve) => client.once('connect', resolve));
-      assert.equal(1, model.id);
-      assert.equal(1, opened);
-
-      await client.close();
-    });
-
-    it('listeners attached after connect observe a failed first attempt', async () => {
-      let attempts = 0;
-
-      function openModel() {
-        attempts++;
-        return attempts === 1 ? Promise.reject(new Error('broker unavailable')) : Promise.resolve(new FakePromiseModel(attempts));
-      }
-
-      const client = await recovery.connectWithRecoveryPromise(openModel, {
-        initialDelay: 1,
-        maxDelay: 1,
-        jitter: 0,
-        waitForConnect: false,
-      });
-
-      const failures = [];
-      const scheduled = [];
-      client.on('connect-failed', (err) => failures.push(err));
-      client.on('reconnect-scheduled', (info) => scheduled.push(info));
-
-      await client.waitForConnect();
-
-      assert.equal(1, failures.length);
-      assert.equal('broker unavailable', failures[0].message);
-      assert.equal(1, scheduled.length);
-      assert.equal(1, scheduled[0].attempt);
-      assert.strictEqual(failures[0], scheduled[0].error);
-      assert.equal(2, attempts);
-
-      await client.close();
-    });
-
-    it('waitForConnect resolves with the recovering model once connected', async () => {
-      function openModel() {
-        return Promise.resolve(new FakePromiseModel(1));
-      }
-
-      const client = await recovery.connectWithRecoveryPromise(openModel, {waitForConnect: false});
-      const connected = await client.waitForConnect();
-
-      assert.strictEqual(client, connected);
-      const ch = await client.createChannel();
-      assert.equal(1, ch.id);
-
-      await client.close();
-    });
-
-    it('close before the first connection cancels it without an unhandled rejection', async (t) => {
-      const rejections = watchUnhandledRejections(t);
-      let setupCalls = 0;
-      let closeCalls = 0;
-      let releaseOpen;
-
-      function openModel() {
-        return new Promise((resolve) => {
-          const model = new FakePromiseModel(1);
-          model.close = () => {
-            closeCalls++;
-            return Promise.resolve();
-          };
-          releaseOpen = () => resolve(model);
-        });
-      }
-
-      const client = await recovery.connectWithRecoveryPromise(openModel, {
-        waitForConnect: false,
-        setup() {
-          setupCalls++;
-        },
-      });
-
-      let connected = false;
-      client.on('connect', () => {
-        connected = true;
-      });
-
-      const pendingChannel = client.createChannel();
-      await new Promise((resolve) => setImmediate(resolve));
-      assert(releaseOpen, 'open should be in flight');
-
-      await client.close();
-
-      await assert.rejects(pendingChannel, {message: 'Connection closed'});
-      await assert.rejects(client.waitForConnect(), {message: 'Connection closed'});
-
-      releaseOpen();
-      await new Promise((resolve) => setImmediate(resolve));
-
-      assert.equal(0, setupCalls);
-      assert.equal(1, closeCalls);
-      assert.equal(false, connected);
-      assert.deepEqual([], rejections);
-    });
-
-    it('exhausting retries emits reconnect-failed without an unhandled rejection', async (t) => {
-      const rejections = watchUnhandledRejections(t);
-      let attempts = 0;
-
-      function openModel() {
-        attempts++;
-        return Promise.reject(new Error('connect failed'));
-      }
-
-      const client = await recovery.connectWithRecoveryPromise(openModel, {
-        initialDelay: 1,
-        maxDelay: 1,
-        jitter: 0,
-        maxRetries: 1,
-        waitForConnect: false,
-      });
-
-      const err = await new Promise((resolve) => client.once('reconnect-failed', resolve));
-      assert.equal('connect failed', err.message);
-      assert.equal(2, attempts);
-
-      await assert.rejects(client.waitForConnect(), {message: 'connect failed'});
-      await new Promise((resolve) => setImmediate(resolve));
-      assert.deepEqual([], rejections);
-
-      await client.close();
-    });
-
-    it('callback connect invokes the callback before the first connection', (_t, done) => {
-      let opened = 0;
-
-      function openModel() {
-        return Promise.resolve(new FakeCallbackModel(++opened));
-      }
-
-      const failures = [];
-      const client = recovery.connectWithRecoveryCallback(openModel, {waitForConnect: false}, (err, c) => {
-        if (err) return done(err);
-        assert.strictEqual(client, c);
-        assert.equal(0, opened);
-
-        c.on('connect-failed', (failure) => failures.push(failure));
-        c.waitForConnect((waitErr, connected) => {
-          if (waitErr) return done(waitErr);
-          assert.strictEqual(client, connected);
-          assert.equal(1, opened);
-          assert.deepEqual([], failures);
-          c.close(done);
-        });
-      });
-
-      assert(client);
-    });
-  });
-});