From 60cee4f045778777a16b6fffd6d5b9a1400d7246 Mon Sep 17 00:00:00 2001 From: Yusuke Sakurai Date: Sat, 21 Mar 2020 22:53:47 +0900 Subject: [PATCH] avoid using same port number for test (#4147) --- cli/js/tests/net_test.ts | 65 +++++++++++++++--------- cli/js/tests/test_util.ts | 18 +++++++ cli/js/tests/tls_test.ts | 12 +++-- std/examples/chat/server.ts | 6 ++- std/examples/chat/server_test.ts | 15 ++++-- std/examples/echo_server.ts | 2 +- std/examples/tests/curl_test.ts | 6 ++- std/examples/tests/echo_server_test.ts | 8 +-- std/http/file_server_test.ts | 28 +++++++--- std/http/http_bench.ts | 3 +- std/http/racing_server.ts | 2 +- std/http/racing_server_test.ts | 12 ++++- std/http/server_test.ts | 23 ++++++--- std/http/test_util.ts | 20 ++++++++ std/http/testdata/simple_https_server.ts | 3 +- std/http/testdata/simple_server.ts | 5 +- 16 files changed, 165 insertions(+), 63 deletions(-) create mode 100644 std/http/test_util.ts diff --git a/cli/js/tests/net_test.ts b/cli/js/tests/net_test.ts index f27dcdc1953917..f62c5c329f162a 100644 --- a/cli/js/tests/net_test.ts +++ b/cli/js/tests/net_test.ts @@ -3,14 +3,16 @@ import { unitTest, assert, assertEquals, - createResolvable + createResolvable, + randomPort } from "./test_util.ts"; unitTest({ perms: { net: true } }, function netTcpListenClose(): void { - const listener = Deno.listen({ hostname: "127.0.0.1", port: 4500 }); + const port = randomPort(); + const listener = Deno.listen({ hostname: "127.0.0.1", port }); assertEquals(listener.addr.transport, "tcp"); assertEquals(listener.addr.hostname, "127.0.0.1"); - assertEquals(listener.addr.port, 4500); + assertEquals(listener.addr.port, port); listener.close(); }); @@ -21,14 +23,15 @@ unitTest( ignore: Deno.build.os === "win" }, function netUdpListenClose(): void { + const port = randomPort(); const socket = Deno.listen({ hostname: "127.0.0.1", - port: 4500, + port, transport: "udp" }); assertEquals(socket.addr.transport, "udp"); assertEquals(socket.addr.hostname, "127.0.0.1"); - assertEquals(socket.addr.port, 4500); + assertEquals(socket.addr.port, port); socket.close(); } ); @@ -38,7 +41,8 @@ unitTest( perms: { net: true } }, async function netTcpCloseWhileAccept(): Promise { - const listener = Deno.listen({ port: 4501 }); + const port = randomPort(); + const listener = Deno.listen({ port }); const p = listener.accept(); listener.close(); let err; @@ -56,7 +60,8 @@ unitTest( unitTest( { perms: { net: true } }, async function netTcpConcurrentAccept(): Promise { - const listener = Deno.listen({ port: 4502 }); + const port = randomPort(); + const listener = Deno.listen({ port }); let acceptErrCount = 0; const checkErr = (e: Error): void => { if (e.message === "Listener has been closed") { @@ -79,19 +84,20 @@ unitTest( unitTest({ perms: { net: true } }, async function netTcpDialListen(): Promise< void > { - const listener = Deno.listen({ port: 4500 }); + const port = randomPort(); + const listener = Deno.listen({ port }); listener.accept().then( async (conn): Promise => { assert(conn.remoteAddr != null); assertEquals(conn.localAddr.hostname, "127.0.0.1"); - assertEquals(conn.localAddr.port, 4500); + assertEquals(conn.localAddr.port, port); await conn.write(new Uint8Array([1, 2, 3])); conn.close(); } ); - const conn = await Deno.connect({ hostname: "127.0.0.1", port: 4500 }); + const conn = await Deno.connect({ hostname: "127.0.0.1", port }); assertEquals(conn.remoteAddr.hostname, "127.0.0.1"); - assertEquals(conn.remoteAddr.port, 4500); + assertEquals(conn.remoteAddr.port, port); assert(conn.localAddr != null); const buf = new Uint8Array(1024); const readResult = await conn.read(buf); @@ -113,13 +119,15 @@ unitTest({ perms: { net: true } }, async function netTcpDialListen(): Promise< unitTest( { ignore: Deno.build.os === "win", perms: { net: true } }, async function netUdpSendReceive(): Promise { - const alice = Deno.listen({ port: 4500, transport: "udp" }); - assertEquals(alice.addr.port, 4500); + const alicePort = randomPort(); + const alice = Deno.listen({ port: alicePort, transport: "udp" }); + assertEquals(alice.addr.port, alicePort); assertEquals(alice.addr.hostname, "0.0.0.0"); assertEquals(alice.addr.transport, "udp"); - const bob = Deno.listen({ port: 4501, transport: "udp" }); - assertEquals(bob.addr.port, 4501); + const bobPort = randomPort(); + const bob = Deno.listen({ port: bobPort, transport: "udp" }); + assertEquals(bob.addr.port, bobPort); assertEquals(bob.addr.hostname, "0.0.0.0"); assertEquals(bob.addr.transport, "udp"); @@ -127,7 +135,7 @@ unitTest( await alice.send(sent, bob.addr); const [recvd, remote] = await bob.receive(); - assertEquals(remote.port, 4500); + assertEquals(remote.port, alicePort); assertEquals(recvd.length, 3); assertEquals(1, recvd[0]); assertEquals(2, recvd[1]); @@ -140,7 +148,8 @@ unitTest( unitTest( { perms: { net: true } }, async function netTcpListenCloseWhileIterating(): Promise { - const listener = Deno.listen({ port: 8000 }); + const port = randomPort(); + const listener = Deno.listen({ port }); const nextWhileClosing = listener[Symbol.asyncIterator]().next(); listener.close(); assertEquals(await nextWhileClosing, { value: undefined, done: true }); @@ -153,7 +162,8 @@ unitTest( unitTest( { ignore: Deno.build.os === "win", perms: { net: true } }, async function netUdpListenCloseWhileIterating(): Promise { - const socket = Deno.listen({ port: 8000, transport: "udp" }); + const port = randomPort(); + const socket = Deno.listen({ port, transport: "udp" }); const nextWhileClosing = socket[Symbol.asyncIterator]().next(); socket.close(); assertEquals(await nextWhileClosing, { value: undefined, done: true }); @@ -170,7 +180,8 @@ unitTest( perms: { net: true } }, async function netListenAsyncIterator(): Promise { - const addr = { hostname: "127.0.0.1", port: 4500 }; + const port = randomPort(); + const addr = { hostname: "127.0.0.1", port }; const listener = Deno.listen(addr); const runAsyncIterator = async (): Promise => { for await (const conn of listener) { @@ -205,7 +216,8 @@ unitTest( perms: { net: true } }, async function netCloseReadSuccess() { - const addr = { hostname: "127.0.0.1", port: 4500 }; + const port = randomPort(); + const addr = { hostname: "127.0.0.1", port }; const listener = Deno.listen(addr); const closeDeferred = createResolvable(); const closeReadDeferred = createResolvable(); @@ -242,7 +254,8 @@ unitTest( perms: { net: true } }, async function netDoubleCloseRead() { - const addr = { hostname: "127.0.0.1", port: 4500 }; + const port = randomPort(); + const addr = { hostname: "127.0.0.1", port }; const listener = Deno.listen(addr); const closeDeferred = createResolvable(); listener.accept().then(async conn => { @@ -274,7 +287,8 @@ unitTest( perms: { net: true } }, async function netCloseWriteSuccess() { - const addr = { hostname: "127.0.0.1", port: 4500 }; + const port = randomPort(); + const addr = { hostname: "127.0.0.1", port }; const listener = Deno.listen(addr); const closeDeferred = createResolvable(); listener.accept().then(async conn => { @@ -313,7 +327,8 @@ unitTest( perms: { net: true } }, async function netDoubleCloseWrite() { - const addr = { hostname: "127.0.0.1", port: 4500 }; + const port = randomPort(); + const addr = { hostname: "127.0.0.1", port }; const listener = Deno.listen(addr); const closeDeferred = createResolvable(); listener.accept().then(async conn => { @@ -365,8 +380,8 @@ unitTest( resolvable.resolve(); } - - const addr = { hostname: "127.0.0.1", port: 4500 }; + const port = randomPort(); + const addr = { hostname: "127.0.0.1", port }; const listener = Deno.listen(addr); iteratorReq(listener); const conn = await Deno.connect(addr); diff --git a/cli/js/tests/test_util.ts b/cli/js/tests/test_util.ts index 980d32bac403b6..347a2204e89deb 100644 --- a/cli/js/tests/test_util.ts +++ b/cli/js/tests/test_util.ts @@ -359,3 +359,21 @@ unitTest( }); } ); +function* portIterator(): IterableIterator { + // use 49152 ~ 55000 for js/cli (rest are for std) + let i = 49152; + while (true) { + yield i; + i++; + if (i > 55000) { + i = 55000; + } + } +} +const it = portIterator(); +/** Obtain (maybe) safe port number for net tests */ +export function randomPort(): number { + const { value } = it.next(); + assert(value != null); + return value; +} diff --git a/cli/js/tests/tls_test.ts b/cli/js/tests/tls_test.ts index 20dd62f9b1ef96..2e6e5afc96eb18 100644 --- a/cli/js/tests/tls_test.ts +++ b/cli/js/tests/tls_test.ts @@ -2,6 +2,7 @@ import { assert, assertEquals, + randomPort, createResolvable, unitTest } from "./test_util.ts"; @@ -43,7 +44,7 @@ unitTest( let err; const options = { hostname: "localhost", - port: 4500, + port: randomPort(), certFile: "cli/tests/tls/localhost.crt", keyFile: "cli/tests/tls/localhost.key" }; @@ -72,10 +73,11 @@ unitTest( unitTest({ perms: { net: true } }, function listenTLSNoReadPerm(): void { let err; + const port = randomPort(); try { Deno.listenTLS({ hostname: "localhost", - port: 4500, + port, certFile: "cli/tests/tls/localhost.crt", keyFile: "cli/tests/tls/localhost.key" }); @@ -94,7 +96,7 @@ unitTest( let err; const options = { hostname: "localhost", - port: 4500, + port: randomPort(), certFile: "cli/tests/tls/localhost.crt", keyFile: "cli/tests/tls/localhost.key" }; @@ -123,7 +125,7 @@ unitTest( let err; const options = { hostname: "localhost", - port: 4500, + port: randomPort(), certFile: "cli/tests/tls/localhost.crt", keyFile: "cli/tests/tls/localhost.key" }; @@ -151,7 +153,7 @@ unitTest( async function dialAndListenTLS(): Promise { const resolvable = createResolvable(); const hostname = "localhost"; - const port = 4500; + const port = randomPort(); const listener = Deno.listenTLS({ hostname, diff --git a/std/examples/chat/server.ts b/std/examples/chat/server.ts index 08aede05bbc6d4..d28f9f43fc324e 100644 --- a/std/examples/chat/server.ts +++ b/std/examples/chat/server.ts @@ -29,7 +29,9 @@ async function wsHandler(ws: WebSocket): Promise { } } -listenAndServe({ port: 8080 }, async req => { +const addr = Deno.args[0] ?? "127.0.0.1:8080"; + +listenAndServe(addr, async req => { if (req.method === "GET" && req.url === "/") { //Serve with hack const u = new URL("./index.html", import.meta.url); @@ -75,4 +77,4 @@ listenAndServe({ port: 8080 }, async req => { } } }); -console.log("chat server starting on :8080...."); +console.log(`chat server starting on ${addr}....`); diff --git a/std/examples/chat/server_test.ts b/std/examples/chat/server_test.ts index 0d21b3787833bd..65e0b595818d52 100644 --- a/std/examples/chat/server_test.ts +++ b/std/examples/chat/server_test.ts @@ -3,13 +3,22 @@ import { assert, assertEquals } from "../../testing/asserts.ts"; import { TextProtoReader } from "../../textproto/mod.ts"; import { BufReader } from "../../io/bufio.ts"; import { connectWebSocket, WebSocket } from "../../ws/mod.ts"; +import { randomPort } from "../../http/test_util.ts"; import { delay } from "../../util/async.ts"; +const port = randomPort(); + const { test, build } = Deno; async function startServer(): Promise { const server = Deno.run({ - args: [Deno.execPath(), "--allow-net", "--allow-read", "server.ts"], + args: [ + Deno.execPath(), + "--allow-net", + "--allow-read", + "server.ts", + `127.0.0.1:${port}` + ], cwd: "examples/chat", stdout: "piped" }); @@ -35,7 +44,7 @@ test({ async fn() { const server = await startServer(); try { - const resp = await fetch("http://127.0.0.1:8080/"); + const resp = await fetch(`http://127.0.0.1:${port}/`); assertEquals(resp.status, 200); assertEquals(resp.headers.get("content-type"), "text/html"); const html = await resp.body.text(); @@ -55,7 +64,7 @@ test({ const server = await startServer(); let ws: WebSocket | undefined; try { - ws = await connectWebSocket("http://127.0.0.1:8080/ws"); + ws = await connectWebSocket(`http://127.0.0.1:${port}/ws`); const it = ws.receive(); assertEquals((await it.next()).value, "Connected: [1]"); ws.send("Hello"); diff --git a/std/examples/echo_server.ts b/std/examples/echo_server.ts index dbcc9b5aead8b5..cdd98fea7244be 100644 --- a/std/examples/echo_server.ts +++ b/std/examples/echo_server.ts @@ -1,6 +1,6 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. const hostname = "0.0.0.0"; -const port = 8080; +const port = +(Deno.args[0] ?? "8080"); const listener = Deno.listen({ hostname, port }); console.log(`Listening on ${hostname}:${port}`); for await (const conn of listener) { diff --git a/std/examples/tests/curl_test.ts b/std/examples/tests/curl_test.ts index bc413b23f572f3..b23e73210dd7ed 100644 --- a/std/examples/tests/curl_test.ts +++ b/std/examples/tests/curl_test.ts @@ -1,14 +1,16 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. import { serve } from "../../http/server.ts"; import { assertStrictEq } from "../../testing/asserts.ts"; +import { randomPort } from "../../http/test_util.ts"; +const port = randomPort(); Deno.test({ name: "[examples/curl] send a request to a specified url", // FIXME(bartlomieju): this test is leaking both resources and ops, // and causes interference with other tests ignore: true, fn: async () => { - const server = serve({ port: 8081 }); + const server = serve({ port }); (async (): Promise => { for await (const req of server) { req.respond({ body: "Hello world" }); @@ -21,7 +23,7 @@ Deno.test({ Deno.execPath(), "--allow-net", "curl.ts", - "http://localhost:8081" + "http://localhost:" + port ], cwd: "examples", stdout: "piped" diff --git a/std/examples/tests/echo_server_test.ts b/std/examples/tests/echo_server_test.ts index 20fd7479c24894..3c18933420313b 100644 --- a/std/examples/tests/echo_server_test.ts +++ b/std/examples/tests/echo_server_test.ts @@ -1,12 +1,14 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. import { assertStrictEq, assertNotEquals } from "../../testing/asserts.ts"; import { BufReader, ReadLineResult } from "../../io/bufio.ts"; +import { randomPort } from "../../http/test_util.ts"; +const port = randomPort(); Deno.test("[examples/echo_server]", async () => { const encoder = new TextEncoder(); const decoder = new TextDecoder(); const process = Deno.run({ - args: [Deno.execPath(), "--allow-net", "echo_server.ts"], + args: [Deno.execPath(), "--allow-net", "echo_server.ts", `${port}`], cwd: "examples", stdout: "piped" }); @@ -19,10 +21,10 @@ Deno.test("[examples/echo_server]", async () => { assertNotEquals(message, Deno.EOF); assertStrictEq( decoder.decode((message as ReadLineResult).line).trim(), - "Listening on 0.0.0.0:8080" + "Listening on 0.0.0.0:" + port ); - conn = await Deno.connect({ hostname: "127.0.0.1", port: 8080 }); + conn = await Deno.connect({ hostname: "127.0.0.1", port }); const connReader = new BufReader(conn); await conn.write(encoder.encode("Hello echo_server\n")); diff --git a/std/http/file_server_test.ts b/std/http/file_server_test.ts index 1fbe3ba970f903..b7cd8a7e168d09 100644 --- a/std/http/file_server_test.ts +++ b/std/http/file_server_test.ts @@ -2,9 +2,11 @@ import { assert, assertEquals, assertStrContains } from "../testing/asserts.ts"; import { BufReader } from "../io/bufio.ts"; import { TextProtoReader } from "../textproto/mod.ts"; +import { randomPort } from "./test_util.ts"; const { test } = Deno; let fileServer: Deno.Process; +const port = randomPort(); async function startFileServer(): Promise { fileServer = Deno.run({ args: [ @@ -14,7 +16,9 @@ async function startFileServer(): Promise { "--allow-net", "http/file_server.ts", ".", - "--cors" + "--cors", + "--port", + `${port}` ], stdout: "piped", stderr: "null" @@ -34,7 +38,7 @@ function killFileServer(): void { test(async function serveFile(): Promise { await startFileServer(); try { - const res = await fetch("http://localhost:4500/README.md"); + const res = await fetch(`http://localhost:${port}/README.md`); assert(res.headers.has("access-control-allow-origin")); assert(res.headers.has("access-control-allow-headers")); assert(res.headers.has("content-type")); @@ -52,7 +56,7 @@ test(async function serveFile(): Promise { test(async function serveDirectory(): Promise { await startFileServer(); try { - const res = await fetch("http://localhost:4500/"); + const res = await fetch(`http://localhost:${port}/`); assert(res.headers.has("access-control-allow-origin")); assert(res.headers.has("access-control-allow-headers")); const page = await res.text(); @@ -74,7 +78,7 @@ test(async function serveDirectory(): Promise { test(async function serveFallback(): Promise { await startFileServer(); try { - const res = await fetch("http://localhost:4500/badfile.txt"); + const res = await fetch(`http://localhost:${port}/badfile.txt`); assert(res.headers.has("access-control-allow-origin")); assert(res.headers.has("access-control-allow-headers")); assertEquals(res.status, 404); @@ -87,12 +91,12 @@ test(async function serveFallback(): Promise { test(async function serveWithUnorthodoxFilename(): Promise { await startFileServer(); try { - let res = await fetch("http://localhost:4500/http/testdata/%"); + let res = await fetch(`http://localhost:${port}/http/testdata/%`); assert(res.headers.has("access-control-allow-origin")); assert(res.headers.has("access-control-allow-headers")); assertEquals(res.status, 200); res.body.close(); - res = await fetch("http://localhost:4500/http/testdata/test%20file.txt"); + res = await fetch(`http://localhost:${port}/http/testdata/test%20file.txt`); assert(res.headers.has("access-control-allow-origin")); assert(res.headers.has("access-control-allow-headers")); assertEquals(res.status, 200); @@ -103,8 +107,16 @@ test(async function serveWithUnorthodoxFilename(): Promise { }); test(async function servePermissionDenied(): Promise { + const _port = randomPort(); const deniedServer = Deno.run({ - args: [Deno.execPath(), "run", "--allow-net", "http/file_server.ts"], + args: [ + Deno.execPath(), + "run", + "--allow-net", + "http/file_server.ts", + "-p", + `${_port}` + ], stdout: "piped", stderr: "piped" }); @@ -116,7 +128,7 @@ test(async function servePermissionDenied(): Promise { assert(s !== Deno.EOF && s.includes("server listening")); try { - const res = await fetch("http://localhost:4500/"); + const res = await fetch(`http://localhost:${_port}/`); res.body.close(); assertStrContains( (await errReader.readLine()) as string, diff --git a/std/http/http_bench.ts b/std/http/http_bench.ts index 9d191283170cd0..060d0ad881af26 100644 --- a/std/http/http_bench.ts +++ b/std/http/http_bench.ts @@ -1,7 +1,8 @@ // Copyright 2018-2020 the Deno authors. All rights reserved. MIT license. import { serve } from "./server.ts"; +import { randomPort } from "./test_util.ts"; -const addr = Deno.args[0] || "127.0.0.1:4500"; +const addr = Deno.args[0] || "127.0.0.1:" + randomPort(); const server = serve(addr); const body = new TextEncoder().encode("Hello World"); diff --git a/std/http/racing_server.ts b/std/http/racing_server.ts index 0b0e5a8a5652af..693531a7fb7e5b 100644 --- a/std/http/racing_server.ts +++ b/std/http/racing_server.ts @@ -2,7 +2,7 @@ import { serve, ServerRequest } from "./server.ts"; import { delay } from "../util/async.ts"; -const addr = Deno.args[1] || "127.0.0.1:4501"; +const addr = Deno.args[0] || "127.0.0.1:4501"; const server = serve(addr); function body(i: number): string { diff --git a/std/http/racing_server_test.ts b/std/http/racing_server_test.ts index d82acebabff5bf..2f88a4703b0c00 100644 --- a/std/http/racing_server_test.ts +++ b/std/http/racing_server_test.ts @@ -1,12 +1,20 @@ import { assert, assertEquals } from "../testing/asserts.ts"; import { BufReader, BufWriter } from "../io/bufio.ts"; import { TextProtoReader } from "../textproto/mod.ts"; +import { randomPort } from "./test_util.ts"; +const port = randomPort(); const { connect, run, test } = Deno; let server: Deno.Process; async function startServer(): Promise { server = run({ - args: [Deno.execPath(), "run", "-A", "http/racing_server.ts"], + args: [ + Deno.execPath(), + "run", + "-A", + "http/racing_server.ts", + "127.0.0.1:" + port + ], stdout: "piped" }); // Once racing server is ready it will write to its stdout. @@ -61,7 +69,7 @@ Step7 test(async function serverPipelineRace(): Promise { await startServer(); - const conn = await connect({ port: 4501 }); + const conn = await connect({ port }); const r = new TextProtoReader(new BufReader(conn)); const w = new BufWriter(conn); await w.write(new TextEncoder().encode(input)); diff --git a/std/http/server_test.ts b/std/http/server_test.ts index 2a7c46134b8db7..d3711162014317 100644 --- a/std/http/server_test.ts +++ b/std/http/server_test.ts @@ -18,6 +18,7 @@ import { BufReader, BufWriter } from "../io/bufio.ts"; import { delay } from "../util/async.ts"; import { encode, decode } from "../strings/mod.ts"; import { mockConn } from "./mock.ts"; +import { randomPort } from "./test_util.ts"; const { Buffer, test } = Deno; @@ -355,8 +356,14 @@ test({ ignore: true, fn: async (): Promise => { // Runs a simple server as another process + const port = randomPort(); const p = Deno.run({ - args: [Deno.execPath(), "--allow-net", "http/testdata/simple_server.ts"], + args: [ + Deno.execPath(), + "--allow-net", + "http/testdata/simple_server.ts", + `${port}` + ], stdout: "piped" }); @@ -395,13 +402,15 @@ test({ // FIXME(bartlomieju): hangs on windows, cause can't do `Deno.kill` ignore: true, fn: async (): Promise => { + const port = randomPort(); // Runs a simple server as another process const p = Deno.run({ args: [ Deno.execPath(), "--allow-net", "--allow-read", - "http/testdata/simple_https_server.ts" + "http/testdata/simple_https_server.ts", + `${port}` ], stdout: "piped" }); @@ -413,7 +422,6 @@ test({ 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(); @@ -424,7 +432,7 @@ test({ // Requests to the server and immediately closes the connection const conn = await Deno.connectTLS({ hostname: "localhost", - port: 4503, + port, certFile: "http/testdata/tls/RootCA.pem" }); await Deno.writeAll( @@ -448,7 +456,7 @@ test({ }); test("close server while iterating", async (): Promise => { - const server = serve(":8123"); + const server = serve({ port: randomPort() }); const nextWhileClosing = server[Symbol.asyncIterator]().next(); server.close(); assertEquals(await nextWhileClosing, { value: undefined, done: true }); @@ -491,8 +499,9 @@ test({ test({ name: "respond error closes connection", async fn(): Promise { + const port = randomPort(); const serverRoutine = async (): Promise => { - const server = serve(":8124"); + const server = serve(":" + port); // @ts-ignore for await (const req of server) { await assertThrowsAsync(async () => { @@ -509,7 +518,7 @@ test({ const p = serverRoutine(); const conn = await Deno.connect({ hostname: "127.0.0.1", - port: 8124 + port }); await Deno.writeAll( conn, diff --git a/std/http/test_util.ts b/std/http/test_util.ts new file mode 100644 index 00000000000000..c86a339a7f7ff0 --- /dev/null +++ b/std/http/test_util.ts @@ -0,0 +1,20 @@ +import { assert } from "../testing/asserts.ts"; + +function* portIterator(): IterableIterator { + // use 55001 ~ 65535 (rest (49152~55000) are for cli/js) + let i = 55001; + while (true) { + yield i; + i++; + if (i > 65535) { + i = 55001; + } + } +} +const it = portIterator(); +/** Obtain (maybe) safe port number for net tests */ +export function randomPort(): number { + const { value } = it.next(); + assert(value != null); + return value; +} diff --git a/std/http/testdata/simple_https_server.ts b/std/http/testdata/simple_https_server.ts index 9330b4172bbdde..9e30456098f81e 100644 --- a/std/http/testdata/simple_https_server.ts +++ b/std/http/testdata/simple_https_server.ts @@ -2,9 +2,10 @@ // This is an example of a https server import { serveTLS } from "../server.ts"; +const port = parseInt(Deno.args[0] || "4503"); const tlsOptions = { hostname: "localhost", - port: 4503, + port, certFile: "./http/testdata/tls/localhost.crt", keyFile: "./http/testdata/tls/localhost.key" }; diff --git a/std/http/testdata/simple_server.ts b/std/http/testdata/simple_server.ts index d8ca4cc97bd72e..05f169705a4270 100644 --- a/std/http/testdata/simple_server.ts +++ b/std/http/testdata/simple_server.ts @@ -2,8 +2,9 @@ // This is an example of a server that responds with an empty body import { serve } from "../server.ts"; -const addr = "0.0.0.0:4502"; -console.log(`Simple server listening on ${addr}`); +const port = parseInt(Deno.args[0] || "4502"); +const addr: Deno.ListenOptions = { port }; +console.log(`Simple server listening on ${port}`); for await (const req of serve(addr)) { req.respond({}); }