amqplib 0.4.2 → 0.5.3

package/lib/frame.js

@@ -7,6 +7,7 @@
 var defs = require('./defs');
 var constants = defs.constants;
 var decode = defs.decode;
+var Buffer = require('safe-buffer').Buffer
 
 var Bits = require('bitsyntax');
 
@@ -105,7 +106,7 @@ module.exports.decodeFrame = function(frame) {
 }
 
 // encoded heartbeat
-module.exports.HEARTBEAT_BUF = new Buffer([constants.FRAME_HEARTBEAT,
+module.exports.HEARTBEAT_BUF = Buffer.from([constants.FRAME_HEARTBEAT,
                                            0, 0, 0, 0, // size = 0
                                            0, 0, // channel = 0
                                            constants.FRAME_END]);

package/lib/heartbeat.js

@@ -40,7 +40,7 @@
 //    at least twice before sending another)
 //
 // This design is based largely on RabbitMQ's heartbeating:
-// https://github.com/rabbitmq/rabbitmq-server/blob/master/src/rabbit_heartbeat.erl
+// https://github.com/rabbitmq/rabbitmq-common/blob/master/src/rabbit_heartbeat.erl
 
 // %% Yes, I could apply the same 'actually passage of time' thing to
 // %% send as well as to recv.

package/package.json

@@ -2,26 +2,28 @@
   "name": "amqplib",
   "homepage": "http://squaremo.github.io/amqp.node/",
   "main": "./channel_api.js",
-  "version": "0.4.2",
+  "version": "0.5.3",
   "description": "An AMQP 0-9-1 (e.g., RabbitMQ) library and client.",
   "repository": {
     "type": "git",
     "url": "https://github.com/squaremo/amqp.node.git"
   },
   "engines": {
-    "node": ">=0.8 <6 || ^6"
+    "node": ">=0.8 <=9"
   },
   "dependencies": {
-    "bitsyntax": "~0.0.4",
-    "buffer-more-ints": "0.0.2",
+    "bitsyntax": "~0.1.0",
+    "bluebird": "^3.5.2",
+    "buffer-more-ints": "~1.0.0",
     "readable-stream": "1.x >=1.1.9",
-    "when": "~3.6.2"
+    "safe-buffer": "~5.1.2",
+    "url-parse": "~1.4.3"
   },
   "devDependencies": {
-    "mocha": "~1",
     "claire": "0.4.1",
-    "uglify-js": "2.4.x",
-    "istanbul": "0.1.x"
+    "istanbul": "0.1.x",
+    "mocha": "^3.5.3",
+    "uglify-js": "2.6.x"
   },
   "scripts": {
     "test": "make test",

package/test/callback_api.js

@@ -8,6 +8,7 @@ var schedule = util.schedule;
 var randomString = util.randomString;
 var kCallback = util.kCallback;
 var domain = require('domain');
+var Buffer = require('safe-buffer').Buffer;
 
 var URL = process.env.URL || 'amqp://localhost';
 
@@ -159,7 +160,7 @@ channel_test('send to queue and consume noAck', function(ch, done) {
       else done(new Error("message content doesn't match:" +
                           msg + " =/= " + m.content.toString()));
     }, {noAck: true, exclusive: true});
-    ch.sendToQueue(q.queue, new Buffer(msg));
+    ch.sendToQueue(q.queue, Buffer.from(msg));
   });
 });
 
@@ -175,7 +176,7 @@ channel_test('send to queue and consume ack', function(ch, done) {
       else done(new Error("message content doesn't match:" +
                           msg + " =/= " + m.content.toString()));
     }, {noAck: false, exclusive: true});
-    ch.sendToQueue(q.queue, new Buffer(msg));
+    ch.sendToQueue(q.queue, Buffer.from(msg));
   });
 });
 
