server.js

/**
 * Tests dependencies.
 */

var http = require('http');
var https = require('https');
var fs = require('fs');
var zlib = require('zlib');
var eio = require('..');
var eioc = require('engine.io-client');
var listen = require('./common').listen;
var expect = require('expect.js');
var request = require('superagent');
var WebSocket = require('ws');

/**
 * Tests.
 */

describe('server', function () {

  describe('verification', function () {
    it('should disallow non-existent transports', function (done) {
      var engine = listen(function (port) {
        request.get('http://localhost:%d/engine.io/default/'.s(port))
          .query({ transport: 'tobi' }) // no tobi transport - outrageous
          .end(function (res) {
            expect(res.status).to.be(400);
            expect(res.body.code).to.be(0);
            expect(res.body.message).to.be('Transport unknown');
            expect(res.header['access-control-allow-origin']).to.be('*');
            done();
          });
      });
    });

    it('should disallow `constructor` as transports', function (done) {
      // make sure we check for actual properties - not those present on every {}
      var engine = listen(function (port) {
        request.get('http://localhost:%d/engine.io/default/'.s(port))
          .set('Origin', 'http://engine.io')
          .query({ transport: 'constructor' })
          .end(function (res) {
            expect(res.status).to.be(400);
            expect(res.body.code).to.be(0);
            expect(res.body.message).to.be('Transport unknown');
            expect(res.header['access-control-allow-credentials']).to.be('true');
            expect(res.header['access-control-allow-origin']).to.be('http://engine.io');
            done();
          });
      });
    });

    it('should disallow non-existent sids', function (done) {
      var engine = listen(function (port) {
        request.get('http://localhost:%d/engine.io/default/'.s(port))
          .set('Origin', 'http://engine.io')
          .query({ transport: 'polling', sid: 'test' })
          .end(function (res) {
            expect(res.status).to.be(400);
            expect(res.body.code).to.be(1);
            expect(res.body.message).to.be('Session ID unknown');
            expect(res.header['access-control-allow-credentials']).to.be('true');
            expect(res.header['access-control-allow-origin']).to.be('http://engine.io');
            done();
          });
      });
    });
  });

  describe('handshake', function () {
    it('should send the io cookie', function (done) {
      var engine = listen(function (port) {
        request.get('http://localhost:%d/engine.io/default/'.s(port))
          .query({ transport: 'polling', b64: 1 })
          .end(function (res) {
            // hack-obtain sid
            var sid = res.text.match(/"sid":"([^"]+)"/)[1];
            expect(res.headers['set-cookie'][0]).to.be('io=' + sid);
            done();
          });
      });
    });

    it('should send the io cookie custom name', function (done) {
      var engine = listen({ cookie: 'woot' }, function (port) {
        request.get('http://localhost:%d/engine.io/default/'.s(port))
          .query({ transport: 'polling', b64: 1 })
          .end(function (res) {
            var sid = res.text.match(/"sid":"([^"]+)"/)[1];
            expect(res.headers['set-cookie'][0]).to.be('woot=' + sid);
            done();
          });
      });
    });

    it('should not send the io cookie', function (done) {
      var engine = listen({ cookie: false }, function (port) {
        request.get('http://localhost:%d/engine.io/default/'.s(port))
          .query({ transport: 'polling' })
          .end(function (res) {
            expect(res.headers['set-cookie']).to.be(undefined);
            done();
          });
      });
    });

    it('should register a new client', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        expect(Object.keys(engine.clients)).to.have.length(0);
        expect(engine.clientsCount).to.be(0);

        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('open', function () {
          expect(Object.keys(engine.clients)).to.have.length(1);
          expect(engine.clientsCount).to.be(1);
          done();
        });
      });
    });

    it('should register a new client with custom id', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        expect(Object.keys(engine.clients)).to.have.length(0);
        expect(engine.clientsCount).to.be(0);

        var customId = 'CustomId' + Date.now();

        engine.generateId = function(req) {
          return customId;
        };

        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.once('open', function () {
          expect(Object.keys(engine.clients)).to.have.length(1);
          expect(engine.clientsCount).to.be(1);
          expect(socket.id).to.be(customId);
          expect(engine.clients[customId].id).to.be(customId);
          done();
        });
      });
    });

    it('should exchange handshake data', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('handshake', function (obj) {
          expect(obj.sid).to.be.a('string');
          expect(obj.pingTimeout).to.be.a('number');
          expect(obj.upgrades).to.be.an('array');
          done();
        });
      });
    });

    it('should allow custom ping timeouts', function (done) {
      var engine = listen({ allowUpgrades: false, pingTimeout: 123 }, function (port) {
        var socket = new eioc.Socket('http://localhost:%d'.s(port));
        socket.on('handshake', function (obj) {
          expect(obj.pingTimeout).to.be(123);
          done();
        });
      });
    });

    it('should trigger a connection event with a Socket', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (socket) {
          expect(socket).to.be.an(eio.Socket);
          done();
        });
      });
    });

    it('should open with polling by default', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (socket) {
          expect(socket.transport.name).to.be('polling');
          done();
        });
      });
    });

    it('should be able to open with ws directly', function (done) {
      var engine = listen({ transports: ['websocket'] }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
        engine.on('connection', function (socket) {
          expect(socket.transport.name).to.be('websocket');
          done();
        });
      });
    });

    it('should not suggest any upgrades for websocket', function (done) {
      var engine = listen({ transports: ['websocket'] }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
        socket.on('handshake', function (obj) {
          expect(obj.upgrades).to.have.length(0);
          done();
        });
      });
    });

    it('should not suggest upgrades when none are availble', function (done) {
      var engine = listen({ transports: ['polling'] }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { });
        socket.on('handshake', function (obj) {
          expect(obj.upgrades).to.have.length(0);
          done();
        });
      });
    });

    it('should only suggest available upgrades', function (done) {
      var engine = listen({ transports: ['polling'] }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { });
        socket.on('handshake', function (obj) {
          expect(obj.upgrades).to.have.length(0);
          done();
        });
      });
    });

    it('should suggest all upgrades when no transports are disabled', function (done) {
      var engine = listen({}, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { });
        socket.on('handshake', function (obj) {
          expect(obj.upgrades).to.have.length(1);
          expect(obj.upgrades).to.have.contain('websocket');
          done();
        });
      });
    });

    it('default to polling when proxy doesn\'t support websocket', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {

        engine.on('connection', function (socket) {
          socket.on('message', function (msg) {
            if ('echo' == msg) socket.send(msg);
          });
        });

        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('open', function () {
          request.get('http://localhost:%d/engine.io/'.s(port))
          .set({ connection: 'close' })
          .query({ transport: 'websocket', sid: socket.id })
          .end(function (err, res) {
            expect(err).to.be(null);
            expect(res.status).to.be(400);
            expect(res.body.code).to.be(3);
            socket.send('echo');
            socket.on('message', function (msg) {
              expect(msg).to.be('echo');
              done();
            });
          });
        });
      });
    });

    it('should allow arbitrary data through query string', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { query: { a: 'b' } });
        engine.on('connection', function (conn) {
          expect(conn.request._query).to.have.keys('transport', 'a');
          expect(conn.request._query.a).to.be('b');
          done();
        });
      });
    });

    it('should allow data through query string in uri', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d?a=b&c=d'.s(port));
        engine.on('connection', function (conn) {
          expect(conn.request._query.EIO).to.be.a('string');
          expect(conn.request._query.a).to.be('b');
          expect(conn.request._query.c).to.be('d');
          done();
        });
      });
    });



    it('should disallow bad requests', function (done) {
      var engine = listen(function (port) {
        request.get('http://localhost:%d/engine.io/default/'.s(port))
          .set('Origin', 'http://engine.io')
          .query({ transport: 'websocket' })
          .end(function (res) {
            expect(res.status).to.be(400);
            expect(res.body.code).to.be(3);
            expect(res.body.message).to.be('Bad request');
            expect(res.header['access-control-allow-credentials']).to.be('true');
            expect(res.header['access-control-allow-origin']).to.be('http://engine.io');
            done();
          });
      });
    });
  });

  describe('close', function () {
    it('should be able to access non-empty writeBuffer at closing (server)', function(done) {
      var opts = {allowUpgrades: false};
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('http://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('close', function (reason) {
            expect(conn.writeBuffer.length).to.be(1);
            setTimeout(function () {
              expect(conn.writeBuffer.length).to.be(0); // writeBuffer has been cleared
            }, 10);
            done();
          });
          conn.writeBuffer.push({ type: 'message', data: 'foo'});
          conn.onError('');
        });
      });
    });

    it('should be able to access non-empty writeBuffer at closing (client)', function(done) {
      var opts = {allowUpgrades: false};
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('http://localhost:%d'.s(port));
        socket.on('open', function() {
          socket.on('close', function (reason) {
            expect(socket.writeBuffer.length).to.be(1);
            setTimeout(function() {
              expect(socket.writeBuffer.length).to.be(0);
            }, 10);
            done();
          });
          socket.writeBuffer.push({ type: 'message', data: 'foo'});
          socket.onError('');
        });
      });
    });

    it('should trigger on server if the client does not pong', function (done) {
      var opts = { allowUpgrades: false, pingInterval: 5, pingTimeout: 5 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('http://localhost:%d'.s(port));
        socket.sendPacket = function (){};
        engine.on('connection', function (conn) {
          conn.on('close', function (reason) {
            expect(reason).to.be('ping timeout');
            done();
          });
        });
      });
    });

    it('should trigger on server even when there is no outstanding polling request (GH-198)', function (done) {
      var opts = { allowUpgrades: false, pingInterval: 500, pingTimeout: 500 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('http://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('close', function (reason) {
            expect(reason).to.be('ping timeout');
            done();
          });
          // client abruptly disconnects, no polling request on this tick since we've just connected
          socket.sendPacket = socket.onPacket = function (){};
          socket.close();
          // then server app tries to close the socket, since client disappeared
          conn.close();
        });
      });
    });

    it('should trigger on client if server does not meet ping timeout', function (done) {
      var opts = { allowUpgrades: false, pingInterval: 50, pingTimeout: 30 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('open', function () {
          // override onPacket to simulate an inactive server after handshake
          socket.onPacket = function(){};
          socket.on('close', function (reason, err) {
            expect(reason).to.be('ping timeout');
            done();
          });
        });
      });
    });

    it('should trigger on both ends upon ping timeout', function (done) {
      var opts = { allowUpgrades: false, pingTimeout: 10, pingInterval: 10 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port))
          , total = 2;

        function onClose (reason, err) {
          expect(reason).to.be('ping timeout');
          --total || done();
        }

        engine.on('connection', function (conn) {
          conn.on('close', onClose);
        });

        socket.on('open', function () {
          // override onPacket to simulate an inactive server after handshake
          socket.onPacket = socket.sendPacket = function(){};
          socket.on('close', onClose);
        });
      });
    });

    it('should trigger when server closes a client', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port))
          , total = 2;

        engine.on('connection', function (conn) {
          conn.on('close', function (reason) {
            expect(reason).to.be('forced close');
            --total || done();
          });
          setTimeout(function () {
            conn.close();
          }, 10);
        });

        socket.on('open', function () {
          socket.on('close', function (reason) {
            expect(reason).to.be('transport close');
            --total || done();
          });
        });
      });
    });

    it('should trigger when server closes a client (ws)', function (done) {
      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] })
          , total = 2;

        engine.on('connection', function (conn) {
          conn.on('close', function (reason) {
            expect(reason).to.be('forced close');
            --total || done();
          });
          setTimeout(function () {
            conn.close();
          }, 10);
        });

        socket.on('open', function () {
          socket.on('close', function (reason) {
            expect(reason).to.be('transport close');
            --total || done();
          });
        });
      });
    });

    it('should trigger when client closes', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port))
          , total = 2;

        engine.on('connection', function (conn) {
          conn.on('close', function (reason) {
            expect(reason).to.be('transport close');
            --total || done();
          });
        });

        socket.on('open', function () {
          socket.on('close', function (reason) {
            expect(reason).to.be('forced close');
            --total || done();
          });

          setTimeout(function () {
            socket.close();
          }, 10);
        });
      });
    });

    it('should trigger when client closes (ws)', function (done) {
      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] })
          , total = 2;

        engine.on('connection', function (conn) {
          conn.on('close', function (reason) {
            expect(reason).to.be('transport close');
            --total || done();
          });
        });

        socket.on('open', function () {
          socket.on('close', function (reason) {
            expect(reason).to.be('forced close');
            --total || done();
          });

          setTimeout(function () {
            socket.close();
          }, 10);
        });
      });
    });

    it('should trigger when calling socket.close() in payload', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));

        engine.on('connection', function (conn) {
          conn.send(null, function () {socket.close();});
          conn.send('this should not be handled');

          conn.on('close', function (reason) {
            expect(reason).to.be('transport close');
            done();
          });
        });

        socket.on('open', function () {
          socket.on('message', function (msg) {
            expect(msg).to.not.be('this should not be handled');
          });

          socket.on('close', function (reason) {
            expect(reason).to.be('forced close');
          });
        });
      });
    });

    it('should abort upgrade if socket is closed (GH-35)', function (done) {
      var engine = listen({ allowUpgrades: true }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('open', function () {
          socket.close();
          // we wait until complete to see if we get an uncaught EPIPE
          setTimeout(function(){
            done();
          }, 100);
        });
      });
    });

    it('should trigger if a poll request is ongoing and the underlying ' +
       'socket closes, as in a browser tab close', function ($done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        // hack to access the sockets created by node-xmlhttprequest
        // see: https://github.com/driverdan/node-XMLHttpRequest/issues/44
        var request = require('http').request;
        var sockets = [];
        http.request = function(opts){
          var req = request.apply(null, arguments);
          req.on('socket', function(socket){
            sockets.push(socket);
          });
          return req;
        };

        function done(){
          http.request = request;
          $done();
        }

        var socket = new eioc.Socket('ws://localhost:%d'.s(port))
          , serverSocket;

        engine.on('connection', function(s){
          serverSocket = s;
        });

        socket.transport.on('poll', function(){
          // we set a timer to wait for the request to actually reach
          setTimeout(function(){
            // at this time server's `connection` should have been fired
            expect(serverSocket).to.be.an('object');

            // OPENED readyState is expected - we qre actually polling
            expect(socket.transport.pollXhr.xhr.readyState).to.be(1);

            // 2 requests sent to the server over an unique port means
            // we should have been assigned 2 sockets
            expect(sockets.length).to.be(2);

            // expect the socket to be open at this point
            expect(serverSocket.readyState).to.be('open');

            // kill the underlying connection
            sockets[1].end();
            serverSocket.on('close', function(reason, err){
              expect(reason).to.be('transport error');
              expect(err.message).to.be('poll connection closed prematurely');
              done();
            });
          }, 50);
        });
      });
    });

    it('should not trigger with connection: close header', function($done){
      var engine = listen({ allowUpgrades: false }, function(port){
        // intercept requests to add connection: close
        var request = http.request;
        http.request = function(){
          var opts = arguments[0];
          opts.headers = opts.headers || {};
          opts.headers.Connection = 'close';
          return request.apply(this, arguments);
        };

        function done(){
          http.request = request;
          $done();
        }

        engine.on('connection', function(socket){
          socket.on('message', function(msg){
            expect(msg).to.equal('test');
            socket.send('woot');
          });
        });

        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('open', function(){
          socket.send('test');
        });
        socket.on('message', function(msg){
          expect(msg).to.be('woot');
          done();
        });
      });
    });

    it('should not trigger early with connection `ping timeout`' +
       'after post handshake timeout', function (done) {
      // first timeout should trigger after `pingInterval + pingTimeout`,
      // not just `pingTimeout`.
      var opts = { allowUpgrades: false, pingInterval: 300, pingTimeout: 100 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        var clientCloseReason = null;

        socket.on('handshake', function() {
          socket.onPacket = function(){};
        });
        socket.on('open', function () {
          socket.on('close', function (reason) {
            clientCloseReason = reason;
          });
        });

        setTimeout(function() {
          expect(clientCloseReason).to.be(null);
          done();
        }, 200);
      });
    });

    it('should not trigger early with connection `ping timeout` ' +
       'after post ping timeout', function (done) {
      // ping timeout should trigger after `pingInterval + pingTimeout`,
      // not just `pingTimeout`.
      var opts = { allowUpgrades: false, pingInterval: 80, pingTimeout: 50 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        var clientCloseReason = null;

        engine.on('connection', function(conn){
          conn.on('heartbeat', function() {
            conn.onPacket = function(){};
          });
        });

        socket.on('open', function () {
          socket.on('close', function (reason) {
            clientCloseReason = reason;
          });
        });

        setTimeout(function() {
          expect(clientCloseReason).to.be(null);
          done();
        }, 100);
      });
    });

    it('should trigger early with connection `transport close` ' +
       'after missing pong', function (done) {
      // ping timeout should trigger after `pingInterval + pingTimeout`,
      // not just `pingTimeout`.
      var opts = { allowUpgrades: false, pingInterval: 80, pingTimeout: 50 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        var clientCloseReason = null;

        socket.on('open', function () {
          socket.on('close', function (reason) {
            clientCloseReason = reason;
          });
        });

        engine.on('connection', function(conn){
          conn.on('heartbeat', function() {
            setTimeout(function() {
              conn.close();
            }, 20);
            setTimeout(function() {
              expect(clientCloseReason).to.be('transport close');
              done();
            }, 100);
          });
        });
      });
    });

    it('should trigger with connection `ping timeout` ' +
       'after `pingInterval + pingTimeout`', function (done) {
      var opts = { allowUpgrades: false, pingInterval: 300, pingTimeout: 100 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        var clientCloseReason = null;

        socket.on('open', function () {
          socket.on('close', function (reason) {
            clientCloseReason = reason;
          });
        });

        engine.on('connection', function(conn){
          conn.once('heartbeat', function() {
            setTimeout(function() {
              socket.onPacket = function(){};
              expect(clientCloseReason).to.be(null);
            }, 150);
            setTimeout(function() {
              expect(clientCloseReason).to.be(null);
            }, 350);
            setTimeout(function() {
              expect(clientCloseReason).to.be('ping timeout');
              done();
            }, 500);
          });
        });
      });
    });

    it('should abort the polling data request if it is ' +
       'in progress', function (done) {
      var engine = listen({ transports: [ 'polling' ] }, function (port) {
        var socket = new eioc.Socket('http://localhost:%d'.s(port));

        engine.on('connection', function (conn) {
          var onDataRequest = conn.transport.onDataRequest;
          conn.transport.onDataRequest = function (req, res) {
            engine.httpServer.close(done);
            onDataRequest.call(conn.transport, req, res);
            req.removeAllListeners();
            conn.close();
          };
        });

        socket.on('open', function () {
          socket.send('test');
        });
      });
    });

    // tests https://github.com/LearnBoost/engine.io-client/issues/207
    // websocket test, transport error
    it('should trigger transport close before open for ws', function(done){
      var opts = { transports: ['websocket'] };
      var engine = listen(opts, function (port) {
        var url = 'ws://%s:%d'.s('0.0.0.50', port);
        var socket = new eioc.Socket(url);
        socket.on('open', function(){
          done(new Error('Test invalidation'));
        });
        socket.on('close', function(reason){
          expect(reason).to.be('transport error');
          done();
        });
      });
    });

    // tests https://github.com/LearnBoost/engine.io-client/issues/207
    // polling test, transport error
    it('should trigger transport close before open for xhr', function(done){
      var opts = { transports: ['polling'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('http://invalidserver:%d'.s(port));
        socket.on('open', function(){
          done(new Error('Test invalidation'));
        });
        socket.on('close', function(reason){
          expect(reason).to.be('transport error');
          done();
        });
      });
    });

    // tests https://github.com/LearnBoost/engine.io-client/issues/207
    // websocket test, force close
    it('should trigger force close before open for ws', function(done){
      var opts = { transports: ['websocket'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('open', function(){
          done(new Error('Test invalidation'));
        });
        socket.on('close', function(reason){
          expect(reason).to.be('forced close');
          done();
        });
        socket.close();
      });
    });

    // tests https://github.com/LearnBoost/engine.io-client/issues/207
    // polling test, force close
    it('should trigger force close before open for xhr', function(done){
      var opts = { transports: ['polling'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('http://localhost:%d'.s(port));
        socket.on('open', function(){
          done(new Error('Test invalidation'));
        });
        socket.on('close', function(reason){
          expect(reason).to.be('forced close');
          done();
        });
        socket.close();
      });
    });

  });

  describe('messages', function () {
    this.timeout(5000);

    it('should arrive from server to client', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.send('a');
        });
        socket.on('open', function () {
          socket.on('message', function (msg) {
            expect(msg).to.be('a');
            done();
          });
        });
      });
    });

    it('should arrive from server to client (multiple)', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port))
          , expected = ['a', 'b', 'c']
          , i = 0;

        engine.on('connection', function (conn) {
          conn.send('a');
          // we use set timeouts to ensure the messages are delivered as part
          // of different.
          setTimeout(function () {
            conn.send('b');

            setTimeout(function () {
              // here we make sure we buffer both the close packet and
              // a regular packet
              conn.send('c');
              conn.close();
            }, 50);
          }, 50);

          conn.on('close', function () {
            // since close fires right after the buffer is drained
            setTimeout(function () {
              expect(i).to.be(3);
              done();
            }, 50);
          });
        });
        socket.on('open', function () {
          socket.on('message', function (msg) {
            expect(msg).to.be(expected[i++]);
          });
        });
      });
    });

    it('should not be receiving data when getting a message longer than maxHttpBufferSize when polling', function(done) {
      var opts = { allowUpgrades: false, transports: ['polling'], maxHttpBufferSize: 5 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('message', function(msg) {
            console.log(msg);
          });
        });
        socket.on('open', function () {
          socket.send('aasdasdakjhasdkjhasdkjhasdkjhasdkjhasdkjhasdkjha');
        });
      });
      setTimeout(done, 1000);
    });

    it('should receive data when getting a message shorter than maxHttpBufferSize when polling', function(done) {
      var opts = { allowUpgrades: false, transports: ['polling'], maxHttpBufferSize: 5 };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('message', function(msg) {
            expect(msg).to.be('a');
            done();
          });
        });
        socket.on('open', function () {
          socket.send('a');
        });
      });
    });


    it('should arrive from server to client (ws)', function (done) {
      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
        engine.on('connection', function (conn) {
          conn.send('a');
        });
        socket.on('open', function () {
          socket.on('message', function (msg) {
            expect(msg).to.be('a');
            done();
          });
        });
      });
    });

    it('should arrive from server to client (multiple, ws)', function (done) {
      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] })
          , expected = ['a', 'b', 'c']
          , i = 0;

        engine.on('connection', function (conn) {
          conn.send('a');
          setTimeout(function () {
            conn.send('b');
            setTimeout(function () {
              conn.send('c');
              conn.close();
            }, 50);
          }, 50);
          conn.on('close', function () {
            setTimeout(function () {
              expect(i).to.be(3);
              done();
            }, 50);
          });
        });

        socket.on('open', function () {
          socket.on('message', function (msg) {
            expect(msg).to.be(expected[i++]);
          });
        });
      });
    });

    it('should arrive from server to client (multiple, no delay, ws)', function (done) {
      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] })
          , expected = ['a', 'b', 'c']
          , i = 0;

        engine.on('connection', function (conn) {
          conn.on('close', function () {
            setTimeout(function () {
              expect(i).to.be(3);
              done();
            }, 50);
          });
          conn.send('a');
          conn.send('b');
          conn.send('c');
          conn.close();
        });

        socket.on('open', function () {
          socket.on('message', function (msg) {
            expect(msg).to.be(expected[i++]);
          });
        });
      });
    });

    it('should arrive when binary data is sent as Int8Array (ws)', function (done) {
      var binaryData = new Int8Array(5);
      for (var i = 0; i < binaryData.length; i++) {
        binaryData[i] = i;
      }

      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function(port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });

        engine.on('connection', function (conn) {
          conn.send(binaryData);
        });

        socket.on('open', function () {
          socket.on('message', function(msg) {
            for (var i = 0; i < binaryData.length; i++) {
              var num = msg.readInt8(i);
              expect(num).to.be(i);
            }
            done();
          });
        });
      });
    });

    it('should arrive when binary data is sent as Int32Array (ws)', function (done) {
      var binaryData = new Int32Array(5);
      for (var i = 0; i < binaryData.length; i++) {
        binaryData[i] = (i + 100) * 9823;
      }

      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function(port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });

        engine.on('connection', function (conn) {
          conn.send(binaryData);
        });

        socket.on('open', function () {
          socket.on('message', function(msg) {
            for (var i = 0, ii = 0; i < binaryData.length; i += 4, ii++) {
              var num = msg.readInt32LE(i);
              expect(num).to.be((ii + 100) * 9823);
            }
            done();
          });
        });
      });
    });

    it('should arrive when binary data is sent as Int32Array, given as ArrayBuffer(ws)', function (done) {
      var binaryData = new Int32Array(5);
      for (var i = 0; i < binaryData.length; i++) {
        binaryData[i] = (i + 100) * 9823;
      }

      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function(port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });

        engine.on('connection', function (conn) {
          conn.send(binaryData.buffer);
        });

        socket.on('open', function () {
          socket.on('message', function(msg) {
            for (var i = 0, ii = 0; i < binaryData.length; i += 4, ii++) {
              var num = msg.readInt32LE(i);
              expect(num).to.be((ii + 100) * 9823);
            }
            done();
          });
        });
      });
    });

    it('should arrive when binary data is sent as Buffer (ws)', function (done) {
      var binaryData = Buffer(5);
      for (var i = 0; i < binaryData.length; i++) {
        binaryData.writeInt8(i, i);
      }

      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function(port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });

        engine.on('connection', function (conn) {
          conn.send(binaryData);
        });

        socket.on('open', function () {
          socket.on('message', function(msg) {
            for (var i = 0; i < binaryData.length; i++) {
              var num = msg.readInt8(i);
              expect(num).to.be(i);
            }
            done();
          });
        });
      });
    });

    it('should arrive when binary data sent as Buffer (polling)', function (done) {
      var binaryData = Buffer(5);
      for (var i = 0; i < binaryData.length; i++) {
        binaryData.writeInt8(i, i);
      }

      var opts = { allowUpgrades: false, transports: ['polling'] };
      var engine = listen(opts, function(port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });

        engine.on('connection', function (conn) {
          conn.send(binaryData);
        });

        socket.on('open', function() {
          socket.on('message', function(msg) {
            for (var i = 0; i < binaryData.length; i++) {
              var num = msg.readInt8(i);
              expect(num).to.be(i);
            }

            done();
          });
        });
      });
    });

    it('should arrive as ArrayBuffer if requested when binary data sent as Buffer (ws)', function (done) {
      var binaryData = Buffer(5);
      for (var i = 0; i < binaryData.length; i++) {
        binaryData.writeInt8(i, i);
      }

      var opts = { allowUpgrades: false, transports: ['websocket'] };
      var engine = listen(opts, function(port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
        socket.binaryType = 'arraybuffer';

        engine.on('connection', function (conn) {
          conn.send(binaryData);
        });

        socket.on('open', function() {
          socket.on('message', function(msg) {
            expect(msg instanceof ArrayBuffer).to.be(true);
            var intArray = new Int8Array(msg);
            for (var i = 0; i < binaryData.length; i++) {
              expect(intArray[i]).to.be(i);
            }

            done();
          });
        });
      });
    });

    it('should arrive as ArrayBuffer if requested when binary data sent as Buffer (polling)', function (done) {
      var binaryData = Buffer(5);
      for (var i = 0; i < binaryData.length; i++) {
        binaryData.writeInt8(i, i);
      }

      var opts = { allowUpgrades: false, transports: ['polling'] };
      var engine = listen(opts, function(port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });
        socket.binaryType = 'arraybuffer';

        engine.on('connection', function (conn) {
          conn.send(binaryData);
        });

        socket.on('open', function() {
          socket.on('message', function(msg) {
            expect(msg instanceof ArrayBuffer).to.be(true);
            var intArray = new Int8Array(msg);
            for (var i = 0; i < binaryData.length; i++) {
              expect(intArray[i]).to.be(i);
            }

            done();
          });
        });
      });
    });


    it('should trigger a flush/drain event', function(done){
      var engine = listen({ allowUpgrades: false }, function(port){
        engine.on('connection', function(socket){
          var totalEvents = 4;

          engine.on('flush', function(sock, buf){
            expect(sock).to.be(socket);
            expect(buf).to.be.an('array');
            --totalEvents || done();
          });
          socket.on('flush', function(buf){
            expect(buf).to.be.an('array');
            --totalEvents || done();
          });

          engine.on('drain', function(sock){
            expect(sock).to.be(socket);
            expect(socket.writeBuffer.length).to.be(0);
            --totalEvents || done();
          });
          socket.on('drain', function(){
            expect(socket.writeBuffer.length).to.be(0);
            --totalEvents || done();
          });

          socket.send('aaaa');
        });

        new eioc.Socket('ws://localhost:%d'.s(port));
      });
    });

    it('should interleave with pongs if many messages buffered ' +
       'after connection open', function (done) {
      this.slow(4000);
      this.timeout(8000);

      var opts = {
        transports: ['websocket'],
        pingInterval: 200,
        pingTimeout: 100
      };

      var engine = listen(opts, function (port) {
        var messageCount = 100;
        var messagePayload = new Array(256 * 256).join('a');
        var connection = null;
        engine.on('connection', function (conn) {
          connection = conn;
        });
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
        socket.on('open', function () {
          for (var i=0;i<messageCount;i++) {
//            connection.send('message: ' + i);   // works
            connection.send(messagePayload + '|message: ' + i);   // does not work
          }
          var receivedCount = 0;
          socket.on('message', function (msg) {
            receivedCount += 1;
            if (receivedCount === messageCount) {
              done();
            }
          });
        });
      });
    });

    it('should support chinese', function(done){
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        var shi = '石室詩士施氏，嗜獅，誓食十獅。';
        var shi2 = '氏時時適市視獅。';
        engine.on('connection', function (conn) {
          conn.send('.');
          conn.send(shi);
          conn.send(shi2);
          conn.once('message', function(msg0){
            expect(msg0).to.be('.');
            conn.once('message', function(msg){
              expect(msg).to.be(shi);
              conn.once('message', function(msg2){
                expect(msg2).to.be(shi2);
                done();
              });
            });
          });
        });
        socket.on('open', function(){
          socket.once('message', function(msg0){
            expect(msg0).to.be('.');
            socket.once('message', function(msg){
              expect(msg).to.be(shi);
              socket.once('message', function(msg2){
                expect(msg2).to.be(shi2);
                socket.send('.');
                socket.send(shi);
                socket.send(shi2);
              });
            });
          });
        });
      });
    });

    it('should send and receive data with key and cert (polling)', function(done){
      var srvOpts = {
        key: fs.readFileSync('test/fixtures/server.key'),
        cert: fs.readFileSync('test/fixtures/server.crt'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        requestCert: true,
        rejectUnauthorized: true
      };

      var opts = {
        key: fs.readFileSync('test/fixtures/client.key'),
        cert: fs.readFileSync('test/fixtures/client.crt'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        transports: ['polling'],
      };

      var srv = https.createServer(srvOpts, function(req, res){
        res.writeHead(200);
        res.end('hello world\n');
      });

      var engine = eio({ transports: ['polling'], allowUpgrades: false });
      engine.attach(srv);
      srv.listen(null, function() {
        var port = srv.address().port;
        var socket = new eioc.Socket('https://localhost:%d'.s(port), opts);

        engine.on('connection', function (conn) {
          conn.on('message', function(msg) {
            expect(msg).to.be('hello');
            done();
          });
        });

        socket.on('open', function() {
          socket.send('hello');
        });
      });
    });

    it('should send and receive data with ca when not requiring auth (polling)', function(done){
      var srvOpts = {
        key: fs.readFileSync('test/fixtures/server.key'),
        cert: fs.readFileSync('test/fixtures/server.crt'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        requestCert: true
      };

      var opts = {
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        transports: ['polling']
      };

      var srv = https.createServer(srvOpts, function(req, res){
        res.writeHead(200);
        res.end('hello world\n');
      });

      var engine = eio({ transports: ['polling'], allowUpgrades: false });
      engine.attach(srv);
      srv.listen(null, function() {
        var port = srv.address().port;
        var socket = new eioc.Socket('https://localhost:%d'.s(port), opts);

        engine.on('connection', function (conn) {
          conn.on('message', function(msg) {
            expect(msg).to.be('hello');
            done();
          });
        });

        socket.on('open', function() {
          socket.send('hello');
        });
      });
    });

    it('should send and receive data with key and cert (ws)', function(done){
      var srvOpts = {
        key: fs.readFileSync('test/fixtures/server.key'),
        cert: fs.readFileSync('test/fixtures/server.crt'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        requestCert: true,
        rejectUnauthorized: true
      };

      var opts = {
        key: fs.readFileSync('test/fixtures/client.key'),
        cert: fs.readFileSync('test/fixtures/client.crt'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        transports: ['websocket']
      };

      var srv = https.createServer(srvOpts, function(req, res){
        res.writeHead(200);
        res.end('hello world\n');
      });

      var engine = eio({ transports: ['websocket'], allowUpgrades: false });
      engine.attach(srv);
      srv.listen(null, function() {
        var port = srv.address().port;
        var socket = new eioc.Socket('https://localhost:%d'.s(port), opts);

        engine.on('connection', function (conn) {
          conn.on('message', function(msg) {
            expect(msg).to.be('hello');
            done();
          });
        });

        socket.on('open', function() {
          socket.send('hello');
        });
      });
    });

    it('should send and receive data with pfx (polling)', function(done){
      var srvOpts = {
        key: fs.readFileSync('test/fixtures/server.key'),
        cert: fs.readFileSync('test/fixtures/server.crt'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        requestCert: true,
        rejectUnauthorized: true
      };

      var opts = {
        pfx: fs.readFileSync('test/fixtures/client.pfx'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        transports: ['polling']
      };

      var srv = https.createServer(srvOpts, function(req, res){
        res.writeHead(200);
        res.end('hello world\n');
      });

      var engine = eio({ transports: ['polling'], allowUpgrades: false });
      engine.attach(srv);
      srv.listen(null, function() {
        var port = srv.address().port;
        var socket = new eioc.Socket('https://localhost:%d'.s(port), opts);

        engine.on('connection', function (conn) {
          conn.on('message', function(msg) {
            expect(msg).to.be('hello');
            done();
          });
        });

        socket.on('open', function() {
          socket.send('hello');
        });
      });
    });

    it('should send and receive data with pfx (ws)', function(done){
      var srvOpts = {
        key: fs.readFileSync('test/fixtures/server.key'),
        cert: fs.readFileSync('test/fixtures/server.crt'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        requestCert: true,
        rejectUnauthorized: true
      };

      var opts = {
        pfx: fs.readFileSync('test/fixtures/client.pfx'),
        ca: fs.readFileSync('test/fixtures/ca.crt'),
        transports: ['websocket']
      };

      var srv = https.createServer(srvOpts, function(req, res){
        res.writeHead(200);
        res.end('hello world\n');
      });

      var engine = eio({ transports: ['websocket'], allowUpgrades: false });
      engine.attach(srv);
      srv.listen(null, function() {
        var port = srv.address().port;
        var socket = new eioc.Socket('https://localhost:%d'.s(port), opts);

        engine.on('connection', function (conn) {
          conn.on('message', function(msg) {
            expect(msg).to.be('hello');
            done();
          });
        });

        socket.on('open', function() {
          socket.send('hello');
        });
      });
    });
  });

  describe('send', function() {
    describe('writeBuffer', function() {
      it('should not empty until `drain` event (polling)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });
          var totalEvents = 2;
          socket.on('open', function() {
            socket.send('a');
            socket.send('b');
            // writeBuffer should be nonempty, with 'a' still in it
            expect(socket.writeBuffer.length).to.eql(2);
          });
          socket.transport.on('drain', function() {
            expect(socket.writeBuffer.length).to.eql(--totalEvents);
            totalEvents || done();
          });
        });
      });

      it('should not empty until `drain` event (websocket)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
          var totalEvents = 2;
          socket.on('open', function() {
            socket.send('a');
            socket.send('b');
            // writeBuffer should be nonempty, with 'a' still in it
            expect(socket.writeBuffer.length).to.eql(2);
          });
          socket.transport.on('drain', function() {
            expect(socket.writeBuffer.length).to.eql(--totalEvents);
            totalEvents || done();
          });
        });
      });
    });

    describe('callback', function() {
      it('should execute in order when message sent (client) (polling)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });
          var i = 0;
          var j = 0;

          engine.on('connection', function(conn) {
            conn.on('message', function(msg) {
              conn.send(msg);
            });
          });

          socket.on('open', function () {
            socket.on('message', function(msg) {
              // send another packet until we've sent 3 total
              if (++i < 3) {
                expect(i).to.eql(j);
                sendFn();
              } else {
                done();
              }
            });

            function sendFn() {
              socket.send(j, (function(value) {
                j++;
              })(j));
            }

            sendFn();
          });
        });
      });

      it('should execute in order when message sent (client) (websocket)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
          var i = 0;
          var j = 0;

          engine.on('connection', function(conn) {
            conn.on('message', function(msg) {
              conn.send(msg);
            });
          });

          socket.on('open', function () {
            socket.on('message', function(msg) {
              // send another packet until we've sent 3 total
              if (++i < 3) {
                expect(i).to.eql(j);
                sendFn();
              } else {
                done();
              }
            });

            function sendFn() {
              socket.send(j, (function(value) {
                j++;
              })(j));
            }

            sendFn();
          });
        });
      });

      it('should execute in order with payloads (client) (polling)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });
          var i = 0;
          var lastCbFired = 0;

          engine.on('connection', function(conn) {
            conn.on('message', function(msg) {
              conn.send(msg);
            });
          });

          socket.on('open', function () {
            socket.on('message', function(msg) {
              expect(msg).to.eql(i + 1);
              i++;
            });

            function cb(value) {
              expect(value).to.eql(lastCbFired + 1);
              lastCbFired = value;
              if (value == 3) {
                done();
              }
            }

            // 2 and 3 will be in the same payload
            socket.once('flush', function() {
              socket.send(2, function() { cb(2); });
              socket.send(3, function() { cb(3); });
            });

            socket.send(1, function() { cb(1); });
          });
        });
      });

      it('should execute in order with payloads (client) (websocket)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
          var i = 0;
          var lastCbFired = 0;

          engine.on('connection', function(conn) {
            conn.on('message', function(msg) {
              conn.send(msg);
            });
          });

          socket.on('open', function () {
            socket.on('message', function(msg) {
              expect(msg).to.eql(i + 1);
              i++;
            });

            function cb(value) {
              expect(value).to.eql(lastCbFired + 1);
              lastCbFired = value;
              if (value == 3) {
                done();
              }
            }

            // 2 and 3 will be in the same payload
            socket.once('flush', function() {
              socket.send(2, function() { cb(2); });
              socket.send(3, function() { cb(3); });
            });

            socket.send(1, function() { cb(1); });
          });
        });
      });

      it('should execute when message sent (polling)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });
          var i = 0;
          var j = 0;

          engine.on('connection', function (conn) {
            conn.send('a', function (transport) {
              i++;
            });
          });
          socket.on('open', function () {
            socket.on('message', function (msg) {
              j++;
            });
          });

          setTimeout(function() {
            expect(i).to.be(j);
            done();
          }, 10);
        });
      });

      it('should execute when message sent (websocket)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['websocket'] });
          var i = 0;
          var j = 0;

          engine.on('connection', function (conn) {
            conn.send('a', function (transport) {
              i++;
            });
          });

          socket.on('open', function () {
            socket.on('message', function (msg) {
              j++;
            });
          });

          setTimeout(function () {
            expect(i).to.be(j);
            done();
          }, 10);
        });
      });

      it('should execute once for each send', function (done) {
        var engine = listen(function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port));
          var a = 0;
          var b = 0;
          var c = 0;
          var all = 0;

          engine.on('connection', function (conn) {
            conn.send('a');
            conn.send('b');
            conn.send('c');
          });

          socket.on('open', function () {
            socket.on('message', function (msg) {
              if (msg === 'a') a ++;
              if (msg === 'b') b ++;
              if (msg === 'c') c ++;

              if(++all === 3) {
                expect(a).to.be(1);
                expect(b).to.be(1);
                expect(c).to.be(1);
                done();
              }
            });
          });
        });
      });

      it('should execute in multipart packet', function (done) {
        var engine = listen(function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port));
          var i = 0;
          var j = 0;

          engine.on('connection', function (conn) {
            conn.send('b', function (transport) {
              i++;
            });

            conn.send('a', function (transport) {
              i++;
            });

          });
          socket.on('open', function () {
            socket.on('message', function (msg) {
              j++;
            });
          });

          setTimeout(function () {
            expect(i).to.be(j);
            done();
          }, 200);
        });
      });

      it('should execute in multipart packet (polling)', function (done) {
        var engine = listen(function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });
          var i = 0;
          var j = 0;

          engine.on('connection', function (conn) {
            conn.send('d', function (transport) {
              i++;
            });

            conn.send('c', function (transport) {
              i++;
            });

            conn.send('b', function (transport) {
              i++;
            });

            conn.send('a', function (transport) {
              i++;
            });

          });
          socket.on('open', function () {
            socket.on('message', function (msg) {
              j++;
            });
          });

          setTimeout(function () {
            expect(i).to.be(j);
            done();
          }, 200);
        });
      });

      it('should clean callback references when socket gets closed with pending callbacks', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });

          engine.on('connection', function (conn) {
            socket.transport.on('pollComplete', function () {
              conn.send('a', function (transport) {
                done(new Error('Test invalidation'));
              });

              if (!conn.writeBuffer.length) {
                done(new Error('Test invalidation'));
              }

              // force to close the socket when we have one or more packet(s) in buffer
              socket.close();
            });

            conn.on('close', function (reason) {
              expect(conn.packetsFn).to.be.empty();
              expect(conn.sentCallbackFn).to.be.empty();
              done();
            });
          });
        });
      });

      it('should not execute when it is not actually sent (polling)', function (done) {
        var engine = listen({ allowUpgrades: false }, function (port) {
          var socket = new eioc.Socket('ws://localhost:%d'.s(port), { transports: ['polling'] });

          socket.transport.on('pollComplete', function(msg) {
            socket.close();
          });

          engine.on('connection', function (conn) {
            var err;
            conn.send('a');
            conn.send('b', function (transport) {
              err = new Error('Test invalidation');
            });
            conn.on('close', function (reason) {
              done(err);
            });
          });
        });
      });
    });
  });

  describe('packet', function() {
    it('should emit when socket receives packet', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('packet', function (packet) {
            expect(packet.type).to.be('message');
            expect(packet.data).to.be('a');
            done();
          });
        });
        socket.on('open', function () {
          socket.send('a');
        });
      });
    });

    it('should emit when receives ping', function (done) {
      var engine = listen({ allowUpgrades: false, pingInterval: 4 }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('packet', function (packet) {
            conn.close();
            expect(packet.type).to.be('ping');
            done();
          });
        });
      });
    });
  });

  describe('packetCreate', function() {
    it('should emit before socket send message', function (done) {
      var engine = listen({ allowUpgrades: false }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('packetCreate', function(packet) {
            expect(packet.type).to.be('message');
            expect(packet.data).to.be('a');
            done();
          });
          conn.send('a');
        });
      });
    });

    it('should emit before send pong', function (done) {
      var engine = listen({ allowUpgrades: false, pingInterval: 4 }, function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        engine.on('connection', function (conn) {
          conn.on('packetCreate', function (packet) {
            conn.close();
            expect(packet.type).to.be('pong');
            done();
          });
        });
      });
    });
  });

  describe('upgrade', function () {
    it('should upgrade', function (done) {
      var engine = listen(function (port) {
        // it takes both to send 50 to verify
        var ready = 2, closed = 2;
        function finish () {
          setTimeout(function () {
            socket.close();
          }, 10);
        }

        // server
        engine.on('connection', function (conn) {
          var lastSent = 0, lastReceived = 0, upgraded = false;
          var interval = setInterval(function () {
            lastSent++;
            conn.send(lastSent);
            if (50 == lastSent) {
              clearInterval(interval);
              --ready || finish();
            }
          }, 2);

          expect(conn.request._query.transport).to.be('polling');

          conn.on('message', function (msg) {
            expect(conn.request._query).to.be.an('object');
            lastReceived++;
            expect(msg).to.eql(lastReceived);
          });

          conn.on('upgrade', function (to) {
            expect(conn.request._query.transport).to.be('polling');
            upgraded = true;
            expect(to.name).to.be('websocket');
            expect(conn.transport.name).to.be('websocket');
          });

          conn.on('close', function (reason) {
            expect(reason).to.be('transport close');
            expect(lastSent).to.be(50);
            expect(lastReceived).to.be(50);
            expect(upgraded).to.be(true);
            --closed || done();
          });
        });

        // client
        var socket = new eioc.Socket('ws://localhost:%d'.s(port));
        socket.on('open', function () {
          var lastSent = 0, lastReceived = 0, upgrades = 0;
          var interval = setInterval(function () {
            lastSent++;
            socket.send(lastSent);
            if (50 == lastSent) {
              clearInterval(interval);
              --ready || finish();
            }
          }, 2);
          socket.on('upgrading', function (to) {
            // we want to make sure for the sake of this test that we have a buffer
            expect(to.name).to.equal('websocket');
            upgrades++;

            // force send a few packets to ensure we test buffer transfer
            lastSent++;
            socket.send(lastSent);
            lastSent++;
            socket.send(lastSent);

            expect(socket.writeBuffer).to.not.be.empty();
          });
          socket.on('upgrade', function (to) {
            expect(to.name).to.equal('websocket');
            upgrades++;
          });
          socket.on('message', function (msg) {
            lastReceived++;
            expect(lastReceived).to.eql(msg);
          });
          socket.on('close', function (reason) {
            expect(reason).to.be('forced close');
            expect(lastSent).to.be(50);
            expect(upgrades).to.be(2);
            --closed || done();
          });
        });
      });

      // attach another engine to make sure it doesn't break upgrades
      var e2 = eio.attach(engine.httpServer, { path: '/foo' });
    });
  });

  describe('http compression', function () {
    it('should compress by default', function (done) {
      var engine = listen({ transports: ['polling'] }, function (port) {
        engine.on('connection', function (conn) {
          var buf = new Buffer(1024);
          for (var i = 0; i < buf.length; i++) buf[i] = i % 0xff;
          conn.send(buf);
        });

        http.get({
          port: port,
          path: '/engine.io/default/?transport=polling'
        }, function(res) {
          var sid = res.headers['set-cookie'][0].split('=')[1];
          http.get({
            port: port,
            path: '/engine.io/default/?transport=polling&sid=' + sid,
            headers: { 'Accept-Encoding': 'gzip, deflate' }
          }, function(res) {
            expect(res.headers['content-encoding']).to.equal('gzip');
            res.pipe(zlib.createGunzip())
              .on('error', done)
              .on('end', done)
              .resume();
          });
        });
      });
    });

    it('should compress using deflate', function (done) {
      var engine = listen({ transports: ['polling'] }, function (port) {
        engine.on('connection', function (conn) {
          var buf = new Buffer(1024);
          for (var i = 0; i < buf.length; i++) buf[i] = i % 0xff;
          conn.send(buf);
        });

        http.get({
          port: port,
          path: '/engine.io/default/?transport=polling'
        }, function(res) {
          var sid = res.headers['set-cookie'][0].split('=')[1];
          http.get({
            port: port,
            path: '/engine.io/default/?transport=polling&sid=' + sid,
            headers: { 'Accept-Encoding': 'deflate' }
          }, function(res) {
            expect(res.headers['content-encoding']).to.equal('deflate');
            res.pipe(zlib.createDeflate())
              .on('error', done)
              .on('end', done)
              .resume();
          });
        });
      });
    });

    it('should set threshold', function (done) {
      var engine = listen({ transports: ['polling'], httpCompression: { threshold: 0 } }, function (port) {
        engine.on('connection', function (conn) {
          var buf = new Buffer(10);
          for (var i = 0; i < buf.length; i++) buf[i] = i % 0xff;
          conn.send(buf);
        });

        http.get({
          port: port,
          path: '/engine.io/default/?transport=polling'
        }, function(res) {
          var sid = res.headers['set-cookie'][0].split('=')[1];
          http.get({
            port: port,
            path: '/engine.io/default/?transport=polling&sid=' + sid,
            headers: { 'Accept-Encoding': 'gzip, deflate' }
          }, function(res) {
            expect(res.headers['content-encoding']).to.equal('gzip');
            done();
          });
        });
      });
    });

    it('should disable compression', function (done) {
      var engine = listen({ transports: ['polling'], httpCompression: false }, function (port) {
        engine.on('connection', function (conn) {
          var buf = new Buffer(1024);
          for (var i = 0; i < buf.length; i++) buf[i] = i % 0xff;
          conn.send(buf);
        });

        http.get({
          port: port,
          path: '/engine.io/default/?transport=polling'
        }, function(res) {
          var sid = res.headers['set-cookie'][0].split('=')[1];
          http.get({
            port: port,
            path: '/engine.io/default/?transport=polling&sid=' + sid,
            headers: { 'Accept-Encoding': 'gzip, deflate' }
          }, function(res) {
            expect(res.headers['content-encoding']).to.be(undefined);
            done();
          });
        });
      });
    });

    it('should disable compression per message', function (done) {
      var engine = listen({ transports: ['polling'] }, function (port) {
        engine.on('connection', function (conn) {
          var buf = new Buffer(1024);
          for (var i = 0; i < buf.length; i++) buf[i] = i % 0xff;
          conn.send(buf, { compress: false });
        });

        http.get({
          port: port,
          path: '/engine.io/default/?transport=polling'
        }, function(res) {
          var sid = res.headers['set-cookie'][0].split('=')[1];
          http.get({
            port: port,
            path: '/engine.io/default/?transport=polling&sid=' + sid,
            headers: { 'Accept-Encoding': 'gzip, deflate' }
          }, function(res) {
            expect(res.headers['content-encoding']).to.be(undefined);
            done();
          });
        });
      });
    });

    it('should not compress when the byte size is below threshold', function (done) {
      var engine = listen({ transports: ['polling'] }, function (port) {
        engine.on('connection', function (conn) {
          var buf = new Buffer(100);
          for (var i = 0; i < buf.length; i++) buf[i] = i % 0xff;
          conn.send(buf);
        });

        http.get({
          port: port,
          path: '/engine.io/default/?transport=polling'
        }, function(res) {
          var sid = res.headers['set-cookie'][0].split('=')[1];
          http.get({
            port: port,
            path: '/engine.io/default/?transport=polling&sid=' + sid,
            headers: { 'Accept-Encoding': 'gzip, deflate' }
          }, function(res) {
            expect(res.headers['content-encoding']).to.be(undefined);
            done();
          });
        });
      });
    });
  });

  describe('extraHeaders', function () {
    this.timeout(5000);

    var headers = {
      'x-custom-header-for-my-project': 'my-secret-access-token',
      'cookie': 'user_session=NI2JlCKF90aE0sJZD9ZzujtdsUqNYSBYxzlTsvdSUe35ZzdtVRGqYFr0kdGxbfc5gUOkR9RGp20GVKza; path=/; expires=Tue, 07-Apr-2015 18:18:08 GMT; secure; HttpOnly'
    };

    function testForTransport(transport, done) {
      var engine = listen(function (port) {
        var socket = new eioc.Socket('ws://localhost:%d'.s(port), {
          extraHeaders: headers,
          transports: [transport]
        });
        engine.on('connection', function (conn) {
          for (var h in headers) {
            expect(conn.request.headers[h]).to.equal(headers[h]);
          }
          done();
        });
        socket.on('open', function () {});
      });
    }

    it('should arrive from client to server via WebSockets', function (done) {
      testForTransport('websocket', done);
    });

    it('should arrive from client to server via XMLHttpRequest', function (done) {
      testForTransport('polling', done);
    });
  });

});