fix(cli/tests): move worker test assertions out of message handlers (#12439)

2 files changed, 98 insertions, 116 deletions

diff --git a/cli/tests/testdata/workers/nested_worker.js b/cli/tests/testdata/workers/nested_worker.js
index 4b51b8763..953bf3bfe 100644
--- a/cli/tests/testdata/workers/nested_worker.js
+++ b/cli/tests/testdata/workers/nested_worker.js
@@ -9,7 +9,7 @@ jsWorker.onerror = (_e) => {
 };
 
 jsWorker.onmessage = (e) => {
-  postMessage({ type: "msg", text: e });
+  postMessage({ type: "msg", text: e.data });
   close();
 };
 
diff --git a/cli/tests/testdata/workers/test.ts b/cli/tests/testdata/workers/test.ts
index 4a6575863..1c345f80b 100644
--- a/cli/tests/testdata/workers/test.ts
+++ b/cli/tests/testdata/workers/test.ts
@@ -5,6 +5,7 @@
 import {
   assert,
   assertEquals,
+  assertMatch,
   assertThrows,
 } from "../../../../test_util/std/testing/asserts.ts";
 import { deferred } from "../../../../test_util/std/async/deferred.ts";
@@ -12,8 +13,6 @@ import { deferred } from "../../../../test_util/std/async/deferred.ts";
 Deno.test({
   name: "worker terminate",
   fn: async function () {
-    const promise = deferred();
-
     const jsWorker = new Worker(
       new URL("test_worker.js", import.meta.url).href,
       { type: "module" },
@@ -23,18 +22,20 @@ Deno.test({
       { type: "module", name: "tsWorker" },
     );
 
-    tsWorker.onmessage = (e) => {
-      assertEquals(e.data, "Hello World");
-      promise.resolve();
+    const promise1 = deferred();
+    jsWorker.onmessage = (e) => {
+      promise1.resolve(e.data);
     };
 
-    jsWorker.onmessage = (e) => {
-      assertEquals(e.data, "Hello World");
-      tsWorker.postMessage("Hello World");
+    const promise2 = deferred();
+    tsWorker.onmessage = (e) => {
+      promise2.resolve(e.data);
     };
 
     jsWorker.postMessage("Hello World");
-    await promise;
+    assertEquals(await promise1, "Hello World");
+    tsWorker.postMessage("Hello World");
+    assertEquals(await promise2, "Hello World");
     tsWorker.terminate();
     jsWorker.terminate();
   },
@@ -43,20 +44,18 @@ Deno.test({
 Deno.test({
   name: "worker from data url",
   async fn() {
-    const promise = deferred();
     const tsWorker = new Worker(
       "data:application/typescript;base64,aWYgKHNlbGYubmFtZSAhPT0gInRzV29ya2VyIikgewogIHRocm93IEVycm9yKGBJbnZhbGlkIHdvcmtlciBuYW1lOiAke3NlbGYubmFtZX0sIGV4cGVjdGVkIHRzV29ya2VyYCk7Cn0KCm9ubWVzc2FnZSA9IGZ1bmN0aW9uIChlKTogdm9pZCB7CiAgcG9zdE1lc3NhZ2UoZS5kYXRhKTsKICBjbG9zZSgpOwp9Owo=",
       { type: "module", name: "tsWorker" },
     );
 
+    const promise = deferred();
     tsWorker.onmessage = (e) => {
-      assertEquals(e.data, "Hello World");
-      promise.resolve();
+      promise.resolve(e.data);
     };
 
     tsWorker.postMessage("Hello World");
-
-    await promise;
+    assertEquals(await promise, "Hello World");
     tsWorker.terminate();
   },
 });
@@ -64,20 +63,18 @@ Deno.test({
 Deno.test({
   name: "worker nested",
   fn: async function () {
-    const promise = deferred();
-
     const nestedWorker = new Worker(
       new URL("nested_worker.js", import.meta.url).href,
       { type: "module", name: "nested" },
     );
 
+    const promise = deferred();
     nestedWorker.onmessage = (e) => {
-      assert(e.data.type !== "error");
-      promise.resolve();
+      promise.resolve(e.data);
     };
 
     nestedWorker.postMessage("Hello World");
-    await promise;
+    assertEquals(await promise, { type: "msg", text: "Hello World" });
     nestedWorker.terminate();
   },
 });
@@ -85,20 +82,19 @@ Deno.test({
 Deno.test({
   name: "worker throws when executing",
   fn: async function () {
-    const promise = deferred();
     const throwingWorker = new Worker(
       new URL("throwing_worker.js", import.meta.url).href,
       { type: "module" },
     );
 
+    const promise = deferred();
     // deno-lint-ignore no-explicit-any
     throwingWorker.onerror = (e: any) => {
       e.preventDefault();
-      assert(/Uncaught Error: Thrown error/.test(e.message));
-      promise.resolve();
+      promise.resolve(e.message);
     };
 
-    await promise;
+    assertMatch(await promise as string, /Uncaught Error: Thrown error/);
     throwingWorker.terminate();
   },
 });
@@ -106,18 +102,19 @@ Deno.test({
 Deno.test({
   name: "worker globals",
   fn: async function () {
-    const promise = deferred();
     const workerOptions: WorkerOptions = { type: "module" };
     const w = new Worker(
       new URL("worker_globals.ts", import.meta.url).href,
       workerOptions,
     );
+
+    const promise = deferred();
     w.onmessage = (e) => {
-      assertEquals(e.data, "true, true, true, true");
-      promise.resolve();
+      promise.resolve(e.data);
     };
+
     w.postMessage("Hello, world!");
-    await promise;
+    assertEquals(await promise, "true, true, true, true");
     w.terminate();
   },
 });
@@ -125,26 +122,23 @@ Deno.test({
 Deno.test({
   name: "worker fetch API",
   fn: async function () {
-    const promise = deferred();
-
     const fetchingWorker = new Worker(
       new URL("fetching_worker.js", import.meta.url).href,
       { type: "module" },
     );
 
+    const promise = deferred();
     // deno-lint-ignore no-explicit-any
     fetchingWorker.onerror = (e: any) => {
       e.preventDefault();
       promise.reject(e.message);
     };
-
     // Defer promise.resolve() to allow worker to shut down
     fetchingWorker.onmessage = (e) => {
-      assert(e.data === "Done!");
-      promise.resolve();
+      promise.resolve(e.data);
     };
 
-    await promise;
+    assertEquals(await promise, "Done!");
     fetchingWorker.terminate();
   },
 });
@@ -169,14 +163,13 @@ Deno.test({
           throw new Error("unreachable");
         };
         setTimeout(() => {
-          assertEquals(testResult, 10000);
-          promise.resolve();
+          promise.resolve(testResult);
         }, 100);
       }
     };
 
     busyWorker.postMessage("ping");
-    await promise;
+    assertEquals(await promise, 10000);
   },
 });
 
@@ -254,27 +247,25 @@ Deno.test({
 Deno.test({
   name: "worker scope is event listener",
   fn: async function () {
-    const promise1 = deferred();
-
     const worker = new Worker(
       new URL("event_worker_scope.js", import.meta.url),
       { type: "module" },
     );
 
+    const promise = deferred();
     worker.onmessage = (e: MessageEvent) => {
-      const { messageHandlersCalled, errorHandlersCalled } = e.data;
-      assertEquals(messageHandlersCalled, 4);
-      assertEquals(errorHandlersCalled, 4);
-      promise1.resolve();
+      promise.resolve(e.data);
     };
-
     worker.onerror = (_e) => {
       throw new Error("unreachable");
     };
 
     worker.postMessage("boom");
     worker.postMessage("ping");
-    await promise1;
+    assertEquals(await promise, {
+      messageHandlersCalled: 4,
+      errorHandlersCalled: 4,
+    });
     worker.terminate();
   },
 });
@@ -282,9 +273,6 @@ Deno.test({
 Deno.test({
   name: "worker with Deno namespace",
   fn: async function () {
-    const promise = deferred();
-    const promise2 = deferred();
-
     const regularWorker = new Worker(
       new URL("non_deno_worker.js", import.meta.url),
       { type: "module" },
@@ -300,39 +288,40 @@ Deno.test({
       },
     );
 
+    const promise1 = deferred();
     regularWorker.onmessage = (e) => {
-      assertEquals(e.data, "Hello World");
       regularWorker.terminate();
-      promise.resolve();
+      promise1.resolve(e.data);
     };
 
+    const promise2 = deferred();
     denoWorker.onmessage = (e) => {
-      assertEquals(e.data, "Hello World");
       denoWorker.terminate();
-      promise2.resolve();
+      promise2.resolve(e.data);
     };
 
     regularWorker.postMessage("Hello World");
-    await promise;
+    assertEquals(await promise1, "Hello World");
     denoWorker.postMessage("Hello World");
-    await promise2;
+    assertEquals(await promise2, "Hello World");
   },
 });
 
 Deno.test({
   name: "worker with crypto in scope",
   fn: async function () {
-    const promise = deferred();
     const w = new Worker(
       new URL("worker_crypto.js", import.meta.url).href,
       { type: "module" },
     );
+
+    const promise = deferred();
     w.onmessage = (e) => {
-      assertEquals(e.data, true);
-      promise.resolve();
+      promise.resolve(e.data);
     };
+
     w.postMessage(null);
-    await promise;
+    assertEquals(await promise, true);
     w.terminate();
   },
 });
@@ -352,11 +341,11 @@ Deno.test({
     };
     w.addEventListener("message", () => arr.push(3));
     w.addEventListener("message", () => {
-      assertEquals(arr, [1, 2, 3]);
       promise.resolve();
     });
     w.postMessage("Hello World");
     await promise;
+    assertEquals(arr, [1, 2, 3]);
     w.terminate();
   },
 });
@@ -403,7 +392,6 @@ Deno.test({
 });
 
 Deno.test("Worker inherits permissions", async function () {
-  const promise = deferred();
   const worker = new Worker(
     new URL("./read_check_worker.js", import.meta.url).href,
     {
@@ -415,19 +403,17 @@ Deno.test("Worker inherits permissions", async function () {
     },
   );
 
-  worker.onmessage = ({ data: hasPermission }) => {
-    assert(hasPermission);
-    promise.resolve();
+  const promise = deferred();
+  worker.onmessage = (e) => {
+    promise.resolve(e.data);
   };
 
   worker.postMessage(null);
-
-  await promise;
+  assertEquals(await promise, true);
   worker.terminate();
 });
 
 Deno.test("Worker limit children permissions", async function () {
-  const promise = deferred();
   const worker = new Worker(
     new URL("./read_check_worker.js", import.meta.url).href,
     {
@@ -441,14 +427,13 @@ Deno.test("Worker limit children permissions", async function () {
     },
   );
 
-  worker.onmessage = ({ data: hasPermission }) => {
-    assert(!hasPermission);
-    promise.resolve();
+  const promise = deferred();
+  worker.onmessage = (e) => {
+    promise.resolve(e.data);
   };
 
   worker.postMessage(null);
-
-  await promise;
+  assertEquals(await promise, false);
   worker.terminate();
 });
 
@@ -578,8 +563,6 @@ Deno.test({
 });
 
 Deno.test("Worker with disabled permissions", async function () {
-  const promise = deferred();
-
   const worker = new Worker(
     new URL("./no_permissions_worker.js", import.meta.url).href,
     {
@@ -591,13 +574,13 @@ Deno.test("Worker with disabled permissions", async function () {
     },
   );
 
-  worker.onmessage = ({ data: sandboxed }) => {
-    assert(sandboxed);
-    promise.resolve();
+  const promise = deferred();
+  worker.onmessage = (e) => {
+    promise.resolve(e.data);
   };
 
   worker.postMessage(null);
-  await promise;
+  assertEquals(await promise, true);
   worker.terminate();
 });
 
@@ -622,11 +605,10 @@ Deno.test({
       new URL("worker_location.ts", import.meta.url).href;
     const w = new Worker(workerModuleHref, { type: "module" });
     w.onmessage = (e) => {
-      assertEquals(e.data, `${workerModuleHref}, true`);
-      promise.resolve();
+      promise.resolve(e.data);
     };
     w.postMessage("Hello, world!");
-    await promise;
+    assertEquals(await promise, `${workerModuleHref}, true`);
     w.terminate();
   },
 });
@@ -635,17 +617,16 @@ Deno.test({
   name: "worker with relative specifier",
   fn: async function () {
     assertEquals(location.href, "http://127.0.0.1:4545/");
-    const promise = deferred();
     const w = new Worker(
       "./workers/test_worker.ts",
       { type: "module", name: "tsWorker" },
     );
+    const promise = deferred();
     w.onmessage = (e) => {
-      assertEquals(e.data, "Hello, world!");
-      promise.resolve();
+      promise.resolve(e.data);
     };
     w.postMessage("Hello, world!");
-    await promise;
+    assertEquals(await promise, "Hello, world!");
     w.terminate();
   },
 });
@@ -704,34 +685,33 @@ Deno.test({
 Deno.test({
   name: "structured cloning postMessage",
   fn: async function () {
-    const result = deferred();
     const worker = new Worker(
       new URL("worker_structured_cloning.ts", import.meta.url).href,
       { type: "module" },
     );
 
+    const result = deferred();
     worker.onmessage = (e) => {
-      // self field should reference itself (circular ref)
-      const value = e.data.self.self.self;
-
-      // fields a and b refer to the same array
-      assertEquals(value.a, ["a", true, 432]);
-      assertEquals(value.a, ["a", true, 432]);
-      value.b[0] = "b";
-      value.a[2] += 5;
-      assertEquals(value.a, ["b", true, 437]);
-      assertEquals(value.b, ["b", true, 437]);
-
-      const len = value.c.size;
-      value.c.add(1); // This value is already in the set.
-      value.c.add(2);
-      assertEquals(len + 1, value.c.size);
-
-      result.resolve();
+      result.resolve(e.data);
     };
 
     worker.postMessage("START");
-    await result;
+    // deno-lint-ignore no-explicit-any
+    const data = await result as any;
+    // self field should reference itself (circular ref)
+    assert(data === data.self);
+    // fields a and b refer to the same array
+    assertEquals(data.a, ["a", true, 432]);
+    assertEquals(data.b, ["a", true, 432]);
+    data.b[0] = "b";
+    data.a[2] += 5;
+    assertEquals(data.a, ["b", true, 437]);
+    assertEquals(data.b, ["b", true, 437]);
+    // c is a set
+    const len = data.c.size;
+    data.c.add(1); // This value is already in the set.
+    data.c.add(2);
+    assertEquals(len + 1, data.c.size);
     worker.terminate();
   },
 });
@@ -740,17 +720,16 @@ Deno.test({
   name: "worker with relative specifier",
   fn: async function () {
     assertEquals(location.href, "http://127.0.0.1:4545/");
-    const promise = deferred();
     const w = new Worker(
       "./workers/test_worker.ts",
       { type: "module", name: "tsWorker" },
     );
+    const promise = deferred();
     w.onmessage = (e) => {
-      assertEquals(e.data, "Hello, world!");
-      promise.resolve();
+      promise.resolve(e.data);
     };
     w.postMessage("Hello, world!");
-    await promise;
+    assertEquals(await promise, "Hello, world!");
     w.terminate();
   },
 });
@@ -773,12 +752,12 @@ Deno.test({
     w.onmessage = () => {
       w.postMessage([sab1, sab2]);
       w.onmessage = () => {
-        assertEquals(bytes1[0], 1);
-        assertEquals(bytes2[0], 2);
         promise.resolve();
       };
     };
     await promise;
+    assertEquals(bytes1[0], 1);
+    assertEquals(bytes2[0], 2);
     w.terminate();
   },
 });
@@ -786,32 +765,35 @@ Deno.test({
 Deno.test({
   name: "Send MessagePorts from / to workers",
   fn: async function () {
-    const result = deferred();
     const worker = new Worker(
       new URL("message_port.ts", import.meta.url).href,
       { type: "module" },
     );
-
     const channel = new MessageChannel();
 
+    const promise1 = deferred();
+    const promise2 = deferred();
+    const promise3 = deferred();
+    const result = deferred();
     worker.onmessage = (e) => {
-      assertEquals(e.data, "1");
-      assertEquals(e.ports.length, 1);
+      promise1.resolve([e.data, e.ports.length]);
       const port1 = e.ports[0];
       port1.onmessage = (e) => {
-        assertEquals(e.data, true);
+        promise2.resolve(e.data);
         port1.close();
         worker.postMessage("3", [channel.port1]);
       };
       port1.postMessage("2");
     };
-
     channel.port2.onmessage = (e) => {
-      assertEquals(e.data, true);
+      promise3.resolve(e.data);
       channel.port2.close();
       result.resolve();
     };
 
+    assertEquals(await promise1, ["1", 1]);
+    assertEquals(await promise2, true);
+    assertEquals(await promise3, true);
     await result;
     worker.terminate();
   },