@@ -183,7 +184,7 @@ channel_test('send to and get from queue', function(ch, done) {
   ch.assertQueue('', {exclusive: true}, function(e, q) {
     if (e != null) return done(e);
     var msg = randomString();
-    ch.sendToQueue(q.queue, new Buffer(msg));
+    ch.sendToQueue(q.queue, Buffer.from(msg));
     waitForMessages(ch, q.queue, function(e, _) {
       if (e != null) return done(e);
       ch.get(q.queue, {noAck: true}, function(e, m) {
@@ -210,12 +211,12 @@ confirm_channel_test('Receive confirmation', function(ch, done) {
   // An unroutable message, on the basis that you're not allowed a
   // queue with an empty name, and you can't make bindings to the
   // default exchange. Tricky eh?
-  ch.publish('', '', new Buffer('foo'), {}, done);
+  ch.publish('', '', Buffer.from('foo'), {}, done);
 });
 
 confirm_channel_test('Wait for confirms', function(ch, done) {
   for (var i=0; i < 1000; i++) {
-    ch.publish('', '', new Buffer('foo'), {});
+    ch.publish('', '', Buffer.from('foo'), {});
   }
   ch.waitForConfirms(done);
 });

package/test/channel.js

@@ -3,7 +3,7 @@
 'use strict';
 
 var assert = require('assert');
-var defer = require('when').defer;
+var Promise = require('bluebird');
 var Channel = require('../lib/channel').Channel;
 var Connection = require('../lib/connection').Connection;
 var util = require('./util');
@@ -12,6 +12,7 @@ var completes = util.completes;
 var defs = require('../lib/defs');
 var conn_handshake = require('./connection').connection_handshake;
 var OPEN_OPTS = require('./connection').OPEN_OPTS;
+var Buffer = require('safe-buffer').Buffer;
 
 var LOG_ERRORS = process.env.LOG_ERRORS;
 
@@ -29,10 +30,10 @@ function baseChannelTest(client, server) {
     });
 
     pair.server.read(8); // discard the protocol header
-    var s = util.runServer(pair.server, function(send, await) {
-      conn_handshake(send, await)
+    var s = util.runServer(pair.server, function(send, wait) {
+      conn_handshake(send, wait)
         .then(function() {
-          server(send, await, bothDone);
+          server(send, wait, bothDone);
         }, fail(bothDone));
     });
   };
@@ -45,21 +46,21 @@ function channelTest(client, server) {
       if (LOG_ERRORS) ch.on('error', console.warn);
       client(ch, done, conn);
     },
-    function(send, await, done) {
-      channel_handshake(send, await)
+    function(send, wait, done) {
+      channel_handshake(send, wait)
       .then(function(ch) {
-        return server(send, await, done, ch);
+        return server(send, wait, done, ch);
       }).then(null, fail(done)); // so you can return a promise to let
                                  // errors bubble out
     }
   );
 };
 
-function channel_handshake(send, await) {
-  return await(defs.ChannelOpen)()
+function channel_handshake(send, wait) {
+  return wait(defs.ChannelOpen)()
     .then(function(open) {
       assert.notEqual(0, open.channel);
-      send(defs.ChannelOpenOk, {channelId: new Buffer('')}, open.channel);
+      send(defs.ChannelOpenOk, {channelId: Buffer.from('')}, open.channel);
       return open.channel;
     });
 }
@@ -76,14 +77,12 @@ var DELIVER_FIELDS = {
 };
 
 function open(ch) {
-  var opened = defer();
-  ch.allocate();
-  ch._rpc(defs.ChannelOpen, {outOfBand: ''}, defs.ChannelOpenOk,
-          function(err, _) {
-            if (err === null) opened.resolve();
-            else opened.reject(err);
-          });
-  return opened.promise;
+  return Promise.try(function() {
+    ch.allocate();
+    return Promise.fromCallback(function(cb) {
+      ch._rpc(defs.ChannelOpen, {outOfBand: ''}, defs.ChannelOpenOk, cb);
+    });
+  });
 }
 
 suite("channel open and close", function() {
@@ -92,7 +91,7 @@ test("open", channelTest(
   function(ch, done) {
     open(ch).then(succeed(done), fail(done));
   },
-  function(send, await, done) {
+  function(send, wait, done) {
     done();
   }));
 
@@ -101,8 +100,8 @@ test("bad server", baseChannelTest(
     var ch = new Channel(c);
     open(ch).then(fail(done), succeed(done));
   },
-  function(send, await, done) {
-    return await(defs.ChannelOpen)()
+  function(send, wait, done) {
+    return wait(defs.ChannelOpen)()
       .then(function(open) {
         send(defs.ChannelCloseOk, {}, open.channel);
       }).then(succeed(done), fail(done));
@@ -112,15 +111,14 @@ test("open, close", channelTest(
   function(ch, done) {
     open(ch)
       .then(function() {
-        var closed = defer();
-        ch.closeBecause("Bye", defs.constants.REPLY_SUCCESS,
-                        closed.resolve);
-        return closed.promise;
+        return new Promise(function(resolve) {
+          ch.closeBecause("Bye", defs.constants.REPLY_SUCCESS, resolve);
+        });
       })
       .then(succeed(done), fail(done));
   },
-  function(send, await, done, ch) {
-    return await(defs.ChannelClose)()
+  function(send, wait, done, ch) {
+    return wait(defs.ChannelClose)()
       .then(function(close) {
         send(defs.ChannelCloseOk, {}, ch);
       }).then(succeed(done), fail(done));
@@ -130,17 +128,19 @@ test("server close", channelTest(
   function(ch, done) {
     ch.on('error', function(error) {
       assert.strictEqual(504, error.code);
+      assert.strictEqual(0, error.classId);
+      assert.strictEqual(0, error.methodId);
       succeed(done)();
     });
     open(ch);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     send(defs.ChannelClose, {
       replyText: 'Forced close',
       replyCode: defs.constants.CHANNEL_ERROR,
       classId: 0, methodId: 0
     }, ch);
-    await(defs.ChannelCloseOk)()
+    wait(defs.ChannelCloseOk)()
       .then(succeed(done), fail(done));
   }));
 
@@ -153,8 +153,8 @@ test("overlapping channel/server close", channelTest(
       ch.closeBecause("Bye", defs.constants.REPLY_SUCCESS);
     }, fail(both));
   },
-  function(send, await, done, ch) {
-    await(defs.ChannelClose)()
+  function(send, wait, done, ch) {
+    wait(defs.ChannelClose)()
       .then(function() {
         send(defs.ConnectionClose, {
           replyText: 'Got there first',
@@ -162,7 +162,7 @@ test("overlapping channel/server close", channelTest(
           classId: 0, methodId: 0
         }, 0);
       })
-      .then(await(defs.ConnectionCloseOk))
+      .then(wait(defs.ConnectionCloseOk))
       .then(succeed(done), fail(done));
   }));
 
@@ -176,8 +176,8 @@ test("double close", channelTest(
       });
     }).then(succeed(done), fail(done));
   },
-  function(send, await, done, ch) {
-    await(defs.ChannelClose)()
+  function(send, wait, done, ch) {
+    wait(defs.ChannelClose)()
       .then(function() {
         send(defs.ChannelCloseOk, {
         }, ch);
@@ -204,22 +204,22 @@ test("RPC", channelTest(
         prefetchSize: 0,
         global: false
       };
-      
+
       ch._rpc(defs.BasicQos, fields, defs.BasicQosOk, wheeboom);
       ch._rpc(defs.BasicQos, fields, defs.BasicQosOk, wheeboom);
       ch._rpc(defs.BasicQos, fields, defs.BasicQosOk, wheeboom);
     }).then(null, fail(rpcLatch));
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     function sendOk(f) {
       send(defs.BasicQosOk, {}, ch);
     }
 
-    return await(defs.BasicQos)()
+    return wait(defs.BasicQos)()
       .then(sendOk)
-      .then(await(defs.BasicQos))
+      .then(wait(defs.BasicQos))
       .then(sendOk)
-      .then(await(defs.BasicQos))
+      .then(wait(defs.BasicQos))
       .then(sendOk)
       .then(succeed(done), fail(done));
   }));
@@ -231,9 +231,11 @@ test("Bad RPC", channelTest(
     var errLatch = latch(2, done);
     ch.on('error', function(error) {
       assert.strictEqual(505, error.code);
+      assert.strictEqual(60, error.classId);
+      assert.strictEqual(72, error.methodId);
       succeed(errLatch)();
     });
-    
+
     open(ch)
       .then(function() {
         ch._rpc(defs.BasicRecover, {requeue: true}, defs.BasicRecoverOk,
@@ -243,12 +245,12 @@ test("Bad RPC", channelTest(
                 });
       }, fail(errLatch));
   },
-  function(send, await, done, ch) {
-    return await()()
+  function(send, wait, done, ch) {
+    return wait()()
       .then(function() {
         send(defs.BasicGetEmpty, {clusterId: ''}, ch);
       }) // oh wait! that was wrong! expect a channel close
-      .then(await(defs.ChannelClose))
+      .then(wait(defs.ChannelClose))
       .then(function() {
         send(defs.ChannelCloseOk, {}, ch);
       }).then(succeed(done), fail(done));
@@ -257,39 +259,49 @@ test("Bad RPC", channelTest(
 test("RPC on closed channel", channelTest(
   function(ch, done) {
     open(ch);
-    var close = defer(), fail1 = defer(), fail2 = defer();
-    ch.on('error', function(error) {
-      assert.strictEqual(504, error.code);
-      close.resolve();
+
+    var close = new Promise(function(resolve) {
+        ch.on('error', function(error) {
+          assert.strictEqual(504, error.code);
+          assert.strictEqual(0, error.classId);
+          assert.strictEqual(0, error.methodId);
+          resolve();
+      });
     });
 
-    function failureCb(d) {
+    function failureCb(resolve, reject) {
       return function(err) {
-        if (err !== null) d.resolve();
-        else d.reject();
+        if (err !== null) resolve();
+        else reject();
       }
     }
 
-    ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk,
-            failureCb(fail1));
-    ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk, 
-            failureCb(fail2));
-    close.promise
-      .then(function() { return fail1.promise; })
-      .then(function() { return fail2.promise; })
-      .then(succeed(done), fail(done));
+    var fail1 = new Promise(function(resolve, reject) {
+      return ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk,
+        failureCb(resolve, reject));
+    });
+
+    var fail2 = new Promise(function(resolve, reject) {
+      return ch._rpc(defs.BasicRecover, {requeue:true}, defs.BasicRecoverOk,
+        failureCb(resolve, reject));
+    });
+
+    Promise.join(close, fail1, fail2)
+      .then(succeed(done))
+      .catch(fail(done));
   },
-  function(send, await, done, ch) {
-    await(defs.BasicRecover)()
+  function(send, wait, done, ch) {
+    wait(defs.BasicRecover)()
       .then(function() {
         send(defs.ChannelClose, {
           replyText: 'Nuh-uh!',
           replyCode: defs.constants.CHANNEL_ERROR,
           methodId: 0, classId: 0
         }, ch);
-        return await(defs.ChannelCloseOk);
+        return wait(defs.ChannelCloseOk);
       })
-      .then(succeed(done), fail(done));
+      .then(succeed(done))
+      .catch(fail(done));
   }));
 
 test("publish all < single chunk threshold", channelTest(
@@ -299,14 +311,14 @@ test("publish all < single chunk threshold", channelTest(
         ch.sendMessage({
           exchange: 'foo', routingKey: 'bar',
           mandatory: false, immediate: false, ticket: 0
-        }, {}, new Buffer('foobar'));
+        }, {}, Buffer.from('foobar'));
       })
       .then(succeed(done), fail(done));
   },
-  function(send, await, done, ch) {
-    await(defs.BasicPublish)()
-      .then(await(defs.BasicProperties))
-      .then(await(undefined)) // content frame
+  function(send, wait, done, ch) {
+    wait(defs.BasicPublish)()
+      .then(wait(defs.BasicProperties))
+      .then(wait(undefined)) // content frame
       .then(function(f) {
         assert.equal('foobar', f.content.toString());
       }).then(succeed(done), fail(done));
@@ -319,13 +331,13 @@ test("publish content > single chunk threshold", channelTest(
       ch.sendMessage({
         exchange: 'foo', routingKey: 'bar',
         mandatory: false, immediate: false, ticket: 0
-      }, {}, new Buffer(3000));
+      }, {}, Buffer.alloc(3000));
     }, done);
   },
-  function(send, await, done, ch) {
-    await(defs.BasicPublish)()
-      .then(await(defs.BasicProperties))
-      .then(await(undefined)) // content frame
+  function(send, wait, done, ch) {
+    wait(defs.BasicPublish)()
+      .then(wait(defs.BasicProperties))
+      .then(wait(undefined)) // content frame
       .then(function(f) {
         assert.equal(3000, f.content.length);
       }).then(succeed(done), fail(done));
@@ -339,14 +351,14 @@ test("publish method & headers > threshold", channelTest(
         exchange: 'foo', routingKey: 'bar',
         mandatory: false, immediate: false, ticket: 0
       }, {
-        headers: {foo: new Buffer(3000)}
-      }, new Buffer('foobar'));
+        headers: {foo: Buffer.alloc(3000)}
+      }, Buffer.from('foobar'));
     }, done);
   },
-  function(send, await, done, ch) {
-    await(defs.BasicPublish)()
-      .then(await(defs.BasicProperties))
-      .then(await(undefined)) // content frame
+  function(send, wait, done, ch) {
+    wait(defs.BasicPublish)()
+      .then(wait(defs.BasicProperties))
+      .then(wait(undefined)) // content frame
       .then(function(f) {
         assert.equal('foobar', f.content.toString());
       }).then(succeed(done), fail(done));
@@ -359,18 +371,18 @@ test("publish zero-length message", channelTest(
       ch.sendMessage({
         exchange: 'foo', routingKey: 'bar',
         mandatory: false, immediate: false, ticket: 0
-      }, {}, new Buffer(0));
+      }, {}, Buffer.alloc(0));
       ch.sendMessage({
         exchange: 'foo', routingKey: 'bar',
         mandatory: false, immediate: false, ticket: 0
-      }, {}, new Buffer(0));
+      }, {}, Buffer.alloc(0));
     }, done);
   },
-  function(send, await, done, ch) {
-    await(defs.BasicPublish)()
-      .then(await(defs.BasicProperties))
+  function(send, wait, done, ch) {
+    wait(defs.BasicPublish)()
+      .then(wait(defs.BasicProperties))
     // no content frame for a zero-length message
-      .then(await(defs.BasicPublish))
+      .then(wait(defs.BasicPublish))
       .then(succeed(done), fail(done));
   }));
 
@@ -383,9 +395,9 @@ test("delivery", channelTest(
       }, done);
     });
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     completes(function() {
-      send(defs.BasicDeliver, DELIVER_FIELDS, ch, new Buffer('barfoo'));
+      send(defs.BasicDeliver, DELIVER_FIELDS, ch, Buffer.from('barfoo'));
     }, done);
   }));
 
@@ -394,13 +406,13 @@ test("zero byte msg", channelTest(
     open(ch);
     ch.on('delivery', function(m) {
       completes(function() {
-        assert.deepEqual(new Buffer(0), m.content);
+        assert.deepEqual(Buffer.alloc(0), m.content);
       }, done);
     });
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     completes(function() {
-      send(defs.BasicDeliver, DELIVER_FIELDS, ch, new Buffer(''));
+      send(defs.BasicDeliver, DELIVER_FIELDS, ch, Buffer.from(''));
     }, done);
   }));
 
@@ -409,16 +421,18 @@ test("bad delivery", channelTest(
     var errorAndClose = latch(2, done);
     ch.on('error', function(error) {
       assert.strictEqual(505, error.code);
+      assert.strictEqual(60, error.classId);
+      assert.strictEqual(60, error.methodId);
       succeed(errorAndClose)();
     });
     ch.on('close', succeed(errorAndClose));
     open(ch);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     send(defs.BasicDeliver, DELIVER_FIELDS, ch);
     // now send another deliver without having sent the content
     send(defs.BasicDeliver, DELIVER_FIELDS, ch);
-    return await(defs.ChannelClose)()
+    return wait(defs.ChannelClose)()
       .then(function() {
         send(defs.ChannelCloseOk, {}, ch);
       }).then(succeed(done), fail(done));
@@ -435,7 +449,7 @@ test("bad content send", channelTest(
       });
     }, done);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     done();
   }));
 
@@ -447,13 +461,13 @@ test("bad properties send", channelTest(
         ch.sendMessage({routingKey: 'foo',
                         exchange: 'amq.direct'},
                        {contentEncoding: 7},
-                       new Buffer('foobar'));
+                       Buffer.from('foobar'));
       });
     }, done);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     done();
-  }));  
+  }));
 
 test("bad consumer", channelTest(
   function(ch, done) {
@@ -463,14 +477,16 @@ test("bad consumer", channelTest(
     });
     ch.on('error', function(error) {
       assert.strictEqual(541, error.code);
+      assert.strictEqual(undefined, error.classId);
+      assert.strictEqual(undefined, error.methodId);
       succeed(errorAndClose)();
     });
     ch.on('close', succeed(errorAndClose));
     open(ch);
   },
-  function(send, await, done, ch) {
-    send(defs.BasicDeliver, DELIVER_FIELDS, ch, new Buffer('barfoo'));
-    return await(defs.ChannelClose)()
+  function(send, wait, done, ch) {
+    send(defs.BasicDeliver, DELIVER_FIELDS, ch, Buffer.from('barfoo'));
+    return wait(defs.ChannelClose)()
       .then(function() {
         send(defs.ChannelCloseOk, {}, ch);
       }).then(succeed(done), fail(done));
@@ -482,6 +498,8 @@ test("bad send in consumer", channelTest(
     ch.on('close', succeed(errorAndClose));
     ch.on('error', function(error) {
       assert.strictEqual(541, error.code);
+      assert.strictEqual(undefined, error.classId);
+      assert.strictEqual(undefined, error.methodId);
       succeed(errorAndClose)();
     });
 
@@ -493,12 +511,12 @@ test("bad send in consumer", channelTest(
 
     open(ch);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     completes(function() {
       send(defs.BasicDeliver, DELIVER_FIELDS, ch,
-           new Buffer('barfoo'));
+           Buffer.from('barfoo'));
     }, done);
-    return await(defs.ChannelClose)()
+    return wait(defs.ChannelClose)()
       .then(function() {
         send(defs.ChannelCloseOk, {}, ch);
       }).then(succeed(done), fail(done));
@@ -513,9 +531,9 @@ test("return", channelTest(
     });
     open(ch);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     completes(function() {
-      send(defs.BasicReturn, DELIVER_FIELDS, ch, new Buffer('barfoo'));
+      send(defs.BasicReturn, DELIVER_FIELDS, ch, Buffer.from('barfoo'));
     }, done);
   }));
 
@@ -528,7 +546,7 @@ test("cancel", channelTest(
     });
     open(ch);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     completes(function() {
       send(defs.BasicCancel, {
         consumerTag: 'product of society',
@@ -547,7 +565,7 @@ function confirmTest(variety, Method) {
       });
       open(ch);
     },
-    function(send, await, done, ch) {
+    function(send, wait, done, ch) {
       completes(function() {
         send(Method, {
           deliveryTag: 1,
@@ -573,7 +591,7 @@ test("out-of-order acks", channelTest(
     ch.pushConfirmCallback(allConfirms);
     open(ch);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     completes(function() {
       send(defs.BasicAck, {deliveryTag: 2, multiple: false}, ch);
       send(defs.BasicAck, {deliveryTag: 3, multiple: false}, ch);
@@ -596,7 +614,7 @@ test("not all out-of-order acks", channelTest(
     });
     open(ch);
   },
-  function(send, await, done, ch) {
+  function(send, wait, done, ch) {
     completes(function() {
       send(defs.BasicAck, {deliveryTag: 2, multiple: false}, ch);
       send(defs.BasicAck, {deliveryTag: 1, multiple: false}, ch);