123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786
// Copyright 2010 The Go Authors. All rights reserved.// Use of this source code is governed by a BSD-style// license that can be found in the LICENSE file.
// Ported from// https://github.com/golang/go/blob/master/src/net/http/responsewrite_test.go
import { TextProtoReader } from "../textproto/mod.ts";import {  assert,  assertEquals,  assertMatch,  assertRejects,  assertStringIncludes,} from "../testing/asserts.ts";import {  Response,  serve,  Server,  ServerRequest,  serveTLS,} from "./server_legacy.ts";import { Buffer, BufReader, BufWriter } from "../io/buffer.ts";import { readAll, writeAll } from "../streams/conversion.ts";import { delay } from "../async/delay.ts";import { mockConn } from "./_mock_conn.ts";import { dirname, fromFileUrl, join, resolve } from "../path/mod.ts";
const moduleDir = dirname(fromFileUrl(import.meta.url));const testdataDir = resolve(moduleDir, "testdata");
interface ResponseTest {  response: Response;  raw: string;}
const responseTests: ResponseTest[] = [  // Default response  {    response: {},    raw: "HTTP/1.1 200 OK\r\n" + "content-length: 0" + "\r\n\r\n",  },  // Empty body with status  {    response: {      status: 404,    },    raw: "HTTP/1.1 404 Not Found\r\n" + "content-length: 0" + "\r\n\r\n",  },  {    response: {      status: 893,      statusText: "Custom error",    },    raw: "HTTP/1.1 893 Custom error\r\n" + "content-length: 0" + "\r\n\r\n",  },  {    response: {      status: 893,      statusText: "",    },    raw: "HTTP/1.1 893 \r\n" + "content-length: 0" + "\r\n\r\n",  },  // HTTP/1.1, chunked coding; empty trailer; close  {    response: {      status: 200,      body: new Buffer(new TextEncoder().encode("abcdef")),    },
    raw: "HTTP/1.1 200 OK\r\n" +      "transfer-encoding: chunked\r\n\r\n" +      "6\r\nabcdef\r\n0\r\n\r\n",  },];
Deno.test("responseWrite", async function () {  for (const testCase of responseTests) {    const buf = new Buffer();    const bufw = new BufWriter(buf);    const request = new ServerRequest();    request.w = bufw;
    request.conn = mockConn();
    await request.respond(testCase.response);    assertEquals(new TextDecoder().decode(buf.bytes()), testCase.raw);    await request.done;  }});
