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() {
    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(err, res) {
          expect(err).to.be.an(Error);
          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(err, res) {
          expect(err).to.be.an(Error);
          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(
          err,
          res
        ) {
          expect(err).to.be.an(Error);
          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(err, res) {
            expect(err).to.be(null);
            expect(res.status).to.be(200);
            expect(listeners).to.eql(2);
            server.once("close", done);
            server.close();
          });
        });
      });
    });
  });
});