flok 0.0.12 → 0.0.14

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/test/Receiver.test.js

@@ -0,0 +1,255 @@
+var assert = require('assert')
+  , Receiver = require('../lib/Receiver');
+require('should');
+require('./hybi-common');
+
+describe('Receiver', function() {
+  it('can parse unmasked text message', function() {
+    var p = new Receiver();
+    var packet = '81 05 48 65 6c 6c 6f';
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal('Hello', data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse close message', function() {
+    var p = new Receiver();
+    var packet = '88 00';
+
+    var gotClose = false;
+    p.onclose = function(data) {
+      gotClose = true;
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotClose.should.be.ok;
+  });
+  it('can parse masked text message', function() {
+    var p = new Receiver();
+    var packet = '81 93 34 83 a8 68 01 b9 92 52 4f a1 c6 09 59 e6 8a 52 16 e6 cb 00 5b a1 d5';
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal('5:::{"name":"echo"}', data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a masked text message longer than 125 bytes', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var packet = '81 FE ' + pack(4, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a really long masked text message', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 64*1024; ++i) message += (i % 5).toString();
+    var packet = '81 FF ' + pack(16, message.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a fragmented masked text message of 300 bytes', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+    var msgpiece1 = message.substr(0, 150);
+    var msgpiece2 = message.substr(150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(packet2));
+    gotData.should.be.ok;
+  });
+  it('can parse a ping message', function() {
+    var p = new Receiver();
+    var message = 'Hello';
+    var packet = '89 ' + getHybiLengthAsHexString(message.length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+      assert.equal(message, data);
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotPing.should.be.ok;
+  });
+  it('can parse a ping with no data', function() {
+    var p = new Receiver();
+    var packet = '89 00';
+
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotPing.should.be.ok;
+  });
+  it('can parse a fragmented masked text message of 300 bytes with a ping in the middle', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+
+    var pingMessage = 'Hello';
+    var pingPacket = '89 ' + getHybiLengthAsHexString(pingMessage.length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    };
+
+    p.add(getBufferFromHexString(packet1));
+    p.add(getBufferFromHexString(pingPacket));
+    p.add(getBufferFromHexString(packet2));
+    gotData.should.be.ok;
+    gotPing.should.be.ok;
+  });
+  it('can parse a fragmented masked text message of 300 bytes with a ping in the middle, which is delievered over sevaral tcp packets', function() {
+    var p = new Receiver();
+    var message = 'A';
+    for (var i = 0; i < 300; ++i) message += (i % 5).toString();
+
+    var msgpiece1 = message.substr(0, 150);
+    var packet1 = '01 FE ' + pack(4, msgpiece1.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece1, '34 83 a8 68'));
+
+    var pingMessage = 'Hello';
+    var pingPacket = '89 ' + getHybiLengthAsHexString(pingMessage.length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(pingMessage, '34 83 a8 68'));
+
+    var msgpiece2 = message.substr(150);
+    var packet2 = '80 FE ' + pack(4, msgpiece2.length) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(msgpiece2, '34 83 a8 68'));
+
+    var gotData = false;
+    p.ontext = function(data) {
+      gotData = true;
+      assert.equal(message, data);
+    };
+    var gotPing = false;
+    p.onping = function(data) {
+      gotPing = true;
+      assert.equal(pingMessage, data);
+    };
+
+    var buffers = [];
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet1)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(pingPacket)));
+    buffers = buffers.concat(splitBuffer(getBufferFromHexString(packet2)));
+    for (var i = 0; i < buffers.length; ++i) {
+      p.add(buffers[i]);
+    }
+    gotData.should.be.ok;
+    gotPing.should.be.ok;
+  });
+  it('can parse a 100 byte long masked binary message', function() {
+    var p = new Receiver();
+    var length = 100;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a 256 byte long masked binary message', function() {
+    var p = new Receiver();
+    var length = 256;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a 200kb long masked binary message', function() {
+    var p = new Receiver();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, true) + ' 34 83 a8 68 ' + getHexStringFromBuffer(mask(message, '34 83 a8 68'));
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+  it('can parse a 200kb long unmasked binary message', function() {
+    var p = new Receiver();
+    var length = 200 * 1024;
+    var message = new Buffer(length);
+    for (var i = 0; i < length; ++i) message[i] = i % 256;
+    var originalMessage = getHexStringFromBuffer(message);
+    var packet = '82 ' + getHybiLengthAsHexString(length, false) + ' ' + getHexStringFromBuffer(message);
+
+    var gotData = false;
+    p.onbinary = function(data) {
+      gotData = true;
+      assert.equal(originalMessage, getHexStringFromBuffer(data));
+    };
+
+    p.add(getBufferFromHexString(packet));
+    gotData.should.be.ok;
+  });
+});
+

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/test/Sender.hixie.test.js

