typespeed 2.0.13 → 2.0.16

package/test/node_modules/amqplib/test/frame.js

@@ -0,0 +1,198 @@
+'use strict';
+
+var assert = require('assert');
+var succeed = require('./util').succeed;
+var fail = require('./util').fail;
+var connection = require('../lib/connection');
+var Frames = connection.Connection;
+var HEARTBEAT = require('../lib/frame').HEARTBEAT;
+var Stream = require('stream');
+var PassThrough = Stream.PassThrough ||
+    require('readable-stream/passthrough');
+
+var defs = require('../lib/defs');
+
+// We'll need to supply a stream which we manipulate ourselves
+
+function inputs() {
+  // don't coalesce buffers, since that could mess up properties
+  // (e.g., encoded frame size)
+  return new PassThrough({objectMode: true});
+}
+
+var HB = Buffer.from([defs.constants.FRAME_HEARTBEAT,
+                     0, 0, // channel 0
+                     0, 0, 0, 0, // zero size
+                     defs.constants.FRAME_END]);
+
+suite("Explicit parsing", function() {
+
+  test('Parse heartbeat', function() {
+    var input = inputs();
+    var frames = new Frames(input);
+    input.write(HB);
+    assert(frames.recvFrame() === HEARTBEAT);
+    assert(!frames.recvFrame());
+  });
+
+  test('Parse partitioned', function() {
+    var input = inputs();
+    var frames = new Frames(input);
+    input.write(HB.slice(0, 3));
+    assert(!frames.recvFrame());
+    input.write(HB.slice(3));
+    assert(frames.recvFrame() === HEARTBEAT);
+    assert(!frames.recvFrame());
+  });
+
+  function testBogusFrame(name, bytes) {
+    test(name, function(done) {
+      var input = inputs();
+      var frames = new Frames(input);
+      frames.frameMax = 5; //for the max frame test
+      input.write(Buffer.from(bytes));
+      frames.step(function(err, frame) {
+        if (err != null) done();
+        else done(new Error('Was a bogus frame!'));
+      });
+    });
+  }
+
+  testBogusFrame('Wrong sized frame',
+                 [defs.constants.FRAME_BODY,
+                  0,0, 0,0,0,0, // zero length
+                  65, // but a byte!
+                  defs.constants.FRAME_END]);
+
+  testBogusFrame('Unknown method frame',
+                 [defs.constants.FRAME_METHOD,
+                  0,0, 0,0,0,4,
+                  0,0,0,0, // garbage ID
+                  defs.constants.FRAME_END]);
+
+  testBogusFrame('> max frame',
+                 [defs.constants.FRAME_BODY,
+                  0,0, 0,0,0,6, // too big!
+                  65,66,67,68,69,70,
+                  defs.constants.FRAME_END]);
+
+});
+
+// Now for a bit more fun.
+
+var amqp = require('./data');
+var claire = require('claire');
+var choice = claire.choice;
+var forAll = claire.forAll;
+var repeat = claire.repeat;
+var label = claire.label;
+var sequence = claire.sequence;
+var transform = claire.transform;
+var sized = claire.sized;
+
+var assertEqualModuloDefaults =
+  require('./codec').assertEqualModuloDefaults;
+
+var Trace = label('frame trace',
+                  repeat(choice.apply(choice, amqp.methods)));
+
+suite("Parsing", function() {
+
+  function testPartitioning(partition) {
+    return forAll(Trace).satisfy(function(t) {
+      var bufs = [];
+      var input = inputs();
+      var frames = new Frames(input);
+      var i = 0, ex;
+      frames.accept = function(f) {
+        // A minor hack to make sure we get the assertion exception;
+        // otherwise, it's just a test that we reached the line
+        // incrementing `i` for each frame.
+        try {
+          assertEqualModuloDefaults(t[i], f.fields);
+        }
+        catch (e) {
+          ex = e;
+        }
+        i++;
+      };
+
+      t.forEach(function(f) {
+        f.channel = 0;
+        bufs.push(defs.encodeMethod(f.id, 0, f.fields));
+      });
+
+      partition(bufs).forEach(function (chunk) { input.write(chunk); });
+      frames.acceptLoop();
+      if (ex) throw ex;
+      return i === t.length;
+    }).asTest({times: 20})
+  };
+
+  test("Parse trace of methods",
+       testPartitioning(function(bufs) { return bufs; }));
+
+  test("Parse concat'd methods",
+       testPartitioning(function(bufs) {
+         return [Buffer.concat(bufs)];
+       }));
+
+  test("Parse partitioned methods",
+       testPartitioning(function(bufs) {
+         var full = Buffer.concat(bufs);
+         var onethird = Math.floor(full.length / 3);
+         var twothirds = 2 * onethird;
+         return [
+           full.slice(0, onethird),
+           full.slice(onethird, twothirds),
+           full.slice(twothirds)
+         ];
+       }));
+});
+
+var FRAME_MAX_MAX = 4096 * 4;
+var FRAME_MAX_MIN = 4096;
+
+var FrameMax = amqp.rangeInt('frame max',
+                             FRAME_MAX_MIN,
+                             FRAME_MAX_MAX);
+
+var Body = sized(function(_n) {
+  return Math.floor(Math.random() * FRAME_MAX_MAX);
+}, repeat(amqp.Octet));
+
+var Content = transform(function(args) {
+  return {
+    method: args[0].fields,
+    header: args[1].fields,
+    body: Buffer.from(args[2])
+  }
+}, sequence(amqp.methods['BasicDeliver'],
+            amqp.properties['BasicProperties'], Body));
+
+suite("Content framing", function() {
+  test("Adhere to frame max",
+       forAll(Content, FrameMax).satisfy(function(content, max) {
+         var input = inputs();
+         var frames = new Frames(input);
+         frames.frameMax = max;
+         frames.sendMessage(
+           0,
+           defs.BasicDeliver, content.method,
+           defs.BasicProperties, content.header,
+           content.body);
+         var f, i = 0, largest = 0;
+         while (f = input.read()) {
+           i++;
+           if (f.length > largest) largest = f.length;
+           if (f.length > max) {
+             return false;
+           }
+         }
+         // The ratio of frames to 'contents' should always be >= 2
+         // (one properties frame and at least one content frame); > 2
+         // indicates fragmentation. The largest is always, of course <= frame max
+         //console.log('Frames: %d; frames per message: %d; largest frame %d', i, i / t.length, largest);
+         return true;
+       }).asTest());
+});

