amqplib 1.0.6 → 1.1.0

package/test/channel.test.js

@@ -1,4 +1,4 @@
-const { describe, it } = require('node:test');
+const { describe, it, beforeEach, afterEach } = require('node:test');
 const assert = require('node:assert');
 const promisify = require('node:util').promisify;
 const Channel = require('../lib/channel').Channel;
@@ -609,4 +609,310 @@ describe('Channel', () => {
       cb();
     }));
   });
+
+  describe('Event handler errors - without handler-error listener', () => {
+    let prevUncaughtExceptionListeners;
+
+    beforeEach(() => {
+      prevUncaughtExceptionListeners = process.rawListeners('uncaughtException').slice();
+      process.removeAllListeners('uncaughtException');
+    });
+
+    afterEach(() => {
+      prevUncaughtExceptionListeners.forEach((h) => process.on('uncaughtException', h));
+    });
+
+    it('throw in close handler kills the connection without handler-error listener', channelTest((ch, cb, conn) => {
+      const expectedErr = new Error('user close handler explodes');
+      let connErrorSeen = false;
+      // The throw propagates to acceptLoop → frameError → onSocketError → connection.emit('error')
+      conn.on('error', (err) => {
+        assert.strictEqual(err, expectedErr);
+        connErrorSeen = true;
+      });
+      // The ChannelCloseOk buffered before the kill is flushed by the mux after the
+      // stream is ended, producing ERR_STREAM_PUSH_AFTER_EOF. Absorb it and use it
+      // as the signal to end the test, since it fires after the conn error.
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err.code, 'ERR_STREAM_PUSH_AFTER_EOF');
+        assert.ok(connErrorSeen);
+        cb();
+      });
+      ch.once('error', (err) => { assert.match(err.message, /Channel closed by server/); });
+      ch.on('close', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.ChannelClose, {
+          replyText: 'Forced close',
+          replyCode: defs.constants.CHANNEL_ERROR,
+          classId: 0,
+          methodId: 0,
+        }, ch);
+      }, cb);
+    }));
+
+    it('throw in error handler becomes uncaught exception', channelTest((ch, cb) => {
+      const expectedErr = new Error('user error handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      ch.on('error', () => { throw expectedErr; });
+      open(ch);
+    }, (send, wait, cb, ch) => {
+      send(defs.ChannelClose, {
+        replyText: 'Forced close',
+        replyCode: defs.constants.CHANNEL_ERROR,
+        classId: 0,
+        methodId: 0,
+      }, ch);
+      wait(defs.ChannelCloseOk)().then(cb, cb);
+    }));
+
+    it('throw in drain handler becomes uncaught exception', channelTest((ch, cb) => {
+      const expectedErr = new Error('user drain handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      ch.on('drain', () => { throw expectedErr; });
+      // Call outside a Promise chain so the throw becomes an uncaughtException
+      open(ch).then(() => setImmediate(() => ch.onBufferDrain()));
+    }, (_send, _wait, cb) => { cb(); }));
+
+    it('throw in ack handler becomes uncaught exception', channelTest((ch, cb) => {
+      const expectedErr = new Error('user ack handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      ch.on('ack', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicAck, { deliveryTag: 1, multiple: false }, ch);
+      }, cb);
+    }));
+
+    it('throw in nack handler becomes uncaught exception', channelTest((ch, cb) => {
+      const expectedErr = new Error('user nack handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      ch.on('nack', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicNack, { deliveryTag: 1, multiple: false, requeue: false }, ch);
+      }, cb);
+    }));
+
+    it('throw in cancel handler becomes uncaught exception', channelTest((ch, cb) => {
+      const expectedErr = new Error('user cancel handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      ch.on('cancel', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicCancel, { consumerTag: 'tag', nowait: false }, ch);
+      }, cb);
+    }));
+
+    it('throw in delivery handler closes channel with error', channelTest((ch, cb) => {
+      // acceptMessageFrame catches the throw and routes it to closeWithError,
+      // which fires channel 'error' then 'close' — it does NOT become an uncaughtException.
+      const expectedErr = new Error('user delivery handler explodes');
+      const decrementLatch = latch(2, cb);
+      ch.on('error', (err) => {
+        assert.strictEqual(err, expectedErr);
+        decrementLatch();
+      });
+      ch.on('close', decrementLatch);
+      ch.on('delivery', () => { throw expectedErr; });
+      open(ch);
+    }, (send, wait, cb, ch) => {
+      send(defs.BasicDeliver, DELIVER_FIELDS, ch, Buffer.from('hello'));
+      wait(defs.ChannelClose)()
+        .then(() => send(defs.ChannelCloseOk, {}, ch))
+        .then(cb, cb);
+    }));
+
+    it('throw in return handler closes channel with error', channelTest((ch, cb) => {
+      // acceptMessageFrame catches the throw and routes it to closeWithError.
+      const expectedErr = new Error('user return handler explodes');
+      const decrementLatch = latch(2, cb);
+      ch.on('error', (err) => {
+        assert.strictEqual(err, expectedErr);
+        decrementLatch();
+      });
+      ch.on('close', decrementLatch);
+      ch.on('return', () => { throw expectedErr; });
+      open(ch);
+    }, (send, wait, cb, ch) => {
+      send(defs.BasicReturn, DELIVER_FIELDS, ch, Buffer.from('hello'));
+      wait(defs.ChannelClose)()
+        .then(() => send(defs.ChannelCloseOk, {}, ch))
+        .then(cb, cb);
+    }));
+  });
+
+  describe('Event handler errors - with handler-error listener', () => {
+    let prevUncaughtExceptionListeners;
+
+    beforeEach(() => {
+      prevUncaughtExceptionListeners = process.rawListeners('uncaughtException').slice();
+      process.removeAllListeners('uncaughtException');
+    });
+
+    afterEach(() => {
+      prevUncaughtExceptionListeners.forEach((h) => process.on('uncaughtException', h));
+    });
+
+    it('throw in close handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user close handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'close');
+        cb();
+      });
+      // A server-initiated ChannelClose always fires 'error' before 'close' (line 291 in channel.js).
+      // Handle it so only the throw from the close handler reaches handler-error.
+      ch.once('error', (err) => { assert.match(err.message, /Channel closed by server/); });
+      ch.on('close', () => { throw expectedErr; });
+      open(ch);
+    }, (send, wait, cb, ch) => {
+      send(defs.ChannelClose, {
+        replyText: 'Forced close',
+        replyCode: defs.constants.CHANNEL_ERROR,
+        classId: 0,
+        methodId: 0,
+      }, ch);
+      wait(defs.ChannelCloseOk)().then(cb, cb);
+    }));
+
+    it('throw in error handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user error handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'error');
+        cb();
+      });
+      ch.on('error', () => { throw expectedErr; });
+      open(ch);
+    }, (send, wait, cb, ch) => {
+      send(defs.ChannelClose, {
+        replyText: 'Forced close',
+        replyCode: defs.constants.CHANNEL_ERROR,
+        classId: 0,
+        methodId: 0,
+      }, ch);
+      wait(defs.ChannelCloseOk)().then(cb, cb);
+    }));
+
+    it('throw in drain handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user drain handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'drain');
+        cb();
+      });
+      ch.on('drain', () => { throw expectedErr; });
+      open(ch).then(() => setImmediate(() => ch.onBufferDrain()));
+    }, (_send, _wait, cb) => { cb(); }));
+
+    it('throw in ack handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user ack handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'ack');
+        cb();
+      });
+      ch.on('ack', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicAck, { deliveryTag: 1, multiple: false }, ch);
+      }, cb);
+    }));
+
+    it('throw in nack handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user nack handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'nack');
+        cb();
+      });
+      ch.on('nack', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicNack, { deliveryTag: 1, multiple: false, requeue: false }, ch);
+      }, cb);
+    }));
+
+    it('throw in cancel handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user cancel handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'cancel');
+        cb();
+      });
+      ch.on('cancel', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicCancel, { consumerTag: 'tag', nowait: false }, ch);
+      }, cb);
+    }));
+
+    it('throw in delivery handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user delivery handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'delivery');
+        cb();
+      });
+      ch.on('delivery', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicDeliver, DELIVER_FIELDS, ch, Buffer.from('hello'));
+      }, cb);
+    }));
+
+    it('throw in return handler is delivered via handler-error event', channelTest((ch, cb) => {
+      const expectedErr = new Error('user return handler explodes');
+      ch.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'return');
+        cb();
+      });
+      ch.on('return', () => { throw expectedErr; });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicReturn, DELIVER_FIELDS, ch, Buffer.from('hello'));
+      }, cb);
+    }));
+
+    it('throw in handler-error handler becomes uncaught exception', channelTest((ch, cb) => {
+      const expectedErr = new Error('handler-error handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      ch.on('handler-error', () => { throw expectedErr; });
+      ch.on('ack', () => { throw new Error('user ack handler explodes'); });
+      open(ch);
+    }, (send, _wait, cb, ch) => {
+      completes(() => {
+        send(defs.BasicAck, { deliveryTag: 1, multiple: false }, ch);
+      }, cb);
+    }));
+  });
 });

