amqplib 0.5.1 → 0.5.5

package/test/channel_api.js

@@ -7,6 +7,7 @@ var succeed = util.succeed, fail = util.fail;
 var schedule = util.schedule;
 var randomString = util.randomString;
 var Promise = require('bluebird');
+var Buffer = require('safe-buffer').Buffer;
 
 var URL = process.env.URL || 'amqp://localhost';
 
@@ -23,7 +24,7 @@ function expectFail(promise) {
 
 // I'll rely on operations being rejected, rather than the channel
 // close error, to detect failure.
-function ignore() {}
+function ignore () {}
 function ignoreErrors(c) {
   c.on('error', ignore); return c;
 }
@@ -112,7 +113,7 @@ chtest("fail on reasserting exchange with different type",
 chtest("channel break on publishing to non-exchange", function(ch) {
   return new Promise(function(resolve) {
     ch.on('error', resolve);
-    ch.publish(randomString(), '', new Buffer('foobar'));
+    ch.publish(randomString(), '', Buffer.from('foobar'));
   });
 });
 
@@ -179,7 +180,7 @@ chtest("send to queue and get from queue", function(ch) {
   var msg = randomString();
   return Promise.join(ch.assertQueue(q, QUEUE_OPTS), ch.purgeQueue(q))
     .then(function() {
-      ch.sendToQueue(q, new Buffer(msg));
+      ch.sendToQueue(q, Buffer.from(msg));
       return waitForMessages(q);
     })
     .then(function() {
@@ -193,7 +194,7 @@ chtest("send to queue and get from queue", function(ch) {
 
 chtest("send (and get) zero content to queue", function(ch) {
   var q = 'test.send-to-q';
-  var msg = new Buffer(0);
+  var msg = Buffer.alloc(0);
   return Promise.join(
     ch.assertQueue(q, QUEUE_OPTS),
     ch.purgeQueue(q))
@@ -224,7 +225,7 @@ chtest("route message", function(ch) {
     ch.purgeQueue(q),
     ch.bindQueue(q, ex, '', {}))
     .then(function() {
-      ch.publish(ex, '', new Buffer(msg));
+      ch.publish(ex, '', Buffer.from(msg));
       return waitForMessages(q);})
     .then(function() {
       return ch.get(q, {noAck: true});})
@@ -239,7 +240,7 @@ chtest("purge queue", function(ch) {
   var q = 'test.purge-queue';
   return ch.assertQueue(q, {durable: false})
     .then(function() {
-      ch.sendToQueue(q, new Buffer('foobar'));
+      ch.sendToQueue(q, Buffer.from('foobar'));
       return waitForMessages(q);})
     .then(function() {
       ch.purgeQueue(q);
@@ -262,7 +263,7 @@ chtest("unbind queue", function(ch) {
     ch.purgeQueue(q),
     ch.bindQueue(q, ex, '', {}))
     .then(function() {
-      ch.publish(ex, '', new Buffer('foobar'));
+      ch.publish(ex, '', Buffer.from('foobar'));
       return waitForMessages(q);})
     .then(function() { // message got through!
       return ch.get(q, {noAck:true})
@@ -271,9 +272,9 @@ chtest("unbind queue", function(ch) {
       return ch.unbindQueue(q, ex, '', {});})
     .then(function() {
       // via the no-longer-existing binding
-      ch.publish(ex, '', new Buffer(viabinding));
+      ch.publish(ex, '', Buffer.from(viabinding));
       // direct to the queue
-      ch.sendToQueue(q, new Buffer(direct));
+      ch.sendToQueue(q, Buffer.from(direct));
       return waitForMessages(q);})
     .then(function() {return ch.get(q)})
     .then(function(m) {
@@ -305,7 +306,7 @@ chtest("consume via exchange-exchange binding", function(ch) {
         }
         ch.consume(q, delivery, {noAck: true})
           .then(function() {
-            ch.publish(ex1, rk, new Buffer(msg));
+            ch.publish(ex1, rk, Buffer.from(msg));
           });
       });
     });
@@ -327,7 +328,7 @@ chtest("unbind exchange", function(ch) {
     ch.bindExchange(dest, source, '', {}),
     ch.bindQueue(q, dest, '', {}))
     .then(function() {
-      ch.publish(source, '', new Buffer('foobar'));
+      ch.publish(source, '', Buffer.from('foobar'));
       return waitForMessages(q);})
     .then(function() { // message got through!
       return ch.get(q, {noAck:true})
@@ -336,9 +337,9 @@ chtest("unbind exchange", function(ch) {
       return ch.unbindExchange(dest, source, '', {});})
     .then(function() {
       // via the no-longer-existing binding
-      ch.publish(source, '', new Buffer(viabinding));
+      ch.publish(source, '', Buffer.from(viabinding));
       // direct to the queue
-      ch.sendToQueue(q, new Buffer(direct));
+      ch.sendToQueue(q, Buffer.from(direct));
       return waitForMessages(q);})
     .then(function() {return ch.get(q)})
     .then(function(m) {
@@ -360,7 +361,7 @@ chtest("cancel consumer", function(ch) {
     ch.consume(q, resolve, {noAck:true})
       .then(function(ok) {
         ctag = ok.consumerTag;
-        ch.sendToQueue(q, new Buffer('foo'));
+        ch.sendToQueue(q, Buffer.from('foo'));
       }));
   });
 
@@ -368,7 +369,7 @@ chtest("cancel consumer", function(ch) {
   return recv1.then(function() {
     var recv2 = Promise.join(
       ch.cancel(ctag).then(function() {
-        return ch.sendToQueue(q, new Buffer('bar'));
+        return ch.sendToQueue(q, Buffer.from('bar'));
       }),
       // but check a message did arrive in the queue
       waitForMessages(q))
@@ -412,8 +413,8 @@ chtest("ack", function(ch) {
     ch.assertQueue(q, QUEUE_OPTS),
     ch.purgeQueue(q))
     .then(function() {
-      ch.sendToQueue(q, new Buffer(msg1));
-      ch.sendToQueue(q, new Buffer(msg2));
+      ch.sendToQueue(q, Buffer.from(msg1));
+      ch.sendToQueue(q, Buffer.from(msg2));
       return waitForMessages(q, 2);
     })
     .then(function() {
@@ -441,7 +442,7 @@ chtest("nack", function(ch) {
   return Promise.join(
     ch.assertQueue(q, QUEUE_OPTS), ch.purgeQueue(q))
     .then(function() {
-      ch.sendToQueue(q, new Buffer(msg1));
+      ch.sendToQueue(q, Buffer.from(msg1));
       return waitForMessages(q);})
     .then(function() {
       return ch.get(q, {noAck: false})})
@@ -466,7 +467,7 @@ chtest("reject", function(ch) {
   return Promise.join(
     ch.assertQueue(q, QUEUE_OPTS), ch.purgeQueue(q))
     .then(function() {
-      ch.sendToQueue(q, new Buffer(msg1));
+      ch.sendToQueue(q, Buffer.from(msg1));
       return waitForMessages(q);})
     .then(function() {
       return ch.get(q, {noAck: false})})
@@ -488,8 +489,8 @@ chtest("prefetch", function(ch) {
     ch.assertQueue(q, QUEUE_OPTS), ch.purgeQueue(q),
     ch.prefetch(1))
     .then(function() {
-      ch.sendToQueue(q, new Buffer('foobar'));
-      ch.sendToQueue(q, new Buffer('foobar'));
+      ch.sendToQueue(q, Buffer.from('foobar'));
+      ch.sendToQueue(q, Buffer.from('foobar'));
       return waitForMessages(q, 2);
     })
     .then(function() {
@@ -526,7 +527,7 @@ confirmtest('message is confirmed', function(ch) {
   return Promise.join(
     ch.assertQueue(q, QUEUE_OPTS), ch.purgeQueue(q))
     .then(function() {
-      return ch.sendToQueue(q, new Buffer('bleep'));
+      return ch.sendToQueue(q, Buffer.from('bleep'));
     });
 });
 
@@ -550,7 +551,7 @@ confirmtest('multiple confirms', function(ch) {
 
         function sendAndPushPromise() {
           var conf = Promise.fromCallback(function(cb) {
-            return ch.sendToQueue(q, new Buffer('bleep'), {}, cb);
+            return ch.sendToQueue(q, Buffer.from('bleep'), {}, cb);
           });
           cs.push(conf);
         }
@@ -575,9 +576,22 @@ confirmtest('multiple confirms', function(ch) {
 
 confirmtest('wait for confirms', function(ch) {
   for (var i=0; i < 1000; i++) {
-    ch.publish('', '', new Buffer('foobar'), {});
+    ch.publish('', '', Buffer.from('foobar'), {});
   }
   return ch.waitForConfirms();
 })
 
+confirmtest('works when channel is closed', function(ch) {
+  for (var i=0; i < 1000; i++) {
+    ch.publish('', '', Buffer.from('foobar'), {});
+  }
+  return ch.close().then(function () {
+    return ch.waitForConfirms()
+  }).then(function () {
+    assert.strictEqual(true, false, 'Wait should have failed.')
+  }, function (e) {
+    assert.strictEqual(e.message, 'channel closed')
+  });
+});
+
 });

package/test/codec.js

@@ -4,7 +4,7 @@ var codec = require('../lib/codec');
 var defs = require('../lib/defs');
 var assert = require('assert');
 var ints = require('buffer-more-ints');
-
+var Buffer = require('safe-buffer').Buffer
 var C = require('claire');
 var forAll = C.forAll;
 
@@ -31,12 +31,12 @@ var testCases = [
     ['float value', {double: 0.5}, [6,100,111,117,98,108,101,100,63,224,0,0,0,0,0,0]],
     ['negative float value', {double: -0.5}, [6,100,111,117,98,108,101,100,191,224,0,0,0,0,0,0]],
     // %% test some boundaries of precision?
-    
+
     // string
     ['string', {string: "boop"}, [6,115,116,114,105,110,103,83,0,0,0,4,98,111,111,112]],
 
     // buffer -> byte array
-    ['byte array from buffer', {bytes: new Buffer([1,2,3,4])},
+    ['byte array from buffer', {bytes: Buffer.from([1,2,3,4])},
      [5,98,121,116,101,115,120,0,0,0,4,1,2,3,4]],
 
     // boolean, void
@@ -64,12 +64,12 @@ function bufferToArray(b) {
     return Array.prototype.slice.call(b);
 }
 
-suite("Explicit encodings", function() {
+suite("Implicit encodings", function() {
 
   testCases.forEach(function(tc) {
     var name = tc[0], val = tc[1], expect = tc[2];
     test(name, function() {
-      var buffer = new Buffer(1000);
+      var buffer = Buffer.alloc(1000);
       var size = codec.encodeTable(buffer, val, 0);
       var result = buffer.slice(4, size);
       assert.deepEqual(expect, bufferToArray(result));
@@ -82,11 +82,11 @@ suite("Explicit encodings", function() {
 var amqp = require('./data');
 
 function roundtrip_table(t) {
-  var buf = new Buffer(4096);
+  var buf = Buffer.alloc(4096);
   var size = codec.encodeTable(buf, t, 0);
   var decoded = codec.decodeFields(buf.slice(4, size)); // ignore the length-prefix
   try {
-    assert.deepEqual(t, decoded);
+    assert.deepEqual(removeExplicitTypes(t), decoded);
   }
   catch (e) { return false; }
   return true;
@@ -119,6 +119,45 @@ suite("Roundtrip values", function() {
   });
 });
 
+// When encoding, you can supply explicitly-typed fields like `{'!':
+// int32, 50}`. Most of these do not appear in the decoded values, so
+// to compare like-to-like we have to remove them from the input.
+function removeExplicitTypes(input) {
+    switch (typeof input) {
+    case 'object':
+        if (input == null) {
+            return null;
+        }
+        if (Array.isArray(input)) {
+            var newArr = [];
+            for (var i = 0; i < input.length; i++) {
+                newArr[i] = removeExplicitTypes(input[i]);
+            }
+            return newArr;
+        }
+        if (Buffer.isBuffer(input)) {
+            return input;
+        }
+        switch (input['!']) {
+        case 'timestamp':
+        case 'decimal':
+        case 'float':
+            return input;
+        case undefined:
+            var newObj = {}
+            for (var k in input) {
+                newObj[k] = removeExplicitTypes(input[k]);
+            }
+            return newObj;
+        default:
+            return input.value;
+        }
+
+    default:
+        return input;
+    }
+}
+
 // Asserts that the decoded fields are equal to the original fields,
 // or equal to a default where absent in the original. The defaults
 // depend on the type of method or properties.
@@ -141,11 +180,11 @@ function assertEqualModuloDefaults(original, decodedFields) {
         // given as strings rather than buffers, but the decoded values
         // will be buffers.
         assert.deepEqual((arg.type === 'longstr') ?
-                         new Buffer(arg.default) : arg.default,
+                         Buffer.from(arg.default) : arg.default,
                          decodedValue);
       }
       else {
-        assert.deepEqual(originalValue, decodedValue);
+        assert.deepEqual(removeExplicitTypes(originalValue), decodedValue);
       }
     }
     catch (assertionErr) {

package/test/connect.js

@@ -1,21 +1,67 @@
 'use strict';
 
 var connect = require('../lib/connect').connect;
+var Buffer = require('safe-buffer').Buffer
+var credentialsFromUrl = require('../lib/connect').credentialsFromUrl;
 var assert = require('assert');
 var util = require('./util');
 var net = require('net');
 var fail = util.fail, succeed = util.succeed,
-    kCallback = util.kCallback;
+    kCallback = util.kCallback,
+    succeedIfAttributeEquals = util.succeedIfAttributeEquals;
+var format = require('util').format;
 
 var URL = process.env.URL || 'amqp://localhost';
 
+var urlparse = require('url-parse');
+
+suite("Credentials", function() {
+
+  function checkCreds(creds, user, pass, done) {
+    if (creds.mechanism != 'PLAIN') {
+      return done('expected mechanism PLAIN');
+    }
+    if (creds.username != user || creds.password != pass) {
+      return done(format("expected '%s', '%s'; got '%s', '%s'",
+                         user, pass, creds.username, creds.password));
+    }
+    done();
+  }
+
+  test("no creds", function(done) {
+    var parts = urlparse('amqp://localhost');
+    var creds = credentialsFromUrl(parts);
+    checkCreds(creds, 'guest', 'guest', done);
+  });
+  test("usual user:pass", function(done) {
+    var parts = urlparse('amqp://user:pass@localhost')
+    var creds = credentialsFromUrl(parts);
+    checkCreds(creds, 'user', 'pass', done);
+  });
+  test("missing user", function(done) {
+    var parts = urlparse('amqps://:password@localhost');
+    var creds = credentialsFromUrl(parts);
+    checkCreds(creds, '', 'password', done);
+  });
+  test("missing password", function(done) {
+    var parts = urlparse('amqps://username:@localhost');
+    var creds = credentialsFromUrl(parts);
+    checkCreds(creds, 'username', '', done);
+  });
+  test("escaped colons", function(done) {
+    var parts = urlparse('amqp://user%3Aname:pass%3Aword@localhost')
+    var creds = credentialsFromUrl(parts);
+    checkCreds(creds, 'user:name', 'pass:word', done);
+  });
+});
+
 suite("Connect API", function() {
 
   test("Connection refused", function(done) {
     connect('amqp://localhost:23450', {},
             kCallback(fail(done), succeed(done)));
   });
-  
+
   // %% this ought to fail the promise, rather than throwing an error
   test("bad URL", function() {
     assert.throws(function() {
@@ -33,6 +79,33 @@ suite("Connect API", function() {
     connect(u, {}, kCallback(fail(done), succeed(done)));
   });
 
+  test("serverProperties", function(done) {
+    var url = require('url');
+    var parts = url.parse(URL, true);
+    var config = parts.query || {};
+    connect(config, {}, function(err, connection) {
+      if (err) { return done(err); }
+      assert.equal(connection.serverProperties.product, 'RabbitMQ');
+      done();
+    });
+  });
+
+  test("using custom heartbeat option", function(done) {
+    var url = require('url');
+    var parts = url.parse(URL, true);
+    var config = parts.query || {};
+    config.heartbeat = 20;
+    connect(config, {}, kCallback(succeedIfAttributeEquals('heartbeat', 20, done), fail(done)));
+  });
+
+  test("wrongly typed heartbeat option", function(done) {
+    var url = require('url');
+    var parts = url.parse(URL, true);
+    var config = parts.query || {};
+    config.heartbeat = 'NOT A NUMBER';
+    connect(config, {}, kCallback(fail(done), succeed(done)));
+  });
+
   test("using plain credentials", function(done) {
     var url = require('url');
     var parts = url.parse(URL, true);
@@ -45,10 +118,22 @@ suite("Connect API", function() {
             kCallback(succeed(done), fail(done)));
   });
 
+  test("using amqplain credentials", function(done) {
+    var url = require('url');
+    var parts = url.parse(URL, true);
+    var u = 'guest', p = 'guest';
+    if (parts.auth) {
+      var auth = parts.auth.split(":");
+      u = auth[0], p = auth[1];
+    }
+    connect(URL, {credentials: require('../lib/credentials').amqplain(u, p)},
+            kCallback(succeed(done), fail(done)));
+  });
+
   test("using unsupported mechanism", function(done) {
     var creds = {
       mechanism: 'UNSUPPORTED',
-      response: function() { return new Buffer(''); }
+      response: function() { return Buffer.from(''); }
     };
     connect(URL, {credentials: creds},
             kCallback(fail(done), succeed(done)));