typespeed 2.0.13 → 2.0.16

package/test/node_modules/amqplib/test/connection.js

@@ -0,0 +1,390 @@
+'use strict';
+
+var assert = require('assert');
+var defs = require('../lib/defs');
+var Connection = require('../lib/connection').Connection;
+var HEARTBEAT = require('../lib/frame').HEARTBEAT;
+var HB_BUF = require('../lib/frame').HEARTBEAT_BUF;
+var util = require('./util');
+var succeed = util.succeed, fail = util.fail, latch = util.latch;
+var completes = util.completes;
+var kCallback = util.kCallback;
+
+var LOG_ERRORS = process.env.LOG_ERRORS;
+
+var OPEN_OPTS = {
+  // start-ok
+  'clientProperties': {},
+  'mechanism': 'PLAIN',
+  'response': Buffer.from(['', 'guest', 'guest'].join(String.fromCharCode(0))),
+  'locale': 'en_US',
+
+  // tune-ok
+  'channelMax': 0,
+  'frameMax': 0,
+  'heartbeat': 0,
+
+  // open
+  'virtualHost': '/',
+  'capabilities': '',
+  'insist': 0
+};
+module.exports.OPEN_OPTS = OPEN_OPTS;
+
+function happy_open(send, wait) {
+  // kick it off
+  send(defs.ConnectionStart,
+       {versionMajor: 0,
+        versionMinor: 9,
+        serverProperties: {},
+        mechanisms: Buffer.from('PLAIN'),
+        locales: Buffer.from('en_US')});
+  return wait(defs.ConnectionStartOk)()
+    .then(function(f) {
+      send(defs.ConnectionTune,
+           {channelMax: 0,
+            heartbeat: 0,
+            frameMax: 0});
+    })
+    .then(wait(defs.ConnectionTuneOk))
+    .then(wait(defs.ConnectionOpen))
+    .then(function(f) {
+      send(defs.ConnectionOpenOk,
+           {knownHosts: ''});
+    });
+}
+module.exports.connection_handshake = happy_open;
+
+function connectionTest(client, server) {
+  return function(done) {
+    var bothDone = latch(2, done);
+    var pair = util.socketPair();
+    var c = new Connection(pair.client);
+    if (LOG_ERRORS) c.on('error', console.warn);
+    client(c, bothDone);
+
+    // NB only not a race here because the writes are synchronous
+    var protocolHeader = pair.server.read(8);
+    assert.deepEqual(Buffer.from("AMQP" + String.fromCharCode(0,0,9,1)),
+                     protocolHeader);
+
+    var s = util.runServer(pair.server, function(send, wait) {
+      server(send, wait, bothDone, pair.server);
+    });
+  };
+}
+
+suite("Connection errors", function() {
+
+  test("socket close during open", function(done) {
+    // RabbitMQ itself will take at least 3 seconds to close the socket
+    // in the event of a handshake problem. Instead of using a live
+    // connection, I'm just going to pretend.
+    var pair = util.socketPair();
+    var conn = new Connection(pair.client);
+    pair.server.on('readable', function() {
+      pair.server.end();
+    });
+    conn.open({}, kCallback(fail(done), succeed(done)));
+  });
+
+  test("bad frame during open", function(done) {
+    var ss = util.socketPair();
+    var conn = new (require('../lib/connection').Connection)(ss.client);
+    ss.server.on('readable', function() {
+      ss.server.write(Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]));
+    });
+    conn.open({}, kCallback(fail(done), succeed(done)));
+  });
+
+});
+
+suite("Connection open", function() {
+
+test("happy", connectionTest(
+  function(c, done) {
+    c.open(OPEN_OPTS, kCallback(succeed(done), fail(done)));
+  },
+  function(send, wait, done) {
+    happy_open(send, wait).then(succeed(done), fail(done));
+  }));
+
+test("wrong first frame", connectionTest(
+  function(c, done) {
+    c.open(OPEN_OPTS, kCallback(fail(done), succeed(done)));
+  },
+  function(send, wait, done) {
+    // bad server! bad! whatever were you thinking?
+    completes(function() {
+      send(defs.ConnectionTune,
+           {channelMax: 0,
+            heartbeat: 0,
+            frameMax: 0});
+    }, done);
+  }));
+
+test("unexpected socket close", connectionTest(
+  function(c, done) {
+    c.open(OPEN_OPTS, kCallback(fail(done), succeed(done)));
+  },
+  function(send, wait, done, socket) {
+    send(defs.ConnectionStart,
+         {versionMajor: 0,
+          versionMinor: 9,
+          serverProperties: {},
+          mechanisms: Buffer.from('PLAIN'),
+          locales: Buffer.from('en_US')});
+    return wait(defs.ConnectionStartOk)()
+      .then(function() {
+        socket.end();
+      })
+      .then(succeed(done), fail(done));
+  }));
+
+});
+
+suite("Connection running", function() {
+
+test("wrong frame on channel 0", connectionTest(
+  function(c, done) {
+    c.on('error', succeed(done));
+    c.open(OPEN_OPTS);
+  },
+  function(send, wait, done) {
+    happy_open(send, wait)
+      .then(function() {
+        // there's actually nothing that would plausibly be sent to a
+        // just opened connection, so this is violating more than one
+        // rule. Nonetheless.
+        send(defs.ChannelOpenOk, {channelId: Buffer.from('')}, 0);
+      })
+      .then(wait(defs.ConnectionClose))
+      .then(function(close) {
+        send(defs.ConnectionCloseOk, {}, 0);
+      }).then(succeed(done), fail(done));
+  }));
+
+test("unopened channel",  connectionTest(
+  function(c, done) {
+    c.on('error', succeed(done));
+    c.open(OPEN_OPTS);
+  },
+  function(send, wait, done) {
+    happy_open(send, wait)
+      .then(function() {
+        // there's actually nothing that would plausibly be sent to a
+        // just opened connection, so this is violating more than one
+        // rule. Nonetheless.
+        send(defs.ChannelOpenOk, {channelId: Buffer.from('')}, 3);
+      })
+      .then(wait(defs.ConnectionClose))
+      .then(function(close) {
+        send(defs.ConnectionCloseOk, {}, 0);
+      }).then(succeed(done), fail(done));
+  }));
+
+test("unexpected socket close", connectionTest(
+  function(c, done) {
+    var errorAndClosed = latch(2, done);
+    c.on('error', succeed(errorAndClosed));
+    c.on('close', succeed(errorAndClosed));
+    c.open(OPEN_OPTS, kCallback(function() {
+      c.sendHeartbeat();
+    }, fail(errorAndClosed)));
+  },
+  function(send, wait, done, socket) {
+    happy_open(send, wait)
+      .then(wait())
+      .then(function() {
+        socket.end();
+      }).then(succeed(done));
+  }));
+
+test("connection.blocked", connectionTest(
+  function(c, done) {
+    c.on('blocked', succeed(done));
+    c.open(OPEN_OPTS);
+  },
+  function(send, wait, done, socket) {
+    happy_open(send, wait)
+      .then(function() {
+        send(defs.ConnectionBlocked, {reason: 'felt like it'}, 0);
+      })
+      .then(succeed(done));
+  }));
+
+test("connection.unblocked", connectionTest(
+  function(c, done) {
+    c.on('unblocked', succeed(done));
+    c.open(OPEN_OPTS);
+  },
+  function(send, wait, done, socket) {
+    happy_open(send, wait)
+      .then(function() {
+        send(defs.ConnectionUnblocked, {}, 0);
+      })
+      .then(succeed(done));
+  }));
+
+
+});
+
+suite("Connection close", function() {
+
+test("happy", connectionTest(
+  function(c, done0) {
+    var done = latch(2, done0);
+    c.on('close', done);
+    c.open(OPEN_OPTS, kCallback(function(_ok) {
+      c.close(kCallback(succeed(done), fail(done)));
+    }, function() {}));
+  },
+  function(send, wait, done) {
+    happy_open(send, wait)
+      .then(wait(defs.ConnectionClose))
+      .then(function(close) {
+        send(defs.ConnectionCloseOk, {});
+      })
+      .then(succeed(done), fail(done));
+  }));
+
+test("interleaved close frames", connectionTest(
+  function(c, done0) {
+    var done = latch(2, done0);
+    c.on('close', done);
+    c.open(OPEN_OPTS, kCallback(function(_ok) {
+      c.close(kCallback(succeed(done), fail(done)));
+    }, done));
+  },
+  function(send, wait, done) {
+    happy_open(send, wait)
+      .then(wait(defs.ConnectionClose))
+      .then(function(f) {
+        send(defs.ConnectionClose, {
+          replyText: "Ha!",
+          replyCode: defs.constants.REPLY_SUCCESS,
+          methodId: 0, classId: 0
+        });
+      })
+      .then(wait(defs.ConnectionCloseOk))
+      .then(function(f) {
+        send(defs.ConnectionCloseOk, {});
+      })
+      .then(succeed(done), fail(done));
+  }));
+
+test("server error close", connectionTest(
+  function(c, done0) {
+    var done = latch(2, done0);
+    c.on('close', succeed(done));
+    c.on('error', succeed(done));
+    c.open(OPEN_OPTS);
+  },
+  function(send, wait, done) {
+    happy_open(send, wait)
+      .then(function(f) {
+        send(defs.ConnectionClose, {
+          replyText: "Begone",
+          replyCode: defs.constants.INTERNAL_ERROR,
+          methodId: 0, classId: 0
+        });
+      })
+      .then(wait(defs.ConnectionCloseOk))
+      .then(succeed(done), fail(done));
+  }));
+
+test("operator-intiated close", connectionTest(
+  function(c, done) {
+    c.on('close', succeed(done));
+    c.on('error', fail(done));
+    c.open(OPEN_OPTS);
+  },
+  function(send, wait, done) {
+    happy_open(send, wait)
+      .then(function(f) {
+        send(defs.ConnectionClose, {
+          replyText: "Begone",
+          replyCode: defs.constants.CONNECTION_FORCED,
+          methodId: 0, classId: 0
+        });
+      })
+      .then(wait(defs.ConnectionCloseOk))
+      .then(succeed(done), fail(done));
+  }));
+
+
+test("double close", connectionTest(
+  function(c, done) {
+    c.open(OPEN_OPTS, kCallback(function() {
+      c.close();
+      // NB no synchronisation, we do this straight away
+      assert.throws(function() {
+        c.close();
+      });
+      done();
+    }, done));
+  },
+  function(send, wait, done) {
+    happy_open(send, wait)
+      .then(wait(defs.ConnectionClose))
+      .then(function() {
+        send(defs.ConnectionCloseOk, {});
+      })
+      .then(succeed(done), fail(done));
+  }));
+
+});
+
+suite("heartbeats", function() {
+
+var heartbeat = require('../lib/heartbeat');
+
+setup(function() {
+  heartbeat.UNITS_TO_MS = 20;
+});
+
+teardown(function() {
+  heartbeat.UNITS_TO_MS = 1000;
+});
+
+test("send heartbeat after open", connectionTest(
+  function(c, done) {
+    completes(function() {
+      var opts = Object.create(OPEN_OPTS);
+      opts.heartbeat = 1;
+      // Don't leave the error waiting to happen for the next test, this
+      // confuses mocha awfully
+      c.on('error', function() {});
+      c.open(opts);
+    }, done);
+  },
+  function(send, wait, done, socket) {
+    var timer;
+    happy_open(send, wait)
+      .then(function() {
+        timer = setInterval(function() {
+          socket.write(HB_BUF);
+        }, heartbeat.UNITS_TO_MS);
+      })
+      .then(wait())
+      .then(function(hb) {
+        if (hb === HEARTBEAT) done();
+        else done("Next frame after silence not a heartbeat");
+        clearInterval(timer);
+      });
+  }));
+
+test("detect lack of heartbeats", connectionTest(
+  function(c, done) {
+    var opts = Object.create(OPEN_OPTS);
+    opts.heartbeat = 1;
+    c.on('error', succeed(done));
+    c.open(opts);
+  },
+  function(send, wait, done, socket) {
+    happy_open(send, wait)
+      .then(succeed(done), fail(done));
+    // conspicuously not sending anything ...
+  }));
+
+});