@@ -0,0 +1,134 @@
+var assert = require('assert')
+  , Sender = require('../lib/Sender.hixie');
+require('should');
+require('./hybi-common');
+
+describe('Sender', function() {
+  describe('#send', function() {
+    it('frames and sends a text message', function(done) {
+      var message = 'Hello world';
+      var received;
+      var socket = {
+        write: function(data, encoding, cb) {
+          received = data;
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(message, {}, function() {
+        received.toString('utf8').should.eql('\u0000' + message + '\ufffd');
+        done();
+      });
+    });
+
+    it('frames and sends an empty message', function(done) {
+      var socket = {
+        write: function(data, encoding, cb) {
+          done();
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send('', {}, function() {});
+    });
+
+    it('frames and sends a buffer', function(done) {
+      var received;
+      var socket = {
+        write: function(data, encoding, cb) {
+          received = data;
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(new Buffer('foobar'), {}, function() {
+        received.toString('utf8').should.eql('\u0000foobar\ufffd');
+        done();
+      });
+    });
+
+    it('frames and sends a binary message', function(done) {
+      var message = 'Hello world';
+      var received;
+      var socket = {
+        write: function(data, encoding, cb) {
+          received = data;
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(message, {binary: true}, function() {
+        received.toString('hex').should.eql(
+	// 0x80 0x0b H e l l o <sp> w o r l d
+	'800b48656c6c6f20776f726c64');
+        done();
+      });
+    });
+/*
+    it('throws an exception for binary data', function(done) {
+      var socket = {
+        write: function(data, encoding, cb) {
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.on('error', function() {
+        done();
+      });
+      sender.send(new Buffer(100), {binary: true}, function() {});
+    });
+*/
+    it('can fauxe stream data', function(done) {
+      var received = [];
+      var socket = {
+        write: function(data, encoding, cb) {
+          received.push(data);
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(new Buffer('foobar'), { fin: false }, function() {});
+      sender.send('bazbar', { fin: false }, function() {});
+      sender.send(new Buffer('end'), { fin: true }, function() {
+        received[0].toString('utf8').should.eql('\u0000foobar');
+        received[1].toString('utf8').should.eql('bazbar');
+        received[2].toString('utf8').should.eql('end\ufffd');
+        done();
+      });
+    });
+  });
+
+  describe('#close', function() {
+    it('sends a hixie close frame', function(done) {
+      var received;
+      var socket = {
+        write: function(data, encoding, cb) {
+          received = data;
+          process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.close(null, null, null, function() {
+        received.toString('utf8').should.eql('\ufffd\u0000');
+        done();
+      });
+    });
+
+    it('sends a message end marker if fauxe streaming has started, before hixie close frame', function(done) {
+      var received = [];
+      var socket = {
+        write: function(data, encoding, cb) {
+          received.push(data);
+          if (cb) process.nextTick(cb);
+        }
+      };
+      var sender = new Sender(socket, {});
+      sender.send(new Buffer('foobar'), { fin: false }, function() {});
+      sender.close(null, null, null, function() {
+        received[0].toString('utf8').should.eql('\u0000foobar');
+        received[1].toString('utf8').should.eql('\ufffd');
+        received[2].toString('utf8').should.eql('\ufffd\u0000');
+        done();
+      });
+    });
+  });
+});

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/test/Sender.test.js

@@ -0,0 +1,24 @@
+var Sender = require('../lib/Sender');
+require('should');
+
+describe('Sender', function() {
+  describe('#frameAndSend', function() {
+    it('does not modify a masked binary buffer', function() {
+      var sender = new Sender({ write: function() {} });
+      var buf = new Buffer([1, 2, 3, 4, 5]);
+      sender.frameAndSend(2, buf, true, true);
+      buf[0].should.eql(1);
+      buf[1].should.eql(2);
+      buf[2].should.eql(3);
+      buf[3].should.eql(4);
+      buf[4].should.eql(5);
+    });
+
+    it('does not modify a masked text buffer', function() {
+      var sender = new Sender({ write: function() {} });
+      var text = 'hi there';
+      sender.frameAndSend(1, text, true, true);
+      text.should.eql('hi there');
+    });
+  });
+});

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/test/Validation.test.js

@@ -0,0 +1,23 @@
+var Validation = require('../lib/Validation').Validation;
+require('should');
+
+describe('Validation', function() {
+  describe('isValidUTF8', function() {
+    it('should return true for a valid utf8 string', function() {
+      var validBuffer = new Buffer('Lorem ipsum dolor sit amet, consectetur adipiscing elit. Quisque gravida mattis rhoncus. Donec iaculis, metus quis varius accumsan, erat mauris condimentum diam, et egestas erat enim ut ligula. Praesent sollicitudin tellus eget dolor euismod euismod. Nullam ac augue nec neque varius luctus. Curabitur elit mi, consequat ultricies adipiscing mollis, scelerisque in erat. Phasellus facilisis fermentum ullamcorper. Nulla et sem eu arcu pharetra pellentesque. Praesent consectetur tempor justo, vel iaculis dui ullamcorper sit amet. Integer tristique viverra ullamcorper. Vivamus laoreet, nulla eget suscipit eleifend, lacus lectus feugiat libero, non fermentum erat nisi at risus. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut pulvinar dignissim tellus, eu dignissim lorem vulputate quis. Morbi ut pulvinar augue.');
+      Validation.isValidUTF8(validBuffer).should.be.ok;
+    });
+    it('should return false for an erroneous string', function() {
+      var invalidBuffer = new Buffer([0xce, 0xba, 0xe1, 0xbd, 0xb9, 0xcf, 0x83, 0xce, 0xbc, 0xce, 0xb5, 0xed, 0xa0, 0x80, 0x65, 0x64, 0x69, 0x74, 0x65, 0x64]);
+      Validation.isValidUTF8(invalidBuffer).should.not.be.ok;
+    });
+    it('should return true for valid cases from the autobahn test suite', function() {
+      Validation.isValidUTF8(new Buffer('\xf0\x90\x80\x80')).should.be.ok;
+      Validation.isValidUTF8(new Buffer([0xf0, 0x90, 0x80, 0x80])).should.be.ok;
+    });
+    it('should return false for erroneous autobahn strings', function() {
+      Validation.isValidUTF8(new Buffer([0xce, 0xba, 0xe1, 0xbd])).should.not.be.ok;
+    });
+  });
+});
+

data/spec/iface/driver/assets/node_modules/socket.io/node_modules/socket.io-client/node_modules/engine.io-client/node_modules/ws/test/WebSocket.integration.js

@@ -0,0 +1,44 @@
+var assert = require('assert')
+  , WebSocket = require('../')
+  , server = require('./testserver');
+
+var port = 20000;
+
+function getArrayBuffer(buf) {
+  var l = buf.length;
+  var arrayBuf = new ArrayBuffer(l);
+  var uint8View = new Uint8Array(arrayBuf);
+
+  for (var i = 0; i < l; i++) {
+    uint8View[i] = buf[i];
+  }
+  return uint8View.buffer;
+}
+
+function areArraysEqual(x, y) {
+  if (x.length != y.length) return false;
+  for (var i = 0, l = x.length; i < l; ++i) {
+    if (x[i] !== y[i]) return false;
+  }
+  return true;
+}
+
+describe('WebSocket', function() {
+  it('communicates successfully with echo service', function(done) {
+    var ws = new WebSocket('ws://echo.websocket.org/', {protocolVersion: 13, origin: 'http://websocket.org'});
+    var str = Date.now().toString();
+    var dataReceived = false;
+    ws.on('open', function() {
+      ws.send(str, {mask: true});
+    });
+    ws.on('close', function() {
+      assert.equal(true, dataReceived);
+      done();
+    });
+    ws.on('message', function(data, flags) {
+      assert.equal(str, data);
+      ws.terminate();
+      dataReceived = true;
+    });
+  });
+});