123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
import EventEmitter from "./events.ts";import http, { type RequestOptions } from "./http.ts";import { ERR_SERVER_NOT_RUNNING } from "./internal/errors.ts";import { assert, assertEquals } from "../testing/asserts.ts";import { deferred } from "../async/deferred.ts";import { gzip } from "./zlib.ts";import { Buffer } from "./buffer.ts";import { serve } from "../http/server.ts";
Deno.test("[node/http listen]", async () => {  {    const server = http.createServer();    assertEquals(0, EventEmitter.listenerCount(server, "request"));  }
  {    const server = http.createServer(() => {});    assertEquals(1, EventEmitter.listenerCount(server, "request"));  }
  {    const promise = deferred<void>();    const server = http.createServer();
    server.listen(() => {      server.close();    });    server.on("close", () => {      promise.resolve();    });
    await promise;  }
  {    const promise = deferred<void>();    const server = http.createServer();
    server.listen().on("listening", () => {      server.close();    });    server.on("close", () => {      promise.resolve();    });
    await promise;  }
  for (const port of [0, -0, 0.0, "0", null, undefined]) {    const promise = deferred<void>();    const server = http.createServer();
    server.listen(port, () => {      server.close();    });    server.on("close", () => {      promise.resolve();    });
    await promise;  }});
