index.spec.js

"use strict";

// ===================================================================

const assert = require("assert/strict");
const { EventEmitter } = require("events");
const fs = require("fs");
const http = require("http");
const os = require("os");
const path = require("path");
const tcpBind = require("tcp-bind");
const t = require("tap");

const HttpServerPlus = require("./");

// ===================================================================

function get(opts) {
  return new Promise(function (resolve, reject) {
    http
      .get(opts, function (response) {
        let body = "";
        response.on("data", function (chunk) {
          body += chunk;
        });
        response.on("end", function () {
          resolve({ body, statusCode: response.statusCode });
        });
      })
      .on("error", reject);
  });
}

// ===================================================================

t.test("HttpServerPlus", async (t) => {
  await t.test("#create()", async (t) => {
    await t.test("creates a new instance", async () => {
      assert(HttpServerPlus.create() instanceof HttpServerPlus);
    });

    await t.test("can register a `request` listener", async () => {
      const listener = function () {};
      const server = HttpServerPlus.create(listener);

      assert.deepEqual(server.listeners("request"), [listener]);
    });
  });

  await t.test(".addresses()", async (t) => {
    await t.test(
      "returns the list of addresses the server is listening at",
      async () => {
        const server = HttpServerPlus.create();
        assert.deepEqual(server.addresses(), []);

        await server.listen({ hostname: "127.0.0.1", port: 0 });
        const addresses = server.addresses();
        assert.equal(addresses.length, 1);
        assert.equal(addresses[0].address, "127.0.0.1");
        assert.equal(typeof addresses[0].port, "number");

        await server.close();
        assert.deepEqual(server.addresses(), []);
      },
    );
  });

  await t.test(".listen()", async (t) => {
    await t.test("can use a host:port", async () => {
      const server = HttpServerPlus.create(function (request, response) {
        response.end("ok");
      });

      const niceAddress = await server.listen({
        hostname: "127.0.0.1",
        port: 0,
      });
      assert.match(niceAddress, /^http:\/\/127\.0\.0\.1:\d+$/);

      const { port } = server.addresses()[0];
      const { body, statusCode } = await get({
        hostname: "127.0.0.1",
        port,
      });
      assert.equal(statusCode, 200);
      assert.equal(body, "ok");

      await server.close();
    });

    await t.test(
      "passes additional listen options through to the underlying server",
      async () => {
        let receivedOptions;
        const fakeServer = new EventEmitter();
        fakeServer.listen = function (options) {
          receivedOptions = options;
          setImmediate(function () {
            fakeServer.emit("listening");
          });
        };
        fakeServer.address = function () {
          return { address: "127.0.0.1", port: 1234 };
        };
        fakeServer.close = function () {
          setImmediate(function () {
            fakeServer.emit("close");
          });
        };

        const server = HttpServerPlus.create({
          createServer: function () {
            return fakeServer;
          },
        });

        await server.listen({
          hostname: "127.0.0.1",
          port: 1234,
          backlog: 42,
        });

        assert.equal(receivedOptions.host, "127.0.0.1");
        assert.equal(receivedOptions.port, 1234);
        assert.equal(receivedOptions.backlog, 42);

        await server.close();
      },
    );

    // FIXME: `tcp-bind` does not work anymore
    t.skip("can use a systemd socket", async () => {
      const SD_LISTEN_FDS_START = 3;

      const server = HttpServerPlus.create();
      const fd = tcpBind(0);

      const env = process.env;
      env.LISTEN_FDS = fd - SD_LISTEN_FDS_START + 1;
      env.LISTEN_PID = process.pid;

      await server.listen({
        systemdSocket: fd - SD_LISTEN_FDS_START, // systemd fds start at 3 but we have not control over it in Node.
      });

      delete env.LISTEN_FDS;
      delete env.LISTEN_PID;

      await server.close();
    });

    await t.test("can use a socket", async () => {
      const dir = fs.mkdtempSync(path.join(os.tmpdir(), "http-server-plus-"));
      const socket = path.join(dir, "http.sock");

      const server = HttpServerPlus.create(function (request, response) {
        response.end("ok");
      });

      try {
        const niceAddress = await server.listen({ socket });
        assert.equal(niceAddress, "http://" + socket);

        const { body, statusCode } = await get({
          socketPath: socket,
          path: "/",
        });
        assert.equal(statusCode, 200);
        assert.equal(body, "ok");
      } finally {
        await server.close();
        fs.rmSync(dir, { force: true, recursive: true });
      }
    });

    await t.test("can use a HTTPS certificate", async () => {
      let receivedOpts;
      const fakeServer = new EventEmitter();
      fakeServer.listen = function () {
        setImmediate(function () {
          fakeServer.emit("listening");
        });
      };
      fakeServer.address = function () {
        return { address: "127.0.0.1", port: 443 };
      };
      fakeServer.close = function () {
        // real `http.Server#close` is always asynchronous; matching that
        // matters here since `Server.prototype.close` closes servers before
        // it starts listening for the aggregate `close` event
        setImmediate(function () {
          fakeServer.emit("close");
        });
      };

      const server = HttpServerPlus.create({
        createSecureServer: function (opts) {
          receivedOpts = opts;
          return fakeServer;
        },
      });

      const niceAddress = await server.listen({
        hostname: "127.0.0.1",
        cert: "cert",
        key: "key",
      });

      assert.equal(receivedOpts.cert, "cert");
      assert.equal(receivedOpts.key, "key");
      assert.match(niceAddress, /^https:\/\/127\.0\.0\.1:443$/);

      await server.close();
    });

    await t.test(
      "returns a promise which will resolve once listening",
      async () => {
        const server = HttpServerPlus.create();

        const niceAddress = await server.listen({
          hostname: "127.0.0.1",
          port: 0,
        });
        assert.equal(typeof niceAddress, "string");

        await server.close();
      },
    );

    await t.test("returns a promise which will reject if failure", async () => {
      const server1 = HttpServerPlus.create();
      await server1.listen({ hostname: "127.0.0.1", port: 0 });
      const { port } = server1.addresses()[0];

      const server2 = HttpServerPlus.create();
      await assert.rejects(
        server2.listen({ hostname: "127.0.0.1", port }),
        function (error) {
          assert.equal(error.code, "EADDRINUSE");
          assert.equal(typeof error.niceAddress, "string");
          return true;
        },
      );

      await server1.close();
    });
  });

  await t.test(".close()", async (t) => {
    await t.test("closes all servers", async () => {
      const server = HttpServerPlus.create();
      await server.listen({ hostname: "127.0.0.1", port: 0 });
      await server.listen({ hostname: "127.0.0.1", port: 0 });
      assert.equal(server.addresses().length, 2);

      await server.close();
      assert.equal(server.addresses().length, 0);
    });

    await t.test(
      "emit the `close` event when all servers are closed",
      async () => {
        const server = HttpServerPlus.create();
        await server.listen({ hostname: "127.0.0.1", port: 0 });

        let closed = false;
        server.on("close", function () {
          closed = true;
        });

        await server.close();
        assert.equal(closed, true);
      },
    );

    await t.test(
      "emit the `close` event even if there are no servers",
      async () => {
        const server = HttpServerPlus.create();

        let closed = false;
        server.on("close", function () {
          closed = true;
        });

        await server.close();
        assert.equal(closed, true);
      },
    );
  });

  await t.test(".ref() / .unref()", async (t) => {
    await t.test("return the instance for chaining", async () => {
      const server = HttpServerPlus.create();
      assert.equal(server.ref(), server);
      assert.equal(server.unref(), server);
    });
  });

  await t.test("error handling", async (t) => {
    await t.test(
      "does not forward errors happening during the initial listen attempt",
      async () => {
        const server1 = HttpServerPlus.create();
        await server1.listen({ hostname: "127.0.0.1", port: 0 });
        const { port } = server1.addresses()[0];

        const server2 = HttpServerPlus.create();
        let forwarded = false;
        server2.on("error", function () {
          forwarded = true;
        });

        await assert.rejects(server2.listen({ hostname: "127.0.0.1", port }));
        assert.equal(forwarded, false);

        await server1.close();
      },
    );

    await t.test(
      "forwards errors happening after the server started listening",
      async () => {
        const fakeServer = new EventEmitter();
        fakeServer.listen = function () {
          setImmediate(function () {
            fakeServer.emit("listening");
          });
        };
        fakeServer.address = function () {
          return { address: "127.0.0.1", port: 1234 };
        };
        fakeServer.close = function () {
          setImmediate(function () {
            fakeServer.emit("close");
          });
        };

        const server = HttpServerPlus.create({
          createServer: function () {
            return fakeServer;
          },
        });

        await server.listen({ hostname: "127.0.0.1", port: 0 });

        const error = new Error("boom");
        const received = await new Promise(function (resolve) {
          server.once("error", resolve);
          fakeServer.emit("error", error);
        });
        assert.equal(received, error);

        await server.close();
      },
    );
  });

  await t.test("can be used exactly like `{http,https}.Server`");
});