language-servers/deno
1
0
Fork 0
mirror of https://github.com/denoland/deno.git synced 2025-09-28 13:14:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

refactor: replace deferred() from std/async with Promise.withResolvers() (#21234)

Browse source 
Closes #21041

---------

Signed-off-by: Asher Gomez <ashersaupingomez@gmail.com>
This commit is contained in:
Asher Gomez 2023-11-22 22:11:20 +11:00 • committed by GitHub
parent 0ffcb46e0f
commit 616354e76c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
35 changed files with 952 additions and 1020 deletions
Download patch file Download diff file Expand all files Collapse all files

7
cli/tests/testdata/run/tls_connecttls.js vendored
View file

@ -1,4 +1,3 @@
import { deferred } from "../../../../test_util/std/async/deferred.ts";
import { import {
assert, assert,
assertEquals, assertEquals,
@ -9,7 +8,7 @@ import { TextProtoReader } from "./textproto.ts";
const encoder = new TextEncoder(); const encoder = new TextEncoder();
const decoder = new TextDecoder(); const decoder = new TextDecoder();
const resolvable = deferred(); const { promise, resolve } = Promise.withResolvers();
const hostname = "localhost"; const hostname = "localhost";
const port = 3505; const port = 3505;
@ -32,7 +31,7 @@ listener.accept().then(
// TODO(bartlomieju): this might be a bug // TODO(bartlomieju): this might be a bug
setTimeout(() => { setTimeout(() => {
conn.close(); conn.close();
resolvable.resolve(); resolve();
}, 0); }, 0);
}, },
); );
@ -65,6 +64,6 @@ await r.readFull(bodyBuf);
assertEquals(decoder.decode(bodyBuf), "Hello World\n"); assertEquals(decoder.decode(bodyBuf), "Hello World\n");
conn.close(); conn.close();
listener.close(); listener.close();
await resolvable; await promise;
console.log("DONE"); console.log("DONE");

7
cli/tests/testdata/run/tls_starttls.js vendored
View file

@ -1,4 +1,3 @@
import { deferred } from "../../../../test_util/std/async/deferred.ts";
import { import {
assert, assert,
assertEquals, assertEquals,
@ -10,7 +9,7 @@ import { TextProtoReader } from "./textproto.ts";
const encoder = new TextEncoder(); const encoder = new TextEncoder();
const decoder = new TextDecoder(); const decoder = new TextDecoder();
const resolvable = deferred(); const { promise, resolve } = Promise.withResolvers();
const hostname = "localhost"; const hostname = "localhost";
const port = 3504; const port = 3504;
@ -33,7 +32,7 @@ listener.accept().then(
// TODO(bartlomieju): this might be a bug // TODO(bartlomieju): this might be a bug
setTimeout(() => { setTimeout(() => {
conn.close(); conn.close();
resolvable.resolve(); resolve();
}, 0); }, 0);
}, },
); );
@ -64,6 +63,6 @@ await r.readFull(bodyBuf);
assertEquals(decoder.decode(bodyBuf), "Hello World\n"); assertEquals(decoder.decode(bodyBuf), "Hello World\n");
conn.close(); conn.close();
listener.close(); listener.close();
await resolvable; await promise;
console.log("DONE"); console.log("DONE");

9
cli/tests/testdata/run/websocket_server_idletimeout.ts vendored
View file

@ -1,8 +1,7 @@
import { assertEquals } from "../../../../test_util/std/testing/asserts.ts"; import { assertEquals } from "../../../../test_util/std/testing/asserts.ts";
import { deferred } from "../../../../test_util/std/async/deferred.ts";
const errorDeferred = deferred(); const errorDeferred = Promise.withResolvers<void>();
const closeDeferred = deferred(); const closeDeferred = Promise.withResolvers<void>();
const listener = Deno.listen({ port: 4509 }); const listener = Deno.listen({ port: 4509 });
console.log("READY"); console.log("READY");
@ -21,6 +20,6 @@ socket.onclose = (e) => {
}; };
await respondWith(response); await respondWith(response);
await errorDeferred; await errorDeferred.promise;
await closeDeferred; await closeDeferred.promise;
listener.close(); listener.close();

6
cli/tests/testdata/run/websocket_server_multi_field_connection_header_test.ts vendored
View file

@ -1,6 +1,4 @@
import { deferred } from "../../unit/test_util.ts"; const { promise, resolve } = Promise.withResolvers<void>();
const promise = deferred();
const listener = Deno.listen({ port: 4319 }); const listener = Deno.listen({ port: 4319 });
console.log("READY"); console.log("READY");
const conn = await listener.accept(); const conn = await listener.accept();
@ -12,6 +10,6 @@ const {
} = Deno.upgradeWebSocket(request); } = Deno.upgradeWebSocket(request);
socket.onerror = () => Deno.exit(1); socket.onerror = () => Deno.exit(1);
socket.onopen = () => socket.close(); socket.onopen = () => socket.close();
socket.onclose = () => promise.resolve(); socket.onclose = () => resolve();
await respondWith(response); await respondWith(response);
await promise; await promise;

83
cli/tests/testdata/run/websocket_test.ts vendored
View file