package/test/node_modules/amqplib/test/mux.js

@@ -0,0 +1,204 @@
+'use strict';
+
+var assert = require('assert');
+var Mux = require('../lib/mux').Mux;
+var PassThrough = require('stream').PassThrough ||
+  require('readable-stream/passthrough');
+
+var latch = require('./util').latch;
+var schedule = require('./util').schedule;
+
+function stream() {
+  return new PassThrough({objectMode: true});
+}
+
+function readAllObjects(s, cb) {
+  var objs = [];
+
+  function read() {
+    var v = s.read();
+    while (v !== null) {
+      objs.push(v);
+      v = s.read();
+    }
+  }
+
+  s.on('end', function() { cb(objs); });
+  s.on('readable', read);
+
+  read();
+}
+
+test("single input", function(done) {
+  var input = stream();
+  var output = stream();
+  input.on('end', function() { output.end() });
+
+  var mux = new Mux(output);
+  mux.pipeFrom(input);
+
+  var 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(function (chunk) { input.write(chunk); });
+
+  readAllObjects(output, function(vals) {
+    assert.deepEqual(data, vals);
+    done();
+  });
+
+  input.end();
+});
+
+test("single input, resuming stream", function(done) {
+  var input = stream();
+  var output = stream();
+  input.on('end', function() { output.end() });
+
+  var 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
+  var data = [1,2,3,4,'skip',6,7,8,9];
+
+  var oldRead  = input.read;
+  input.read = function(size) {
+    var val = oldRead.call(input, size)
+
+    if (val === 'skip') {
+      input.emit('readable');
+      return null
+    }
+
+    return val;
+  }
+
+  data.forEach(function (chunk) { input.write(chunk); });
+
+  readAllObjects(output, function(vals) {
+    assert.deepEqual([1,2,3,4,6,7,8,9], vals);
+    done();
+  });
+
+  input.end();
+});
+
+test("two sequential inputs", function(done) {
+  var input1 = stream();
+  var input2 = stream();
+  var output = stream();
+  var mux = new Mux(output);
+  mux.pipeFrom(input1);
+  mux.pipeFrom(input2);
+
+  var data = [1,2,3,4,5,6,7,8,9];
+  data.forEach(function(v) { input1.write(v); });
+
+  input1.on('end', function() {
+    data.forEach(function (v) { input2.write(v); });
+    input2.end();
+  });
+  input2.on('end', function() { output.end(); });
+
+  input1.end();
+  readAllObjects(output, function(vs) {
+    assert.equal(2 * data.length, vs.length);
+    done();
+  });
+});
+
+test("two interleaved inputs", function(done) {
+  var input1 = stream();
+  var input2 = stream();
+  var output = stream();
+  var mux = new Mux(output);
+  mux.pipeFrom(input1);
+  mux.pipeFrom(input2);
+
+  var endLatch = latch(2, function() { output.end(); });
+  input1.on('end', endLatch);
+  input2.on('end', endLatch);
+
+  var data = [1,2,3,4,5,6,7,8,9];
+  data.forEach(function(v) { input1.write(v); });
+  input1.end();
+
+  data.forEach(function(v) { input2.write(v); });
+  input2.end();
+
+  readAllObjects(output, function(vs) {
+    assert.equal(2 * data.length, vs.length);
+    done();
+  });
+});
+
+test("unpipe", function(done) {
+  var input = stream();
+  var output = stream();
+  var mux = new Mux(output);
+
+  var pipedData = [1,2,3,4,5];
+  var unpipedData = [6,7,8,9];
+
+  mux.pipeFrom(input);
+
+  schedule(function() {
+    pipedData.forEach(function (chunk) { input.write(chunk); });
+
+    schedule(function() {
+      mux.unpipeFrom(input);
+
+      schedule(function() {
+        unpipedData.forEach(function(chunk) { input.write(chunk); });
+        input.end();
+        schedule(function() {
+          // exhaust so that 'end' fires
+          var v; while (v = input.read());
+        });
+      });
+    });
+
+  });
+
+  input.on('end', function() {
+    output.end();
+  });
+
+  readAllObjects(output, function(vals) {
+    try {
+      assert.deepEqual(pipedData, vals);
+      done();
+    }
+    catch (e) { done(e); }
+  });
+});
+
+test("roundrobin", function(done) {
+  var input1 = stream();
+  var input2 = stream();
+  var output = stream();
+  var mux = new Mux(output);
+
+  mux.pipeFrom(input1);
+  mux.pipeFrom(input2);
+
+  var endLatch = latch(2, function() { output.end(); });
+  input1.on('end', endLatch);
+  input2.on('end', endLatch);
+
+  var ones = [1,1,1,1,1];
+  ones.forEach(function(v) { input1.write(v); });
+  input1.end();
+
+  var twos = [2,2,2,2,2];
+  twos.forEach(function(v) { input2.write(v); });
+  input2.end();
+
+  readAllObjects(output, function(vs) {
+    assert.deepEqual([1,2,1,2,1,2,1,2,1,2], vs);
+    done();
+  });
+
+});