package/test/node_modules/amqplib/test/data.js

@@ -0,0 +1,254 @@
+// Property-based testing representations of various things in AMQP
+
+'use strict';
+
+var C = require('claire');
+var forAll = C.forAll;
+var arb = C.data;
+var transform = C.transform;
+var repeat = C.repeat;
+var label = C.label;
+var sequence = C.sequence;
+var asGenerator = C.asGenerator;
+var sized = C.sized;
+var recursive = C.recursive;
+var choice = C.choice;
+var Undefined = C.Undefined;
+
+// Stub these out so we can use outside tests
+// if (!suite) var suite = function() {}
+// if (!test) var test = function() {}
+
+// These aren't exported in claire/index. so I could have to reproduce
+// them I guess.
+function choose(a, b) {
+  return Math.random() * (b - a) + a;
+}
+
+function chooseInt(a, b) {
+  return Math.floor(choose(a, b));
+}
+
+function rangeInt(name, a, b) {
+  return label(name,
+               asGenerator(function(_) { return chooseInt(a, b); }));
+}
+
+function toFloat32(i) {
+  var b = Buffer.alloc(4);
+  b.writeFloatBE(i, 0);
+  return b.readFloatBE(0);
+}
+
+function floatChooser(maxExp) {
+  return function() {
+    var n = Number.NaN;
+    while (isNaN(n)) {
+      var mantissa = Math.random() * 2 - 1;
+      var exponent = chooseInt(0, maxExp);
+      n = Math.pow(mantissa, exponent);
+  }
+    return n;
+  }
+}
+
+function explicitType(t, underlying) {
+    return label(t, transform(function(n) {
+        return {'!': t, value: n};
+    }, underlying));
+}
+
+// FIXME null, byte array, others?
+
+var Octet = rangeInt('octet', 0, 255);
+var ShortStr = label('shortstr',
+                     transform(function(s) {
+                       return s.substr(0, 255);
+                     }, arb.Str));
+
+var LongStr = label('longstr',
+                    transform(
+                      function(bytes) { return Buffer.from(bytes); },
+                      repeat(Octet)));
+
+var UShort = rangeInt('short-uint', 0, 0xffff);
+var ULong = rangeInt('long-uint', 0, 0xffffffff);
+var ULongLong = rangeInt('longlong-uint', 0, 0xffffffffffffffff);
+var Short = rangeInt('short-int', -0x8000, 0x7fff);
+var Long = rangeInt('long-int', -0x80000000, 0x7fffffff);
+var LongLong = rangeInt('longlong-int', -0x8000000000000000,
+                        0x7fffffffffffffff);
+var Bit = label('bit', arb.Bool);
+var Double = label('double', asGenerator(floatChooser(308)));
+var Float = label('float', transform(toFloat32, floatChooser(38)));
+var Timestamp = label('timestamp', transform(
+  function(n) {
+    return {'!': 'timestamp', value: n};
+  }, ULongLong));
+var Decimal = label('decimal', transform(
+  function(args) {
+    return {'!': 'decimal', value: {places: args[1], digits: args[0]}};
+  }, sequence(arb.UInt, Octet)));
+
+// Signed 8 bit int
+var Byte = rangeInt('byte', -128, 127);
+
+// Explicitly typed values
+var ExByte = explicitType('byte', Byte);
+var ExInt8 = explicitType('int8', Byte);
+var ExShort = explicitType('short', Short);
+var ExInt16 = explicitType('int16', Short);
+var ExInt = explicitType('int', Long);
+var ExInt32 = explicitType('int32', Long);
+var ExLong = explicitType('long', LongLong);
+var ExInt64 = explicitType('int64', LongLong);
+
+var FieldArray = label('field-array', recursive(function() {
+  return arb.Array(
+    arb.Null,
+    LongStr, ShortStr,
+    Octet, UShort, ULong, ULongLong,
+    Byte, Short, Long, LongLong,
+    ExByte, ExInt8, ExShort, ExInt16,
+    ExInt, ExInt32, ExLong, ExInt64,
+    Bit, Float, Double, FieldTable, FieldArray)
+}));
+
+var FieldTable = label('table', recursive(function() {
+  return sized(function() { return 5; },
+               arb.Object(
+                 arb.Null,
+                 LongStr, ShortStr, Octet,
+                 UShort, ULong, ULongLong,
+                 Byte, Short, Long, LongLong,
+                 ExByte, ExInt8, ExShort, ExInt16,
+                 ExInt, ExInt32, ExLong, ExInt64,
+                 Bit, Float, Double, FieldArray, FieldTable))
+}));
+
+// Internal tests of our properties
+var domainProps = [
+  [Octet, function(n) { return n >= 0 && n < 256; }],
+  [ShortStr, function(s) { return typeof s === 'string' && s.length < 256; }],
+  [LongStr, function(s) { return Buffer.isBuffer(s); }],
+  [UShort, function(n) { return n >= 0 && n <= 0xffff; }],
+  [ULong, function(n) { return n >= 0 && n <= 0xffffffff; }],
+  [ULongLong, function(n) {
+    return n >= 0 && n <= 0xffffffffffffffff; }],
+  [Short, function(n) { return n >= -0x8000 && n <= 0x8000; }],
+  [Long, function(n) { return n >= -0x80000000 && n < 0x80000000; }],
+  [LongLong, function(n) { return n >= -0x8000000000000000 && n < 0x8000000000000000; }],
+  [Bit, function(b) { return typeof b === 'boolean'; }],
+  [Double, function(f) { return !isNaN(f) && isFinite(f); }],
+  [Float, function(f) { return !isNaN(f) && isFinite(f) && (Math.log(Math.abs(f)) * Math.LOG10E) < 309; }],
+  [Decimal, function(d) {
+    return d['!'] === 'decimal' &&
+      d.value['places'] <= 255 &&
+      d.value['digits'] <= 0xffffffff;
+  }],
+  [Timestamp, function(t) { return t['!'] === 'timestamp'; }],
+  [FieldTable, function(t) { return typeof t === 'object'; }],
+  [FieldArray, function(a) { return Array.isArray(a); }]
+];
+
+suite("Domains", function() {
+  domainProps.forEach(function(p) {
+    test(p[0] + ' domain',
+         forAll(p[0]).satisfy(p[1]).asTest({times: 500}));
+  });
+});
+
+// For methods and properties (as opposed to field table values) it's
+// easier just to accept and produce numbers for timestamps.
+var ArgTimestamp = label('timestamp', ULongLong);
+
+// These are the domains used in method arguments
+var ARG_TYPES = {
+  'octet': Octet,
+  'shortstr': ShortStr,
+  'longstr': LongStr,
+  'short': UShort,
+  'long': ULong,
+  'longlong': ULongLong,
+  'bit': Bit,
+  'table': FieldTable,
+  'timestamp': ArgTimestamp
+};
+
+function argtype(thing) {
+  if (thing.default === undefined) {
+    return ARG_TYPES[thing.type];
+  }
+  else {
+    return choice(ARG_TYPES[thing.type], Undefined);
+  }
+}
+
+function zipObject(vals, names) {
+  var obj = {};
+  vals.forEach(function(v, i) { obj[names[i]] = v; });
+  return obj;
+}
+
+function name(arg) { return arg.name; }
+
+var defs = require('../lib/defs');
+
+function method(info) {
+  var domain = sequence.apply(null, info.args.map(argtype));
+  var names = info.args.map(name);
+  return label(info.name, transform(function(fieldVals) {
+    return {id: info.id,
+            fields: zipObject(fieldVals, names)};
+  }, domain));
+}
+
+function properties(info) {
+  var types = info.args.map(argtype);
+  types.unshift(ULongLong); // size
+  var domain = sequence.apply(null, types);
+  var names = info.args.map(name);
+  return label(info.name, transform(function(fieldVals) {
+    return {id: info.id,
+            size: fieldVals[0],
+            fields: zipObject(fieldVals.slice(1), names)};
+  }, domain));
+}
+
+var methods = [];
+var propertieses = [];
+
+for (var k in defs) {
+  if (k.substr(0, 10) === 'methodInfo') {
+    methods.push(method(defs[k]));
+    methods[defs[k].name] = method(defs[k]);
+  }
+  else if (k.substr(0, 14) === 'propertiesInfo') {
+    propertieses.push(properties(defs[k]));
+    propertieses[defs[k].name] = properties(defs[k]);
+  }
+};
+
+module.exports = {
+  Octet: Octet,
+  ShortStr: ShortStr,
+  LongStr: LongStr,
+  UShort: UShort,
+  ULong: ULong,
+  ULongLong: ULongLong,
+  Short: Short,
+  Long: Long,
+  LongLong: LongLong,
+  Bit: Bit,
+  Double: Double,
+  Float: Float,
+  Timestamp: Timestamp,
+  Decimal: Decimal,
+  FieldArray: FieldArray,
+  FieldTable: FieldTable,
+
+  methods: methods,
+  properties: propertieses
+};
+
+module.exports.rangeInt = rangeInt;