package/test/channel_api.test.js

@@ -25,6 +25,15 @@ describe('updateSecret', () => {
         .finally(() => c.close())
     );
   });
+
+  it('emits update-secret-ok event', () => {
+    return connect().then((c) =>
+      new Promise((resolve, reject) => {
+        c.on('update-secret-ok', resolve);
+        c.updateSecret(Buffer.from('new secret'), 'no reason').catch(reject);
+      }).finally(() => c.close())
+    );
+  });
 });
 
 describe('assert, check, delete', () => {

package/test/connection.test.js

@@ -300,6 +300,357 @@ describe('Connection', () => {
     }));
   });
 
+  describe('Event handler errors - without handler-event listener', () => {
+    let prevUncaughtExceptionListeners;
+
+    beforeEach(() => {
+      prevUncaughtExceptionListeners = process.rawListeners('uncaughtException').slice();
+      process.removeAllListeners('uncaughtException');
+    });
+
+    afterEach(() => {
+      prevUncaughtExceptionListeners.forEach((h) => process.on('uncaughtException', h));
+      heartbeat.UNITS_TO_MS = 1000;
+    });
+
+    it('throw in close handler from server-initiated close is swallowed without handler-error listener', connectionTest((c, cb) => {
+      c.on('close', () => { throw new Error('user handler explodes'); });
+      c.open(OPEN_OPTS);
+      cb();
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionClose, {
+          replyText: 'Begone',
+          replyCode: defs.constants.CONNECTION_FORCED,
+          methodId: 0,
+          classId: 0,
+        }))
+        .then(wait(defs.ConnectionCloseOk))
+        .then(cb, cb);
+    }));
+
+    it('throw in close handler from client-initiated close is swallowed without handler-error listener', connectionTest((c, cb) => {
+      c.open(OPEN_OPTS, (err) => {
+        assert.ifError(err);
+        c.on('close', () => { throw new Error('user handler explodes on client close'); });
+        c.close();
+        cb();
+      });
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(wait(defs.ConnectionClose))
+        .then(() => send(defs.ConnectionCloseOk, {}))
+        .then(cb, cb);
+    }));
+
+    it('throw in error handler becomes uncaught exception', connectionTest((c, cb) => {
+      const expectedErr = new Error('user error handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      c.on('error', () => { throw expectedErr; });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionClose, {
+          replyText: 'Begone',
+          replyCode: defs.constants.INTERNAL_ERROR,
+          methodId: 0,
+          classId: 0,
+        }))
+        .then(wait(defs.ConnectionCloseOk))
+        .then(cb, cb);
+    }));
+
+    it('throw in blocked handler becomes uncaught exception', connectionTest((c, cb) => {
+      const expectedErr = new Error('user blocked handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      c.on('blocked', () => { throw expectedErr; });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionBlocked, { reason: 'memory' }, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in unblocked handler becomes uncaught exception', connectionTest((c, cb) => {
+      const expectedErr = new Error('user unblocked handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      c.on('unblocked', () => { throw expectedErr; });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionUnblocked, {}, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in update-secret-ok handler becomes uncaught exception', connectionTest((c, cb) => {
+      const expectedErr = new Error('user update-secret-ok handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      c.open(OPEN_OPTS, (err) => {
+        assert.ifError(err);
+        c.on('update-secret-ok', () => { throw expectedErr; });
+        c._updateSecret(Buffer.from('new secret'), 'reason', () => {});
+      });
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(wait(defs.ConnectionUpdateSecret))
+        .then(() => send(defs.ConnectionUpdateSecretOk, {}, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in error handler from closeWithError becomes uncaught exception', connectionTest((c, cb) => {
+      const expectedErr = new Error('user error handler explodes on closeWithError');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      c.once('error', (err) => {
+        assert.match(err.message, /Unexpected frame on channel 0/);
+        throw expectedErr;
+      });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ChannelOpenOk, { channelId: Buffer.from('') }, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in error handler from onSocketError', connectionTest((c, cb) => {
+      const expectedErr = new Error('user error handler explodes on socket error');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      c.once('error', (err) => {
+        assert.match(err.message, /Unexpected close/);
+        throw expectedErr;
+      });
+      c.open(OPEN_OPTS, (err) => {
+        assert.ifError(err);
+        c.sendHeartbeat();
+      });
+    }, (send, wait, cb, socket) => {
+      handshake(send, wait)
+        .then(wait())
+        .then(() => socket.end())
+        .then(cb, cb);
+    }));
+
+    it('throw in error handler from heartbeat timeout', connectionTest((c, cb) => {
+      heartbeat.UNITS_TO_MS = 20;
+      const expectedErr = new Error('user error handler explodes on heartbeat timeout');
+      const opts = Object.create(OPEN_OPTS);
+      opts.heartbeat = 1;
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        c.heartbeater.clear();
+        cb();
+      });
+      c.on('error', (err) => {
+        assert.match(err.message, /Heartbeat timeout/);
+        throw expectedErr;
+      });
+      c.open(opts);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(cb, cb);
+      // conspicuously not sending anything ...
+    }));
+  });
+
+  describe('Event handler errors - with handler-error listener', () => {
+    let prevUncaughtExceptionListeners;
+
+    beforeEach(() => {
+      prevUncaughtExceptionListeners = process.rawListeners('uncaughtException').slice();
+      process.removeAllListeners('uncaughtException');
+    });
+
+    afterEach(() => {
+      prevUncaughtExceptionListeners.forEach((h) => process.on('uncaughtException', h));
+      heartbeat.UNITS_TO_MS = 1000;
+    });
+
+    it('throw in close handler is delivered via handler-error event', connectionTest((c, cb) => {
+      const expectedErr = new Error('user close handler explodes');
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'close');
+        cb();
+      });
+      c.on('close', () => { throw expectedErr; });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionClose, {
+          replyText: 'Begone',
+          replyCode: defs.constants.CONNECTION_FORCED,
+          methodId: 0,
+          classId: 0,
+        }))
+        .then(wait(defs.ConnectionCloseOk))
+        .then(cb, cb);
+    }));
+
+    it('throw in error handler is delivered via handler-error event', connectionTest((c, cb) => {
+      const expectedErr = new Error('user error handler explodes');
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'error');
+        cb();
+      });
+      c.on('error', () => { throw expectedErr; });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionClose, {
+          replyText: 'Begone',
+          replyCode: defs.constants.INTERNAL_ERROR,
+          methodId: 0,
+          classId: 0,
+        }))
+        .then(wait(defs.ConnectionCloseOk))
+        .then(cb, cb);
+    }));
+
+    it('throw in blocked handler is delivered via handler-error event', connectionTest((c, cb) => {
+      const expectedErr = new Error('user blocked handler explodes');
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'blocked');
+        cb();
+      });
+      c.on('blocked', () => { throw expectedErr; });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionBlocked, { reason: 'memory' }, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in unblocked handler is delivered via handler-error event', connectionTest((c, cb) => {
+      const expectedErr = new Error('user unblocked handler explodes');
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'unblocked');
+        cb();
+      });
+      c.on('unblocked', () => { throw expectedErr; });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionUnblocked, {}, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in update-secret-ok handler is delivered via handler-error event', connectionTest((c, cb) => {
+      const expectedErr = new Error('user update-secret-ok handler explodes');
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'update-secret-ok');
+        cb();
+      });
+      c.open(OPEN_OPTS, (err) => {
+        assert.ifError(err);
+        c.on('update-secret-ok', () => { throw expectedErr; });
+        c._updateSecret(Buffer.from('new secret'), 'reason', () => {});
+      });
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(wait(defs.ConnectionUpdateSecret))
+        .then(() => send(defs.ConnectionUpdateSecretOk, {}, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in error handler from heartbeat timeout is delivered via handler-error event', connectionTest((c, cb) => {
+      heartbeat.UNITS_TO_MS = 20;
+      const expectedErr = new Error('user error handler explodes on heartbeat timeout');
+      const opts = Object.create(OPEN_OPTS);
+      opts.heartbeat = 1;
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'error');
+        c.heartbeater.clear();
+        cb();
+      });
+      c.on('error', (err) => {
+        assert.match(err.message, /Heartbeat timeout/);
+        throw expectedErr;
+      });
+      c.open(opts);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(cb, cb);
+      // conspicuously not sending anything ...
+    }));
+
+    it('throw in error handler from closeWithError is delivered via handler-error event', connectionTest((c, cb) => {
+      const expectedErr = new Error('user error handler explodes on closeWithError');
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'error');
+        cb();
+      });
+      c.once('error', (err) => {
+        assert.match(err.message, /Unexpected frame on channel 0/);
+        throw expectedErr;
+      });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ChannelOpenOk, { channelId: Buffer.from('') }, 0))
+        .then(cb, cb);
+    }));
+
+    it('throw in error handler from onSocketError is delivered via handler-error event', connectionTest((c, cb) => {
+      const expectedErr = new Error('user error handler explodes on socket error');
+      c.on('handler-error', (err, event) => {
+        assert.strictEqual(err, expectedErr);
+        assert.strictEqual(event, 'error');
+        cb();
+      });
+      c.once('error', (err) => {
+        assert.match(err.message, /Unexpected close/);
+        throw expectedErr;
+      });
+      c.open(OPEN_OPTS, (err) => {
+        assert.ifError(err);
+        c.sendHeartbeat();
+      });
+    }, (send, wait, cb, socket) => {
+      handshake(send, wait)
+        .then(wait())
+        .then(() => socket.end())
+        .then(cb, cb);
+    }));
+
+    it('throw in handler-error handler becomes uncaught exception', connectionTest((c, cb) => {
+      const expectedErr = new Error('handler-error handler explodes');
+      process.once('uncaughtException', (err) => {
+        assert.strictEqual(err, expectedErr);
+        cb();
+      });
+      c.on('handler-error', () => { throw expectedErr; });
+      c.on('blocked', () => { throw new Error('user blocked handler explodes'); });
+      c.open(OPEN_OPTS);
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionBlocked, { reason: 'memory' }, 0))
+        .then(cb, cb);
+    }));
+  });
+
   describe('heartbeats', () => {
 
     beforeEach(() => {