4 files changed, 115 insertions, 22 deletions
diff --git a/test/js/node/disabled-module.test.cjs b/test/js/node/disabled-module.test.cjs
deleted file mode 100644
index bc4817b8d..000000000
--- a/test/js/node/disabled-module.test.cjs
+++ /dev/null
@@ -1,6 +0,0 @@
-test("not implemented yet module masquerades as undefined in cjs and throws an error", () => {
-  const worker_threads = require("worker_threads");
-
-  expect(typeof worker_threads).toBe("undefined");
-  expect(typeof worker_threads.getEnvironmentData).toBe("undefined");
-});
diff --git a/test/js/node/disabled-module.test.js b/test/js/node/disabled-module.test.js
deleted file mode 100644
index 7333a0f1f..000000000
--- a/test/js/node/disabled-module.test.js
+++ /dev/null
@@ -1,16 +0,0 @@
-import { expect, test } from "bun:test";
-import * as worker_threads from "worker_threads";
-import worker_threads_default from "worker_threads";
-
-test("not implemented yet module masquerades as undefined and throws an error", () => {
-  expect(typeof worker_threads.default).toBe("undefined");
-  expect(typeof worker_threads_default).toBe("undefined");
-  expect(typeof worker_threads.getEnvironmentData).toBe("undefined");
-  expect(typeof worker_threads_default.getEnvironmentData).toBe("undefined");
-});
-
-test("esbuild functions with worker_threads stub", async () => {
-  const esbuild = await import("esbuild");
-  const result = await esbuild.transform('console . log( "hello world" )', { minify: true });
-  expect(result.code).toBe('console.log("hello world");\n');
-});
diff --git a/test/js/node/worker_threads/worker.js b/test/js/node/worker_threads/worker.js
new file mode 100644
index 000000000..e45b2e4b6
--- /dev/null
+++ b/test/js/node/worker_threads/worker.js
@@ -0,0 +1,8 @@
+const wt = require("worker_threads");
+
+wt.parentPort.on("message", e => {
+  let sharedBufferView = new Int32Array(e.sharedBuffer);
+  wt.workerData.postMessage("done!");
+  Atomics.add(sharedBufferView, 0, 1);
+  Atomics.notify(sharedBufferView, 0, Infinity);
+});
diff --git a/test/js/node/worker_threads/worker_threads.test.ts b/test/js/node/worker_threads/worker_threads.test.ts
new file mode 100644
index 000000000..3bee1a50e
--- /dev/null
+++ b/test/js/node/worker_threads/worker_threads.test.ts
@@ -0,0 +1,107 @@
+import wt from "worker_threads";
+import {
+  getEnvironmentData,
+  isMainThread,
+  markAsUntransferable,
+  moveMessagePortToContext,
+  parentPort,
+  receiveMessageOnPort,
+  resourceLimits,
+  setEnvironmentData,
+  SHARE_ENV,
+  threadId,
+  workerData,
+  BroadcastChannel,
+  MessageChannel,
+  MessagePort,
+  Worker,
+} from "worker_threads";
+test("all properties are present", () => {
+  expect(wt).toHaveProperty("getEnvironmentData");
+  expect(wt).toHaveProperty("isMainThread");
+  expect(wt).toHaveProperty("markAsUntransferable");
+  expect(wt).toHaveProperty("moveMessagePortToContext");
+  expect(wt).toHaveProperty("parentPort");
+  expect(wt).toHaveProperty("receiveMessageOnPort");
+  expect(wt).toHaveProperty("resourceLimits");
+  expect(wt).toHaveProperty("SHARE_ENV");
+  expect(wt).toHaveProperty("setEnvironmentData");
+  expect(wt).toHaveProperty("threadId");
+  expect(wt).toHaveProperty("workerData");
+  expect(wt).toHaveProperty("BroadcastChannel");
+  expect(wt).toHaveProperty("MessageChannel");
+  expect(wt).toHaveProperty("MessagePort");
+  expect(wt).toHaveProperty("Worker");
+
+  expect(getEnvironmentData).toBeDefined();
+  expect(isMainThread).toBeDefined();
+  expect(markAsUntransferable).toBeDefined();
+  expect(moveMessagePortToContext).toBeDefined();
+  expect(parentPort).toBeDefined();
+  expect(receiveMessageOnPort).toBeDefined();
+  expect(resourceLimits).toBeDefined();
+  expect(SHARE_ENV).toBeDefined();
+  expect(setEnvironmentData).toBeDefined();
+  expect(threadId).toBeDefined();
+  expect(workerData).toBeUndefined();
+  expect(BroadcastChannel).toBeDefined();
+  expect(MessageChannel).toBeDefined();
+  expect(MessagePort).toBeDefined();
+  expect(Worker).toBeDefined();
+
+  expect(() => {
+    wt.markAsUntransferable();
+  }).toThrow("not implemented");
+
+  expect(() => {
+    wt.moveMessagePortToContext();
+  }).toThrow("not implemented");
+});
+
+test("receiveMessageOnPort works across threads", () => {
+  const { port1, port2 } = new MessageChannel();
+  var worker = new wt.Worker(new URL("./worker.js", import.meta.url).href, {
+    workerData: port2,
+    transferList: [port2],
+  });
+  let sharedBuffer = new SharedArrayBuffer(8);
+  let sharedBufferView = new Int32Array(sharedBuffer);
+  let msg = { sharedBuffer };
+  worker.postMessage(msg);
+  Atomics.wait(sharedBufferView, 0, 0);
+  const message = receiveMessageOnPort(port1);
+  expect(message).toBeDefined();
+  expect(message!.message).toBe("done!");
+});
+
+test("receiveMessageOnPort works with FIFO", () => {
+  const { port1, port2 } = new wt.MessageChannel();
+
+  const message1 = { hello: "world" };
+  const message2 = { foo: "bar" };
+
+  // Make sure receiveMessageOnPort() works in a FIFO way, the same way it does
+  // when we’re using events.
+  expect(receiveMessageOnPort(port2)).toBe(undefined);
+  port1.postMessage(message1);
+  port1.postMessage(message2);
+  expect(receiveMessageOnPort(port2)).toStrictEqual({ message: message1 });
+  expect(receiveMessageOnPort(port2)).toStrictEqual({ message: message2 });
+  expect(receiveMessageOnPort(port2)).toBe(undefined);
+  expect(receiveMessageOnPort(port2)).toBe(undefined);
+
+  // Make sure message handlers aren’t called.
+  port2.on("message", () => {
+    expect().fail("message handler must not be called");
+  });
+  port1.postMessage(message1);
+  expect(receiveMessageOnPort(port2)).toStrictEqual({ message: message1 });
+  port1.close();
+
+  for (const value of [null, 0, -1, {}, []]) {
+    expect(() => {
+      // @ts-ignore
+      receiveMessageOnPort(value);
+    }).toThrow();
+  }
+});