Skip to main content
Using Deno in production at your company? Earn free Deno merch.
Give us feedback
Module

std/http/server_test.ts

Deno standard library
Go to Latest
File
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632
// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.import { type ConnInfo, serve, serveListener, Server, serveTls,} from "./server.ts";import { mockConn as createMockConn } from "./_mock_conn.ts";import { dirname, fromFileUrl, join, resolve } from "../path/mod.ts";import { writeAll } from "../io/write_all.ts";import { readAll } from "../io/read_all.ts";import { delay } from "../async/mod.ts";import { assert, assertEquals, assertNotEquals, assertRejects, assertStrictEquals, assertThrows, unreachable,} from "../assert/mod.ts";
const moduleDir = dirname(fromFileUrl(import.meta.url));const testdataDir = resolve(moduleDir, "testdata");
let port = 4800;function getPort() { return port++;}
type AcceptCallSideEffect = ({ acceptCallCount,}: { acceptCallCount: number;}) => void | Promise<void>;
class MockListener implements Deno.Listener { conn: Deno.Conn; #closed = false; #rejectionError?: Error; #rejectionCount: number; #acceptCallSideEffect: AcceptCallSideEffect; acceptCallTimes: number[] = []; acceptCallIntervals: number[] = []; acceptCallCount = 0;
constructor({ conn, rejectionError, rejectionCount = Infinity, acceptCallSideEffect = () => {}, }: { conn: Deno.Conn; rejectionError?: Error; rejectionCount?: number; acceptCallSideEffect?: AcceptCallSideEffect; }) { this.conn = conn; this.#rejectionError = rejectionError; this.#rejectionCount = rejectionCount; this.#acceptCallSideEffect = acceptCallSideEffect; }
get addr(): Deno.Addr { return this.conn.localAddr; }
get rid(): number { return 4505; }
#shouldReject(): boolean { return ( typeof this.#rejectionError !== "undefined" && this.acceptCallCount <= this.#rejectionCount ); }
async accept(): Promise<Deno.Conn> { if (this.#closed) { throw new Deno.errors.BadResource("MockListener has closed"); }
const now = performance.now(); this.acceptCallIntervals.push(now - (this.acceptCallTimes.at(-1) ?? now)); this.acceptCallTimes.push(now); this.acceptCallCount++; this.#acceptCallSideEffect({ acceptCallCount: this.acceptCallCount });
await delay(0);
return this.#shouldReject() ? Promise.reject(this.#rejectionError) : Promise.resolve(this.conn); }
[Symbol.dispose]() { this.close(); }
close() { this.#closed = true; }
async *[Symbol.asyncIterator](): AsyncIterableIterator<Deno.Conn> { while (true) { if (this.#closed) { break; }
const now = performance.now(); this.acceptCallIntervals.push(now - (this.acceptCallTimes.at(-1) ?? now)); this.acceptCallTimes.push(now); this.acceptCallCount++; this.#acceptCallSideEffect({ acceptCallCount: this.acceptCallCount });
await delay(0);
if (this.#shouldReject()) { throw this.#rejectionError; }
yield this.conn; } }
ref() { }
unref() { }}
Deno.test( "Server exposes the addresses the server is listening on as addrs property", async () => { const listenerOneOptions = { hostname: "127.0.0.1", port: getPort(), }; const listenerTwoOptions = { hostname: "127.0.0.1", port: getPort(), }; const listenerOne = Deno.listen(listenerOneOptions); const listenerTwo = Deno.listen(listenerTwoOptions);
const addrHostname = "0.0.0.0"; const addrPort = getPort(); const handler = () => new Response();
const server = new Server({ port: addrPort, hostname: addrHostname, handler, }); const servePromiseOne = server.serve(listenerOne); const servePromiseTwo = server.serve(listenerTwo); const servePromiseThree = server.listenAndServe();
try { assertEquals(server.addrs.length, 3); assertEquals(server.addrs[0]!.transport, "tcp"); assertEquals( (server.addrs[0] as Deno.NetAddr).hostname, listenerOneOptions.hostname, ); assertEquals( (server.addrs[0] as Deno.NetAddr).port, listenerOneOptions.port, ); assertEquals(server.addrs[1]!.transport, "tcp"); assertEquals( (server.addrs[1] as Deno.NetAddr).hostname, listenerTwoOptions.hostname, ); assertEquals( (server.addrs[1] as Deno.NetAddr).port, listenerTwoOptions.port, ); assertEquals(server.addrs[2]!.transport, "tcp"); assertEquals((server.addrs[2] as Deno.NetAddr).hostname, addrHostname); assertEquals((server.addrs[2] as Deno.NetAddr).port, addrPort); } finally { server.close(); await servePromiseOne; await servePromiseTwo; await servePromiseThree; } },);
Deno.test("Server exposes whether the server is closed as closed property", () => { const handler = () => new Response(); const server = new Server({ handler }); try { assertEquals(server.closed, false); } finally { server.close(); assertEquals(server.closed, true); }});
Deno.test( "Server.close() throws an error if the server is already closed", () => { const handler = () => new Response(); const server = new Server({ handler }); server.close();
assertThrows(() => server.close(), Deno.errors.Http, "Server closed"); },);
Deno.test( "Server.serve() throws an error if the server is already closed", async () => { const handler = () => new Response(); const server = new Server({ handler }); server.close();
const listenOptions = { hostname: "localhost", port: getPort(), }; using listener = Deno.listen(listenOptions);
await assertRejects( () => server.serve(listener), Deno.errors.Http, "Server closed", ); },);
Deno.test( "Server.listenAndServe() throws an error if the server is already closed", async () => { const handler = () => new Response(); const server = new Server({ handler }); server.close();
await assertRejects( () => server.listenAndServe(), Deno.errors.Http, "Server closed", ); },);
Deno.test( "Server.listenAndServeTls() throws an error if the server is already closed", async () => { const handler = () => new Response(); const server = new Server({ handler }); server.close();
const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key");
await assertRejects( () => server.listenAndServeTls(certFile, keyFile), Deno.errors.Http, "Server closed", ); },);
Deno.test( "serveListener() does not overwrite an abort signal handler", async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions); const handler = () => new Response(); const onAbort = () => {}; const abortController = new AbortController();
abortController.signal.onabort = onAbort;
const servePromise = serveListener(listener, handler, { signal: abortController.signal, });
try { assertStrictEquals(abortController.signal.onabort, onAbort); } finally { abortController.abort(); await servePromise; } },);
Deno.test( "serve() does not overwrite an abort signal handler", async () => { const handler = () => new Response(); const onAbort = () => {}; const abortController = new AbortController();
abortController.signal.onabort = onAbort;
const servePromise = serve(handler, { hostname: "localhost", port: getPort(), signal: abortController.signal, });
try { assertStrictEquals(abortController.signal.onabort, onAbort); } finally { abortController.abort(); await servePromise; } },);
Deno.test( "serveTls() not overwrite an abort signal handler", async () => { const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key"); const handler = () => new Response(); const onAbort = () => {}; const abortController = new AbortController();
abortController.signal.onabort = onAbort;
const servePromise = serveTls(handler, { hostname: "localhost", port: getPort(), certFile, keyFile, signal: abortController.signal, });
try { assertStrictEquals(abortController.signal.onabort, onAbort); } finally { abortController.abort(); await servePromise; } },);
Deno.test( "serveListener() does not throw if abort when the server is already closed", async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions); const handler = () => new Response(); const abortController = new AbortController();
const servePromise = serveListener(listener, handler, { signal: abortController.signal, });
abortController.abort();
try { abortController.abort(); } finally { await servePromise; } },);
Deno.test( "serve() does not throw if abort when the server is already closed", async () => { const handler = () => new Response(); const abortController = new AbortController();
const servePromise = serve(handler, { hostname: "localhost", port: getPort(), signal: abortController.signal, });
abortController.abort();
try { abortController.abort(); } finally { await servePromise; } },);
Deno.test( "serveTls() does not throw if abort when the server is already closed", async () => { const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key"); const handler = () => new Response(); const abortController = new AbortController();
const servePromise = serveTls(handler, { hostname: "localhost", port: getPort(), certFile, keyFile, signal: abortController.signal, });
abortController.abort();
try { abortController.abort(); } finally { await servePromise; } },);
Deno.test(`Server.serve() responds with internal server error if response body is already consumed`, async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions);
const url = `http://${listenOptions.hostname}:${listenOptions.port}`; const body = "Internal Server Error"; const status = 500;
async function handler() { const response = new Response("Hello, world!"); await response.text(); return response; }
const server = new Server({ handler }); const servePromise = server.serve(listener);
try { const response = await fetch(url); assertEquals(await response.text(), body); assertEquals(response.status, status); } finally { server.close(); await servePromise; }});
Deno.test(`Server.serve() handles requests`, async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions);
const url = `http://${listenOptions.hostname}:${listenOptions.port}`; const status = 418; const method = "GET"; const body = `${method}: ${url} - Hello Deno on HTTP!`;
const handler = () => new Response(body, { status });
const server = new Server({ handler }); const servePromise = server.serve(listener);
try { const response = await fetch(url, { method }); assertEquals(await response.text(), body); assertEquals(response.status, status); } finally { server.close(); await servePromise; }});
Deno.test(`Server.listenAndServe() handles requests`, async () => { const hostname = "localhost"; const port = getPort(); const url = `http://${hostname}:${port}`; const status = 418; const method = "POST"; const body = `${method}: ${url} - Hello Deno on HTTP!`;
const handler = () => new Response(body, { status });
const server = new Server({ hostname, port, handler }); const servePromise = server.listenAndServe();
try { const response = await fetch(url, { method }); assertEquals(await response.text(), body); assertEquals(response.status, status); } finally { server.close(); await servePromise; }});
Deno.test({ // PermissionDenied: Permission denied (os error 13) // Will pass if run as root user. ignore: true, name: `Server.listenAndServe() handles requests on the default HTTP port`, fn: async () => { const addr = "localhost"; const url = `http://${addr}`; const status = 418; const method = "PATCH"; const body = `${method}: ${url} - Hello Deno on HTTP!`;
const handler = () => new Response(body, { status });
const server = new Server({ hostname: addr, handler }); const servePromise = server.listenAndServe();
try { const response = await fetch(url, { method }); assertEquals(await response.text(), body); assertEquals(response.status, status); } finally { server.close(); await servePromise; } },});
Deno.test(`Server.listenAndServeTls() handles requests`, async () => { const hostname = "localhost"; const port = getPort(); const addr = `${hostname}:${port}`; const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key"); const url = `http://${addr}`; const status = 418; const method = "DELETE"; const body = `${method}: ${url} - Hello Deno on HTTPS!`;
const handler = () => new Response(body, { status });
const server = new Server({ hostname, port, handler }); const servePromise = server.listenAndServeTls(certFile, keyFile);
try { // Invalid certificate, connection should throw on first read or write // but should not crash the server. using badConn = await Deno.connectTls({ hostname, port, // missing certFile });
await assertRejects( () => badConn.read(new Uint8Array(1)), Deno.errors.InvalidData, "invalid peer certificate: UnknownIssuer", "Read with missing certFile didn't throw an InvalidData error when it should have.", );
// Valid request after invalid using conn = await Deno.connectTls({ hostname, port, certFile: join(testdataDir, "tls/RootCA.pem"), });
await writeAll( conn, new TextEncoder().encode(`${method.toUpperCase()} / HTTP/1.0\r\n\r\n`), );
const response = new TextDecoder().decode(await readAll(conn));
assert(response.includes(`HTTP/1.0 ${status}`), "Status code not correct"); assert(response.includes(body), "Response body not correct"); } finally { server.close(); await servePromise; }});
Deno.test({ // PermissionDenied: Permission denied (os error 13) // Will pass if run as root user. ignore: true, name: `Server.listenAndServeTls() handles requests on the default HTTPS port`, fn: async () => { const hostname = "localhost"; const port = 443; const addr = hostname; const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key"); const url = `http://${addr}`; const status = 418; const method = "PUT"; const body = `${method}: ${url} - Hello Deno on HTTPS!`;
const handler = () => new Response(body, { status });
const server = new Server({ hostname, port, handler }); const servePromise = server.listenAndServeTls(certFile, keyFile);
try { // Invalid certificate, connection should throw on first read or write // but should not crash the server. using badConn = await Deno.connectTls({ hostname, port, // missing certFile });
await assertRejects( () => badConn.read(new Uint8Array(1)), Deno.errors.InvalidData, "invalid peer certificate contents: invalid peer certificate: UnknownIssuer", "Read with missing certFile didn't throw an InvalidData error when it should have.", );
// Valid request after invalid using conn = await Deno.connectTls({ hostname, port, certFile: join(testdataDir, "tls/RootCA.pem"), });
await writeAll( conn, new TextEncoder().encode(`${method.toUpperCase()} / HTTP/1.0\r\n\r\n`), );
const response = new TextDecoder().decode(await readAll(conn));
assert( response.includes(`HTTP/1.0 ${status}`), "Status code not correct", ); assert(response.includes(body), "Response body not correct"); } finally { server.close(); await servePromise; } },});
Deno.test(`serve() handles requests`, async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions);
const url = `http://${listenOptions.hostname}:${listenOptions.port}`; const status = 418; const method = "GET"; const body = `${method}: ${url} - Hello Deno on HTTP!`;
const handler = () => new Response(body, { status }); const abortController = new AbortController();
const servePromise = serveListener(listener, handler, { signal: abortController.signal, });
try { const response = await fetch(url, { method }); assertEquals(await response.text(), body); assertEquals(response.status, status); } finally { abortController.abort(); await servePromise; }});
Deno.test(`serve() handles requests`, async () => { const hostname = "localhost"; const port = getPort(); const url = `http://${hostname}:${port}`; const status = 418; const method = "POST"; const body = `${method}: ${url} - Hello Deno on HTTP!`;
const handler = () => new Response(body, { status }); const abortController = new AbortController();
const servePromise = serve(handler, { hostname, port, signal: abortController.signal, });
try { const response = await fetch(url, { method }); assertEquals(await response.text(), body); assertEquals(response.status, status); } finally { abortController.abort(); await servePromise; }});
Deno.test(`serve() listens on the port 8000 by default`, async () => { const url = "http://localhost:8000"; const body = "Hello from port 8000";
const handler = () => new Response(body); const abortController = new AbortController();
const servePromise = serve(handler, { signal: abortController.signal, }); servePromise.catch(() => {});
try { const response = await fetch(url); assertEquals(await response.text(), body); } finally { abortController.abort(); await servePromise; }});
Deno.test(`serve() handles websocket requests`, async () => { const hostname = "localhost"; const port = getPort(); const url = `ws://${hostname}:${port}`; const message = `${url} - Hello Deno on WebSocket!`;
const abortController = new AbortController();
const servePromise = serve( (request) => { const { socket, response } = Deno.upgradeWebSocket(request); // Return the received message as it is socket.onmessage = (event) => socket.send(event.data); return response; }, { hostname, port, signal: abortController.signal, }, );
const ws = new WebSocket(url); const closePromise = new Promise((resolve) => { ws.onclose = resolve; }); try { ws.onopen = () => ws.send(message); const response = await new Promise((resolve) => { ws.onmessage = (event) => resolve(event.data); }); assertEquals(response, message); } finally { ws.close(); abortController.abort(); await servePromise; await closePromise; }});
Deno.test(`Server.listenAndServeTls() handles requests`, async () => { const hostname = "localhost"; const port = getPort(); const addr = `${hostname}:${port}`; const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key"); const url = `http://${addr}`; const status = 418; const method = "PATCH"; const body = `${method}: ${url} - Hello Deno on HTTPS!`;
const handler = () => new Response(body, { status }); const abortController = new AbortController();
const servePromise = serveTls(handler, { hostname, port, certFile, keyFile, signal: abortController.signal, });
try { // Invalid certificate, connection should throw on first read or write // but should not crash the server. using badConn = await Deno.connectTls({ hostname, port, // missing certFile });
await assertRejects( () => badConn.read(new Uint8Array(1)), Deno.errors.InvalidData, "invalid peer certificate: UnknownIssuer", "Read with missing certFile didn't throw an InvalidData error when it should have.", );
// Valid request after invalid using conn = await Deno.connectTls({ hostname, port, certFile: join(testdataDir, "tls/RootCA.pem"), });
await writeAll( conn, new TextEncoder().encode(`${method.toUpperCase()} / HTTP/1.0\r\n\r\n`), );
const response = new TextDecoder().decode(await readAll(conn));
assert(response.includes(`HTTP/1.0 ${status}`), "Status code not correct"); assert(response.includes(body), "Response body not correct"); } finally { abortController.abort(); await servePromise; }});
Deno.test( "Server does not reject when the listener is closed (though the server will continually try and fail to accept connections on the listener until it is closed)", async () => { using listener = Deno.listen({ port: getPort() }); const handler = () => new Response(); const server = new Server({ handler });
let servePromise;
try { servePromise = server.serve(listener); await delay(10); } finally { server.close(); await servePromise; } },);
Deno.test( "Server does not reject when there is a tls handshake with tcp corruption", async () => { const conn = createMockConn(); const rejectionError = new Deno.errors.InvalidData( "test-tcp-corruption-error", ); const listener = new MockListener({ conn, rejectionError }); const handler = () => new Response(); const server = new Server({ handler });
let servePromise;
try { servePromise = server.serve(listener); await delay(10); } finally { server.close(); await servePromise; } },);
Deno.test( "Server does not reject when the tls session is aborted", async () => { const conn = createMockConn(); const rejectionError = new Deno.errors.ConnectionReset( "test-tls-session-aborted-error", ); const listener = new MockListener({ conn, rejectionError }); const handler = () => new Response(); const server = new Server({ handler });
let servePromise;
try { servePromise = server.serve(listener); await delay(10); } finally { server.close(); await servePromise; } },);
Deno.test("Server does not reject when the socket is closed", async () => { const conn = createMockConn(); const rejectionError = new Deno.errors.NotConnected( "test-socket-closed-error", ); const listener = new MockListener({ conn, rejectionError }); const handler = () => new Response(); const server = new Server({ handler });
let servePromise;
try { servePromise = server.serve(listener); await delay(10); } finally { server.close(); await servePromise; }});
Deno.test( "Server does implement a backoff delay when accepting a connection throws an expected error and reset the backoff when successfully accepting a connection again", async () => { // acceptDelay(n) = 5 * 2^n for n=0...7 capped at 1000 afterwards. const expectedBackoffDelays = [ 5, 10, 20, 40, 80, 160, 320, 640, 1000, 1000, ]; const rejectionCount = expectedBackoffDelays.length;
let resolver: (value: unknown) => void;
// Construct a promise we know will only resolve after listener.accept() has // been called enough times to assert on our expected backoff delays, i.e. // the number of rejections + 1 success. const expectedBackoffDelaysCompletedPromise = new Promise((resolve) => { resolver = resolve; });
const acceptCallSideEffect = ({ acceptCallCount, }: { acceptCallCount: number; }) => { if (acceptCallCount > rejectionCount + 1) { resolver(undefined); } };
const conn = createMockConn(); const rejectionError = new Deno.errors.NotConnected( "test-socket-closed-error", );
const listener = new MockListener({ conn, rejectionError, rejectionCount, acceptCallSideEffect, });
const handler = () => new Response(); const server = new Server({ handler }); const servePromise = server.serve(listener);
// Wait for all the expected failures / backoff periods to have completed. await expectedBackoffDelaysCompletedPromise;
server.close(); await servePromise;
listener.acceptCallIntervals.shift(); console.log("\n Accept call intervals vs expected backoff intervals:"); console.table( listener.acceptCallIntervals.map((col, i) => [ col, expectedBackoffDelays[i] ?? "<1000, reset", ]), );
// Assert that the time between the accept calls is greater than or equal to // the expected backoff delay. for (let i = 0; i < rejectionCount; i++) { assertEquals( listener.acceptCallIntervals[i]! >= expectedBackoffDelays[i]!, true, ); }
// Assert that the backoff delay has been reset following successfully // accepting a connection, i.e. it doesn't remain at 1000ms. assertEquals(listener.acceptCallIntervals[rejectionCount]! < 1000, true); },);
Deno.test("Server does not leak async ops when closed", () => { const hostname = "127.0.0.1"; const port = getPort(); const handler = () => new Response(); const server = new Server({ port, hostname, handler }); server.listenAndServe(); server.close(); // Otherwise, the test would fail with: AssertionError: Test case is leaking async ops.});
Deno.test("Server aborts accept backoff delay when closing", async () => { const hostname = "127.0.0.1"; const port = getPort(); const handler = () => new Response();
const rejectionError = new Deno.errors.NotConnected( "test-socket-closed-error", ); const rejectionCount = 1; const conn = createMockConn();
const listener = new MockListener({ conn, rejectionError, rejectionCount, });
const server = new Server({ port, hostname, handler }); server.serve(listener);
// Wait until the connection is rejected and the backoff delay starts. await delay(0);
// Close the server, this should end the test without still having an active timer that would trigger an // AssertionError: Test case is leaking async ops. server.close();});
Deno.test("Server rejects if the listener throws an unexpected error accepting a connection", async () => { const conn = createMockConn(); const rejectionError = new Error("test-unexpected-error"); const listener = new MockListener({ conn, rejectionError }); const handler = () => new Response(); const server = new Server({ handler }); await assertRejects( () => server.serve(listener), Error, rejectionError.message, );});
Deno.test( "Server rejects if the listener throws an unexpected error accepting a connection", async () => { const conn = createMockConn(); const rejectionError = new Error("test-unexpected-error"); const listener = new MockListener({ conn, rejectionError }); const handler = () => new Response(); const server = new Server({ handler }); await assertRejects( () => server.serve(listener), Error, rejectionError.message, ); },);
Deno.test( "Server does not reject when the connection is closed before the message is complete", async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions);
const onRequest = Promise.withResolvers<void>(); const postRespondWith = Promise.withResolvers<void>();
const handler = async () => { onRequest.resolve();
await delay(0);
try { return new Response("test-response"); } finally { postRespondWith.resolve(); } };
const server = new Server({ handler }); const servePromise = server.serve(listener);
using conn = await Deno.connect(listenOptions);
await writeAll(conn, new TextEncoder().encode(`GET / HTTP/1.0\r\n\r\n`));
await onRequest.promise;
await postRespondWith.promise; server.close();
await servePromise; },);
Deno.test("Server does not reject when the handler throws", async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions);
const postRespondWith = Promise.withResolvers<void>();
const handler = () => { try { throw new Error("test-error"); } finally { postRespondWith.resolve(); } };
const server = new Server({ handler }); const servePromise = server.serve(listener);
using conn = await Deno.connect(listenOptions);
await writeAll(conn, new TextEncoder().encode(`GET / HTTP/1.0\r\n\r\n`));
await postRespondWith.promise; server.close(); await servePromise;});
Deno.test("Server does not close the http2 downstream connection when the response stream throws", async () => { const listenOptions = { hostname: "localhost", port: getPort(), certFile: join(testdataDir, "tls/localhost.crt"), keyFile: join(testdataDir, "tls/localhost.key"), alpnProtocols: ["h2"], }; const listener = Deno.listenTls(listenOptions); const url = `https://${listenOptions.hostname}:${listenOptions.port}/`;
let n = 0; const a = Promise.withResolvers<void>(); const connections = new Set();
const handler = (_req: Request, connInfo: ConnInfo) => { connections.add(connInfo); return new Response( new ReadableStream({ async start(controller) { n++; if (n === 3) { throw new Error("test-error"); } await a.promise; controller.enqueue(new TextEncoder().encode("a")); controller.close(); }, }), ); };
const server = new Server({ handler }); const servePromise = server.serve(listener);
const caCert = await Deno.readTextFile( join(testdataDir, "tls/RootCA.pem"), ); const client = Deno.createHttpClient({ caCerts: [caCert], }); const resp1 = await fetch(url, { client }); const resp2 = await fetch(url, { client });
const err = await assertRejects(async () => { const resp3 = await fetch(url, { client }); const _data = await resp3.text(); }); assert(err); a.resolve(); assertEquals(await resp1.text(), "a"); assertEquals(await resp2.text(), "a");
const numConns = connections.size; assertEquals( numConns, 1, `fetch should have reused a single connection, but used ${numConns} instead.`, ); assertEquals(n, 3, "The handler should have been called three times");
client.close(); server.close(); await servePromise;});
Deno.test("Server parses IPV6 addresses", async () => { const hostname = "[::1]"; const port = getPort(); const url = `http://${hostname}:${port}`; const method = "GET"; const status = 418; const body = `${method}: ${url} - Hello Deno on HTTP!`;
const handler = () => new Response(body, { status }); const abortController = new AbortController();
const servePromise = serve(handler, { hostname, port, signal: abortController.signal, });
try { const response = await fetch(url, { method }); assertEquals(await response.text(), body); assertEquals(response.status, status); } finally { abortController.abort(); await servePromise; }});
Deno.test("Server.serve() can be called multiple times", async () => { const listenerOneOptions = { hostname: "localhost", port: getPort(), }; const listenerTwoOptions = { hostname: "localhost", port: getPort(), }; const listenerOne = Deno.listen(listenerOneOptions); const listenerTwo = Deno.listen(listenerTwoOptions);
const handler = (_request: Request, connInfo: ConnInfo) => { if ((connInfo.localAddr as Deno.NetAddr).port === listenerOneOptions.port) { return new Response("Hello listener one!"); } else if ( (connInfo.localAddr as Deno.NetAddr).port === listenerTwoOptions.port ) { return new Response("Hello listener two!"); }
unreachable(); };
const server = new Server({ handler }); const servePromiseOne = server.serve(listenerOne); const servePromiseTwo = server.serve(listenerTwo);
try { const responseOne = await fetch( `http://${listenerOneOptions.hostname}:${listenerOneOptions.port}`, ); assertEquals(await responseOne.text(), "Hello listener one!");
const responseTwo = await fetch( `http://${listenerTwoOptions.hostname}:${listenerTwoOptions.port}`, ); assertEquals(await responseTwo.text(), "Hello listener two!"); } finally { server.close(); await servePromiseOne; await servePromiseTwo; }});
Deno.test( "Server.listenAndServe() throws if called multiple times", async () => { const handler = () => unreachable();
const server = new Server({ port: 4505, handler }); const servePromise = server.listenAndServe();
try { await assertRejects(() => server.listenAndServe(), Deno.errors.AddrInUse); } finally { server.close(); await servePromise; } },);
Deno.test( "Server.listenAndServeTls() throws if called multiple times", async () => { const handler = () => unreachable();
const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key");
const server = new Server({ port: 4505, handler }); const servePromise = server.listenAndServeTls(certFile, keyFile);
try { await assertRejects( () => server.listenAndServeTls(certFile, keyFile), Deno.errors.AddrInUse, ); } finally { server.close(); await servePromise; } },);
Deno.test( "Sever() handler is called with the request instance and connection information", async () => { const hostname = "127.0.0.1"; const port = getPort(); const addr = `${hostname}:${port}`;
let receivedRequest: Request; let receivedConnInfo: ConnInfo;
const handler = (request: Request, connInfo: ConnInfo) => { receivedRequest = request; receivedConnInfo = connInfo;
return new Response("Hello Deno!"); };
const server = new Server({ hostname, port, handler }); const servePromise = server.listenAndServe();
const url = `http://${addr}/`;
try { const response = await fetch(url); await response.text();
assertEquals(receivedRequest!.url, url); assertEquals(receivedConnInfo!.localAddr.transport, "tcp"); assertEquals( (receivedConnInfo!.localAddr as Deno.NetAddr).hostname, hostname, ); assertEquals((receivedConnInfo!.localAddr as Deno.NetAddr).port, port); assertEquals(receivedConnInfo!.remoteAddr.transport, "tcp"); assertEquals( (receivedConnInfo!.remoteAddr as Deno.NetAddr).hostname, hostname, ); } finally { server.close(); await servePromise; } },);
Deno.test("serve() calls onError when Handler throws", async () => { const hostname = "localhost"; const port = getPort(); const url = `http://${hostname}:${port}`; const handler = (_request: Request, _connInfo: ConnInfo) => { throw new Error("I failed to serve the request"); }; const abortController = new AbortController();
const servePromise = serve(handler, { hostname, port, signal: abortController.signal, });
try { const response = await fetch(url); assertEquals(await response.text(), "Internal Server Error"); assertEquals(response.status, 500); } finally { abortController.abort(); await servePromise; }});
Deno.test("serve() calls custom onError when Handler throws", async () => { const hostname = "localhost"; const port = getPort(); const url = `http://${hostname}:${port}`; const handler = (_request: Request, _connInfo: ConnInfo) => { throw new Error("I failed to serve the request"); }; const onError = (_error: unknown) => { return new Response("custom error page", { status: 500 }); }; const abortController = new AbortController();
const servePromise = serve(handler, { hostname, port, onError, signal: abortController.signal, });
try { const response = await fetch(url); assertEquals(await response.text(), "custom error page"); assertEquals(response.status, 500); } finally { abortController.abort(); await servePromise; }});
Deno.test("serveListener() calls custom onError when Handler throws", async () => { const listenOptions = { hostname: "localhost", port: getPort(), }; const listener = Deno.listen(listenOptions);
const url = `http://${listenOptions.hostname}:${listenOptions.port}`; const handler = (_request: Request, _connInfo: ConnInfo) => { throw new Error("I failed to serve the request"); }; const onError = (_error: unknown) => { return new Response("custom error page", { status: 500 }); }; const abortController = new AbortController();
const servePromise = serveListener(listener, handler, { onError, signal: abortController.signal, });
try { const response = await fetch(url); assertEquals(await response.text(), "custom error page"); assertEquals(response.status, 500); } finally { abortController.abort(); await servePromise; }});
Deno.test("Server.serveTls() supports custom onError", async () => { const hostname = "localhost"; const port = getPort(); const certFile = join(testdataDir, "tls/localhost.crt"); const keyFile = join(testdataDir, "tls/localhost.key"); const status = 500; const method = "PATCH"; const body = "custom error page";
const handler = () => { throw new Error("I failed to serve the request."); }; const onError = (_error: unknown) => new Response(body, { status }); const abortController = new AbortController();
const servePromise = serveTls(handler, { hostname, port, certFile, keyFile, onError, signal: abortController.signal, });
try { using conn = await Deno.connectTls({ hostname, port, certFile: join(testdataDir, "tls/RootCA.pem"), });
await writeAll( conn, new TextEncoder().encode( `${method.toUpperCase()} / HTTP/1.0\r\n\r\n`, ), );
const response = new TextDecoder().decode(await readAll(conn));
assert( response.includes(`HTTP/1.0 ${status}`), "Status code not correct", ); assert( response.includes(body), "Response body not correct", ); } finally { abortController.abort(); await servePromise; }});
Deno.test("serve() calls onListen callback when the server started listening", () => { const abortController = new AbortController(); return serve((_) => new Response("hello"), { async onListen({ hostname, port }) { const responseText = await (await fetch("http://localhost:8000/")).text(); assertEquals(hostname, "0.0.0.0"); assertEquals(port, 8000); assertEquals(responseText, "hello"); abortController.abort(); }, signal: abortController.signal, });});
Deno.test("serve() calls onListen callback with ephemeral port", () => { const abortController = new AbortController(); return serve((_) => new Response("hello"), { port: 0, async onListen({ hostname, port }) { assertEquals(hostname, "0.0.0.0"); assertNotEquals(port, 0); const responseText = await (await fetch(`http://localhost:${port}/`)) .text(); assertEquals(responseText, "hello"); abortController.abort(); }, signal: abortController.signal, });});
Deno.test("serve() doesn't print the message when onListen set to undefined", async () => { const command = new Deno.Command(Deno.execPath(), { args: [ "eval", "--no-lock", ` import { serve } from "./http/server.ts"; serve(() => new Response("hello"), { onListen: undefined }); Deno.exit(0); `, ], }); const { code, stdout } = await command.output(); assertEquals(code, 0); assertEquals(new TextDecoder().decode(stdout), "");});
Deno.test("serve() can print customized start-up message in onListen handler", async () => { const command = new Deno.Command(Deno.execPath(), { args: [ "eval", "--no-lock", ` import { serve } from "./http/server.ts"; serve(() => new Response("hello"), { onListen({ port, hostname }) { console.log("Server started at " + hostname + " port " + port); } }); Deno.exit(0); `, ], }); const { stdout, code } = await command.output(); assertEquals(code, 0); assertEquals( new TextDecoder().decode(stdout), "Server started at 0.0.0.0 port 8000\n", );});
Deno.test("serveTls() calls onListen callback with ephemeral port", () => { const abortController = new AbortController(); return serveTls((_) => new Response("hello"), { port: 0, certFile: join(testdataDir, "tls/localhost.crt"), keyFile: join(testdataDir, "tls/localhost.key"), async onListen({ hostname, port }) { assertEquals(hostname, "0.0.0.0"); assertNotEquals(port, 0); const caCert = await Deno.readTextFile( join(testdataDir, "tls/RootCA.pem"), ); const client = Deno.createHttpClient({ caCerts: [caCert] }); const responseText = await (await fetch(`https://localhost:${port}/`, { client })) .text(); client.close(); assertEquals(responseText, "hello"); abortController.abort(); }, signal: abortController.signal, });});
Deno.test("serveTls() handles cert key injection directly from memory rather than file system.", () => { const abortController = new AbortController(); return serveTls((_) => new Response("hello"), { port: 0, cert: Deno.readTextFileSync(join(testdataDir, "tls/localhost.crt")), key: Deno.readTextFileSync(join(testdataDir, "tls/localhost.key")), async onListen({ hostname, port }) { assertEquals(hostname, "0.0.0.0"); assertNotEquals(port, 0); const caCert = await Deno.readTextFile( join(testdataDir, "tls/RootCA.pem"), ); const client = Deno.createHttpClient({ caCerts: [caCert] }); const responseText = await ( await fetch(`https://localhost:${port}/`, { client }) ).text(); client.close(); assertEquals(responseText, "hello"); abortController.abort(); }, signal: abortController.signal, });});
Deno.test("serve() doesn't throw with string port number", () => { const ac = new AbortController(); return serve((_) => new Response("hello"), { // deno-lint-ignore no-explicit-any port: "0" as any, onListen() { ac.abort(); }, signal: ac.signal, });});
Deno.test("serveTls() doesn't throw with string port number", () => { const ac = new AbortController(); return serveTls((_) => new Response("hello"), { // deno-lint-ignore no-explicit-any port: "0" as any, cert: Deno.readTextFileSync(join(testdataDir, "tls/localhost.crt")), key: Deno.readTextFileSync(join(testdataDir, "tls/localhost.key")), onListen() { ac.abort(); }, signal: ac.signal, });});