123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503
// 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, assertNotEOF } from "../testing/asserts.ts";import { Response, ServerRequest, serve } from "./server.ts";import { BufReader, BufWriter } from "../io/bufio.ts";import { delay, deferred } from "../util/async.ts";import { encode, decode } from "../strings/mod.ts";import { mockConn } from "./mock.ts";
const { Buffer, test } = Deno;
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"  },  // 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"  }];
test(async function responseWrite(): Promise<void> {  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(buf.toString(), testCase.raw);    await request.done;  }});
test(async function requestContentLength(): Promise<void> {  // Has content length  {    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("content-length", "5");    const buf = new Buffer(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(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 | Deno.EOF> {    const result = await r.read(p);    if (typeof result === "number") {      _total += result;    }    return result;  }  return {    read,    get total(): number {      return _total;    }  };}test(async function requestBodyWithContentLength(): Promise<void> {  {    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("content-length", "5");    const buf = new Buffer(encode("Hello"));    req.r = new BufReader(buf);    const body = decode(await Deno.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(encode(longText));    req.r = new BufReader(buf);    const body = decode(await Deno.readAll(req.body));    assertEquals(body, longText);  }  // Handler ignored to consume body});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(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);});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 = 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");});test(async function requestBodyWithTransferEncoding(): 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(encode(chunksData));    req.r = new BufReader(buf);    const body = decode(await Deno.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(encode(chunksData));    req.r = new BufReader(buf);    const body = decode(await Deno.readAll(req.body));    assertEquals(body, longText);  }});
test(async function requestBodyReaderWithContentLength(): Promise<void> {  {    const shortText = "Hello";    const req = new ServerRequest();    req.headers = new Headers();    req.headers.set("content-length", "" + shortText.length);    const buf = new Buffer(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);      assertNotEOF(nread);      const s = 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, Deno.EOF);  }
  // 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(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);      assertNotEOF(nread);      const s = 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, Deno.EOF);  }});
test(async function requestBodyReaderWithTransferEncoding(): 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(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);      assertNotEOF(nread);      const s = 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, Deno.EOF);  }
  // 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(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);      assertNotEOF(nread);      const s = 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, Deno.EOF);  }});
test("destroyed connection", async (): Promise<void> => {  // Runs a simple server as another process  const p = Deno.run({    args: [Deno.execPath(), "--allow-net", "http/testdata/simple_server.ts"],    stdout: "piped"  });
  try {    const r = new TextProtoReader(new BufReader(p.stdout!));    const s = await r.readLine();    assert(s !== Deno.EOF && s.includes("server listening"));
    let serverIsRunning = true;    p.status()      .then((): void => {        serverIsRunning = false;      })      .catch((_): void => {}); // Ignores the error when closing the process.
    await delay(100);
    // Reqeusts 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.    p.close();  }});
test("serveTLS", async (): Promise<void> => {  // Runs a simple server as another process  const p = Deno.run({    args: [      Deno.execPath(),      "--allow-net",      "--allow-read",      "http/testdata/simple_https_server.ts"    ],    stdout: "piped"  });
  try {    const r = new TextProtoReader(new BufReader(p.stdout!));    const s = await r.readLine();    assert(      s !== Deno.EOF && s.includes("server listening"),      "server must be started"    );
    let serverIsRunning = true;    p.status()      .then((): void => {        serverIsRunning = false;      })      .catch((_): void => {}); // Ignores the error when closing the process.
    // Requests to the server and immediately closes the connection    const conn = await Deno.connectTLS({      hostname: "localhost",      port: 4503,      certFile: "http/testdata/tls/RootCA.pem"    });    await Deno.writeAll(      conn,      new TextEncoder().encode("GET / HTTP/1.0\r\n\r\n")    );    const res = new Uint8Array(100);    const nread = assertNotEOF(await conn.read(res));    conn.close();    const resStr = new TextDecoder().decode(res.subarray(0, nread));    assert(resStr.includes("Hello HTTPS"));    assert(serverIsRunning);  } finally {    // Stops the sever.    p.close();  }});
test("close server while iterating", async (): Promise<void> => {  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 });});
// TODO(kevinkassimo): create a test that works on Windows.// The following test is to ensure that if an error occurs during respond// would result in connection closed. (such that fd/resource is freed).// On *nix, a delayed second attempt to write to a CLOSE_WAIT connection would// receive a RST and thus trigger an error during response for us to test.// We need to find a way to similarly trigger an error on Windows so that// we can test if connection is closed.if (Deno.build.os !== "win") {  test("respond error handling", async (): Promise<void> => {    const connClosedPromise = deferred();    const serverRoutine = async (): Promise<void> => {      let reqCount = 0;      const server = serve(":8124");      // @ts-ignore      const serverRid = server.listener["rid"];      let connRid = -1;      for await (const req of server) {        connRid = req.conn.rid;        reqCount++;        await Deno.readAll(req.body);        await connClosedPromise;        try {          await req.respond({            body: new TextEncoder().encode("Hello World")          });          await delay(100);          req.done = deferred();          // This duplicate respond is to ensure we get a write failure from the          // other side. Our client would enter CLOSE_WAIT stage after close(),          // meaning first server .send (.respond) after close would still work.          // However, a second send would fail under RST, which is similar          // to the scenario where a failure happens during .respond          await req.respond({            body: new TextEncoder().encode("Hello World")          });        } catch {          break;        }      }      server.close();      const resources = Deno.resources();      assert(reqCount === 1);      // Server should be gone      assert(!(serverRid in resources));      // The connection should be destroyed      assert(!(connRid in resources));    };    const p = serverRoutine();    const conn = await Deno.connect({      hostname: "127.0.0.1",      port: 8124    });    await Deno.writeAll(      conn,      new TextEncoder().encode("GET / HTTP/1.1\r\n\r\n")    );    conn.close(); // abruptly closing connection before response.    // conn on server side enters CLOSE_WAIT state.    connClosedPromise.resolve();    await p;  });}