foster/denoland-deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2024-12-31 11:34:15 -05:00
Code Issues Packages 1 Wiki Activity

avoid using same port number for test (#4147)

Browse source
This commit is contained in:
Yusuke Sakurai 2020-03-21 22:53:47 +09:00 committed by GitHub
parent 0adc86f105
commit 60cee4f045
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 165 additions and 63 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
cli/js/tests/net_test.ts
View file

@ -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<void> {
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<void> {
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<void> => {
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<void> {
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<void> {
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<void> {
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<void> {
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<void> => {
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);

18
cli/js/tests/test_util.ts
View file

@ -359,3 +359,21 @@ unitTest(
});
}
);
function* portIterator(): IterableIterator<number> {
// 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;
}

12
cli/js/tests/tls_test.ts
View file

@ -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<void> {
const resolvable = createResolvable();
const hostname = "localhost";
const port = 4500;
const port = randomPort();
const listener = Deno.listenTLS({
hostname,

6
std/examples/chat/server.ts
View file

@ -29,7 +29,9 @@ async function wsHandler(ws: WebSocket): Promise<void> {
}
}
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}....`);

15
std/examples/chat/server_test.ts
View file

@ -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<Deno.Process> {
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");

2
std/examples/echo_server.ts
View file

@ -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) {

6
std/examples/tests/curl_test.ts
View file

@ -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<void> => {
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"

8
std/examples/tests/echo_server_test.ts
View file

@ -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"));

28
std/http/file_server_test.ts
View file

@ -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<void> {
fileServer = Deno.run({
args: [
@ -14,7 +16,9 @@ async function startFileServer(): Promise<void> {
"--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<void> {
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<void> {
test(async function serveDirectory(): Promise<void> {
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<void> {
test(async function serveFallback(): Promise<void> {
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<void> {
test(async function serveWithUnorthodoxFilename(): Promise<void> {
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<void> {
});
test(async function servePermissionDenied(): Promise<void> {
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<void> {
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,

3
std/http/http_bench.ts
View file

@ -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");

2
std/http/racing_server.ts
View file

@ -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 {

12
std/http/racing_server_test.ts
View file

@ -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<void> {
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<void> {
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));

23
std/http/server_test.ts
View file

@ -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<void> => {
// 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<void> => {
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<void> => {
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<void> {
const port = randomPort();
const serverRoutine = async (): Promise<void> => {
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,

20
std/http/test_util.ts Normal file
View file

@ -0,0 +1,20 @@
import { assert } from "../testing/asserts.ts";
function* portIterator(): IterableIterator<number> {
// 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;
}

3
std/http/testdata/simple_https_server.ts vendored
View file

@ -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"
};

5
std/http/testdata/simple_server.ts vendored
View file

@ -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({});
}