Deno.test("requestContentLength", function (): void {  // Has content length  {    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("content-length", "5");    const buf = new Buffer(new TextEncoder().encode("Hello"));    req.r = new BufReader(buf);    assertEquals(req.contentLength, 5);  }  // No content length  {    const shortText = "Hello";    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("transfer-encoding", "chunked");    let chunksData = "";    let chunkOffset = 0;    const maxChunkSize = 70;    while (chunkOffset < shortText.length) {      const chunkSize = Math.min(maxChunkSize, shortText.length - chunkOffset);      chunksData += `${chunkSize.toString(16)}\r\n${        shortText.substr(chunkOffset, chunkSize)      }\r\n`;      chunkOffset += chunkSize;    }    chunksData += "0\r\n\r\n";    const buf = new Buffer(new TextEncoder().encode(chunksData));    req.r = new BufReader(buf);    assertEquals(req.contentLength, null);  }});
interface TotalReader extends Deno.Reader {  total: number;}function totalReader(r: Deno.Reader): TotalReader {  let _total = 0;  async function read(p: Uint8Array): Promise<number | null> {    const result = await r.read(p);    if (typeof result === "number") {      _total += result;    }    return result;  }  return {    read,    get total(): number {      return _total;    },  };}Deno.test("requestBodyWithContentLength", async function () {  {    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("content-length", "5");    const buf = new Buffer(new TextEncoder().encode("Hello"));    req.r = new BufReader(buf);    const body = new TextDecoder().decode(await readAll(req.body));    assertEquals(body, "Hello");  }
  // Larger than internal buf  {    const longText = "1234\n".repeat(1000);    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("Content-Length", "5000");    const buf = new Buffer(new TextEncoder().encode(longText));    req.r = new BufReader(buf);    const body = new TextDecoder().decode(await readAll(req.body));    assertEquals(body, longText);  }  // Handler ignored to consume body});Deno.test(  "ServerRequest.finalize() should consume unread body / content-length",  async () => {    const text = "deno.land";    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("content-length", "" + text.length);    const tr = totalReader(new Buffer(new TextEncoder().encode(text)));    req.r = new BufReader(tr);    req.w = new BufWriter(new Buffer());    await req.respond({ status: 200, body: "ok" });    assertEquals(tr.total, 0);    await req.finalize();    assertEquals(tr.total, text.length);  },);Deno.test(  "ServerRequest.finalize() should consume unread body / chunked, trailers",  async () => {    const text = [      "5",      "Hello",      "4",      "Deno",      "0",      "",      "deno: land",      "node: js",      "",      "",    ].join("\r\n");    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("transfer-encoding", "chunked");    req.headers.set("trailer", "deno,node");    const body = new TextEncoder().encode(text);    const tr = totalReader(new Buffer(body));    req.r = new BufReader(tr);    req.w = new BufWriter(new Buffer());    await req.respond({ status: 200, body: "ok" });    assertEquals(tr.total, 0);    assertEquals(req.headers.has("trailer"), true);    assertEquals(req.headers.has("deno"), false);    assertEquals(req.headers.has("node"), false);    await req.finalize();    assertEquals(tr.total, body.byteLength);    assertEquals(req.headers.has("trailer"), false);    assertEquals(req.headers.get("deno"), "land");    assertEquals(req.headers.get("node"), "js");  },);Deno.test("requestBodyWithTransferEncoding", async function () {  {    const shortText = "Hello";    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("transfer-encoding", "chunked");    let chunksData = "";    let chunkOffset = 0;    const maxChunkSize = 70;    while (chunkOffset < shortText.length) {      const chunkSize = Math.min(maxChunkSize, shortText.length - chunkOffset);      chunksData += `${chunkSize.toString(16)}\r\n${        shortText.substr(chunkOffset, chunkSize)      }\r\n`;      chunkOffset += chunkSize;    }    chunksData += "0\r\n\r\n";    const buf = new Buffer(new TextEncoder().encode(chunksData));    req.r = new BufReader(buf);    const body = new TextDecoder().decode(await readAll(req.body));    assertEquals(body, shortText);  }
  // Larger than internal buf  {    const longText = "1234\n".repeat(1000);    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("transfer-encoding", "chunked");    let chunksData = "";    let chunkOffset = 0;    const maxChunkSize = 70;    while (chunkOffset < longText.length) {      const chunkSize = Math.min(maxChunkSize, longText.length - chunkOffset);      chunksData += `${chunkSize.toString(16)}\r\n${        longText.substr(chunkOffset, chunkSize)      }\r\n`;      chunkOffset += chunkSize;    }    chunksData += "0\r\n\r\n";    const buf = new Buffer(new TextEncoder().encode(chunksData));    req.r = new BufReader(buf);    const body = new TextDecoder().decode(await readAll(req.body));    assertEquals(body, longText);  }});
Deno.test("requestBodyReaderWithContentLength", async function (): Promise<  void> {  {    const shortText = "Hello";    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("content-length", "" + shortText.length);    const buf = new Buffer(new TextEncoder().encode(shortText));    req.r = new BufReader(buf);    const readBuf = new Uint8Array(6);    let offset = 0;    while (offset < shortText.length) {      const nread = await req.body.read(readBuf);      assert(nread !== null);      const s = new TextDecoder().decode(readBuf.subarray(0, nread as number));      assertEquals(shortText.substr(offset, nread as number), s);      offset += nread as number;    }    const nread = await req.body.read(readBuf);    assertEquals(nread, null);  }
  // Larger than given buf  {    const longText = "1234\n".repeat(1000);    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("Content-Length", "5000");    const buf = new Buffer(new TextEncoder().encode(longText));    req.r = new BufReader(buf);    const readBuf = new Uint8Array(1000);    let offset = 0;    while (offset < longText.length) {      const nread = await req.body.read(readBuf);      assert(nread !== null);      const s = new TextDecoder().decode(readBuf.subarray(0, nread as number));      assertEquals(longText.substr(offset, nread as number), s);      offset += nread as number;    }    const nread = await req.body.read(readBuf);    assertEquals(nread, null);  }});
Deno.test("requestBodyReaderWithTransferEncoding", async function (): Promise<  void> {  {    const shortText = "Hello";    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("transfer-encoding", "chunked");    let chunksData = "";    let chunkOffset = 0;    const maxChunkSize = 70;    while (chunkOffset < shortText.length) {      const chunkSize = Math.min(maxChunkSize, shortText.length - chunkOffset);      chunksData += `${chunkSize.toString(16)}\r\n${        shortText.substr(chunkOffset, chunkSize)      }\r\n`;      chunkOffset += chunkSize;    }    chunksData += "0\r\n\r\n";    const buf = new Buffer(new TextEncoder().encode(chunksData));    req.r = new BufReader(buf);    const readBuf = new Uint8Array(6);    let offset = 0;    while (offset < shortText.length) {      const nread = await req.body.read(readBuf);      assert(nread !== null);      const s = new TextDecoder().decode(readBuf.subarray(0, nread as number));      assertEquals(shortText.substr(offset, nread as number), s);      offset += nread as number;    }    const nread = await req.body.read(readBuf);    assertEquals(nread, null);  }
  // Larger than internal buf  {    const longText = "1234\n".repeat(1000);    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("transfer-encoding", "chunked");    let chunksData = "";    let chunkOffset = 0;    const maxChunkSize = 70;    while (chunkOffset < longText.length) {      const chunkSize = Math.min(maxChunkSize, longText.length - chunkOffset);      chunksData += `${chunkSize.toString(16)}\r\n${        longText.substr(chunkOffset, chunkSize)      }\r\n`;      chunkOffset += chunkSize;    }    chunksData += "0\r\n\r\n";    const buf = new Buffer(new TextEncoder().encode(chunksData));    req.r = new BufReader(buf);    const readBuf = new Uint8Array(1000);    let offset = 0;    while (offset < longText.length) {      const nread = await req.body.read(readBuf);      assert(nread !== null);      const s = new TextDecoder().decode(readBuf.subarray(0, nread as number));      assertEquals(longText.substr(offset, nread as number), s);      offset += nread as number;    }    const nread = await req.body.read(readBuf);    assertEquals(nread, null);  }});
Deno.test({  name: "destroyed connection",  ignore: Deno.build.os == "windows",  fn: async () => {    // Runs a simple server as another process    const p = Deno.run({      cmd: [        Deno.execPath(),        "run",        "--quiet",        "--allow-net",        "testdata/simple_server_legacy.ts",      ],      cwd: moduleDir,      stdout: "piped",    });
    let serverIsRunning = true;    const statusPromise = p      .status()      .then((): void => {        serverIsRunning = false;      })      .catch((_): void => {}); // Ignores the error when closing the process.
    try {      const r = new TextProtoReader(new BufReader(p.stdout));      const s = await r.readLine();      assert(s !== null && s.includes("server listening"));      await delay(100);      // Requests to the server and immediately closes the connection      const conn = await Deno.connect({ port: 4502 });      await conn.write(new TextEncoder().encode("GET / HTTP/1.0\n\n"));      conn.close();      // Waits for the server to handle the above (broken) request      await delay(100);      assert(serverIsRunning);    } finally {      // Stops the sever and allows `p.status()` promise to resolve      Deno.kill(p.pid, "SIGKILL");      await statusPromise;      p.stdout.close();      p.close();    }  },});
Deno.test({  name: "serveTLS",  ignore: Deno.build.os == "windows",  fn: async () => {    // Runs a simple server as another process    const p = Deno.run({      cmd: [        Deno.execPath(),        "run",        "--quiet",        "--allow-net",        "--allow-read",        "testdata/simple_https_server_legacy.ts",      ],      cwd: moduleDir,      stdout: "piped",    });
    let serverIsRunning = true;    const statusPromise = p      .status()      .then((): void => {        serverIsRunning = false;      })      .catch((_): void => {}); // Ignores the error when closing the process.
    try {      const r = new TextProtoReader(new BufReader(p.stdout));      const s = await r.readLine();      assert(        s !== null && s.includes("server listening"),        "server must be started",      );      // Requests to the server and immediately closes the connection      const conn = await Deno.connectTls({        hostname: "localhost",        port: 4503,        certFile: join(testdataDir, "tls/RootCA.pem"),      });      await writeAll(        conn,        new TextEncoder().encode("GET / HTTP/1.0\r\n\r\n"),      );      const res = new Uint8Array(100);      const nread = await conn.read(res);      assert(nread !== null);      conn.close();      const resStr = new TextDecoder().decode(res.subarray(0, nread));      assert(resStr.includes("Hello HTTPS"));      assert(serverIsRunning);    } finally {      // Stops the sever and allows `p.status()` promise to resolve      Deno.kill(p.pid, "SIGKILL");      await statusPromise;      p.stdout.close();      p.close();    }  },});
Deno.test(  "close server while iterating",  async () => {    const server = serve(":8123");    const nextWhileClosing = server[Symbol.asyncIterator]().next();    server.close();    assertEquals(await nextWhileClosing, { value: undefined, done: true });
    const nextAfterClosing = server[Symbol.asyncIterator]().next();    assertEquals(await nextAfterClosing, { value: undefined, done: true });  },);
Deno.test({  name: "[http] close server while connection is open",  async fn() {    async function iteratorReq(server: Server) {      for await (const req of server) {        await req.respond({ body: new TextEncoder().encode(req.url) });      }    }
    const server = serve(":8123");    const p = iteratorReq(server);    const conn = await Deno.connect({ hostname: "127.0.0.1", port: 8123 });    await writeAll(      conn,      new TextEncoder().encode("GET /hello HTTP/1.1\r\n\r\n"),    );    const res = new Uint8Array(100);    const nread = await conn.read(res);    assert(nread !== null);    const resStr = new TextDecoder().decode(res.subarray(0, nread));    assertStringIncludes(resStr, "/hello");    server.close();    await p;    // Client connection should still be open, verify that    // it's visible in resource table.    const resources = Deno.resources();    assertEquals(resources[conn.rid], "tcpStream");    conn.close();  },});
Deno.test({  name: "respond error closes connection",  async fn() {    const serverRoutine = async () => {      const server = serve(":8124");      for await (const req of server) {        await assertRejects(          async () => {            await req.respond({              status: 12345,              body: new TextEncoder().encode("Hello World"),            });          },          Deno.errors.InvalidData,          "Empty statusText",        );        // The connection should be destroyed        assert(!(req.conn.rid in Deno.resources()));        server.close();      }    };    const p = serverRoutine();    const conn = await Deno.connect({      hostname: "127.0.0.1",      port: 8124,    });    await writeAll(      conn,      new TextEncoder().encode("GET / HTTP/1.1\r\n\r\n"),    );    conn.close();    await p;  },});
Deno.test({  name: "[http] request error gets 400 response",  async fn() {    const server = serve(":8124");    const entry = server[Symbol.asyncIterator]().next();    const conn = await Deno.connect({      hostname: "127.0.0.1",      port: 8124,    });    await writeAll(      conn,      new TextEncoder().encode(        "GET / HTTP/1.1\r\nmalformedHeader\r\n\r\n\r\n\r\n",      ),    );    const responseString = new TextDecoder().decode(await readAll(conn));    assertMatch(      responseString,      /^HTTP\/1\.1 400 Bad Request\r\ncontent-length: \d+\r\n\r\n.*\r\n\r\n$/ms,    );    conn.close();    server.close();    assert((await entry).done);  },});
Deno.test({  name: "[http] finalizing invalid chunked data closes connection",  async fn() {    const serverRoutine = async () => {      const server = serve(":8124");      for await (const req of server) {        await req.respond({ status: 200, body: "Hello, world!" });        break;      }      server.close();    };    const p = serverRoutine();    const conn = await Deno.connect({      hostname: "127.0.0.1",      port: 8124,    });    await writeAll(      conn,      new TextEncoder().encode(        "PUT / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\nzzzzzzz\r\nhello",      ),    );    await conn.closeWrite();    const responseString = new TextDecoder().decode(await readAll(conn));    assertEquals(      responseString,      "HTTP/1.1 200 OK\r\ncontent-length: 13\r\n\r\nHello, world!",    );    conn.close();    await p;  },});
Deno.test({  name: "[http] finalizing chunked unexpected EOF closes connection",  async fn() {    const serverRoutine = async () => {      const server = serve(":8124");      for await (const req of server) {        await req.respond({ status: 200, body: "Hello, world!" });        break;      }      server.close();    };    const p = serverRoutine();    const conn = await Deno.connect({      hostname: "127.0.0.1",      port: 8124,    });    await writeAll(      conn,      new TextEncoder().encode(        "PUT / HTTP/1.1\r\nTransfer-Encoding: chunked\r\n\r\n5\r\nHello",      ),    );    conn.closeWrite();    const responseString = new TextDecoder().decode(await readAll(conn));    assertEquals(      responseString,      "HTTP/1.1 200 OK\r\ncontent-length: 13\r\n\r\nHello, world!",    );    conn.close();    await p;  },});
Deno.test({  name:    "[http] receiving bad request from a closed connection should not throw",  async fn() {    const server = serve(":8124");    const serverRoutine = async () => {      for await (const req of server) {        await req.respond({ status: 200, body: "Hello, world!" });      }    };    const p = serverRoutine();    const conn = await Deno.connect({      hostname: "127.0.0.1",      port: 8124,    });    await writeAll(      conn,      new TextEncoder().encode([        // A normal request is required:        "GET / HTTP/1.1",        "Host: localhost",        "",        // The bad request:        "GET / HTTP/1.1",        "Host: localhost",        "INVALID!HEADER!",        "",        "",      ].join("\r\n")),    );    // After sending the two requests, don't receive the responses.
    // Closing the connection now.    conn.close();
    // The server will write responses to the closed connection,    // the first few `write()` calls will not throws, until the server received    // the TCP RST. So we need the normal request before the bad request to    // make the server do a few writes before it writes that `400` response.
    // Wait for server to handle requests.    await delay(10);
    server.close();    await p;  },});
Deno.test({  name: "serveTLS Invalid Cert",  // TODO(kt3k): Enable this test  ignore: true,  fn: async () => {    async function iteratorReq(server: Server) {      for await (const req of server) {        await req.respond({ body: new TextEncoder().encode("Hello HTTPS") });      }    }    const port = 9122;    const tlsOptions = {      hostname: "localhost",      port,      certFile: join(testdataDir, "tls/localhost.crt"),      keyFile: join(testdataDir, "tls/localhost.key"),    };    const server = serveTLS(tlsOptions);    const p = iteratorReq(server);
    try {      // Invalid certificate, connection should throw on first read or write      // but should not crash the server      const badConn = await Deno.connectTls({        hostname: "localhost",        port,        // certFile      });      await assertRejects(        () => badConn.read(new Uint8Array(1)),        Deno.errors.InvalidData,      );      badConn.close();
      // Valid request after invalid      const conn = await Deno.connectTls({        hostname: "localhost",        port,        certFile: join(testdataDir, "tls/RootCA.pem"),      });
      await writeAll(        conn,        new TextEncoder().encode("GET / HTTP/1.0\r\n\r\n"),      );      const res = new Uint8Array(100);      const nread = await conn.read(res);      assert(nread !== null);      conn.close();      const resStr = new TextDecoder().decode(res.subarray(0, nread));      assert(resStr.includes("Hello HTTPS"));    } finally {      // Stops the sever and allows `p.status()` promise to resolve      server.close();      await p;    }  },});
Deno.test({  name: "server.serve() should be able to parse IPV4 address",  fn: (): void => {    const server = serve("127.0.0.1:8124");    const addr = server.listener.addr as Deno.NetAddr;    assertEquals(addr.hostname, "127.0.0.1");    assertEquals(addr.port, 8124);    assertEquals(addr.transport, "tcp");    server.close();  },});
Deno.test({  name: "server.serve() should be able to parse IPV6 address",  fn: (): void => {    const server = serve("[::1]:8124");    const addr = server.listener.addr as Deno.NetAddr;    assertEquals(addr.hostname, "::1");    assertEquals(addr.port, 8124);    assertEquals(addr.transport, "tcp");    server.close();  },});