socket.io/test/engine.io.js

/**
 * Test dependencies.
 */

var net = require('net');
var eio = require('..');
var listen = require('./common').listen;
var expect = require('expect.js');
var request = require('superagent');
var http = require('http');

/**
 * Tests.
 */

describe('engine', function () {
  it('should expose protocol number', function () {
    expect(eio.protocol).to.be.a('number');
  });

  it('should be the same version as client', function () {
    expect(eio.protocol).to.be.a('number');
    var version = require('../package').version;
    expect(version).to.be(require('engine.io-client/package').version);
  });

  describe('engine()', function () {
    it('should create a Server when require called with no arguments', function () {
      var engine = eio();
      expect(engine).to.be.an(eio.Server);
      expect(engine.ws).to.be.ok();
    });
  });

  describe('listen', function () {
    it('should open a http server that returns 501', function (done) {
      listen(function (port) {
        request.get('http://localhost:%d/'.s(port), function (res) {
          expect(res.status).to.be(501);
          done();
        });
      });
    });
  });

  describe('attach()', function () {
    it('should work from require()', function () {
      var server = http.createServer();
      var engine = eio(server);

      expect(engine).to.be.an(eio.Server);
    });

    it('should return an engine.Server', function () {
      var server = http.createServer();
      var engine = eio.attach(server);

      expect(engine).to.be.an(eio.Server);
    });

    it('should attach engine to an http server', function (done) {
      var server = http.createServer();
      eio.attach(server);

      server.listen(function () {
        var uri = 'http://localhost:%d/engine.io/default/'.s(server.address().port);
        request.get(uri, function (res) {
          expect(res.status).to.be(400);
          expect(res.body.code).to.be(0);
          expect(res.body.message).to.be('Transport unknown');
          server.once('close', done);
          server.close();
        });
      });
    });

    it('should destroy upgrades not handled by engine', function (done) {
      var server = http.createServer();
      eio.attach(server, { destroyUpgradeTimeout: 50 });

      server.listen(function () {
        var client = net.createConnection(server.address().port);
        client.setEncoding('ascii');
        client.write([
          'GET / HTTP/1.1',
          'Connection: Upgrade',
          'Upgrade: IRC/6.9',
          '', ''
        ].join('\r\n'));

        var check = setTimeout(function () {
          done(new Error('Client should have ended'));
        }, 100);

        client.on('end', function () {
          clearTimeout(check);
          done();
        });
      });
    });

    it('should not destroy unhandled upgrades with destroyUpgrade:false', function (done) {
      var server = http.createServer();
      eio.attach(server, { destroyUpgrade: false, destroyUpgradeTimeout: 50 });

      server.listen(function () {
        var client = net.createConnection(server.address().port);
        client.on('connect', function () {
          client.setEncoding('ascii');
          client.write([
            'GET / HTTP/1.1',
            'Connection: Upgrade',
            'Upgrade: IRC/6.9',
            '', ''
          ].join('\r\n'));

          setTimeout(function () {
            client.removeListener('end', onEnd);
            done();
          }, 100);

          function onEnd () {
            done(new Error('Client should not end'));
          }

          client.on('end', onEnd);
        });
      });
    });

    it('should destroy unhandled upgrades with after a timeout', function (done) {
      var server = http.createServer();
      eio.attach(server, { destroyUpgradeTimeout: 200 });

      server.listen(function () {
        var client = net.createConnection(server.address().port);
        client.on('connect', function () {
          client.setEncoding('ascii');
          client.write([
            'GET / HTTP/1.1',
            'Connection: Upgrade',
            'Upgrade: IRC/6.9',
            '', ''
          ].join('\r\n'));

          // send from client to server
          // tests that socket is still alive
          // this will not keep the socket open as the server does not handle it
          setTimeout(function () {
            client.write('foo');
          }, 100);

          function onEnd () {
            done();
          }

          client.on('end', onEnd);
        });
      });
    });

    it('should not destroy handled upgrades with after a timeout', function (done) {
      var server = http.createServer();
      eio.attach(server, { destroyUpgradeTimeout: 100 });

      // write to the socket to keep engine.io from closing it by writing before the timeout
      server.on('upgrade', function (req, socket) {
        socket.write('foo');
        socket.on('data', function (chunk) {
          expect(chunk.toString()).to.be('foo');
          socket.end();
        });
      });

      server.listen(function () {
        var client = net.createConnection(server.address().port);

        client.on('connect', function () {
          client.setEncoding('ascii');
          client.write([
            'GET / HTTP/1.1',
            'Connection: Upgrade',
            'Upgrade: IRC/6.9',
            '', ''
          ].join('\r\n'));

          // test that socket is still open by writing after the timeout period
          setTimeout(function () {
            client.write('foo');
          }, 200);

          client.on('data', function (data) {
          });

          client.on('end', done);
        });
      });
    });

    it('should preserve original request listeners', function (done) {
      var listeners = 0;
      var server = http.createServer(function (req, res) {
        expect(req && res).to.be.ok();
        listeners++;
      });

      server.on('request', function (req, res) {
        expect(req && res).to.be.ok();
        res.writeHead(200);
        res.end('');
        listeners++;
      });

      eio.attach(server);

      server.listen(function () {
        var port = server.address().port;
        request.get('http://localhost:%d/engine.io/default/'.s(port), function (res) {
          expect(res.status).to.be(400);
          expect(res.body.code).to.be(0);
          expect(res.body.message).to.be('Transport unknown');
          request.get('http://localhost:%d/test'.s(port), function (res) {
            expect(res.status).to.be(200);
            expect(listeners).to.eql(2);
            server.once('close', done);
            server.close();
          });
        });
      });
    });
  });
});