package/test/node_modules/amqplib/test/util.js

@@ -0,0 +1,219 @@
+'use strict';
+
+var crypto = require('crypto');
+var Connection = require('../lib/connection').Connection;
+var PassThrough =
+  require('stream').PassThrough ||
+  require('readable-stream/passthrough');
+var defs = require('../lib/defs');
+var assert = require('assert');
+
+var schedule = (typeof setImmediate === 'function') ?
+  setImmediate : process.nextTick;
+
+function randomString() {
+  var hash = crypto.createHash('sha1');
+  hash.update(crypto.randomBytes(64));
+  return hash.digest('base64');
+}
+
+
+// Set up a socket pair {client, server}, such that writes to the
+// client are readable from the server, and writes to the server are
+// readable at the client.
+//
+//          +---+      +---+
+//          | C |      | S |
+// --write->| l |----->| e |--read-->
+//          | i |      | r |
+// <--read--| e |<-----| v |<-write--
+//          | n |      | e |
+//          | t |      | r |
+//          +---+      +---+
+//
+// I also need to make sure that end called on either socket affects
+// the other.
+
+function socketPair() {
+  var server = new PassThrough();
+  var client = new PassThrough();
+  server.write = client.push.bind(client);
+  client.write = server.push.bind(server);
+  function end(chunk, encoding) {
+    if (chunk) this.push(chunk, encoding);
+    this.push(null);
+  }
+  server.end = end.bind(client);
+  client.end = end.bind(server);
+
+  return {client: client, server: server};
+}
+
+function runServer(socket, run) {
+  var frames = new Connection(socket);
+  // We will be closing the socket without doing a closing handshake,
+  // so cheat
+  frames.expectSocketClose = true;
+  // We also need to create some channel buffers, again a cheat
+  frames.freshChannel(null);
+  frames.freshChannel(null);
+  frames.freshChannel(null);
+
+  function send(id, fields, channel, content) {
+    channel = channel || 0;
+    if (content) {
+      schedule(function() {
+        frames.sendMessage(channel, id, fields,
+                           defs.BasicProperties, fields,
+                           content);
+      });
+    }
+    else {
+      schedule(function() {
+        frames.sendMethod(channel, id, fields);
+      });
+    }
+  }
+
+  function wait(method) {
+    return function() {
+      return new Promise(function(resolve, reject) {
+        if (method) {
+          frames.step(function(e, f) {
+            if (e !== null) return reject(e);
+            if (f.id === method)
+              resolve(f);
+            else
+              reject(new Error("Expected method: " + method +
+                                 ", got " + f.id));
+          });
+        }
+        else {
+          frames.step(function(e, f) {
+            if (e !== null) return reject(e);
+            else resolve(f);
+          });
+        }
+      });
+    };
+  }
+  run(send, wait);
+  return frames;
+}
+
+// Produce a callback that will complete the test successfully
+function succeed(done) {
+  return function() { done(); }
+}
+
+// Produce a callback that will complete the test successfully
+// only if the value is an object, it has the specified
+// attribute, and its value is equals to the expected value
+function succeedIfAttributeEquals(attribute, value, done) {
+  return function(object) {
+    if (object && !(object instanceof Error) && value === object[attribute]) {
+      return done();
+    }
+
+    done(new Error(attribute + " is not equal to " + value));
+  };
+}
+
+// Produce a callback that will fail the test, given either an error
+// (to be used as a failure continuation) or any other value (to be
+// used as a success continuation when failure is expected)
+function fail(done) {
+  return function(err) {
+    if (err instanceof Error) done(err);
+    else done(new Error("Expected to fail, instead got " + err.toString()));
+  }
+}
+
+// Create a function that will call done once it's been called itself
+// `count` times. If it's called with an error value, it will
+// immediately call done with that error value.
+function latch(count, done) {
+  var awaiting = count;
+  var alive = true;
+  return function(err) {
+    if (err instanceof Error && alive) {
+      alive = false;
+      done(err);
+    }
+    else {
+      awaiting--;
+      if (awaiting === 0 && alive) {
+        alive = false;
+        done();
+      }
+    }
+  };
+}
+
+// Call a thunk with a continuation that will be called with an error
+// if the thunk throws one, or nothing if it runs to completion.
+function completes(thunk, done) {
+  try {
+    thunk();
+    done();
+  }
+  catch (e) { done(e); }
+}
+
+// Construct a Node.JS-style callback from a success continuation and
+// an error continuation
+function kCallback(k, ek) {
+  return function(err, val) {
+    if (err === null) k && k(val);
+    else ek && ek(err);
+  };
+}
+
+// A noddy way to make tests depend on the node version.
+function versionGreaterThan(actual, spec) {
+
+  function int(e) { return parseInt(e); }
+
+  var version = actual.split('.').map(int);
+  var desired = spec.split('.').map(int);
+  for (var i=0; i < desired.length; i++) {
+    var a = version[i], b = desired[i];
+    if (a != b) return a > b;
+  }
+  return false;
+}
+
+suite('versionGreaterThan', function() {
+
+test('full spec', function() {
+  assert(versionGreaterThan('0.8.26', '0.6.12'));
+  assert(versionGreaterThan('0.8.26', '0.8.21'));
+});
+
+test('partial spec', function() {
+  assert(versionGreaterThan('0.9.12', '0.8'));
+});
+
+test('not greater', function() {
+  assert(!versionGreaterThan('0.8.12', '0.8.26'));
+  assert(!versionGreaterThan('0.6.2', '0.6.12'));
+  assert(!versionGreaterThan('0.8.29', '0.8'));
+});
+
+test
+
+});
+
+module.exports = {
+  socketPair: socketPair,
+  runServer: runServer,
+  succeed: succeed,
+  succeedIfAttributeEquals: succeedIfAttributeEquals,
+  fail: fail,
+  latch: latch,
+  completes: completes,
+  kCallback: kCallback,
+  schedule: schedule,
+  randomString: randomString,
+  versionGreaterThan: versionGreaterThan
+};

package/test/node_modules/buffer-more-ints/.travis.yml

@@ -0,0 +1,6 @@
+language: node_js
+node_js:
+  - "0.11"
+  - "0.10"
+  - "0.8"
+  - "0.6"

package/test/node_modules/buffer-more-ints/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2012 David Wragg. All rights reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+IN THE SOFTWARE.