@ -5,7 +5,6 @@ import {
assertThrows, assertThrows,
fail, fail,
} from "../../../../test_util/std/testing/asserts.ts"; } from "../../../../test_util/std/testing/asserts.ts";
import { deferred } from "../../../../test_util/std/async/deferred.ts";
Deno.test("invalid scheme", () => { Deno.test("invalid scheme", () => {
assertThrows(() => new WebSocket("foo://localhost:4242")); assertThrows(() => new WebSocket("foo://localhost:4242"));
@ -21,7 +20,7 @@ Deno.test("duplicate protocols", () => {
}); });
Deno.test("invalid server", async () => { Deno.test("invalid server", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:2121"); const ws = new WebSocket("ws://localhost:2121");
let err = false; let err = false;
ws.onerror = () => { ws.onerror = () => {
@ -29,7 +28,7 @@ Deno.test("invalid server", async () => {
}; };
ws.onclose = () => { ws.onclose = () => {
if (err) { if (err) {
promise.resolve(); resolve();
} else { } else {
fail(); fail();
} }
@ -39,20 +38,20 @@ Deno.test("invalid server", async () => {
}); });
Deno.test("connect & close", async () => { Deno.test("connect & close", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onopen = () => { ws.onopen = () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("connect & abort", async () => { Deno.test("connect & abort", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.close(); ws.close();
let err = false; let err = false;
@ -61,7 +60,7 @@ Deno.test("connect & abort", async () => {
}; };
ws.onclose = () => { ws.onclose = () => {
if (err) { if (err) {
promise.resolve(); resolve();
} else { } else {
fail(); fail();
} }
@ -71,18 +70,18 @@ Deno.test("connect & abort", async () => {
}); });
Deno.test("connect & close custom valid code", async () => { Deno.test("connect & close custom valid code", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onopen = () => ws.close(1000); ws.onopen = () => ws.close(1000);
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("connect & close custom invalid code", async () => { Deno.test("connect & close custom invalid code", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onopen = () => { ws.onopen = () => {
@ -90,24 +89,24 @@ Deno.test("connect & close custom invalid code", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("connect & close custom valid reason", async () => { Deno.test("connect & close custom valid reason", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onopen = () => ws.close(1000, "foo"); ws.onopen = () => ws.close(1000, "foo");
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("connect & close custom invalid reason", async () => { Deno.test("connect & close custom invalid reason", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onopen = () => { ws.onopen = () => {
@ -115,13 +114,13 @@ Deno.test("connect & close custom invalid reason", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("echo string", async () => { Deno.test("echo string", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onopen = () => ws.send("foo"); ws.onopen = () => ws.send("foo");
@ -130,31 +129,31 @@ Deno.test("echo string", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("echo string tls", async () => { Deno.test("echo string tls", async () => {
const promise1 = deferred(); const deferred1 = Promise.withResolvers<void>();
const promise2 = deferred(); const deferred2 = Promise.withResolvers<void>();
const ws = new WebSocket("wss://localhost:4243"); const ws = new WebSocket("wss://localhost:4243");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onopen = () => ws.send("foo"); ws.onopen = () => ws.send("foo");
ws.onmessage = (e) => { ws.onmessage = (e) => {
assertEquals(e.data, "foo"); assertEquals(e.data, "foo");
ws.close(); ws.close();
promise1.resolve(); deferred1.resolve();
}; };
ws.onclose = () => { ws.onclose = () => {
promise2.resolve(); deferred2.resolve();
}; };
await promise1; await deferred1.promise;
await promise2; await deferred2.promise;
}); });
Deno.test("websocket error", async () => { Deno.test("websocket error", async () => {
const promise1 = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("wss://localhost:4242"); const ws = new WebSocket("wss://localhost:4242");
ws.onopen = () => fail(); ws.onopen = () => fail();
ws.onerror = (err) => { ws.onerror = (err) => {
@ -163,13 +162,13 @@ Deno.test("websocket error", async () => {
err.message, err.message,
"NetworkError: failed to connect to WebSocket: received corrupt message of type InvalidContentType", "NetworkError: failed to connect to WebSocket: received corrupt message of type InvalidContentType",
); );
promise1.resolve(); resolve();
}; };
await promise1; await promise;
}); });
Deno.test("echo blob with binaryType blob", async () => { Deno.test("echo blob with binaryType blob", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
const blob = new Blob(["foo"]); const blob = new Blob(["foo"]);
ws.onerror = () => fail(); ws.onerror = () => fail();
@ -183,13 +182,13 @@ Deno.test("echo blob with binaryType blob", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("echo blob with binaryType arraybuffer", async () => { Deno.test("echo blob with binaryType arraybuffer", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.binaryType = "arraybuffer"; ws.binaryType = "arraybuffer";
const blob = new Blob(["foo"]); const blob = new Blob(["foo"]);
@ -202,13 +201,13 @@ Deno.test("echo blob with binaryType arraybuffer", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("echo uint8array with binaryType blob", async () => { Deno.test("echo uint8array with binaryType blob", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
const uint = new Uint8Array([102, 111, 111]); const uint = new Uint8Array([102, 111, 111]);
ws.onerror = () => fail(); ws.onerror = () => fail();
@ -220,13 +219,13 @@ Deno.test("echo uint8array with binaryType blob", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("echo uint8array with binaryType arraybuffer", async () => { Deno.test("echo uint8array with binaryType arraybuffer", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.binaryType = "arraybuffer"; ws.binaryType = "arraybuffer";
const uint = new Uint8Array([102, 111, 111]); const uint = new Uint8Array([102, 111, 111]);
@ -237,13 +236,13 @@ Deno.test("echo uint8array with binaryType arraybuffer", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("echo arraybuffer with binaryType blob", async () => { Deno.test("echo arraybuffer with binaryType blob", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
const buffer = new ArrayBuffer(3); const buffer = new ArrayBuffer(3);
ws.onerror = () => fail(); ws.onerror = () => fail();
@ -255,13 +254,13 @@ Deno.test("echo arraybuffer with binaryType blob", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("echo arraybuffer with binaryType arraybuffer", async () => { Deno.test("echo arraybuffer with binaryType arraybuffer", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
ws.binaryType = "arraybuffer"; ws.binaryType = "arraybuffer";
const buffer = new ArrayBuffer(3); const buffer = new ArrayBuffer(3);
@ -272,13 +271,13 @@ Deno.test("echo arraybuffer with binaryType arraybuffer", async () => {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("Event Handlers order", async () => { Deno.test("Event Handlers order", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4242"); const ws = new WebSocket("ws://localhost:4242");
const arr: number[] = []; const arr: number[] = [];
ws.onerror = () => fail(); ws.onerror = () => fail();
@ -292,18 +291,18 @@ Deno.test("Event Handlers order", async () => {
ws.onmessage = () => arr.push(2); ws.onmessage = () => arr.push(2);
ws.onopen = () => ws.send("Echo"); ws.onopen = () => ws.send("Echo");
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test("Close without frame", async () => { Deno.test("Close without frame", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4244"); const ws = new WebSocket("ws://localhost:4244");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onclose = (e) => { ws.onclose = (e) => {
assertEquals(e.code, 1005); assertEquals(e.code, 1005);
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });

2
cli/tests/testdata/test/steps/invalid_usage.out vendored
View file

@ -68,7 +68,7 @@ error: Started test step with sanitizers while another test step was running:
FAILURES FAILURES
capturing => ./test/steps/invalid_usage.ts:3:6 capturing => ./test/steps/invalid_usage.ts:1:6
top level missing await ... step => ./test/steps/invalid_usage.ts:[WILDCARD] top level missing await ... step => ./test/steps/invalid_usage.ts:[WILDCARD]
inner missing await ... step ... inner => ./test/steps/invalid_usage.ts:[WILDCARD] inner missing await ... step ... inner => ./test/steps/invalid_usage.ts:[WILDCARD]
parallel steps with sanitizers ... step 2 => ./test/steps/invalid_usage.ts:[WILDCARD] parallel steps with sanitizers ... step 2 => ./test/steps/invalid_usage.ts:[WILDCARD]

34
cli/tests/testdata/test/steps/invalid_usage.ts vendored
View file

@ -1,5 +1,3 @@
import { deferred } from "../../../../../test_util/std/async/deferred.ts";
Deno.test("capturing", async (t) => { Deno.test("capturing", async (t) => {
let capturedContext!: Deno.TestContext; let capturedContext!: Deno.TestContext;
await t.step("some step", (t) => { await t.step("some step", (t) => {
@ -32,27 +30,27 @@ Deno.test({
Deno.test("parallel steps with sanitizers", async (t) => { Deno.test("parallel steps with sanitizers", async (t) => {
// not allowed because steps with sanitizers cannot be run in parallel // not allowed because steps with sanitizers cannot be run in parallel
const step1Entered = deferred(); const step1Entered = Promise.withResolvers<void>();
const testFinished = deferred(); const testFinished = Promise.withResolvers<void>();
t.step("step 1", async () => { t.step("step 1", async () => {
step1Entered.resolve(); step1Entered.resolve();
await testFinished; await testFinished.promise;
}); });
await step1Entered; await step1Entered.promise;
await t.step("step 2", () => {}); await t.step("step 2", () => {});
}); });
Deno.test("parallel steps when first has sanitizer", async (t) => { Deno.test("parallel steps when first has sanitizer", async (t) => {
const step1Entered = deferred(); const step1Entered = Promise.withResolvers<void>();
const step2Finished = deferred(); const step2Finished = Promise.withResolvers<void>();
const step1 = t.step({ const step1 = t.step({
name: "step 1", name: "step 1",
fn: async () => { fn: async () => {
step1Entered.resolve(); step1Entered.resolve();
await step2Finished; await step2Finished.promise;
}, },
}); });
await step1Entered; await step1Entered.promise;
await t.step({ await t.step({
name: "step 2", name: "step 2",
fn: () => {}, fn: () => {},
@ -65,19 +63,19 @@ Deno.test("parallel steps when first has sanitizer", async (t) => {
}); });
Deno.test("parallel steps when second has sanitizer", async (t) => { Deno.test("parallel steps when second has sanitizer", async (t) => {
const step1Entered = deferred(); const step1Entered = Promise.withResolvers<void>();
const step2Finished = deferred(); const step2Finished = Promise.withResolvers<void>();
const step1 = t.step({ const step1 = t.step({
name: "step 1", name: "step 1",
fn: async () => { fn: async () => {
step1Entered.resolve(); step1Entered.resolve();
await step2Finished; await step2Finished.promise;
}, },
sanitizeOps: false, sanitizeOps: false,
sanitizeResources: false, sanitizeResources: false,
sanitizeExit: false, sanitizeExit: false,
}); });
await step1Entered; await step1Entered.promise;
await t.step({ await t.step({
name: "step 2", name: "step 2",
fn: async () => { fn: async () => {
@ -91,19 +89,19 @@ Deno.test("parallel steps when second has sanitizer", async (t) => {
Deno.test({ Deno.test({
name: "parallel steps where only inner tests have sanitizers", name: "parallel steps where only inner tests have sanitizers",
fn: async (t) => { fn: async (t) => {
const step1Entered = deferred(); const step1Entered = Promise.withResolvers<void>();
const step2Finished = deferred(); const step2Finished = Promise.withResolvers<void>();
const step1 = t.step("step 1", async (t) => { const step1 = t.step("step 1", async (t) => {
await t.step({ await t.step({
name: "step inner", name: "step inner",
fn: async () => { fn: async () => {
step1Entered.resolve(); step1Entered.resolve();
await step2Finished; await step2Finished.promise;
}, },
sanitizeOps: true, sanitizeOps: true,
}); });
}); });
await step1Entered; await step1Entered.promise;
await t.step("step 2", async (t) => { await t.step("step 2", async (t) => {
await t.step({ await t.step({
name: "step inner", name: "step inner",

6
cli/tests/testdata/test/steps/passing_steps.ts vendored
View file

@ -1,5 +1,3 @@
import { deferred } from "../../../../../test_util/std/async/deferred.ts";
Deno.test("description", async (t) => { Deno.test("description", async (t) => {
const success = await t.step("step 1", async (t) => { const success = await t.step("step 1", async (t) => {
await t.step("inner 1", () => {}); await t.step("inner 1", () => {});
@ -107,9 +105,9 @@ Deno.test("steps buffered then streaming reporting", async (t) => {
name: "step 1", name: "step 1",
fn: async (t) => { fn: async (t) => {
// also ensure the buffered tests display in order regardless of the second one finishing first // also ensure the buffered tests display in order regardless of the second one finishing first
const step2Finished = deferred(); const step2Finished = Promise.withResolvers<void>();
const step1 = t.step("step 1 - 1", async () => { const step1 = t.step("step 1 - 1", async () => {
await step2Finished; await step2Finished.promise;
}); });
const step2 = t.step("step 1 - 2", async (t) => { const step2 = t.step("step 1 - 2", async (t) => {
await t.step("step 1 - 2 - 1", () => {}); await t.step("step 1 - 2 - 1", () => {});

25
cli/tests/testdata/workers/bench_round_robin.ts vendored
View file

@ -5,13 +5,8 @@ const data = "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello World\n";
const workerCount = 4; const workerCount = 4;
const cmdsPerWorker = 400; const cmdsPerWorker = 400;
import {
Deferred,
deferred,
} from "../../../../test_util/std/async/deferred.ts";
function handleAsyncMsgFromWorker( function handleAsyncMsgFromWorker(
promiseTable: Map<number, Deferred<string>>, promiseTable: Map<number, ReturnType<typeof Promise.withResolvers<string>>>,
msg: { cmdId: number; data: string }, msg: { cmdId: number; data: string },
) { ) {
const promise = promiseTable.get(msg.cmdId); const promise = promiseTable.get(msg.cmdId);
@ -22,15 +17,17 @@ function handleAsyncMsgFromWorker(
} }
async function main() { async function main() {
const workers: Array<[Map<number, Deferred<string>>, Worker]> = []; const workers: Array<
[Map<number, ReturnType<typeof Promise.withResolvers<string>>>, Worker]
> = [];
for (let i = 1; i <= workerCount; ++i) { for (let i = 1; i <= workerCount; ++i) {
const worker = new Worker( const worker = new Worker(
import.meta.resolve("./bench_worker.ts"), import.meta.resolve("./bench_worker.ts"),
{ type: "module" }, { type: "module" },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
if (e.data.cmdId === 0) promise.resolve(); if (e.data.cmdId === 0) resolve();
}; };
worker.postMessage({ cmdId: 0, action: 2 }); worker.postMessage({ cmdId: 0, action: 2 });
await promise; await promise;
@ -45,19 +42,19 @@ async function main() {
for (const cmdId of Array(cmdsPerWorker).keys()) { for (const cmdId of Array(cmdsPerWorker).keys()) {
const promises: Array<Promise<string>> = []; const promises: Array<Promise<string>> = [];
for (const [promiseTable, worker] of workers) { for (const [promiseTable, worker] of workers) {
const promise = deferred<string>(); const deferred = Promise.withResolvers<string>();
promiseTable.set(cmdId, promise); promiseTable.set(cmdId, deferred);
worker.postMessage({ cmdId: cmdId, action: 1, data }); worker.postMessage({ cmdId: cmdId, action: 1, data });
promises.push(promise); promises.push(deferred.promise);
} }
for (const promise of promises) { for (const promise of promises) {
await promise; await promise;
} }
} }
for (const [, worker] of workers) { for (const [, worker] of workers) {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
if (e.data.cmdId === 3) promise.resolve(); if (e.data.cmdId === 3) resolve();
}; };
worker.postMessage({ action: 3 }); worker.postMessage({ action: 3 });
await promise; await promise;

185
cli/tests/testdata/workers/test.ts vendored
View file

@ -8,7 +8,6 @@ import {
assertMatch, assertMatch,
assertThrows, assertThrows,
} from "../../../../test_util/std/testing/asserts.ts"; } from "../../../../test_util/std/testing/asserts.ts";
import { deferred } from "../../../../test_util/std/async/deferred.ts";
Deno.test({ Deno.test({
name: "worker terminate", name: "worker terminate",
@ -22,20 +21,20 @@ Deno.test({
{ type: "module", name: "tsWorker" }, { type: "module", name: "tsWorker" },
); );
const promise1 = deferred(); const deferred1 = Promise.withResolvers<string>();
jsWorker.onmessage = (e) => { jsWorker.onmessage = (e) => {
promise1.resolve(e.data); deferred1.resolve(e.data);
}; };
const promise2 = deferred(); const deferred2 = Promise.withResolvers<string>();
tsWorker.onmessage = (e) => { tsWorker.onmessage = (e) => {
promise2.resolve(e.data); deferred2.resolve(e.data);
}; };
jsWorker.postMessage("Hello World"); jsWorker.postMessage("Hello World");
assertEquals(await promise1, "Hello World"); assertEquals(await deferred1.promise, "Hello World");
tsWorker.postMessage("Hello World"); tsWorker.postMessage("Hello World");
assertEquals(await promise2, "Hello World"); assertEquals(await deferred2.promise, "Hello World");
tsWorker.terminate(); tsWorker.terminate();
jsWorker.terminate(); jsWorker.terminate();
}, },
@ -49,9 +48,9 @@ Deno.test({
{ type: "module", name: "tsWorker" }, { type: "module", name: "tsWorker" },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
tsWorker.onmessage = (e) => { tsWorker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
tsWorker.postMessage("Hello World"); tsWorker.postMessage("Hello World");
@ -68,9 +67,10 @@ Deno.test({
{ type: "module", name: "nested" }, { type: "module", name: "nested" },
); );
const promise = deferred(); // deno-lint-ignore no-explicit-any
const { promise, resolve } = Promise.withResolvers<any>();
nestedWorker.onmessage = (e) => { nestedWorker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
nestedWorker.postMessage("Hello World"); nestedWorker.postMessage("Hello World");
@ -87,11 +87,11 @@ Deno.test({
{ type: "module" }, { type: "module" },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
throwingWorker.onerror = (e: any) => { throwingWorker.onerror = (e: any) => {
e.preventDefault(); e.preventDefault();
promise.resolve(e.message); resolve(e.message);
}; };
assertMatch(await promise as string, /Uncaught Error: Thrown error/); assertMatch(await promise as string, /Uncaught Error: Thrown error/);
@ -108,9 +108,9 @@ Deno.test({
workerOptions, workerOptions,
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
w.onmessage = (e) => { w.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
w.postMessage("Hello, world!"); w.postMessage("Hello, world!");
@ -128,9 +128,9 @@ Deno.test({
workerOptions, workerOptions,
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
w.onmessage = (e) => { w.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
w.postMessage("Hello, world!"); w.postMessage("Hello, world!");
@ -147,15 +147,15 @@ Deno.test({
{ type: "module" }, { type: "module" },
); );
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<string>();
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
fetchingWorker.onerror = (e: any) => { fetchingWorker.onerror = (e: any) => {
e.preventDefault(); e.preventDefault();
promise.reject(e.message); reject(e.message);
}; };
// Defer promise.resolve() to allow worker to shut down // Defer promise.resolve() to allow worker to shut down
fetchingWorker.onmessage = (e) => { fetchingWorker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
assertEquals(await promise, "Done!"); assertEquals(await promise, "Done!");
@ -166,7 +166,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "worker terminate busy loop", name: "worker terminate busy loop",
fn: async function () { fn: async function () {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<number>();
const busyWorker = new Worker( const busyWorker = new Worker(
import.meta.resolve("./busy_worker.js"), import.meta.resolve("./busy_worker.js"),
@ -183,7 +183,7 @@ Deno.test({
throw new Error("unreachable"); throw new Error("unreachable");
}; };
setTimeout(() => { setTimeout(() => {
promise.resolve(testResult); resolve(testResult);
}, 100); }, 100);
} }
}; };
@ -198,7 +198,7 @@ Deno.test({
fn: async function () { fn: async function () {
// See issue for details // See issue for details
// https://github.com/denoland/deno/issues/4080 // https://github.com/denoland/deno/issues/4080
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const racyWorker = new Worker( const racyWorker = new Worker(
import.meta.resolve("./racy_worker.js"), import.meta.resolve("./racy_worker.js"),
@ -207,7 +207,7 @@ Deno.test({
racyWorker.onmessage = (_e) => { racyWorker.onmessage = (_e) => {
setTimeout(() => { setTimeout(() => {
promise.resolve(); resolve();
}, 100); }, 100);
}; };
@ -222,8 +222,8 @@ Deno.test({
let messageHandlersCalled = 0; let messageHandlersCalled = 0;
let errorHandlersCalled = 0; let errorHandlersCalled = 0;
const promise1 = deferred(); const deferred1 = Promise.withResolvers<void>();
const promise2 = deferred(); const deferred2 = Promise.withResolvers<void>();
const worker = new Worker( const worker = new Worker(
import.meta.resolve("./event_worker.js"), import.meta.resolve("./event_worker.js"),
@ -238,7 +238,7 @@ Deno.test({
}); });
worker.addEventListener("message", (_e: Event) => { worker.addEventListener("message", (_e: Event) => {
messageHandlersCalled++; messageHandlersCalled++;
promise1.resolve(); deferred1.resolve();
}); });
worker.onerror = (e) => { worker.onerror = (e) => {
@ -250,15 +250,15 @@ Deno.test({
}); });
worker.addEventListener("error", (_e: Event) => { worker.addEventListener("error", (_e: Event) => {
errorHandlersCalled++; errorHandlersCalled++;
promise2.resolve(); deferred2.resolve();
}); });
worker.postMessage("ping"); worker.postMessage("ping");
await promise1; await deferred1.promise;
assertEquals(messageHandlersCalled, 3); assertEquals(messageHandlersCalled, 3);
worker.postMessage("boom"); worker.postMessage("boom");
await promise2; await deferred2.promise;
assertEquals(errorHandlersCalled, 3); assertEquals(errorHandlersCalled, 3);
worker.terminate(); worker.terminate();
}, },
@ -272,9 +272,10 @@ Deno.test({
{ type: "module" }, { type: "module" },
); );
const promise = deferred(); // deno-lint-ignore no-explicit-any
const { promise, resolve } = Promise.withResolvers<any>();
worker.onmessage = (e: MessageEvent) => { worker.onmessage = (e: MessageEvent) => {
promise.resolve(e.data); resolve(e.data);
}; };
worker.onerror = (_e) => { worker.onerror = (_e) => {
throw new Error("unreachable"); throw new Error("unreachable");
@ -298,10 +299,10 @@ Deno.test({
{ type: "module", deno: { permissions: "inherit" } }, { type: "module", deno: { permissions: "inherit" } },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
denoWorker.onmessage = (e) => { denoWorker.onmessage = (e) => {
denoWorker.terminate(); denoWorker.terminate();
promise.resolve(e.data); resolve(e.data);
}; };
denoWorker.postMessage("Hello World"); denoWorker.postMessage("Hello World");
@ -317,9 +318,9 @@ Deno.test({
{ type: "module" }, { type: "module" },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<boolean>();
w.onmessage = (e) => { w.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
w.postMessage(null); w.postMessage(null);
@ -331,7 +332,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "Worker event handler order", name: "Worker event handler order",
fn: async function () { fn: async function () {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const w = new Worker( const w = new Worker(
import.meta.resolve("./test_worker.ts"), import.meta.resolve("./test_worker.ts"),
{ type: "module", name: "tsWorker" }, { type: "module", name: "tsWorker" },
@ -343,7 +344,7 @@ Deno.test({
}; };
w.addEventListener("message", () => arr.push(3)); w.addEventListener("message", () => arr.push(3));
w.addEventListener("message", () => { w.addEventListener("message", () => {
promise.resolve(); resolve();
}); });
w.postMessage("Hello World"); w.postMessage("Hello World");
await promise; await promise;
@ -355,13 +356,13 @@ Deno.test({
Deno.test({ Deno.test({
name: "Worker immediate close", name: "Worker immediate close",
fn: async function () { fn: async function () {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const w = new Worker( const w = new Worker(
import.meta.resolve("./immediately_close_worker.js"), import.meta.resolve("./immediately_close_worker.js"),
{ type: "module" }, { type: "module" },
); );
setTimeout(() => { setTimeout(() => {
promise.resolve(); resolve();
}, 1000); }, 1000);
await promise; await promise;
w.terminate(); w.terminate();
@ -371,7 +372,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "Worker post undefined", name: "Worker post undefined",
fn: async function () { fn: async function () {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const worker = new Worker( const worker = new Worker(
import.meta.resolve("./post_undefined.ts"), import.meta.resolve("./post_undefined.ts"),
{ type: "module" }, { type: "module" },
@ -380,7 +381,7 @@ Deno.test({
const handleWorkerMessage = (e: MessageEvent) => { const handleWorkerMessage = (e: MessageEvent) => {
console.log("main <- worker:", e.data); console.log("main <- worker:", e.data);
worker.terminate(); worker.terminate();
promise.resolve(); resolve();
}; };
worker.addEventListener("messageerror", () => console.log("message error")); worker.addEventListener("messageerror", () => console.log("message error"));
@ -399,9 +400,9 @@ Deno.test("Worker inherits permissions", async function () {
{ type: "module", deno: { permissions: "inherit" } }, { type: "module", deno: { permissions: "inherit" } },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<boolean>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
worker.postMessage(null); worker.postMessage(null);
@ -415,9 +416,9 @@ Deno.test("Worker limit children permissions", async function () {
{ type: "module", deno: { permissions: { read: false } } }, { type: "module", deno: { permissions: { read: false } } },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<boolean>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
worker.postMessage(null); worker.postMessage(null);
@ -443,8 +444,9 @@ Deno.test("Worker limit children permissions granularly", async function () {
}, },
}, },
); );
const promise = deferred(); // deno-lint-ignore no-explicit-any
worker.onmessage = ({ data }) => promise.resolve(data); const { promise, resolve } = Promise.withResolvers<any>();
worker.onmessage = ({ data }) => resolve(data);
assertEquals(await promise, { assertEquals(await promise, {
envGlobal: "prompt", envGlobal: "prompt",
envFoo: "granted", envFoo: "granted",
@ -482,8 +484,9 @@ Deno.test("Nested worker limit children permissions", async function () {
import.meta.resolve("./parent_read_check_worker.js"), import.meta.resolve("./parent_read_check_worker.js"),
{ type: "module", deno: { permissions: "inherit" } }, { type: "module", deno: { permissions: "inherit" } },
); );
const promise = deferred(); // deno-lint-ignore no-explicit-any
worker.onmessage = ({ data }) => promise.resolve(data); const { promise, resolve } = Promise.withResolvers<any>();
worker.onmessage = ({ data }) => resolve(data);
assertEquals(await promise, { assertEquals(await promise, {
envGlobal: "prompt", envGlobal: "prompt",
envFoo: "prompt", envFoo: "prompt",
@ -541,9 +544,9 @@ Deno.test("Worker with disabled permissions", async function () {
{ type: "module", deno: { permissions: "none" } }, { type: "module", deno: { permissions: "none" } },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<boolean>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
worker.postMessage(null); worker.postMessage(null);
@ -557,9 +560,10 @@ Deno.test("Worker permissions are not inherited with empty permission object", a
{ type: "module", deno: { permissions: {} } }, { type: "module", deno: { permissions: {} } },
); );
const promise = deferred(); // deno-lint-ignore no-explicit-any
const { promise, resolve } = Promise.withResolvers<any>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
worker.postMessage(null); worker.postMessage(null);
@ -581,9 +585,10 @@ Deno.test("Worker permissions are not inherited with single specified permission
{ type: "module", deno: { permissions: { net: true } } }, { type: "module", deno: { permissions: { net: true } } },
); );
const promise = deferred(); // deno-lint-ignore no-explicit-any
const { promise, resolve } = Promise.withResolvers<any>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
worker.postMessage(null); worker.postMessage(null);
@ -615,11 +620,11 @@ Deno.test("Worker with invalid permission arg", function () {
Deno.test({ Deno.test({
name: "worker location", name: "worker location",
fn: async function () { fn: async function () {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
const workerModuleHref = import.meta.resolve("./worker_location.ts"); const workerModuleHref = import.meta.resolve("./worker_location.ts");
const w = new Worker(workerModuleHref, { type: "module" }); const w = new Worker(workerModuleHref, { type: "module" });
w.onmessage = (e) => { w.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
w.postMessage("Hello, world!"); w.postMessage("Hello, world!");
assertEquals(await promise, `${workerModuleHref}, true`); assertEquals(await promise, `${workerModuleHref}, true`);
@ -635,9 +640,9 @@ Deno.test({
"./workers/test_worker.ts", "./workers/test_worker.ts",
{ type: "module", name: "tsWorker" }, { type: "module", name: "tsWorker" },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
w.onmessage = (e) => { w.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
w.postMessage("Hello, world!"); w.postMessage("Hello, world!");
assertEquals(await promise, "Hello, world!"); assertEquals(await promise, "Hello, world!");
@ -648,7 +653,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "Worker with top-level-await", name: "Worker with top-level-await",
fn: async function () { fn: async function () {
const result = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const worker = new Worker( const worker = new Worker(
import.meta.resolve("./worker_with_top_level_await.ts"), import.meta.resolve("./worker_with_top_level_await.ts"),
{ type: "module" }, { type: "module" },
@ -657,12 +662,12 @@ Deno.test({
if (e.data == "ready") { if (e.data == "ready") {
worker.postMessage("trigger worker handler"); worker.postMessage("trigger worker handler");
} else if (e.data == "triggered worker handler") { } else if (e.data == "triggered worker handler") {
result.resolve(); resolve();
} else { } else {
result.reject(new Error("Handler didn't run during top-level delay.")); reject(new Error("Handler didn't run during top-level delay."));
} }
}; };
await result; await promise;
worker.terminate(); worker.terminate();
}, },
}); });
@ -670,15 +675,15 @@ Deno.test({
Deno.test({ Deno.test({
name: "Worker with native HTTP", name: "Worker with native HTTP",
fn: async function () { fn: async function () {
const result = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const worker = new Worker( const worker = new Worker(
import.meta.resolve("./http_worker.js"), import.meta.resolve("./http_worker.js"),
{ type: "module", deno: { permissions: "inherit" } }, { type: "module", deno: { permissions: "inherit" } },
); );
worker.onmessage = () => { worker.onmessage = () => {
result.resolve(); resolve();
}; };
await result; await promise;
assert(worker); assert(worker);
const response = await fetch("http://localhost:4506"); const response = await fetch("http://localhost:4506");
@ -695,14 +700,14 @@ Deno.test({
{ type: "module" }, { type: "module" },
); );
const result = deferred(); // deno-lint-ignore no-explicit-any
const { promise, resolve } = Promise.withResolvers<any>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
result.resolve(e.data); resolve(e.data);
}; };
worker.postMessage("START"); worker.postMessage("START");
// deno-lint-ignore no-explicit-any const data = await promise;
const data = await result as any;
// self field should reference itself (circular ref) // self field should reference itself (circular ref)
assert(data === data.self); assert(data === data.self);
// fields a and b refer to the same array // fields a and b refer to the same array
@ -729,9 +734,9 @@ Deno.test({
"./workers/test_worker.ts", "./workers/test_worker.ts",
{ type: "module", name: "tsWorker" }, { type: "module", name: "tsWorker" },
); );
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<string>();
w.onmessage = (e) => { w.onmessage = (e) => {
promise.resolve(e.data); resolve(e.data);
}; };
w.postMessage("Hello, world!"); w.postMessage("Hello, world!");
assertEquals(await promise, "Hello, world!"); assertEquals(await promise, "Hello, world!");
@ -742,7 +747,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "worker SharedArrayBuffer", name: "worker SharedArrayBuffer",
fn: async function () { fn: async function () {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const workerOptions: WorkerOptions = { type: "module" }; const workerOptions: WorkerOptions = { type: "module" };
const w = new Worker( const w = new Worker(
import.meta.resolve("./shared_array_buffer.ts"), import.meta.resolve("./shared_array_buffer.ts"),
@ -757,7 +762,7 @@ Deno.test({
w.onmessage = () => { w.onmessage = () => {
w.postMessage([sab1, sab2]); w.postMessage([sab1, sab2]);
w.onmessage = () => { w.onmessage = () => {
promise.resolve(); resolve();
}; };
}; };
await promise; await promise;
@ -776,30 +781,31 @@ Deno.test({
); );
const channel = new MessageChannel(); const channel = new MessageChannel();
const promise1 = deferred(); // deno-lint-ignore no-explicit-any
const promise2 = deferred(); const deferred1 = Promise.withResolvers<any>();
const promise3 = deferred(); const deferred2 = Promise.withResolvers<boolean>();
const result = deferred(); const deferred3 = Promise.withResolvers<boolean>();
const result = Promise.withResolvers<void>();
worker.onmessage = (e) => { worker.onmessage = (e) => {
promise1.resolve([e.data, e.ports.length]); deferred1.resolve([e.data, e.ports.length]);
const port1 = e.ports[0]; const port1 = e.ports[0];
port1.onmessage = (e) => { port1.onmessage = (e) => {
promise2.resolve(e.data); deferred2.resolve(e.data);
port1.close(); port1.close();
worker.postMessage("3", [channel.port1]); worker.postMessage("3", [channel.port1]);
}; };
port1.postMessage("2"); port1.postMessage("2");
}; };
channel.port2.onmessage = (e) => { channel.port2.onmessage = (e) => {
promise3.resolve(e.data); deferred3.resolve(e.data);
channel.port2.close(); channel.port2.close();
result.resolve(); result.resolve();
}; };
assertEquals(await promise1, ["1", 1]); assertEquals(await deferred1.promise, ["1", 1]);
assertEquals(await promise2, true); assertEquals(await deferred2.promise, true);
assertEquals(await promise3, true); assertEquals(await deferred3.promise, true);
await result; await result.promise;
worker.terminate(); worker.terminate();
}, },
}); });
@ -818,14 +824,15 @@ Deno.test({
w.postMessage(null); w.postMessage(null);
const memoryUsagePromise = deferred(); // deno-lint-ignore no-explicit-any
const { promise, resolve } = Promise.withResolvers<any>();
w.onmessage = function (evt) { w.onmessage = function (evt) {
memoryUsagePromise.resolve(evt.data); resolve(evt.data);
}; };
assertEquals( assertEquals(
Object.keys( Object.keys(
await memoryUsagePromise as unknown as Record<string, number>, await promise as unknown as Record<string, number>,
), ),
["rss", "heapTotal", "heapUsed", "external"], ["rss", "heapTotal", "heapUsed", "external"],
); );

17
cli/tests/unit/http_test.ts
View file

@ -8,7 +8,6 @@ import {
assertRejects, assertRejects,
assertStrictEquals, assertStrictEquals,
assertThrows, assertThrows,
deferred,
delay, delay,
fail, fail,
} from "./test_util.ts"; } from "./test_util.ts";
@ -592,9 +591,9 @@ Deno.test(
let counter = 0; let counter = 0;
const deferreds = [ const deferreds = [
deferred(), Promise.withResolvers<void>(),
deferred(), Promise.withResolvers<void>(),
deferred(), Promise.withResolvers<void>(),
]; ];
async function writeRequest(conn: Deno.Conn) { async function writeRequest(conn: Deno.Conn) {
@ -639,7 +638,7 @@ Deno.test(
return controller.close(); return controller.close();
} }
await deferreds[counter - 1]; await deferreds[counter - 1].promise;
controller.enqueue(`${counter}\n`); controller.enqueue(`${counter}\n`);
counter++; counter++;
@ -795,13 +794,13 @@ Deno.test({ permissions: { net: true } }, async function httpServerWebSocket() {
await close; await close;
})(); })();
const def = deferred(); const def = Promise.withResolvers<void>();
const ws = new WebSocket(`ws://localhost:${listenPort}`); const ws = new WebSocket(`ws://localhost:${listenPort}`);
ws.onmessage = (m) => assertEquals(m.data, "foo"); ws.onmessage = (m) => assertEquals(m.data, "foo");
ws.onerror = () => fail(); ws.onerror = () => fail();
ws.onclose = () => def.resolve(); ws.onclose = () => def.resolve();
ws.onopen = () => ws.send("foo"); ws.onopen = () => ws.send("foo");
await def; await def.promise;
await promise; await promise;
}); });
@ -2287,7 +2286,7 @@ Deno.test("upgradeHttp unix", {
ignore: Deno.build.os === "windows", ignore: Deno.build.os === "windows",
}, async () => { }, async () => {
const filePath = tmpUnixSocketPath(); const filePath = tmpUnixSocketPath();
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
async function client() { async function client() {
const unixConn = await Deno.connect({ path: filePath, transport: "unix" }); const unixConn = await Deno.connect({ path: filePath, transport: "unix" });
@ -2303,7 +2302,7 @@ Deno.test("upgradeHttp unix", {
), ),
); );
unixConn.close(); unixConn.close();
promise.resolve(); resolve();
}, 500); }, 500);
await promise; await promise;
} }

80
cli/tests/unit/kv_test.ts
View file

@ -6,8 +6,6 @@ import {
assertNotEquals, assertNotEquals,
assertRejects, assertRejects,
assertThrows, assertThrows,
Deferred,
deferred,
} from "./test_util.ts"; } from "./test_util.ts";
import { assertType, IsExact } from "../../../test_util/std/testing/types.ts"; import { assertType, IsExact } from "../../../test_util/std/testing/types.ts";
@ -1404,11 +1402,11 @@ async function _typeCheckingTests() {
} }
queueTest("basic listenQueue and enqueue", async (db) => { queueTest("basic listenQueue and enqueue", async (db) => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db.listenQueue((msg) => { const listener = db.listenQueue((msg) => {
dequeuedMessage = msg; dequeuedMessage = msg;
promise.resolve(); resolve();
}); });
try { try {
const res = await db.enqueue("test"); const res = await db.enqueue("test");
@ -1426,17 +1424,19 @@ for (const { name, value } of VALUE_CASES) {
queueTest(`listenQueue and enqueue ${name}`, async (db) => { queueTest(`listenQueue and enqueue ${name}`, async (db) => {
const numEnqueues = 10; const numEnqueues = 10;
let count = 0; let count = 0;
const promises: Deferred<unknown>[] = []; const deferreds: ReturnType<typeof Promise.withResolvers<unknown>>[] = [];
const listeners: Promise<void>[] = []; const listeners: Promise<void>[] = [];
listeners.push(db.listenQueue((msg: unknown) => { listeners.push(db.listenQueue((msg: unknown) => {
promises[count++].resolve(msg); deferreds[count++].resolve(msg);
})); }));
try { try {
for (let i = 0; i < numEnqueues; i++) { for (let i = 0; i < numEnqueues; i++) {
promises.push(deferred()); deferreds.push(Promise.withResolvers<unknown>());
await db.enqueue(value); await db.enqueue(value);
} }
const dequeuedMessages = await Promise.all(promises); const dequeuedMessages = await Promise.all(
deferreds.map(({ promise }) => promise),
);
for (let i = 0; i < numEnqueues; i++) { for (let i = 0; i < numEnqueues; i++) {
assertEquals(dequeuedMessages[i], value); assertEquals(dequeuedMessages[i], value);
} }
@ -1450,17 +1450,17 @@ for (const { name, value } of VALUE_CASES) {
} }
queueTest("queue mixed types", async (db) => { queueTest("queue mixed types", async (db) => {
let promise: Deferred<void>; let deferred: ReturnType<typeof Promise.withResolvers<void>>;
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db.listenQueue((msg: unknown) => { const listener = db.listenQueue((msg: unknown) => {
dequeuedMessage = msg; dequeuedMessage = msg;
promise.resolve(); deferred.resolve();
}); });
try { try {
for (const item of VALUE_CASES) { for (const item of VALUE_CASES) {
promise = deferred(); deferred = Promise.withResolvers<void>();
await db.enqueue(item.value); await db.enqueue(item.value);
await promise; await deferred.promise;
assertEquals(dequeuedMessage, item.value); assertEquals(dequeuedMessage, item.value);
} }
} finally { } finally {
@ -1471,12 +1471,12 @@ queueTest("queue mixed types", async (db) => {
queueTest("queue delay", async (db) => { queueTest("queue delay", async (db) => {
let dequeueTime: number | undefined; let dequeueTime: number | undefined;
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db.listenQueue((msg) => { const listener = db.listenQueue((msg) => {
dequeueTime = Date.now(); dequeueTime = Date.now();
dequeuedMessage = msg; dequeuedMessage = msg;
promise.resolve(); resolve();
}); });
try { try {
const enqueueTime = Date.now(); const enqueueTime = Date.now();
@ -1493,12 +1493,12 @@ queueTest("queue delay", async (db) => {
queueTest("queue delay with atomic", async (db) => { queueTest("queue delay with atomic", async (db) => {
let dequeueTime: number | undefined; let dequeueTime: number | undefined;
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db.listenQueue((msg) => { const listener = db.listenQueue((msg) => {
dequeueTime = Date.now(); dequeueTime = Date.now();
dequeuedMessage = msg; dequeuedMessage = msg;
promise.resolve(); resolve();
}); });
try { try {
const enqueueTime = Date.now(); const enqueueTime = Date.now();
@ -1520,14 +1520,14 @@ queueTest("queue delay with atomic", async (db) => {
queueTest("queue delay and now", async (db) => { queueTest("queue delay and now", async (db) => {
let count = 0; let count = 0;
let dequeueTime: number | undefined; let dequeueTime: number | undefined;
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db.listenQueue((msg) => { const listener = db.listenQueue((msg) => {
count += 1; count += 1;
if (count == 2) { if (count == 2) {
dequeueTime = Date.now(); dequeueTime = Date.now();
dequeuedMessage = msg; dequeuedMessage = msg;
promise.resolve(); resolve();
} }
}); });
try { try {
@ -1564,12 +1564,12 @@ dbTest("queue large delay", async (db) => {
}); });
queueTest("listenQueue with async callback", async (db) => { queueTest("listenQueue with async callback", async (db) => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db.listenQueue(async (msg) => { const listener = db.listenQueue(async (msg) => {
dequeuedMessage = msg; dequeuedMessage = msg;
await sleep(100); await sleep(100);
promise.resolve(); resolve();
}); });
try { try {
await db.enqueue("test"); await db.enqueue("test");
@ -1603,20 +1603,20 @@ queueTest("queue retries", async (db) => {
queueTest("multiple listenQueues", async (db) => { queueTest("multiple listenQueues", async (db) => {
const numListens = 10; const numListens = 10;
let count = 0; let count = 0;
const promises: Deferred<void>[] = []; const deferreds: ReturnType<typeof Promise.withResolvers<void>>[] = [];
const dequeuedMessages: unknown[] = []; const dequeuedMessages: unknown[] = [];
const listeners: Promise<void>[] = []; const listeners: Promise<void>[] = [];
for (let i = 0; i < numListens; i++) { for (let i = 0; i < numListens; i++) {
listeners.push(db.listenQueue((msg) => { listeners.push(db.listenQueue((msg) => {
dequeuedMessages.push(msg); dequeuedMessages.push(msg);
promises[count++].resolve(); deferreds[count++].resolve();
})); }));
} }
try { try {
for (let i = 0; i < numListens; i++) { for (let i = 0; i < numListens; i++) {
promises.push(deferred()); deferreds.push(Promise.withResolvers<void>());
await db.enqueue("msg_" + i); await db.enqueue("msg_" + i);
await promises[i]; await deferreds[i].promise;
const msg = dequeuedMessages[i]; const msg = dequeuedMessages[i];
assertEquals("msg_" + i, msg); assertEquals("msg_" + i, msg);
} }
@ -1629,11 +1629,11 @@ queueTest("multiple listenQueues", async (db) => {
}); });
queueTest("enqueue with atomic", async (db) => { queueTest("enqueue with atomic", async (db) => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db.listenQueue((msg) => { const listener = db.listenQueue((msg) => {
dequeuedMessage = msg; dequeuedMessage = msg;
promise.resolve(); resolve();
}); });
try { try {
@ -1661,7 +1661,7 @@ queueTest("enqueue with atomic", async (db) => {
}); });
queueTest("enqueue with atomic nonce", async (db) => { queueTest("enqueue with atomic nonce", async (db) => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const nonce = crypto.randomUUID(); const nonce = crypto.randomUUID();
@ -1672,7 +1672,7 @@ queueTest("enqueue with atomic nonce", async (db) => {
const nonceValue = await db.get(["nonces", nonce]); const nonceValue = await db.get(["nonces", nonce]);
if (nonceValue.versionstamp === null) { if (nonceValue.versionstamp === null) {
dequeuedMessage = message.msg; dequeuedMessage = message.msg;
promise.resolve(); resolve();
return; return;
} }
@ -1720,13 +1720,13 @@ Deno.test({
let db: Deno.Kv = await Deno.openKv(filename); let db: Deno.Kv = await Deno.openKv(filename);
let count = 0; let count = 0;
let promise = deferred(); let deferred = Promise.withResolvers<void>();
// Register long-running handler. // Register long-running handler.
let listener = db.listenQueue(async (_msg) => { let listener = db.listenQueue(async (_msg) => {
count += 1; count += 1;
if (count == 3) { if (count == 3) {
promise.resolve(); deferred.resolve();
} }
await new Promise(() => {}); await new Promise(() => {});
}); });
@ -1735,7 +1735,7 @@ Deno.test({
await db.enqueue("msg0"); await db.enqueue("msg0");
await db.enqueue("msg1"); await db.enqueue("msg1");
await db.enqueue("msg2"); await db.enqueue("msg2");
await promise; await deferred.promise;
// Close the database and wait for the listener to finish. // Close the database and wait for the listener to finish.
db.close(); db.close();
@ -1751,18 +1751,18 @@ Deno.test({
db = await Deno.openKv(filename); db = await Deno.openKv(filename);
count = 0; count = 0;
promise = deferred(); deferred = Promise.withResolvers<void>();
// Register a handler that will complete quickly. // Register a handler that will complete quickly.
listener = db.listenQueue((_msg) => { listener = db.listenQueue((_msg) => {
count += 1; count += 1;
if (count == 3) { if (count == 3) {
promise.resolve(); deferred.resolve();
} }
}); });
// Wait for the handlers to finish. // Wait for the handlers to finish.
await promise; await deferred.promise;
assertEquals(3, count); assertEquals(3, count);
db.close(); db.close();
await listener; await listener;
@ -1789,7 +1789,7 @@ Deno.test({
let db: Deno.Kv = await Deno.openKv(filename); let db: Deno.Kv = await Deno.openKv(filename);
let count = 0; let count = 0;
let promise = deferred(); let deferred = Promise.withResolvers<void>();
// Register long-running handler. // Register long-running handler.
let listener = db.listenQueue((_msg) => {}); let listener = db.listenQueue((_msg) => {});
@ -1807,18 +1807,18 @@ Deno.test({
db = await Deno.openKv(filename); db = await Deno.openKv(filename);
count = 0; count = 0;
promise = deferred(); deferred = Promise.withResolvers<void>();
// Register a handler that will complete quickly. // Register a handler that will complete quickly.
listener = db.listenQueue((_msg) => { listener = db.listenQueue((_msg) => {
count += 1; count += 1;
if (count == 3) { if (count == 3) {
promise.resolve(); deferred.resolve();
} }
}); });
// Wait for the handlers to finish. // Wait for the handlers to finish.
await promise; await deferred.promise;
assertEquals(3, count); assertEquals(3, count);
db.close(); db.close();
await listener; await listener;
@ -1839,11 +1839,11 @@ Deno.test({
try { try {
const db0 = await Deno.openKv(filename); const db0 = await Deno.openKv(filename);
const db1 = await Deno.openKv(filename); const db1 = await Deno.openKv(filename);
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
let dequeuedMessage: unknown = null; let dequeuedMessage: unknown = null;
const listener = db0.listenQueue((msg) => { const listener = db0.listenQueue((msg) => {
dequeuedMessage = msg; dequeuedMessage = msg;
promise.resolve(); resolve();
}); });
try { try {
const res = await db1.enqueue("test"); const res = await db1.enqueue("test");

778
cli/tests/unit/serve_test.ts
View file

File diff suppressed because it is too large Load diff

2
cli/tests/unit/test_util.ts
View file

@ -20,8 +20,6 @@ export {
unimplemented, unimplemented,
unreachable, unreachable,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
export { deferred } from "../../../test_util/std/async/deferred.ts";
export type { Deferred } from "../../../test_util/std/async/deferred.ts";
export { delay } from "../../../test_util/std/async/delay.ts"; export { delay } from "../../../test_util/std/async/delay.ts";
export { readLines } from "../../../test_util/std/io/read_lines.ts"; export { readLines } from "../../../test_util/std/io/read_lines.ts";
export { parse as parseArgs } from "../../../test_util/std/flags/mod.ts"; export { parse as parseArgs } from "../../../test_util/std/flags/mod.ts";

49
cli/tests/unit/tls_test.ts
View file

@ -6,8 +6,6 @@ import {
assertRejects, assertRejects,
assertStrictEquals, assertStrictEquals,
assertThrows, assertThrows,
Deferred,
deferred,
} from "./test_util.ts"; } from "./test_util.ts";
import { BufReader, BufWriter } from "../../../test_util/std/io/mod.ts"; import { BufReader, BufWriter } from "../../../test_util/std/io/mod.ts";
import { readAll } from "../../../test_util/std/streams/read_all.ts"; import { readAll } from "../../../test_util/std/streams/read_all.ts";
@ -178,7 +176,7 @@ Deno.test(
Deno.test( Deno.test(
{ permissions: { read: true, net: true } }, { permissions: { read: true, net: true } },
async function dialAndListenTLS() { async function dialAndListenTLS() {
const resolvable = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const hostname = "localhost"; const hostname = "localhost";
const port = 3500; const port = 3500;
@ -201,7 +199,7 @@ Deno.test(
// TODO(bartlomieju): this might be a bug // TODO(bartlomieju): this might be a bug
setTimeout(() => { setTimeout(() => {
conn.close(); conn.close();
resolvable.resolve(); resolve();
}, 0); }, 0);
}, },
); );
@ -231,13 +229,13 @@ Deno.test(
assertEquals(decoder.decode(bodyBuf), "Hello World\n"); assertEquals(decoder.decode(bodyBuf), "Hello World\n");
conn.close(); conn.close();
listener.close(); listener.close();
await resolvable; await promise;
}, },
); );
Deno.test( Deno.test(
{ permissions: { read: false, net: true } }, { permissions: { read: false, net: true } },
async function listenTlsWithCertAndKey() { async function listenTlsWithCertAndKey() {
const resolvable = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const hostname = "localhost"; const hostname = "localhost";
const port = 3500; const port = 3500;
@ -254,7 +252,7 @@ Deno.test(
await conn.write(response); await conn.write(response);
setTimeout(() => { setTimeout(() => {
conn.close(); conn.close();
resolvable.resolve(); resolve();
}, 0); }, 0);
}, },
); );
@ -284,7 +282,7 @@ Deno.test(
assertEquals(decoder.decode(bodyBuf), "Hello World\n"); assertEquals(decoder.decode(bodyBuf), "Hello World\n");
conn.close(); conn.close();
listener.close(); listener.close();
await resolvable; await promise;
}, },
); );
@ -770,20 +768,20 @@ async function tlsWithTcpFailureTestImpl(
tcpConn2: tcpClientConn, tcpConn2: tcpClientConn,
}; };
const tcpForwardingInterruptPromise1 = deferred<void>(); const tcpForwardingInterruptDeferred1 = Promise.withResolvers<void>();
const tcpForwardingPromise1 = forwardBytes( const tcpForwardingPromise1 = forwardBytes(
tcpConn2, tcpConn2,
tcpConn1, tcpConn1,
cipherByteCount, cipherByteCount,
tcpForwardingInterruptPromise1, tcpForwardingInterruptDeferred1,
); );
const tcpForwardingInterruptPromise2 = deferred<void>(); const tcpForwardingInterruptDeferred2 = Promise.withResolvers<void>();
const tcpForwardingPromise2 = forwardBytes( const tcpForwardingPromise2 = forwardBytes(
tcpConn1, tcpConn1,
tcpConn2, tcpConn2,
Infinity, Infinity,
tcpForwardingInterruptPromise2, tcpForwardingInterruptDeferred2,
); );
switch (phase) { switch (phase) {
@ -836,7 +834,7 @@ async function tlsWithTcpFailureTestImpl(
} }
await tlsTrafficPromise1; await tlsTrafficPromise1;
tcpForwardingInterruptPromise2.resolve(); tcpForwardingInterruptDeferred2.resolve();
await tcpForwardingPromise2; await tcpForwardingPromise2;
await tcpConn2.closeWrite(); await tcpConn2.closeWrite();
await tlsTrafficPromise2; await tlsTrafficPromise2;
@ -852,8 +850,8 @@ async function tlsWithTcpFailureTestImpl(
receiveBytes(tlsConn2, 0x99, 99999), receiveBytes(tlsConn2, 0x99, 99999),
]); ]);
tcpForwardingInterruptPromise1.resolve(); tcpForwardingInterruptDeferred1.resolve();
await tcpForwardingPromise1; await tcpForwardingInterruptDeferred1.promise;
switch (failureMode) { switch (failureMode) {
case "corruption": case "corruption":
@ -862,7 +860,7 @@ async function tlsWithTcpFailureTestImpl(
() => receiveEof(tlsConn1), () => receiveEof(tlsConn1),
Deno.errors.InvalidData, Deno.errors.InvalidData,
); );
tcpForwardingInterruptPromise2.resolve(); tcpForwardingInterruptDeferred2.resolve();
break; break;
case "shutdown": case "shutdown":
await Promise.all([ await Promise.all([
@ -934,12 +932,15 @@ async function tlsWithTcpFailureTestImpl(
source: Deno.Conn, source: Deno.Conn,
sink: Deno.Conn, sink: Deno.Conn,
count: number, count: number,
interruptPromise: Deferred<void>, interruptPromise: ReturnType<typeof Promise.withResolvers<void>>,
) { ) {
let buf = new Uint8Array(1 << 12 /* 4 kB */); let buf = new Uint8Array(1 << 12 /* 4 kB */);
while (count > 0) { while (count > 0) {
buf = buf.subarray(0, Math.min(buf.length, count)); buf = buf.subarray(0, Math.min(buf.length, count));
const nread = await Promise.race([source.read(buf), interruptPromise]); const nread = await Promise.race([
source.read(buf),
interruptPromise.promise,
]);
if (nread == null) break; // Either EOF or interrupted. if (nread == null) break; // Either EOF or interrupted.
const nwritten = await sink.write(buf.subarray(0, nread)); const nwritten = await sink.write(buf.subarray(0, nread));
assertStrictEquals(nread, nwritten); assertStrictEquals(nread, nwritten);
@ -1405,7 +1406,7 @@ Deno.test(
Deno.test( Deno.test(
{ permissions: { net: true } }, { permissions: { net: true } },
async function listenTlsWithReuseAddr() { async function listenTlsWithReuseAddr() {
const resolvable1 = deferred(); const deferred1 = Promise.withResolvers<void>();
const hostname = "localhost"; const hostname = "localhost";
const port = 3500; const port = 3500;
@ -1413,25 +1414,25 @@ Deno.test(
listener1.accept().then((conn) => { listener1.accept().then((conn) => {
conn.close(); conn.close();
resolvable1.resolve(); deferred1.resolve();
}); });
const conn1 = await Deno.connectTls({ hostname, port, caCerts }); const conn1 = await Deno.connectTls({ hostname, port, caCerts });
conn1.close(); conn1.close();
await resolvable1; await deferred1.promise;
listener1.close(); listener1.close();
const resolvable2 = deferred(); const deferred2 = Promise.withResolvers<void>();
const listener2 = Deno.listenTls({ hostname, port, cert, key }); const listener2 = Deno.listenTls({ hostname, port, cert, key });
listener2.accept().then((conn) => { listener2.accept().then((conn) => {
conn.close(); conn.close();
resolvable2.resolve(); deferred2.resolve();
}); });
const conn2 = await Deno.connectTls({ hostname, port, caCerts }); const conn2 = await Deno.connectTls({ hostname, port, caCerts });
conn2.close(); conn2.close();
await resolvable2; await deferred2.promise;
listener2.close(); listener2.close();
}, },
); );

92
cli/tests/unit/websocket_test.ts
View file

@ -1,11 +1,5 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
import { import { assert, assertEquals, assertThrows, fail } from "./test_util.ts";
assert,
assertEquals,
assertThrows,
deferred,
fail,
} from "./test_util.ts";
const servePort = 4248; const servePort = 4248;
const serveUrl = `ws://localhost:${servePort}/`; const serveUrl = `ws://localhost:${servePort}/`;
@ -18,23 +12,23 @@ Deno.test({ permissions: "none" }, function websocketPermissionless() {
}); });
Deno.test(async function websocketConstructorTakeURLObjectAsParameter() { Deno.test(async function websocketConstructorTakeURLObjectAsParameter() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const ws = new WebSocket(new URL("ws://localhost:4242/")); const ws = new WebSocket(new URL("ws://localhost:4242/"));
assertEquals(ws.url, "ws://localhost:4242/"); assertEquals(ws.url, "ws://localhost:4242/");
ws.onerror = (e) => promise.reject(e); ws.onerror = (e) => reject(e);
ws.onopen = () => ws.close(); ws.onopen = () => ws.close();
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test(async function websocketH2SendSmallPacket() { Deno.test(async function websocketH2SendSmallPacket() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const ws = new WebSocket(new URL("wss://localhost:4249/")); const ws = new WebSocket(new URL("wss://localhost:4249/"));
assertEquals(ws.url, "wss://localhost:4249/"); assertEquals(ws.url, "wss://localhost:4249/");
let messageCount = 0; let messageCount = 0;
ws.onerror = (e) => promise.reject(e); ws.onerror = (e) => reject(e);
ws.onopen = () => { ws.onopen = () => {
ws.send("a".repeat(16)); ws.send("a".repeat(16));
ws.send("a".repeat(16)); ws.send("a".repeat(16));
@ -46,17 +40,17 @@ Deno.test(async function websocketH2SendSmallPacket() {
} }
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test(async function websocketH2SendLargePacket() { Deno.test(async function websocketH2SendLargePacket() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const ws = new WebSocket(new URL("wss://localhost:4249/")); const ws = new WebSocket(new URL("wss://localhost:4249/"));
assertEquals(ws.url, "wss://localhost:4249/"); assertEquals(ws.url, "wss://localhost:4249/");
let messageCount = 0; let messageCount = 0;
ws.onerror = (e) => promise.reject(e); ws.onerror = (e) => reject(e);
ws.onopen = () => { ws.onopen = () => {
ws.send("a".repeat(65000)); ws.send("a".repeat(65000));
ws.send("a".repeat(65000)); ws.send("a".repeat(65000));
@ -68,16 +62,16 @@ Deno.test(async function websocketH2SendLargePacket() {
} }
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test(async function websocketSendLargePacket() { Deno.test(async function websocketSendLargePacket() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const ws = new WebSocket(new URL("wss://localhost:4243/")); const ws = new WebSocket(new URL("wss://localhost:4243/"));
assertEquals(ws.url, "wss://localhost:4243/"); assertEquals(ws.url, "wss://localhost:4243/");
ws.onerror = (e) => promise.reject(e); ws.onerror = (e) => reject(e);
ws.onopen = () => { ws.onopen = () => {
ws.send("a".repeat(65000)); ws.send("a".repeat(65000));
}; };
@ -85,17 +79,17 @@ Deno.test(async function websocketSendLargePacket() {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test(async function websocketSendLargeBinaryPacket() { Deno.test(async function websocketSendLargeBinaryPacket() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const ws = new WebSocket(new URL("wss://localhost:4243/")); const ws = new WebSocket(new URL("wss://localhost:4243/"));
ws.binaryType = "arraybuffer"; ws.binaryType = "arraybuffer";
assertEquals(ws.url, "wss://localhost:4243/"); assertEquals(ws.url, "wss://localhost:4243/");
ws.onerror = (e) => promise.reject(e); ws.onerror = (e) => reject(e);
ws.onopen = () => { ws.onopen = () => {
ws.send(new Uint8Array(65000)); ws.send(new Uint8Array(65000));
}; };
@ -104,17 +98,17 @@ Deno.test(async function websocketSendLargeBinaryPacket() {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
Deno.test(async function websocketSendLargeBlobPacket() { Deno.test(async function websocketSendLargeBlobPacket() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const ws = new WebSocket(new URL("wss://localhost:4243/")); const ws = new WebSocket(new URL("wss://localhost:4243/"));
ws.binaryType = "arraybuffer"; ws.binaryType = "arraybuffer";
assertEquals(ws.url, "wss://localhost:4243/"); assertEquals(ws.url, "wss://localhost:4243/");
ws.onerror = (e) => promise.reject(e); ws.onerror = (e) => reject(e);
ws.onopen = () => { ws.onopen = () => {
ws.send(new Blob(["a".repeat(65000)])); ws.send(new Blob(["a".repeat(65000)]));
}; };
@ -123,7 +117,7 @@ Deno.test(async function websocketSendLargeBlobPacket() {
ws.close(); ws.close();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
}); });
@ -131,15 +125,15 @@ Deno.test(async function websocketSendLargeBlobPacket() {
// https://github.com/denoland/deno/pull/17762 // https://github.com/denoland/deno/pull/17762
// https://github.com/denoland/deno/issues/17761 // https://github.com/denoland/deno/issues/17761
Deno.test(async function websocketPingPong() { Deno.test(async function websocketPingPong() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const ws = new WebSocket("ws://localhost:4245/"); const ws = new WebSocket("ws://localhost:4245/");
assertEquals(ws.url, "ws://localhost:4245/"); assertEquals(ws.url, "ws://localhost:4245/");
ws.onerror = (e) => promise.reject(e); ws.onerror = (e) => reject(e);
ws.onmessage = (e) => { ws.onmessage = (e) => {
ws.send(e.data); ws.send(e.data);
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); resolve();
}; };
await promise; await promise;
ws.close(); ws.close();
@ -147,7 +141,7 @@ Deno.test(async function websocketPingPong() {
// TODO(mmastrac): This requires us to ignore bad certs // TODO(mmastrac): This requires us to ignore bad certs
// Deno.test(async function websocketSecureConnect() { // Deno.test(async function websocketSecureConnect() {
// const promise = deferred(); // const { promise, resolve } = Promise.withResolvers<void>();
// const ws = new WebSocket("wss://localhost:4243/"); // const ws = new WebSocket("wss://localhost:4243/");
// assertEquals(ws.url, "wss://localhost:4243/"); // assertEquals(ws.url, "wss://localhost:4243/");
// ws.onerror = (error) => { // ws.onerror = (error) => {
@ -156,7 +150,7 @@ Deno.test(async function websocketPingPong() {
// }; // };
// ws.onopen = () => ws.close(); // ws.onopen = () => ws.close();
// ws.onclose = () => { // ws.onclose = () => {
// promise.resolve(); // resolve();
// }; // };
// await promise; // await promise;
// }); // });
@ -166,7 +160,7 @@ Deno.test(
{ sanitizeOps: false, sanitizeResources: false }, { sanitizeOps: false, sanitizeResources: false },
async function websocketWriteLock() { async function websocketWriteLock() {
const ac = new AbortController(); const ac = new AbortController();
const listeningPromise = deferred(); const listeningDeferred = Promise.withResolvers<void>();
const server = Deno.serve({ const server = Deno.serve({
handler: (req) => { handler: (req) => {
@ -181,13 +175,13 @@ Deno.test(
return response; return response;
}, },
signal: ac.signal, signal: ac.signal,
onListen: () => listeningPromise.resolve(), onListen: () => listeningDeferred.resolve(),
hostname: "localhost", hostname: "localhost",
port: servePort, port: servePort,
}); });
await listeningPromise; await listeningDeferred.promise;
const promise = deferred(); const deferred = Promise.withResolvers<void>();
const ws = new WebSocket(serveUrl); const ws = new WebSocket(serveUrl);
assertEquals(ws.url, serveUrl); assertEquals(ws.url, serveUrl);
ws.onerror = () => fail(); ws.onerror = () => fail();
@ -196,13 +190,13 @@ Deno.test(
setTimeout(() => { setTimeout(() => {
ws.send(e.data); ws.send(e.data);
}, 1000); }, 1000);
promise.resolve(); deferred.resolve();
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); deferred.resolve();
}; };
await Promise.all([promise, server.finished]); await Promise.all([deferred.promise, server.finished]);
ws.close(); ws.close();
}, },
); );
@ -212,10 +206,10 @@ Deno.test({
sanitizeOps: false, sanitizeOps: false,
sanitizeResources: false, sanitizeResources: false,
}, async function websocketDoubleClose() { }, async function websocketDoubleClose() {
const promise = deferred(); const deferred = Promise.withResolvers<void>();
const ac = new AbortController(); const ac = new AbortController();
const listeningPromise = deferred(); const listeningDeferred = Promise.withResolvers<void>();
const server = Deno.serve({ const server = Deno.serve({
handler: (req) => { handler: (req) => {
@ -233,12 +227,12 @@ Deno.test({
return response; return response;
}, },
signal: ac.signal, signal: ac.signal,
onListen: () => listeningPromise.resolve(), onListen: () => listeningDeferred.resolve(),
hostname: "localhost", hostname: "localhost",
port: servePort, port: servePort,
}); });
await listeningPromise; await listeningDeferred.promise;
const ws = new WebSocket(serveUrl); const ws = new WebSocket(serveUrl);
assertEquals(ws.url, serveUrl); assertEquals(ws.url, serveUrl);
@ -247,9 +241,9 @@ Deno.test({
if (m.data == "Hello") ws.send("bye"); if (m.data == "Hello") ws.send("bye");
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); deferred.resolve();
}; };
await Promise.all([promise, server.finished]); await Promise.all([deferred.promise, server.finished]);
}); });
// https://github.com/denoland/deno/issues/19483 // https://github.com/denoland/deno/issues/19483
@ -257,10 +251,10 @@ Deno.test({
sanitizeOps: false, sanitizeOps: false,
sanitizeResources: false, sanitizeResources: false,
}, async function websocketCloseFlushes() { }, async function websocketCloseFlushes() {
const promise = deferred(); const deferred = Promise.withResolvers<void>();
const ac = new AbortController(); const ac = new AbortController();
const listeningPromise = deferred(); const listeningDeferred = Promise.withResolvers<void>();
const server = Deno.serve({ const server = Deno.serve({
handler: (req) => { handler: (req) => {
@ -275,12 +269,12 @@ Deno.test({
return response; return response;
}, },
signal: ac.signal, signal: ac.signal,
onListen: () => listeningPromise.resolve(), onListen: () => listeningDeferred.resolve(),
hostname: "localhost", hostname: "localhost",
port: servePort, port: servePort,
}); });
await listeningPromise; await listeningDeferred.promise;
const ws = new WebSocket(serveUrl); const ws = new WebSocket(serveUrl);
assertEquals(ws.url, serveUrl); assertEquals(ws.url, serveUrl);
@ -295,9 +289,9 @@ Deno.test({
} }
}; };
ws.onclose = () => { ws.onclose = () => {
promise.resolve(); deferred.resolve();
}; };
await Promise.all([promise, server.finished]); await Promise.all([deferred.promise, server.finished]);
assert(seenBye); assert(seenBye);
}); });

21
cli/tests/unit_node/_fs/_fs_read_test.ts
View file

@ -10,7 +10,6 @@ import { open, openSync } from "node:fs";
import { Buffer } from "node:buffer"; import { Buffer } from "node:buffer";
import * as path from "../../../../test_util/std/path/mod.ts"; import * as path from "../../../../test_util/std/path/mod.ts";
import { closeSync } from "node:fs"; import { closeSync } from "node:fs";
import { deferred } from "../../../../test_util/std/async/deferred.ts";
async function readTest( async function readTest(
testData: string, testData: string,
@ -132,7 +131,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "[std/node/fs] Read fs.read(fd, options, cb) signature", name: "[std/node/fs] Read fs.read(fd, options, cb) signature",
async fn() { async fn() {
const promise = deferred(); const { promise, reject, resolve } = Promise.withResolvers<void>();
const file = Deno.makeTempFileSync(); const file = Deno.makeTempFileSync();
Deno.writeTextFileSync(file, "hi there"); Deno.writeTextFileSync(file, "hi there");
const fd = openSync(file, "r+"); const fd = openSync(file, "r+");
@ -154,10 +153,10 @@ Deno.test({
Buffer.from([104, 105, 32, 116, 104, 101, 114, 101, 0, 0, 0]), Buffer.from([104, 105, 32, 116, 104, 101, 114, 101, 0, 0, 0]),
); );
} catch (e) { } catch (e) {
promise.reject(e); reject(e);
return; return;
} }
promise.resolve(); resolve();
}, },
); );
closeSync(fd); closeSync(fd);
@ -168,7 +167,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "[std/node/fs] Read fs.read(fd, cb) signature", name: "[std/node/fs] Read fs.read(fd, cb) signature",
async fn() { async fn() {
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const file = Deno.makeTempFileSync(); const file = Deno.makeTempFileSync();
Deno.writeTextFileSync(file, "hi deno"); Deno.writeTextFileSync(file, "hi deno");
const fd = openSync(file, "r+"); const fd = openSync(file, "r+");
@ -178,10 +177,10 @@ Deno.test({
assertStrictEquals(bytesRead, 7); assertStrictEquals(bytesRead, 7);
assertStrictEquals(data?.byteLength, 16384); assertStrictEquals(data?.byteLength, 16384);
} catch (e) { } catch (e) {
promise.reject(e); reject(e);
return; return;
} }
promise.resolve(); resolve();
}); });
closeSync(fd); closeSync(fd);
await promise; await promise;
@ -277,27 +276,27 @@ Deno.test({
await Deno.writeTextFile(file, "abc"); await Deno.writeTextFile(file, "abc");
await t.step("without position option", async () => { await t.step("without position option", async () => {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
let called = false; let called = false;
const fd = openSync(file, "r"); const fd = openSync(file, "r");
read(fd, () => { read(fd, () => {
called = true; called = true;
closeSync(fd); closeSync(fd);
promise.resolve(); resolve();
}); });
assertFalse(called); assertFalse(called);
await promise; await promise;
}); });
await t.step("with position option", async () => { await t.step("with position option", async () => {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
let called = false; let called = false;
const buffer = Buffer.alloc(2); const buffer = Buffer.alloc(2);
const fd = openSync(file, "r"); const fd = openSync(file, "r");
read(fd, { position: 1, buffer, offset: 0, length: 2 }, () => { read(fd, { position: 1, buffer, offset: 0, length: 2 }, () => {
called = true; called = true;
closeSync(fd); closeSync(fd);
promise.resolve(); resolve();
}); });
assertFalse(called); assertFalse(called);
await promise; await promise;

13
cli/tests/unit_node/async_hooks_test.ts
View file

@ -4,7 +4,6 @@ import {
assert, assert,
assertEquals, assertEquals,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
import { deferred } from "../../../test_util/std/async/deferred.ts";
Deno.test(async function foo() { Deno.test(async function foo() {
const asyncLocalStorage = new AsyncLocalStorage(); const asyncLocalStorage = new AsyncLocalStorage();
@ -68,16 +67,16 @@ Deno.test(async function bar() {
Deno.test(async function nested() { Deno.test(async function nested() {
const als = new AsyncLocalStorage(); const als = new AsyncLocalStorage();
const promise = deferred(); const deferred = Promise.withResolvers();
const promise1 = deferred(); const deferred1 = Promise.withResolvers();
als.run(null, () => { als.run(null, () => {
als.run({ x: 1 }, () => { als.run({ x: 1 }, () => {
promise.resolve(als.getStore()); deferred.resolve(als.getStore());
}); });
promise1.resolve(als.getStore()); deferred1.resolve(als.getStore());
}); });
assertEquals(await promise, { x: 1 }); assertEquals(await deferred.promise, { x: 1 });
assertEquals(await promise1, null); assertEquals(await deferred1.promise, null);
}); });

147
cli/tests/unit_node/child_process_test.ts
View file

@ -10,45 +10,46 @@ import {
assertStrictEquals, assertStrictEquals,
assertStringIncludes, assertStringIncludes,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
import { Deferred, deferred } from "../../../test_util/std/async/deferred.ts";
import * as path from "../../../test_util/std/path/mod.ts"; import * as path from "../../../test_util/std/path/mod.ts";
const { spawn, spawnSync, execFile, execFileSync, ChildProcess } = CP; const { spawn, spawnSync, execFile, execFileSync, ChildProcess } = CP;
function withTimeout<T>(timeoutInMS = 10_000): Deferred<T> { function withTimeout<T>(
const promise = deferred<T>(); timeoutInMS = 10_000,
): ReturnType<typeof Promise.withResolvers<T>> {
const deferred = Promise.withResolvers<T>();
const timer = setTimeout(() => { const timer = setTimeout(() => {
promise.reject("Timeout"); deferred.reject("Timeout");
}, timeoutInMS); }, timeoutInMS);
promise.then(() => { deferred.promise.then(() => {
clearTimeout(timer); clearTimeout(timer);
}); });
return promise; return deferred;
} }
// TODO(uki00a): Once Node.js's `parallel/test-child-process-spawn-error.js` works, this test case should be removed. // TODO(uki00a): Once Node.js's `parallel/test-child-process-spawn-error.js` works, this test case should be removed.
Deno.test("[node/child_process spawn] The 'error' event is emitted when no binary is found", async () => { Deno.test("[node/child_process spawn] The 'error' event is emitted when no binary is found", async () => {
const promise = withTimeout(); const deferred = withTimeout<void>();
const childProcess = spawn("no-such-cmd"); const childProcess = spawn("no-such-cmd");
childProcess.on("error", (_err: Error) => { childProcess.on("error", (_err: Error) => {
// TODO(@bartlomieju) Assert an error message. // TODO(@bartlomieju) Assert an error message.
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
}); });
Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit code after the child process ends", async () => { Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit code after the child process ends", async () => {
const promise = withTimeout(); const deferred = withTimeout<void>();
const childProcess = spawn(Deno.execPath(), ["--help"], { const childProcess = spawn(Deno.execPath(), ["--help"], {
env: { NO_COLOR: "true" }, env: { NO_COLOR: "true" },
}); });
try { try {
let exitCode = null; let exitCode = null;
childProcess.on("exit", (code: number) => { childProcess.on("exit", (code: number) => {
promise.resolve(); deferred.resolve();
exitCode = code; exitCode = code;
}); });
await promise; await deferred.promise;
assertStrictEquals(exitCode, 0); assertStrictEquals(exitCode, 0);
assertStrictEquals(childProcess.exitCode, exitCode); assertStrictEquals(childProcess.exitCode, exitCode);
} finally { } finally {
@ -59,16 +60,16 @@ Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit c
}); });
Deno.test("[node/child_process disconnect] the method exists", async () => { Deno.test("[node/child_process disconnect] the method exists", async () => {
const promise = withTimeout(); const deferred = withTimeout<void>();
const childProcess = spawn(Deno.execPath(), ["--help"], { const childProcess = spawn(Deno.execPath(), ["--help"], {
env: { NO_COLOR: "true" }, env: { NO_COLOR: "true" },
}); });
try { try {
childProcess.disconnect(); childProcess.disconnect();
childProcess.on("exit", () => { childProcess.on("exit", () => {
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
} finally { } finally {
childProcess.kill(); childProcess.kill();
childProcess.stdout?.destroy(); childProcess.stdout?.destroy();
@ -79,7 +80,7 @@ Deno.test("[node/child_process disconnect] the method exists", async () => {
Deno.test({ Deno.test({
name: "[node/child_process spawn] Verify that stdin and stdout work", name: "[node/child_process spawn] Verify that stdin and stdout work",
fn: async () => { fn: async () => {
const promise = withTimeout(); const deferred = withTimeout<void>();
const childProcess = spawn(Deno.execPath(), ["fmt", "-"], { const childProcess = spawn(Deno.execPath(), ["fmt", "-"], {
env: { NO_COLOR: "true" }, env: { NO_COLOR: "true" },
stdio: ["pipe", "pipe"], stdio: ["pipe", "pipe"],
@ -94,9 +95,9 @@ Deno.test({
childProcess.stdin.write(" console.log('hello')", "utf-8"); childProcess.stdin.write(" console.log('hello')", "utf-8");
childProcess.stdin.end(); childProcess.stdin.end();
childProcess.on("close", () => { childProcess.on("close", () => {
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
assertStrictEquals(data, `console.log("hello");\n`); assertStrictEquals(data, `console.log("hello");\n`);
} finally { } finally {
childProcess.kill(); childProcess.kill();
@ -107,7 +108,7 @@ Deno.test({
Deno.test({ Deno.test({
name: "[node/child_process spawn] stdin and stdout with binary data", name: "[node/child_process spawn] stdin and stdout with binary data",
fn: async () => { fn: async () => {
const promise = withTimeout(); const deferred = withTimeout<void>();
const p = path.join( const p = path.join(
path.dirname(path.fromFileUrl(import.meta.url)), path.dirname(path.fromFileUrl(import.meta.url)),
"./testdata/binary_stdio.js", "./testdata/binary_stdio.js",
@ -127,9 +128,9 @@ Deno.test({
childProcess.stdin.write(buffer); childProcess.stdin.write(buffer);
childProcess.stdin.end(); childProcess.stdin.end();
childProcess.on("close", () => { childProcess.on("close", () => {
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
assertEquals(new Uint8Array(data!), buffer); assertEquals(new Uint8Array(data!), buffer);
} finally { } finally {
childProcess.kill(); childProcess.kill();
@ -140,7 +141,7 @@ Deno.test({
async function spawnAndGetEnvValue( async function spawnAndGetEnvValue(
inputValue: string | number | boolean, inputValue: string | number | boolean,
): Promise<string> { ): Promise<string> {
const promise = withTimeout<string>(); const deferred = withTimeout<string>();
const env = spawn( const env = spawn(
`"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`, `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
{ {
@ -152,14 +153,14 @@ async function spawnAndGetEnvValue(
let envOutput = ""; let envOutput = "";
assert(env.stdout); assert(env.stdout);
env.on("error", (err: Error) => promise.reject(err)); env.on("error", (err: Error) => deferred.reject(err));
env.stdout.on("data", (data) => { env.stdout.on("data", (data) => {
envOutput += data; envOutput += data;
}); });
env.on("close", () => { env.on("close", () => {
promise.resolve(envOutput.trim()); deferred.resolve(envOutput.trim());
}); });
return await promise; return await deferred.promise;
} finally { } finally {
env.kill(); env.kill();
} }
@ -191,7 +192,7 @@ Deno.test({
// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-event.js` works. // TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-event.js` works.
Deno.test("[child_process spawn] 'spawn' event", async () => { Deno.test("[child_process spawn] 'spawn' event", async () => {
const timeout = withTimeout(); const timeout = withTimeout<void>();
const subprocess = spawn(Deno.execPath(), ["eval", "console.log('ok')"]); const subprocess = spawn(Deno.execPath(), ["eval", "console.log('ok')"]);
let didSpawn = false; let didSpawn = false;
@ -205,13 +206,13 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
const promises = [] as Promise<void>[]; const promises = [] as Promise<void>[];
function mustBeCalledAfterSpawn() { function mustBeCalledAfterSpawn() {
const promise = deferred<void>(); const deferred = Promise.withResolvers<void>();
promises.push(promise); promises.push(deferred.promise);
return () => { return () => {
if (didSpawn) { if (didSpawn) {
promise.resolve(); deferred.resolve();
} else { } else {
promise.reject( deferred.reject(
new Error("function should be called after the 'spawn' event"), new Error("function should be called after the 'spawn' event"),
); );
} }
@ -229,7 +230,7 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
subprocess.on("close", mustBeCalledAfterSpawn()); subprocess.on("close", mustBeCalledAfterSpawn());
try { try {
await Promise.race([Promise.all(promises), timeout]); await Promise.race([Promise.all(promises), timeout.promise]);
timeout.resolve(); timeout.resolve();
} finally { } finally {
subprocess.kill(); subprocess.kill();
@ -238,12 +239,12 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works. // TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works.
Deno.test("[child_process spawn] Verify that a shell is executed", async () => { Deno.test("[child_process spawn] Verify that a shell is executed", async () => {
const promise = withTimeout(); const deferred = withTimeout<void>();
const doesNotExist = spawn("does-not-exist", { shell: true }); const doesNotExist = spawn("does-not-exist", { shell: true });
try { try {
assertNotStrictEquals(doesNotExist.spawnfile, "does-not-exist"); assertNotStrictEquals(doesNotExist.spawnfile, "does-not-exist");
doesNotExist.on("error", () => { doesNotExist.on("error", () => {
promise.reject("The 'error' event must not be emitted."); deferred.reject("The 'error' event must not be emitted.");
}); });
doesNotExist.on("exit", (code: number, signal: null) => { doesNotExist.on("exit", (code: number, signal: null) => {
assertStrictEquals(signal, null); assertStrictEquals(signal, null);
@ -254,9 +255,9 @@ Deno.test("[child_process spawn] Verify that a shell is executed", async () => {
assertStrictEquals(code, 127); // Exit code of /bin/sh }); assertStrictEquals(code, 127); // Exit code of /bin/sh });
} }
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
} finally { } finally {
doesNotExist.kill(); doesNotExist.kill();
doesNotExist.stdout?.destroy(); doesNotExist.stdout?.destroy();
@ -269,7 +270,7 @@ Deno.test({
ignore: Deno.build.os === "windows", ignore: Deno.build.os === "windows",
name: "[node/child_process spawn] Verify that passing arguments works", name: "[node/child_process spawn] Verify that passing arguments works",
async fn() { async fn() {
const promise = withTimeout(); const deferred = withTimeout<void>();
const echo = spawn("echo", ["foo"], { const echo = spawn("echo", ["foo"], {
shell: true, shell: true,
}); });
@ -286,9 +287,9 @@ Deno.test({
}); });
echo.on("close", () => { echo.on("close", () => {
assertStrictEquals(echoOutput.trim(), "foo"); assertStrictEquals(echoOutput.trim(), "foo");
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
} finally { } finally {
echo.kill(); echo.kill();
} }
@ -300,7 +301,7 @@ Deno.test({
ignore: Deno.build.os === "windows", ignore: Deno.build.os === "windows",
name: "[node/child_process spawn] Verity that shell features can be used", name: "[node/child_process spawn] Verity that shell features can be used",
async fn() { async fn() {
const promise = withTimeout(); const deferred = withTimeout<void>();
const cmd = "echo bar | cat"; const cmd = "echo bar | cat";
const command = spawn(cmd, { const command = spawn(cmd, {
shell: true, shell: true,
@ -315,10 +316,10 @@ Deno.test({
command.on("close", () => { command.on("close", () => {
assertStrictEquals(commandOutput.trim(), "bar"); assertStrictEquals(commandOutput.trim(), "bar");
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
} finally { } finally {
command.kill(); command.kill();
} }
@ -331,7 +332,7 @@ Deno.test({
name: name:
"[node/child_process spawn] Verity that environment is properly inherited", "[node/child_process spawn] Verity that environment is properly inherited",
async fn() { async fn() {
const promise = withTimeout(); const deferred = withTimeout<void>();
const env = spawn( const env = spawn(
`"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`, `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
{ {
@ -343,15 +344,15 @@ Deno.test({
let envOutput = ""; let envOutput = "";
assert(env.stdout); assert(env.stdout);
env.on("error", (err: Error) => promise.reject(err)); env.on("error", (err: Error) => deferred.reject(err));
env.stdout.on("data", (data) => { env.stdout.on("data", (data) => {
envOutput += data; envOutput += data;
}); });
env.on("close", () => { env.on("close", () => {
assertStrictEquals(envOutput.trim(), "buzz"); assertStrictEquals(envOutput.trim(), "buzz");
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
} finally { } finally {
env.kill(); env.kill();
} }
@ -496,16 +497,16 @@ Deno.test({
"./testdata/infinite_loop.js", "./testdata/infinite_loop.js",
); );
const childProcess = spawn(Deno.execPath(), ["run", script]); const childProcess = spawn(Deno.execPath(), ["run", script]);
const p = withTimeout(); const p = withTimeout<void>();
const pStdout = withTimeout(); const pStdout = withTimeout<void>();
const pStderr = withTimeout(); const pStderr = withTimeout<void>();
childProcess.on("exit", () => p.resolve()); childProcess.on("exit", () => p.resolve());
childProcess.stdout.on("close", () => pStdout.resolve()); childProcess.stdout.on("close", () => pStdout.resolve());
childProcess.stderr.on("close", () => pStderr.resolve()); childProcess.stderr.on("close", () => pStderr.resolve());
childProcess.kill("SIGKILL"); childProcess.kill("SIGKILL");
await p; await p.promise;
await pStdout; await pStdout.promise;
await pStderr; await pStderr.promise;
assert(childProcess.killed); assert(childProcess.killed);
assertEquals(childProcess.signalCode, "SIGKILL"); assertEquals(childProcess.signalCode, "SIGKILL");
assertExists(childProcess.exitCode); assertExists(childProcess.exitCode);
@ -527,9 +528,9 @@ Deno.test({
"--unstable", "--unstable",
script, script,
]); ]);
const p = deferred(); const deferred = Promise.withResolvers<void>();
childProcess.on("exit", () => p.resolve()); childProcess.on("exit", () => deferred.resolve());
await p; await deferred.promise;
}, },
}); });
@ -547,14 +548,14 @@ Deno.test({
"foo", "foo",
"index.js", "index.js",
); );
const p = deferred(); const p = Promise.withResolvers<void>();
const cp = CP.fork(script, [], { cwd: testdataDir, stdio: "pipe" }); const cp = CP.fork(script, [], { cwd: testdataDir, stdio: "pipe" });
let output = ""; let output = "";
cp.on("close", () => p.resolve()); cp.on("close", () => p.resolve());
cp.stdout?.on("data", (data) => { cp.stdout?.on("data", (data) => {
output += data; output += data;
}); });
await p; await p.promise;
assertEquals(output, "foo\ntrue\ntrue\ntrue\n"); assertEquals(output, "foo\ntrue\ntrue\ntrue\n");
}, },
}); });
@ -567,7 +568,7 @@ Deno.test(
"[node/child_process spawn] supports windowsVerbatimArguments option", "[node/child_process spawn] supports windowsVerbatimArguments option",
{ ignore: Deno.build.os !== "windows" }, { ignore: Deno.build.os !== "windows" },
async () => { async () => {
const cmdFinished = deferred(); const cmdFinished = Promise.withResolvers<void>();
let output = ""; let output = "";
const cp = spawn("cmd", ["/d", "/s", "/c", '"deno ^"--version^""'], { const cp = spawn("cmd", ["/d", "/s", "/c", '"deno ^"--version^""'], {
stdio: "pipe", stdio: "pipe",
@ -577,7 +578,7 @@ Deno.test(
cp.stdout?.on("data", (data) => { cp.stdout?.on("data", (data) => {
output += data; output += data;
}); });
await cmdFinished; await cmdFinished.promise;
assertStringIncludes(output, "deno"); assertStringIncludes(output, "deno");
assertStringIncludes(output, "v8"); assertStringIncludes(output, "v8");
assertStringIncludes(output, "typescript"); assertStringIncludes(output, "typescript");
@ -587,7 +588,7 @@ Deno.test(
Deno.test( Deno.test(
"[node/child_process spawn] supports stdio array option", "[node/child_process spawn] supports stdio array option",
async () => { async () => {
const cmdFinished = deferred(); const cmdFinished = Promise.withResolvers<void>();
let output = ""; let output = "";
const script = path.join( const script = path.join(
path.dirname(path.fromFileUrl(import.meta.url)), path.dirname(path.fromFileUrl(import.meta.url)),
@ -599,7 +600,7 @@ Deno.test(
output += data; output += data;
}); });
cp.on("close", () => cmdFinished.resolve()); cp.on("close", () => cmdFinished.resolve());
await cmdFinished; await cmdFinished.promise;
assertStringIncludes(output, "foo"); assertStringIncludes(output, "foo");
assertStringIncludes(output, "close"); assertStringIncludes(output, "close");
@ -609,7 +610,7 @@ Deno.test(
Deno.test( Deno.test(
"[node/child_process spawn] supports stdio [0, 1, 2] option", "[node/child_process spawn] supports stdio [0, 1, 2] option",
async () => { async () => {
const cmdFinished = deferred(); const cmdFinished = Promise.withResolvers<void>();
let output = ""; let output = "";
const script = path.join( const script = path.join(
path.dirname(path.fromFileUrl(import.meta.url)), path.dirname(path.fromFileUrl(import.meta.url)),
@ -621,7 +622,7 @@ Deno.test(
output += data; output += data;
}); });
cp.on("close", () => cmdFinished.resolve()); cp.on("close", () => cmdFinished.resolve());
await cmdFinished; await cmdFinished.promise;
assertStringIncludes(output, "foo"); assertStringIncludes(output, "foo");
assertStringIncludes(output, "close"); assertStringIncludes(output, "close");
@ -638,16 +639,16 @@ Deno.test({
// Spawn an infinite cat // Spawn an infinite cat
const cp = spawn("cat", ["-"]); const cp = spawn("cat", ["-"]);
const p = withTimeout(); const p = withTimeout<void>();
const pStdout = withTimeout(); const pStdout = withTimeout<void>();
const pStderr = withTimeout(); const pStderr = withTimeout<void>();
cp.on("exit", () => p.resolve()); cp.on("exit", () => p.resolve());
cp.stdout.on("close", () => pStdout.resolve()); cp.stdout.on("close", () => pStdout.resolve());
cp.stderr.on("close", () => pStderr.resolve()); cp.stderr.on("close", () => pStderr.resolve());
cp.kill("SIGIOT"); cp.kill("SIGIOT");
await p; await p.promise;
await pStdout; await pStdout.promise;
await pStderr; await pStderr.promise;
assert(cp.killed); assert(cp.killed);
assertEquals(cp.signalCode, "SIGIOT"); assertEquals(cp.signalCode, "SIGIOT");
}, },
@ -655,7 +656,7 @@ Deno.test({
// Regression test for https://github.com/denoland/deno/issues/20373 // Regression test for https://github.com/denoland/deno/issues/20373
Deno.test(async function undefinedValueInEnvVar() { Deno.test(async function undefinedValueInEnvVar() {
const promise = withTimeout<string>(); const deferred = withTimeout<string>();
const env = spawn( const env = spawn(
`"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`, `"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
{ {
@ -673,18 +674,18 @@ Deno.test(async function undefinedValueInEnvVar() {
let envOutput = ""; let envOutput = "";
assert(env.stdout); assert(env.stdout);
env.on("error", (err: Error) => promise.reject(err)); env.on("error", (err: Error) => deferred.reject(err));
env.stdout.on("data", (data) => { env.stdout.on("data", (data) => {
envOutput += data; envOutput += data;
}); });
env.on("close", () => { env.on("close", () => {
promise.resolve(envOutput.trim()); deferred.resolve(envOutput.trim());
}); });
await promise; await deferred.promise;
} finally { } finally {
env.kill(); env.kill();
} }
const value = await promise; const value = await deferred.promise;
assertEquals(value, "BAZ"); assertEquals(value, "BAZ");
}); });

5
cli/tests/unit_node/events_test.ts
View file

@ -1,12 +1,11 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
import { deferred } from "../../../test_util/std/async/deferred.ts";
import { EventEmitter } from "node:events"; import { EventEmitter } from "node:events";
EventEmitter.captureRejections = true; EventEmitter.captureRejections = true;
Deno.test("regression #20441", async () => { Deno.test("regression #20441", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const ee = new EventEmitter(); const ee = new EventEmitter();
@ -20,7 +19,7 @@ Deno.test("regression #20441", async () => {
}); });
ee.on("error", function (_) { ee.on("error", function (_) {
promise.resolve(); resolve();
}); });
ee.emit("foo"); ee.emit("foo");

25
cli/tests/unit_node/http2_test.ts
View file

@ -2,7 +2,6 @@
import * as http2 from "node:http2"; import * as http2 from "node:http2";
import * as net from "node:net"; import * as net from "node:net";
import { deferred } from "../../../test_util/std/async/deferred.ts";
import { assertEquals } from "../../../test_util/std/testing/asserts.ts"; import { assertEquals } from "../../../test_util/std/testing/asserts.ts";
for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) { for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) {
@ -41,17 +40,17 @@ for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) {
}); });
req.end(); req.end();
const endPromise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
setTimeout(() => { setTimeout(() => {
try { try {
client.close(); client.close();
} catch (_) { } catch (_) {
// pass // pass
} }
endPromise.resolve(); resolve();
}, 2000); }, 2000);
await endPromise; await promise;
assertEquals(receivedHeaders, { ":status": 200 }); assertEquals(receivedHeaders, { ":status": 200 });
assertEquals(receivedData, "hello world\n"); assertEquals(receivedData, "hello world\n");
@ -67,14 +66,14 @@ Deno.test(`[node/http2 client createConnection]`, {
ignore: Deno.build.os === "windows", ignore: Deno.build.os === "windows",
}, async () => { }, async () => {
const url = "http://127.0.0.1:4246"; const url = "http://127.0.0.1:4246";
const createConnPromise = deferred(); const createConnDeferred = Promise.withResolvers<void>();
// Create a server to respond to the HTTP2 requests // Create a server to respond to the HTTP2 requests
const client = http2.connect(url, { const client = http2.connect(url, {
createConnection() { createConnection() {
const socket = net.connect({ host: "127.0.0.1", port: 4246 }); const socket = net.connect({ host: "127.0.0.1", port: 4246 });
socket.on("connect", () => { socket.on("connect", () => {
createConnPromise.resolve(); createConnDeferred.resolve();
}); });
return socket; return socket;
@ -94,7 +93,7 @@ Deno.test(`[node/http2 client createConnection]`, {
}); });
req.end(); req.end();
const endPromise = deferred(); const endPromise = Promise.withResolvers<void>();
setTimeout(() => { setTimeout(() => {
try { try {
client.close(); client.close();
@ -104,8 +103,8 @@ Deno.test(`[node/http2 client createConnection]`, {
endPromise.resolve(); endPromise.resolve();
}, 2000); }, 2000);
await createConnPromise; await createConnDeferred.promise;
await endPromise; await endPromise.promise;
assertEquals(receivedData, "hello world\n"); assertEquals(receivedData, "hello world\n");
}); });
@ -127,11 +126,9 @@ Deno.test("[node/http2 server]", { sanitizeOps: false }, async () => {
const stream = await new Promise<http2.ServerHttp2Stream>((resolve) => const stream = await new Promise<http2.ServerHttp2Stream>((resolve) =>
session.on("stream", resolve) session.on("stream", resolve)
); );
const _headers = await new Promise((resolve) => await new Promise((resolve) => stream.on("headers", resolve));
stream.on("headers", resolve) await new Promise((resolve) => stream.on("data", resolve));
); await new Promise((resolve) => stream.on("end", resolve));
const _data = await new Promise((resolve) => stream.on("data", resolve));
const _end = await new Promise((resolve) => stream.on("end", resolve));
stream.respond(); stream.respond();
stream.end(); stream.end();
const resp = await responsePromise; const resp = await responsePromise;

163
cli/tests/unit_node/http_test.ts
View file

@ -9,7 +9,6 @@ import {
fail, fail,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
import { assertSpyCalls, spy } from "../../../test_util/std/testing/mock.ts"; import { assertSpyCalls, spy } from "../../../test_util/std/testing/mock.ts";
import { deferred } from "../../../test_util/std/async/deferred.ts";
import { gzip } from "node:zlib"; import { gzip } from "node:zlib";
import { Buffer } from "node:buffer"; import { Buffer } from "node:buffer";
@ -28,42 +27,42 @@ Deno.test("[node/http listen]", async () => {
} }
{ {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer(); const server = http.createServer();
server.listen(() => { server.listen(() => {
server.close(); server.close();
}); });
server.on("close", () => { server.on("close", () => {
promise.resolve(); resolve();
}); });
await promise; await promise;
} }
{ {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer(); const server = http.createServer();
server.listen().on("listening", () => { server.listen().on("listening", () => {
server.close(); server.close();
}); });
server.on("close", () => { server.on("close", () => {
promise.resolve(); resolve();
}); });
await promise; await promise;
} }
for (const port of [0, -0, 0.0, "0", null, undefined]) { for (const port of [0, -0, 0.0, "0", null, undefined]) {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer(); const server = http.createServer();
server.listen(port, () => { server.listen(port, () => {
server.close(); server.close();
}); });
server.on("close", () => { server.on("close", () => {
promise.resolve(); resolve();
}); });
await promise; await promise;
@ -72,43 +71,43 @@ Deno.test("[node/http listen]", async () => {
Deno.test("[node/http close]", async () => { Deno.test("[node/http close]", async () => {
{ {
const promise1 = deferred<void>(); const deferred1 = Promise.withResolvers<void>();
const promise2 = deferred<void>(); const deferred2 = Promise.withResolvers<void>();
// Node quirk: callback gets exception object, event listener does not. // Node quirk: callback gets exception object, event listener does not.
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
const server = http.createServer().close((err: any) => { const server = http.createServer().close((err: any) => {
assertEquals(err.code, "ERR_SERVER_NOT_RUNNING"); assertEquals(err.code, "ERR_SERVER_NOT_RUNNING");
promise1.resolve(); deferred1.resolve();
}); });
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
server.on("close", (err: any) => { server.on("close", (err: any) => {
assertEquals(err, undefined); assertEquals(err, undefined);
promise2.resolve(); deferred2.resolve();
}); });
server.on("listening", () => { server.on("listening", () => {
throw Error("unreachable"); throw Error("unreachable");
}); });
await promise1; await deferred1.promise;
await promise2; await deferred2.promise;
} }
{ {
const promise1 = deferred<void>(); const deferred1 = Promise.withResolvers<void>();
const promise2 = deferred<void>(); const deferred2 = Promise.withResolvers<void>();
const server = http.createServer().listen().close((err) => { const server = http.createServer().listen().close((err) => {
assertEquals(err, undefined); assertEquals(err, undefined);
promise1.resolve(); deferred1.resolve();
}); });
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
server.on("close", (err: any) => { server.on("close", (err: any) => {
assertEquals(err, undefined); assertEquals(err, undefined);
promise2.resolve(); deferred2.resolve();
}); });
server.on("listening", () => { server.on("listening", () => {
throw Error("unreachable"); throw Error("unreachable");
}); });
await promise1; await deferred1.promise;
await promise2; await deferred2.promise;
} }
}); });
@ -117,7 +116,7 @@ Deno.test("[node/http] chunked response", async () => {
const body of [undefined, "", "ok"] const body of [undefined, "", "ok"]
) { ) {
const expected = body ?? ""; const expected = body ?? "";
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => { const server = http.createServer((_req, res) => {
res.writeHead(200, { "transfer-encoding": "chunked" }); res.writeHead(200, { "transfer-encoding": "chunked" });
@ -134,7 +133,7 @@ Deno.test("[node/http] chunked response", async () => {
const actual = await res.text(); const actual = await res.text();
assertEquals(actual, expected); assertEquals(actual, expected);
server.close(() => promise.resolve()); server.close(() => resolve());
}); });
await promise; await promise;
@ -143,7 +142,7 @@ Deno.test("[node/http] chunked response", async () => {
// Test empty chunks: https://github.com/denoland/deno/issues/17194 // Test empty chunks: https://github.com/denoland/deno/issues/17194
Deno.test("[node/http] empty chunk in the middle of response", async () => { Deno.test("[node/http] empty chunk in the middle of response", async () => {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => { const server = http.createServer((_req, res) => {
res.write("a"); res.write("a");
@ -159,7 +158,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
); );
const actual = await res.text(); const actual = await res.text();
assertEquals(actual, "ab"); assertEquals(actual, "ab");
server.close(() => promise.resolve()); server.close(() => resolve());
}); });
await promise; await promise;
@ -167,7 +166,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async () => { Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async () => {
for (const status of [101, 204, 205, 304]) { for (const status of [101, 204, 205, 304]) {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => { const server = http.createServer((_req, res) => {
res.statusCode = status; res.statusCode = status;
res.end(""); res.end("");
@ -179,15 +178,15 @@ Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async
); );
await res.arrayBuffer(); await res.arrayBuffer();
assertEquals(res.status, status); assertEquals(res.status, status);
server.close(() => promise.resolve()); server.close(() => resolve());
}); });
await promise; await promise;
} }
}); });
Deno.test("[node/http] request default protocol", async () => { Deno.test("[node/http] request default protocol", async () => {
const promise = deferred<void>(); const deferred1 = Promise.withResolvers<void>();
const promise2 = deferred<void>(); const deferred2 = Promise.withResolvers<void>();
const server = http.createServer((_, res) => { const server = http.createServer((_, res) => {
res.end("ok"); res.end("ok");
}); });
@ -210,22 +209,22 @@ Deno.test("[node/http] request default protocol", async () => {
}); });
clientRes = res; clientRes = res;
assertEquals(res.statusCode, 200); assertEquals(res.statusCode, 200);
promise2.resolve(); deferred2.resolve();
}, },
); );
clientReq.end(); clientReq.end();
}); });
server.on("close", () => { server.on("close", () => {
promise.resolve(); deferred1.resolve();
}); });
await promise; await deferred1.promise;
await promise2; await deferred2.promise;
assert(clientReq.socket instanceof EventEmitter); assert(clientReq.socket instanceof EventEmitter);
assertEquals(clientRes!.complete, true); assertEquals(clientRes!.complete, true);
}); });
Deno.test("[node/http] request with headers", async () => { Deno.test("[node/http] request with headers", async () => {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((req, res) => { const server = http.createServer((req, res) => {
assertEquals(req.headers["x-foo"], "bar"); assertEquals(req.headers["x-foo"], "bar");
res.end("ok"); res.end("ok");
@ -249,7 +248,7 @@ Deno.test("[node/http] request with headers", async () => {
req.end(); req.end();
}); });
server.on("close", () => { server.on("close", () => {
promise.resolve(); resolve();
}); });
await promise; await promise;
}); });
@ -258,7 +257,7 @@ Deno.test("[node/http] non-string buffer response", {
// TODO(kt3k): Enable sanitizer. A "zlib" resource is leaked in this test case. // TODO(kt3k): Enable sanitizer. A "zlib" resource is leaked in this test case.
sanitizeResources: false, sanitizeResources: false,
}, async () => { }, async () => {
const promise = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_, res) => { const server = http.createServer((_, res) => {
res.socket!.end(); res.socket!.end();
gzip( gzip(
@ -281,7 +280,7 @@ Deno.test("[node/http] non-string buffer response", {
} catch (e) { } catch (e) {
server.emit("error", e); server.emit("error", e);
} finally { } finally {
server.close(() => promise.resolve()); server.close(() => resolve());
} }
}); });
await promise; await promise;
@ -461,7 +460,7 @@ Deno.test("[node/http] send request with chunked body as default", async () => {
}); });
Deno.test("[node/http] ServerResponse _implicitHeader", async () => { Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
const d = deferred<void>(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => { const server = http.createServer((_req, res) => {
const writeHeadSpy = spy(res, "writeHead"); const writeHeadSpy = spy(res, "writeHead");
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
@ -476,11 +475,11 @@ Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
const res = await fetch(`http://localhost:${port}`); const res = await fetch(`http://localhost:${port}`);
assertEquals(await res.text(), "Hello World"); assertEquals(await res.text(), "Hello World");
server.close(() => { server.close(() => {
d.resolve(); resolve();
}); });
}); });
await d; await promise;
}); });
Deno.test("[node/http] server unref", async () => { Deno.test("[node/http] server unref", async () => {
@ -504,7 +503,7 @@ Deno.test("[node/http] server unref", async () => {
Deno.test("[node/http] ClientRequest handle non-string headers", async () => { Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
let headers: any; let headers: any;
const def = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request("http://localhost:4545/echo_server", { const req = http.request("http://localhost:4545/echo_server", {
method: "POST", method: "POST",
headers: { 1: 2 }, headers: { 1: 2 },
@ -514,18 +513,18 @@ Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
resp.on("data", () => {}); resp.on("data", () => {});
resp.on("end", () => { resp.on("end", () => {
def.resolve(); resolve();
}); });
}); });
req.once("error", (e) => def.reject(e)); req.once("error", (e) => reject(e));
req.end(); req.end();
await def; await promise;
assertEquals(headers!["1"], "2"); assertEquals(headers!["1"], "2");
}); });
Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => { Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
let body = ""; let body = "";
const def = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = https.request("https://localhost:5545/http_version", { const req = https.request("https://localhost:5545/http_version", {
method: "POST", method: "POST",
headers: { 1: 2 }, headers: { 1: 2 },
@ -535,39 +534,39 @@ Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
}); });
resp.on("end", () => { resp.on("end", () => {
def.resolve(); resolve();
}); });
}); });
req.once("error", (e) => def.reject(e)); req.once("error", (e) => reject(e));
req.end(); req.end();
await def; await promise;
assertEquals(body, "HTTP/1.1"); assertEquals(body, "HTTP/1.1");
}); });
Deno.test("[node/http] ClientRequest setTimeout", async () => { Deno.test("[node/http] ClientRequest setTimeout", async () => {
let body = ""; let body = "";
const def = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const timer = setTimeout(() => def.reject("timed out"), 50000); const timer = setTimeout(() => reject("timed out"), 50000);
const req = http.request("http://localhost:4545/http_version", (resp) => { const req = http.request("http://localhost:4545/http_version", (resp) => {
resp.on("data", (chunk) => { resp.on("data", (chunk) => {
body += chunk; body += chunk;
}); });
resp.on("end", () => { resp.on("end", () => {
def.resolve(); resolve();
}); });
}); });
req.setTimeout(120000); req.setTimeout(120000);
req.once("error", (e) => def.reject(e)); req.once("error", (e) => reject(e));
req.end(); req.end();
await def; await promise;
clearTimeout(timer); clearTimeout(timer);
assertEquals(body, "HTTP/1.1"); assertEquals(body, "HTTP/1.1");
}); });
Deno.test("[node/http] ClientRequest PATCH", async () => { Deno.test("[node/http] ClientRequest PATCH", async () => {
let body = ""; let body = "";
const def = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request("http://localhost:4545/echo_server", { const req = http.request("http://localhost:4545/echo_server", {
method: "PATCH", method: "PATCH",
}, (resp) => { }, (resp) => {
@ -576,20 +575,20 @@ Deno.test("[node/http] ClientRequest PATCH", async () => {
}); });
resp.on("end", () => { resp.on("end", () => {
def.resolve(); resolve();
}); });
}); });
req.write("hello "); req.write("hello ");
req.write("world"); req.write("world");
req.once("error", (e) => def.reject(e)); req.once("error", (e) => reject(e));
req.end(); req.end();
await def; await promise;
assertEquals(body, "hello world"); assertEquals(body, "hello world");
}); });
Deno.test("[node/http] ClientRequest PUT", async () => { Deno.test("[node/http] ClientRequest PUT", async () => {
let body = ""; let body = "";
const def = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request("http://localhost:4545/echo_server", { const req = http.request("http://localhost:4545/echo_server", {
method: "PUT", method: "PUT",
}, (resp) => { }, (resp) => {
@ -598,20 +597,20 @@ Deno.test("[node/http] ClientRequest PUT", async () => {
}); });
resp.on("end", () => { resp.on("end", () => {
def.resolve(); resolve();
}); });
}); });
req.write("hello "); req.write("hello ");
req.write("world"); req.write("world");
req.once("error", (e) => def.reject(e)); req.once("error", (e) => reject(e));
req.end(); req.end();
await def; await promise;
assertEquals(body, "hello world"); assertEquals(body, "hello world");
}); });
Deno.test("[node/http] ClientRequest search params", async () => { Deno.test("[node/http] ClientRequest search params", async () => {
let body = ""; let body = "";
const def = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request({ const req = http.request({
host: "localhost:4545", host: "localhost:4545",
path: "search_params?foo=bar", path: "search_params?foo=bar",
@ -621,18 +620,18 @@ Deno.test("[node/http] ClientRequest search params", async () => {
}); });
resp.on("end", () => { resp.on("end", () => {
def.resolve(); resolve();
}); });
}); });
req.once("error", (e) => def.reject(e)); req.once("error", (e) => reject(e));
req.end(); req.end();
await def; await promise;
assertEquals(body, "foo=bar"); assertEquals(body, "foo=bar");
}); });
Deno.test("[node/http] HTTPS server", async () => { Deno.test("[node/http] HTTPS server", async () => {
const promise = deferred<void>(); const deferred = Promise.withResolvers<void>();
const promise2 = deferred<void>(); const deferred2 = Promise.withResolvers<void>();
const client = Deno.createHttpClient({ const client = Deno.createHttpClient({
caCerts: [Deno.readTextFileSync("cli/tests/testdata/tls/RootCA.pem")], caCerts: [Deno.readTextFileSync("cli/tests/testdata/tls/RootCA.pem")],
}); });
@ -652,14 +651,14 @@ Deno.test("[node/http] HTTPS server", async () => {
assertEquals(res.status, 200); assertEquals(res.status, 200);
assertEquals(await res.text(), "success!"); assertEquals(await res.text(), "success!");
server.close(); server.close();
promise2.resolve(); deferred2.resolve();
}); });
}) })
.on("error", () => fail()); .on("error", () => fail());
server.on("close", () => { server.on("close", () => {
promise.resolve(); deferred.resolve();
}); });
await Promise.all([promise, promise2]); await Promise.all([deferred.promise, deferred2.promise]);
client.close(); client.close();
}); });
@ -667,7 +666,7 @@ Deno.test(
"[node/http] client upgrade", "[node/http] client upgrade",
{ permissions: { net: true } }, { permissions: { net: true } },
async () => { async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((req, res) => { const server = http.createServer((req, res) => {
// @ts-ignore: It exists on TLSSocket // @ts-ignore: It exists on TLSSocket
assert(!req.socket.encrypted); assert(!req.socket.encrypted);
@ -706,7 +705,7 @@ Deno.test(
// @ts-ignore it's a socket for real // @ts-ignore it's a socket for real
serverSocket!.end(); serverSocket!.end();
server.close(() => { server.close(() => {
promise.resolve(); resolve();
}); });
}); });
}); });
@ -725,7 +724,7 @@ Deno.test(
received = true; received = true;
return new Response("hello"); return new Response("hello");
}); });
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
let body = ""; let body = "";
const request = http.request( const request = http.request(
@ -736,11 +735,11 @@ Deno.test(
}); });
resp.on("end", () => { resp.on("end", () => {
promise.resolve(); resolve();
}); });
}, },
); );
request.on("error", promise.reject); request.on("error", reject);
request.end(() => { request.end(() => {
assert(received); assert(received);
}); });
@ -754,22 +753,22 @@ Deno.test(
); );
Deno.test("[node/http] server emits error if addr in use", async () => { Deno.test("[node/http] server emits error if addr in use", async () => {
const promise = deferred<void>(); const deferred1 = Promise.withResolvers<void>();
const promise2 = deferred<Error>(); const deferred2 = Promise.withResolvers<Error>();
const server = http.createServer(); const server = http.createServer();
server.listen(9001); server.listen(9001);
const server2 = http.createServer(); const server2 = http.createServer();
server2.on("error", (e) => { server2.on("error", (e) => {
promise2.resolve(e); deferred2.resolve(e);
}); });
server2.listen(9001); server2.listen(9001);
const err = await promise2; const err = await deferred2.promise;
server.close(() => promise.resolve()); server.close(() => deferred1.resolve());
server2.close(); server2.close();
await promise; await deferred1.promise;
const expectedMsg = Deno.build.os === "windows" const expectedMsg = Deno.build.os === "windows"
? "Only one usage of each socket address" ? "Only one usage of each socket address"
: "Address already in use"; : "Address already in use";
@ -795,15 +794,15 @@ Deno.test(
return new Response("hello"); return new Response("hello");
}, },
); );
const promise = deferred(); const { promise, resolve, reject } = Promise.withResolvers<void>();
const request = http.request("http://localhost:5929/"); const request = http.request("http://localhost:5929/");
request.on("error", promise.reject); request.on("error", reject);
request.on("close", () => {}); request.on("close", () => {});
request.end(); request.end();
setTimeout(() => { setTimeout(() => {
request.destroy(new Error()); request.destroy(new Error());
promise.resolve(); resolve();
}, 100); }, 100);
await promise; await promise;

5
cli/tests/unit_node/internal/_randomFill_test.ts
View file

@ -6,7 +6,6 @@ import {
assertNotEquals, assertNotEquals,
assertThrows, assertThrows,
} from "../../../../test_util/std/testing/asserts.ts"; } from "../../../../test_util/std/testing/asserts.ts";
import { deferred } from "../../../../test_util/std/async/deferred.ts";
const validateNonZero = (buf: Buffer) => { const validateNonZero = (buf: Buffer) => {
if (!buf.some((ch) => ch > 0)) throw new Error("Error"); if (!buf.some((ch) => ch > 0)) throw new Error("Error");
@ -17,14 +16,14 @@ const validateZero = (buf: Buffer) => {
}; };
Deno.test("[node/crypto.randomFill]", async () => { Deno.test("[node/crypto.randomFill]", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<boolean>();
const buf = Buffer.alloc(10); const buf = Buffer.alloc(10);
const before = buf.toString("hex"); const before = buf.toString("hex");
randomFill(buf, 5, 5, (_err, bufTwo) => { randomFill(buf, 5, 5, (_err, bufTwo) => {
const after = bufTwo?.toString("hex"); const after = bufTwo?.toString("hex");
assertEquals(before.slice(0, 10), after?.slice(0, 10)); assertEquals(before.slice(0, 10), after?.slice(0, 10));
promise.resolve(true); resolve(true);
}); });
await promise; await promise;

9
cli/tests/unit_node/internal/scrypt_test.ts
View file

@ -2,10 +2,9 @@
import { scrypt, scryptSync } from "node:crypto"; import { scrypt, scryptSync } from "node:crypto";
import { Buffer } from "node:buffer"; import { Buffer } from "node:buffer";
import { assertEquals } from "../../../../test_util/std/testing/asserts.ts"; import { assertEquals } from "../../../../test_util/std/testing/asserts.ts";
import { deferred } from "../../../../test_util/std/async/deferred.ts";
Deno.test("scrypt works correctly", async () => { Deno.test("scrypt works correctly", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<boolean>();
scrypt("password", "salt", 32, (err, key) => { scrypt("password", "salt", 32, (err, key) => {
if (err) throw err; if (err) throw err;
@ -46,14 +45,14 @@ Deno.test("scrypt works correctly", async () => {
115, 115,
]), ]),
); );
promise.resolve(true); resolve(true);
}); });
await promise; await promise;
}); });
Deno.test("scrypt works with options", async () => { Deno.test("scrypt works with options", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<boolean>();
scrypt( scrypt(
"password", "password",
@ -101,7 +100,7 @@ Deno.test("scrypt works with options", async () => {
71, 71,
]), ]),
); );
promise.resolve(true); resolve(true);
}, },
); );

43
cli/tests/unit_node/net_test.ts
View file

@ -5,15 +5,14 @@ import {
assert, assert,
assertEquals, assertEquals,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
import { Deferred, deferred } from "../../../test_util/std/async/deferred.ts";
import * as path from "../../../test_util/std/path/mod.ts"; import * as path from "../../../test_util/std/path/mod.ts";
import * as http from "node:http"; import * as http from "node:http";
Deno.test("[node/net] close event emits after error event", async () => { Deno.test("[node/net] close event emits after error event", async () => {
const socket = net.createConnection(27009, "doesnotexist"); const socket = net.createConnection(27009, "doesnotexist");
const events: ("error" | "close")[] = []; const events: ("error" | "close")[] = [];
const errorEmitted = deferred(); const errorEmitted = Promise.withResolvers<void>();
const closeEmitted = deferred(); const closeEmitted = Promise.withResolvers<void>();
socket.once("error", () => { socket.once("error", () => {
events.push("error"); events.push("error");
errorEmitted.resolve(); errorEmitted.resolve();
@ -22,14 +21,14 @@ Deno.test("[node/net] close event emits after error event", async () => {
events.push("close"); events.push("close");
closeEmitted.resolve(); closeEmitted.resolve();
}); });
await Promise.all([errorEmitted, closeEmitted]); await Promise.all([errorEmitted.promise, closeEmitted.promise]);
// `error` happens before `close` // `error` happens before `close`
assertEquals(events, ["error", "close"]); assertEquals(events, ["error", "close"]);
}); });
Deno.test("[node/net] the port is available immediately after close callback", async () => { Deno.test("[node/net] the port is available immediately after close callback", async () => {
const p = deferred(); const deferred = Promise.withResolvers<void>();
// This simulates what get-port@5.1.1 does. // This simulates what get-port@5.1.1 does.
const getAvailablePort = (port: number) => const getAvailablePort = (port: number) =>
@ -48,11 +47,11 @@ Deno.test("[node/net] the port is available immediately after close callback", a
const port = await getAvailablePort(5555); const port = await getAvailablePort(5555);
const httpServer = http.createServer(); const httpServer = http.createServer();
httpServer.on("error", (e) => p.reject(e)); httpServer.on("error", (e) => deferred.reject(e));
httpServer.listen(port, () => { httpServer.listen(port, () => {
httpServer.close(() => p.resolve()); httpServer.close(() => deferred.resolve());
}); });
await p; await deferred.promise;
}); });
Deno.test("[node/net] net.connect().unref() works", async () => { Deno.test("[node/net] net.connect().unref() works", async () => {
@ -100,16 +99,16 @@ Deno.test({
}); });
Deno.test("[node/net] connection event has socket value", async () => { Deno.test("[node/net] connection event has socket value", async () => {
const p = deferred(); const deferred = Promise.withResolvers<void>();
const p2 = deferred(); const deferred2 = Promise.withResolvers<void>();
const server = net.createServer(); const server = net.createServer();
server.on("error", p.reject); server.on("error", deferred.reject);
server.on("connection", (socket) => { server.on("connection", (socket) => {
assert(socket !== undefined); assert(socket !== undefined);
socket.end(); socket.end();
server.close(() => { server.close(() => {
p.resolve(); deferred.resolve();
}); });
}); });
server.listen(async () => { server.listen(async () => {
@ -125,10 +124,10 @@ Deno.test("[node/net] connection event has socket value", async () => {
// //
} }
p2.resolve(); deferred2.resolve();
}); });
await Promise.all([p, p2]); await Promise.all([deferred.promise, deferred2.promise]);
}); });
/// We need to make sure that any shared buffers are never used concurrently by two reads. /// We need to make sure that any shared buffers are never used concurrently by two reads.
@ -137,17 +136,19 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
const socketCount = 9; const socketCount = 9;
class TestSocket { class TestSocket {
dataReceived: Deferred<undefined> = deferred(); dataReceived: ReturnType<typeof Promise.withResolvers<void>> = Promise
.withResolvers<void>();
events: string[] = []; events: string[] = [];
socket: net.Socket | undefined; socket: net.Socket | undefined;
} }
const finished = deferred(); const finished = Promise.withResolvers<void>();
const serverSocketsClosed: Deferred<undefined>[] = []; const serverSocketsClosed: ReturnType<typeof Promise.withResolvers<void>>[] =
[];
const server = net.createServer(); const server = net.createServer();
server.on("connection", (socket) => { server.on("connection", (socket) => {
assert(socket !== undefined); assert(socket !== undefined);
const i = serverSocketsClosed.push(deferred()); const i = serverSocketsClosed.push(Promise.withResolvers<void>());
socket.on("data", (data) => { socket.on("data", (data) => {
socket.write(new TextDecoder().decode(data)); socket.write(new TextDecoder().decode(data));
}); });
@ -183,7 +184,7 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
sockets[i].socket?.write(`${i}`.repeat(3)); sockets[i].socket?.write(`${i}`.repeat(3));
} }
await Promise.all(sockets.map((socket) => socket.dataReceived)); await Promise.all(sockets.map((socket) => socket.dataReceived.promise));
for (let i = 0; i < socketCount; i++) { for (let i = 0; i < socketCount; i++) {
sockets[i].socket?.end(); sockets[i].socket?.end();
@ -194,8 +195,8 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
}); });
}); });
await finished; await finished.promise;
await Promise.all(serverSocketsClosed); await Promise.all(serverSocketsClosed.map(({ promise }) => promise));
for (let i = 0; i < socketCount; i++) { for (let i = 0; i < socketCount; i++) {
assertEquals(sockets[i].events, [`${i}`.repeat(3), `${i}`.repeat(3)]); assertEquals(sockets[i].events, [`${i}`.repeat(3), `${i}`.repeat(3)]);

5
cli/tests/unit_node/process_test.ts
View file

@ -13,7 +13,6 @@ import {
assertThrows, assertThrows,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
import { stripColor } from "../../../test_util/std/fmt/colors.ts"; import { stripColor } from "../../../test_util/std/fmt/colors.ts";
import { deferred } from "../../../test_util/std/async/deferred.ts";
import * as path from "../../../test_util/std/path/mod.ts"; import * as path from "../../../test_util/std/path/mod.ts";
import { delay } from "../../../test_util/std/async/delay.ts"; import { delay } from "../../../test_util/std/async/delay.ts";
@ -368,7 +367,7 @@ Deno.test({
// stdin resource is present before the test starts. // stdin resource is present before the test starts.
sanitizeResources: false, sanitizeResources: false,
async fn() { async fn() {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const expected = ["foo", "bar", null, "end"]; const expected = ["foo", "bar", null, "end"];
const data: (string | null)[] = []; const data: (string | null)[] = [];
@ -385,7 +384,7 @@ Deno.test({
process.stdin.push("bar"); process.stdin.push("bar");
process.nextTick(() => { process.nextTick(() => {
process.stdin.push(null); process.stdin.push(null);
promise.resolve(); resolve();
}); });
}); });

7
cli/tests/unit_node/tls_test.ts
View file

@ -5,7 +5,6 @@ import {
assertInstanceOf, assertInstanceOf,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
import { delay } from "../../../test_util/std/async/delay.ts"; import { delay } from "../../../test_util/std/async/delay.ts";
import { deferred } from "../../../test_util/std/async/deferred.ts";
import { fromFileUrl, join } from "../../../test_util/std/path/mod.ts"; import { fromFileUrl, join } from "../../../test_util/std/path/mod.ts";
import { serveTls } from "../../../test_util/std/http/server.ts"; import { serveTls } from "../../../test_util/std/http/server.ts";
import * as tls from "node:tls"; import * as tls from "node:tls";
@ -89,7 +88,7 @@ Deno.test("tls.connect mid-read tcp->tls upgrade", async () => {
}); });
Deno.test("tls.createServer creates a TLS server", async () => { Deno.test("tls.createServer creates a TLS server", async () => {
const p = deferred(); const deferred = Promise.withResolvers<void>();
const server = tls.createServer( const server = tls.createServer(
// deno-lint-ignore no-explicit-any // deno-lint-ignore no-explicit-any
{ host: "0.0.0.0", key, cert } as any, { host: "0.0.0.0", key, cert } as any,
@ -131,9 +130,9 @@ Deno.test("tls.createServer creates a TLS server", async () => {
conn.close(); conn.close();
server.close(); server.close();
p.resolve(); deferred.resolve();
}); });
await p; await deferred.promise;
}); });
Deno.test("TLSSocket can construct without options", () => { Deno.test("TLSSocket can construct without options", () => {

9
cli/tests/unit_node/zlib_test.ts
View file

@ -4,7 +4,6 @@ import {
assert, assert,
assertEquals, assertEquals,
} from "../../../test_util/std/testing/asserts.ts"; } from "../../../test_util/std/testing/asserts.ts";
import { deferred } from "../../../test_util/std/async/deferred.ts";
import { fromFileUrl, relative } from "../../../test_util/std/path/mod.ts"; import { fromFileUrl, relative } from "../../../test_util/std/path/mod.ts";
import { import {
brotliCompressSync, brotliCompressSync,
@ -24,7 +23,7 @@ Deno.test("brotli compression sync", () => {
}); });
Deno.test("brotli compression", async () => { Deno.test("brotli compression", async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const compress = createBrotliCompress(); const compress = createBrotliCompress();
const filePath = relative( const filePath = relative(
Deno.cwd(), Deno.cwd(),
@ -43,7 +42,7 @@ Deno.test("brotli compression", async () => {
const stream2 = input2.pipe(decompress).pipe(output2); const stream2 = input2.pipe(decompress).pipe(output2);
stream2.on("finish", () => { stream2.on("finish", () => {
promise.resolve(); resolve();
}); });
}); });
@ -73,12 +72,12 @@ Deno.test(
"zlib create deflate with dictionary", "zlib create deflate with dictionary",
{ sanitizeResources: false }, { sanitizeResources: false },
async () => { async () => {
const promise = deferred(); const { promise, resolve } = Promise.withResolvers<void>();
const handle = createDeflate({ const handle = createDeflate({
dictionary: Buffer.alloc(0), dictionary: Buffer.alloc(0),
}); });
handle.on("close", () => promise.resolve()); handle.on("close", () => resolve());
handle.end(); handle.end();
handle.destroy(); handle.destroy();

31
ext/node/polyfills/_util/async.ts
View file

@ -1,39 +1,10 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
// This module is vendored from std/async/deferred.ts and std/async/delay.ts // This module is vendored from std/async/delay.ts
// (with some modifications) // (with some modifications)
// TODO(petamoriken): enable prefer-primordials for node polyfills // TODO(petamoriken): enable prefer-primordials for node polyfills
// deno-lint-ignore-file prefer-primordials // deno-lint-ignore-file prefer-primordials
export interface Deferred<T> extends Promise<T> {
readonly state: "pending" | "fulfilled" | "rejected";
resolve(value?: T | PromiseLike<T>): void;
// deno-lint-ignore no-explicit-any
reject(reason?: any): void;
}
/** Creates a Promise with the `reject` and `resolve` functions */
export function deferred<T>(): Deferred<T> {
let methods;
let state = "pending";
const promise = new Promise<T>((resolve, reject) => {
methods = {
async resolve(value: T | PromiseLike<T>) {
await value;
state = "fulfilled";
resolve(value);
},
// deno-lint-ignore no-explicit-any
reject(reason?: any) {
state = "rejected";
reject(reason);
},
};
});
Object.defineProperty(promise, "state", { get: () => state });
return Object.assign(promise, methods) as Deferred<T>;
}
/** Resolve a Promise after a given amount of milliseconds. */ /** Resolve a Promise after a given amount of milliseconds. */
export function delay( export function delay(
ms: number, ms: number,

11
ext/node/polyfills/http.ts
View file

@ -7,7 +7,6 @@
const core = globalThis.__bootstrap.core; const core = globalThis.__bootstrap.core;
import { TextEncoder } from "ext:deno_web/08_text_encoding.js"; import { TextEncoder } from "ext:deno_web/08_text_encoding.js";
import { type Deferred, deferred } from "ext:deno_node/_util/async.ts";
import { setTimeout } from "ext:deno_web/02_timers.js"; import { setTimeout } from "ext:deno_web/02_timers.js";
import { import {
_normalizeArgs, _normalizeArgs,
@ -1556,7 +1555,7 @@ export class ServerImpl extends EventEmitter {
#server: Deno.Server; #server: Deno.Server;
#unref = false; #unref = false;
#ac?: AbortController; #ac?: AbortController;
#servePromise: Deferred<void>; #serveDeferred: ReturnType<typeof Promise.withResolvers<void>>;
listening = false; listening = false;
constructor(opts, requestListener?: ServerHandler) { constructor(opts, requestListener?: ServerHandler) {
@ -1573,8 +1572,8 @@ export class ServerImpl extends EventEmitter {
this._opts = opts; this._opts = opts;
this.#servePromise = deferred(); this.#serveDeferred = Promise.withResolvers<void>();
this.#servePromise.then(() => this.emit("close")); this.#serveDeferred.promise.then(() => this.emit("close"));
if (requestListener !== undefined) { if (requestListener !== undefined) {
this.on("request", requestListener); this.on("request", requestListener);
} }
@ -1660,7 +1659,7 @@ export class ServerImpl extends EventEmitter {
if (this.#unref) { if (this.#unref) {
this.#server.unref(); this.#server.unref();
} }
this.#server.finished.then(() => this.#servePromise!.resolve()); this.#server.finished.then(() => this.#serveDeferred!.resolve());
} }
setTimeout() { setTimeout() {
@ -1700,7 +1699,7 @@ export class ServerImpl extends EventEmitter {
this.#ac.abort(); this.#ac.abort();
this.#ac = undefined; this.#ac = undefined;
} else { } else {
this.#servePromise!.resolve(); this.#serveDeferred!.resolve();
} }
this.#server = undefined; this.#server = undefined;

25
ext/node/polyfills/http2.ts
View file

@ -20,7 +20,6 @@ import {
import { FileHandle } from "node:fs/promises"; import { FileHandle } from "node:fs/promises";
import { kStreamBaseField } from "ext:deno_node/internal_binding/stream_wrap.ts"; import { kStreamBaseField } from "ext:deno_node/internal_binding/stream_wrap.ts";
import { addTrailers, serveHttpOnConnection } from "ext:deno_http/00_serve.js"; import { addTrailers, serveHttpOnConnection } from "ext:deno_http/00_serve.js";
import { type Deferred, deferred } from "ext:deno_node/_util/async.ts";
import { nextTick } from "ext:deno_node/_next_tick.ts"; import { nextTick } from "ext:deno_node/_next_tick.ts";
import { TextEncoder } from "ext:deno_web/08_text_encoding.js"; import { TextEncoder } from "ext:deno_web/08_text_encoding.js";
import { Duplex } from "node:stream"; import { Duplex } from "node:stream";
@ -552,9 +551,9 @@ function getAuthority(headers) {
export class Http2Stream extends EventEmitter { export class Http2Stream extends EventEmitter {
#session: Http2Session; #session: Http2Session;
#headers: Deferred<Http2Headers>; #headers: Promise<Http2Headers>;
#controllerPromise: Deferred<ReadableStreamDefaultController<Uint8Array>>; #controllerPromise: Promise<ReadableStreamDefaultController<Uint8Array>>;
#readerPromise: Deferred<ReadableStream<Uint8Array>>; #readerPromise: Promise<ReadableStream<Uint8Array>>;
#closed: boolean; #closed: boolean;
_response: Response; _response: Response;
@ -1260,7 +1259,7 @@ function callTimeout() {
} }
export class ServerHttp2Stream extends Http2Stream { export class ServerHttp2Stream extends Http2Stream {
_promise: Deferred<Response>; _deferred: ReturnType<typeof Promise.withResolvers<Response>>;
#body: ReadableStream<Uint8Array>; #body: ReadableStream<Uint8Array>;
#waitForTrailers: boolean; #waitForTrailers: boolean;
#headersSent: boolean; #headersSent: boolean;
@ -1273,7 +1272,7 @@ export class ServerHttp2Stream extends Http2Stream {
body: ReadableStream<Uint8Array>, body: ReadableStream<Uint8Array>,
) { ) {
super(session, headers, controllerPromise, Promise.resolve(reader)); super(session, headers, controllerPromise, Promise.resolve(reader));
this._promise = new deferred(); this._deferred = Promise.withResolvers<Response>();
this.#body = body; this.#body = body;
} }
@ -1319,10 +1318,10 @@ export class ServerHttp2Stream extends Http2Stream {
} }
} }
if (options?.endStream) { if (options?.endStream) {
this._promise.resolve(this._response = new Response("", response)); this._deferred.resolve(this._response = new Response("", response));
} else { } else {
this.#waitForTrailers = options?.waitForTrailers; this.#waitForTrailers = options?.waitForTrailers;
this._promise.resolve( this._deferred.resolve(
this._response = new Response(this.#body, response), this._response = new Response(this.#body, response),
); );
} }
@ -1368,12 +1367,12 @@ export class Http2Server extends Server {
this.#abortController.signal, this.#abortController.signal,
async (req: Request) => { async (req: Request) => {
try { try {
const controllerPromise: Deferred< const controllerDeferred = Promise.withResolvers<
ReadableStreamDefaultController<Uint8Array> ReadableStreamDefaultController<Uint8Array>
> = deferred(); >();
const body = new ReadableStream({ const body = new ReadableStream({
start(controller) { start(controller) {
controllerPromise.resolve(controller); controllerDeferred.resolve(controller);
}, },
}); });
const headers: Http2Headers = {}; const headers: Http2Headers = {};
@ -1385,13 +1384,13 @@ export class Http2Server extends Server {
const stream = new ServerHttp2Stream( const stream = new ServerHttp2Stream(
session, session,
Promise.resolve(headers), Promise.resolve(headers),
controllerPromise, controllerDeferred.promise,
req.body, req.body,
body, body,
); );
session.emit("stream", stream, headers); session.emit("stream", stream, headers);
this.emit("stream", stream, headers); this.emit("stream", stream, headers);
return await stream._promise; return await stream._deferred.promise;
} catch (e) { } catch (e) {
console.log(">>> Error in serveHttpOnConnection", e); console.log(">>> Error in serveHttpOnConnection", e);
} }

13
ext/node/polyfills/internal/child_process.ts
View file

@ -11,7 +11,6 @@ import { EventEmitter } from "node:events";
import { os } from "ext:deno_node/internal_binding/constants.ts"; import { os } from "ext:deno_node/internal_binding/constants.ts";
import { notImplemented, warnNotImplemented } from "ext:deno_node/_utils.ts"; import { notImplemented, warnNotImplemented } from "ext:deno_node/_utils.ts";
import { Readable, Stream, Writable } from "node:stream"; import { Readable, Stream, Writable } from "node:stream";
import { deferred } from "ext:deno_node/_util/async.ts";
import { isWindows } from "ext:deno_node/_util/os.ts"; import { isWindows } from "ext:deno_node/_util/os.ts";
import { nextTick } from "ext:deno_node/_next_tick.ts"; import { nextTick } from "ext:deno_node/_next_tick.ts";
import { import {
@ -151,7 +150,7 @@ export class ChildProcess extends EventEmitter {
]; ];
#process!: Deno.ChildProcess; #process!: Deno.ChildProcess;
#spawned = deferred<void>(); #spawned = Promise.withResolvers<void>();
constructor( constructor(
command: string, command: string,
@ -253,7 +252,7 @@ export class ChildProcess extends EventEmitter {
(async () => { (async () => {
const status = await this.#process.status; const status = await this.#process.status;
this.exitCode = status.code; this.exitCode = status.code;
this.#spawned.then(async () => { this.#spawned.promise.then(async () => {
const exitCode = this.signalCode == null ? this.exitCode : null; const exitCode = this.signalCode == null ? this.exitCode : null;
const signalCode = this.signalCode == null ? null : this.signalCode; const signalCode = this.signalCode == null ? null : this.signalCode;
// The 'exit' and 'close' events must be emitted after the 'spawn' event. // The 'exit' and 'close' events must be emitted after the 'spawn' event.
@ -688,22 +687,22 @@ function waitForReadableToClose(readable: Readable) {
} }
function waitForStreamToClose(stream: Stream) { function waitForStreamToClose(stream: Stream) {
const promise = deferred<void>(); const deferred = Promise.withResolvers<void>();
const cleanup = () => { const cleanup = () => {
stream.removeListener("close", onClose); stream.removeListener("close", onClose);
stream.removeListener("error", onError); stream.removeListener("error", onError);
}; };
const onClose = () => { const onClose = () => {
cleanup(); cleanup();
promise.resolve(); deferred.resolve();
}; };
const onError = (err: Error) => { const onError = (err: Error) => {
cleanup(); cleanup();
promise.reject(err); deferred.reject(err);
}; };
stream.once("close", onClose); stream.once("close", onClose);
stream.once("error", onError); stream.once("error", onError);
return promise; return deferred.promise;
} }
/** /**

25
ext/node/polyfills/testing.ts
View file

@ -5,23 +5,6 @@
import { notImplemented, warnNotImplemented } from "ext:deno_node/_utils.ts"; import { notImplemented, warnNotImplemented } from "ext:deno_node/_utils.ts";
export function deferred() {
let methods;
const promise = new Promise((resolve, reject) => {
methods = {
async resolve(value) {
await value;
resolve(value);
},
// deno-lint-ignore no-explicit-any
reject(reason?: any) {
reject(reason);
},
};
});
return Object.assign(promise, methods);
}
export function run() { export function run() {
notImplemented("test.run"); notImplemented("test.run");
} }
@ -124,13 +107,13 @@ function prepareOptions(name, options, fn, overrides) {
return { fn, options: finalOptions, name }; return { fn, options: finalOptions, name };
} }
function wrapTestFn(fn, promise) { function wrapTestFn(fn, resolve) {
return async function (t) { return async function (t) {
const nodeTestContext = new NodeTestContext(t); const nodeTestContext = new NodeTestContext(t);
try { try {
await fn(nodeTestContext); await fn(nodeTestContext);
} finally { } finally {
promise.resolve(undefined); resolve();
} }
}; };
} }
@ -138,11 +121,11 @@ function wrapTestFn(fn, promise) {
function prepareDenoTest(name, options, fn, overrides) { function prepareDenoTest(name, options, fn, overrides) {
const prepared = prepareOptions(name, options, fn, overrides); const prepared = prepareOptions(name, options, fn, overrides);
const promise = deferred(); const { promise, resolve } = Promise.withResolvers();
const denoTestOptions = { const denoTestOptions = {
name: prepared.name, name: prepared.name,
fn: wrapTestFn(prepared.fn, promise), fn: wrapTestFn(prepared.fn, resolve),
only: prepared.options.only, only: prepared.options.only,
ignore: prepared.options.todo || prepared.options.skip, ignore: prepared.options.todo || prepared.options.skip,
}; };

24
test_ffi/tests/test.js
View file

@ -482,30 +482,12 @@ function test_fill_buffer(fillValue, arr) {
test_fill_buffer(0, [2, 3, 4]); test_fill_buffer(0, [2, 3, 4]);
test_fill_buffer(5, [2, 7, 3, 2, 1]); test_fill_buffer(5, [2, 7, 3, 2, 1]);
// Test non blocking calls const deferred = Promise.withResolvers();
function deferred() {
let methods;
const promise = new Promise((resolve, reject) => {
methods = {
async resolve(value) {
await value;
resolve(value);
},
reject(reason) {
reject(reason);
},
};
});
return Object.assign(promise, methods);
}
const promise = deferred();
const buffer3 = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]); const buffer3 = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
dylib.symbols.nonblocking_buffer(buffer3, buffer3.length).then(() => { dylib.symbols.nonblocking_buffer(buffer3, buffer3.length).then(() => {
promise.resolve(); deferred.resolve();
}); });
await promise; await deferred.promise;
let start = performance.now(); let start = performance.now();
dylib.symbols.sleep_blocking(100); dylib.symbols.sleep_blocking(100);

9
tools/util.js
View file

@ -1,5 +1,4 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license. // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
import { deferred } from "../test_util/std/async/deferred.ts";
import { import {
dirname, dirname,
fromFileUrl, fromFileUrl,
@ -182,10 +181,10 @@ const downloadUrl =
export async function downloadPrebuilt(toolName) { export async function downloadPrebuilt(toolName) {
// Ensure only one download per tool happens at a time // Ensure only one download per tool happens at a time
if (DOWNLOAD_TASKS[toolName]) { if (DOWNLOAD_TASKS[toolName]) {
return await DOWNLOAD_TASKS[toolName]; return await DOWNLOAD_TASKS[toolName].promise;
} }
const downloadPromise = DOWNLOAD_TASKS[toolName] = deferred(); const downloadDeferred = DOWNLOAD_TASKS[toolName] = Promise.withResolvers();
const spinner = wait({ const spinner = wait({
text: "Downloading prebuilt tool: " + toolName, text: "Downloading prebuilt tool: " + toolName,
interval: 1000, interval: 1000,
@ -230,12 +229,12 @@ export async function downloadPrebuilt(toolName) {
await Deno.rename(tempFile, toolPath); await Deno.rename(tempFile, toolPath);
} catch (e) { } catch (e) {
spinner.fail(); spinner.fail();
downloadPromise.reject(e); downloadDeferred.reject(e);
throw e; throw e;
} }
spinner.succeed(); spinner.succeed();
downloadPromise.resolve(null); downloadDeferred.resolve(null);
} }
export async function verifyVersion(toolName, toolPath) { export async function verifyVersion(toolName, toolPath) {