Deno.test("[node/http close]", async () => {  {    const promise1 = deferred<void>();    const promise2 = deferred<void>();    // Node quirk: callback gets exception object, event listener does not.    const server = http.createServer().close((err) => {      assert(err instanceof ERR_SERVER_NOT_RUNNING);      promise1.resolve();    });    server.on("close", (err) => {      assertEquals(err, undefined);      promise2.resolve();    });    server.on("listening", () => {      throw Error("unreachable");    });    await promise1;    await promise2;  }
  {    const promise1 = deferred<void>();    const promise2 = deferred<void>();    const server = http.createServer().listen().close((err) => {      assertEquals(err, undefined);      promise1.resolve();    });    server.on("close", (err) => {      assertEquals(err, undefined);      promise2.resolve();    });    server.on("listening", () => {      throw Error("unreachable");    });    await promise1;    await promise2;  }});
Deno.test("[node/http] chunked response", async () => {  for (    const body of [undefined, "", "ok"]  ) {    const expected = body ?? "";    const promise = deferred<void>();
    const server = http.createServer((_req, res) => {      res.writeHead(200, { "transfer-encoding": "chunked" });      res.end(body);    });
    server.listen(async () => {      const res = await fetch(`http://127.0.0.1:${server.address().port}/`);      assert(res.ok);
      const actual = await res.text();      assertEquals(actual, expected);
      server.close(() => promise.resolve());    });
    await promise;  }});
// TODO(kt3k): This test case exercises the workaround for https://github.com/denoland/deno/issues/17194// This should be removed when #17194 is resolved.Deno.test("[node/http] empty chunk in the middle of response", async () => {  const promise = deferred<void>();
  const server = http.createServer((_req, res) => {    res.write("a");    res.write("");    res.write("b");    res.end();  });
  server.listen(async () => {    const res = await fetch(`http://127.0.0.1:${server.address().port}/`);    const actual = await res.text();    assertEquals(actual, "ab");    server.close(() => promise.resolve());  });
  await promise;});
Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async () => {  for (const status of [101, 204, 205, 304]) {    const promise = deferred<void>();    const server = http.createServer((_req, res) => {      res.statusCode = status;      res.end("");    });    server.listen(async () => {      const res = await fetch(`http://127.0.0.1:${server.address().port}/`);      await res.arrayBuffer();      assertEquals(res.status, status);      server.close(() => promise.resolve());    });    await promise;  }});
Deno.test("[node/http] request default protocol", async () => {  const promise = deferred<void>();  const server = http.createServer((_, res) => {    res.end("ok");  });  server.listen(() => {    const req = http.request(      { host: "localhost", port: server.address().port },      (res) => {        res.on("data", () => {});        res.on("end", () => {          server.close();        });        assertEquals(res.statusCode, 200);      },    );    req.end();  });  server.on("close", () => {    promise.resolve();  });  await promise;});
Deno.test("[node/http] request with headers", async () => {  const promise = deferred<void>();  const server = http.createServer((req, res) => {    assertEquals(req.headers["x-foo"], "bar");    res.end("ok");  });  server.listen(() => {    const req = http.request(      {        host: "localhost",        port: server.address().port,        headers: { "x-foo": "bar" },      },      (res) => {        res.on("data", () => {});        res.on("end", () => {          server.close();        });        assertEquals(res.statusCode, 200);      },    );    req.end();  });  server.on("close", () => {    promise.resolve();  });  await promise;});
Deno.test("[node/http] non-string buffer response", async () => {  const promise = deferred<void>();  const server = http.createServer((_, res) => {    gzip(      Buffer.from("a".repeat(100), "utf8"),      {},      (_err: Error, data: Buffer) => {        res.setHeader("Content-Encoding", "gzip");        res.end(data);      },    );  });  server.listen(async () => {    const res = await fetch(`http://localhost:${server.address().port}`);    try {      const text = await res.text();      assertEquals(text, "a".repeat(100));    } catch (e) {      server.emit("error", e);    } finally {      server.close();    }  });  server.on("close", () => {    promise.resolve();  });  await promise;});
Deno.test("[node/http] http.IncomingMessage can be created without url", () => {  const message = new http.IncomingMessage(    // adapted from https://github.com/dougmoscrop/serverless-http/blob/80bfb3e940057d694874a8b0bc12ad96d2abe7ab/lib/request.js#L7    {      // @ts-expect-error - non-request properties will also be passed in, e.g. by serverless-http      encrypted: true,      readable: false,      remoteAddress: "foo",      address: () => ({ port: 443 }),      end: Function.prototype,      destroy: Function.prototype,    },  );  message.url = "https://example.com";});
Deno.test("[node/http] set http.IncomingMessage.statusMessage", () => {  const message = new http.IncomingMessageForClient(    new Response(null, { status: 404, statusText: "Not Found" }),    {      encrypted: true,      readable: false,      remoteAddress: "foo",      // @ts-expect-error - good enough for this test      address() {        return { port: 443, family: "IPv4" };      },      end(_cb) {        return this;      },      destroy(_e) {        return;      },    },  );  assertEquals(message.statusMessage, "Not Found");  message.statusMessage = "boom";  assertEquals(message.statusMessage, "boom");});
Deno.test("[node/http] send request with non-chunked body", async () => {  let requestHeaders: Headers;  let requestBody = "";
  const hostname = "localhost";  const port = 4505;
  // NOTE: Instead of node/http.createServer(), serve() in std/http/server.ts is used.  // https://github.com/denoland/deno_std/pull/2755#discussion_r1005592634  const handler = async (req: Request) => {    requestHeaders = req.headers;    requestBody = await req.text();    return new Response("ok");  };  const abortController = new AbortController();  const servePromise = serve(handler, {    hostname,    port,    signal: abortController.signal,    onListen: undefined,  });
  const opts: RequestOptions = {    host: hostname,    port,    method: "POST",    headers: {      "Content-Type": "text/plain; charset=utf-8",      "Content-Length": "11",    },  };  const req = http.request(opts, (res) => {    res.on("data", () => {});    res.on("end", () => {      abortController.abort();    });    assertEquals(res.statusCode, 200);    assertEquals(requestHeaders.get("content-length"), "11");    assertEquals(requestHeaders.has("transfer-encoding"), false);    assertEquals(requestBody, "hello world");  });  req.write("hello ");  req.write("world");  req.end();
  await servePromise;});
Deno.test("[node/http] send request with chunked body", async () => {  let requestHeaders: Headers;  let requestBody = "";
  const hostname = "localhost";  const port = 4505;
  // NOTE: Instead of node/http.createServer(), serve() in std/http/server.ts is used.  // https://github.com/denoland/deno_std/pull/2755#discussion_r1005592634  const handler = async (req: Request) => {    requestHeaders = req.headers;    requestBody = await req.text();    return new Response("ok");  };  const abortController = new AbortController();  const servePromise = serve(handler, {    hostname,    port,    signal: abortController.signal,    onListen: undefined,  });
  const opts: RequestOptions = {    host: hostname,    port,    method: "POST",    headers: {      "Content-Type": "text/plain; charset=utf-8",      "Content-Length": "11",      "Transfer-Encoding": "chunked",    },  };  const req = http.request(opts, (res) => {    res.on("data", () => {});    res.on("end", () => {      abortController.abort();    });    assertEquals(res.statusCode, 200);    assertEquals(requestHeaders.has("content-length"), false);    assertEquals(requestHeaders.get("transfer-encoding"), "chunked");    assertEquals(requestBody, "hello world");  });  req.write("hello ");  req.write("world");  req.end();
  await servePromise;});
Deno.test("[node/http] send request with chunked body as default", async () => {  let requestHeaders: Headers;  let requestBody = "";
  const hostname = "localhost";  const port = 4505;
  // NOTE: Instead of node/http.createServer(), serve() in std/http/server.ts is used.  // https://github.com/denoland/deno_std/pull/2755#discussion_r1005592634  const handler = async (req: Request) => {    requestHeaders = req.headers;    requestBody = await req.text();    return new Response("ok");  };  const abortController = new AbortController();  const servePromise = serve(handler, {    hostname,    port,    signal: abortController.signal,    onListen: undefined,  });
  const opts: RequestOptions = {    host: hostname,    port,    method: "POST",    headers: {      "Content-Type": "text/plain; charset=utf-8",    },  };  const req = http.request(opts, (res) => {    res.on("data", () => {});    res.on("end", () => {      abortController.abort();    });    assertEquals(res.statusCode, 200);    assertEquals(requestHeaders.has("content-length"), false);    assertEquals(requestHeaders.get("transfer-encoding"), "chunked");    assertEquals(requestBody, "hello world");  });  req.write("hello ");  req.write("world");  req.end();
  await servePromise;});