Add workerd test and run format

Author: ketanhwr

Diff for: src/workerd/io/io-context.c++

@@ -7,9 +7,9 @@
 #include <workerd/io/io-gate.h>
 #include <workerd/io/worker.h>
 #include <workerd/jsg/jsg.h>
+#include <workerd/jsg/setup.h>
 #include <workerd/util/sentry.h>
 #include <workerd/util/uncaught-exception-source.h>
-#include <workerd/jsg/setup.h>
 
 #include <kj/debug.h>
 
@@ -451,7 +451,8 @@ kj::Promise<void> IoContext::IncomingRequest::drain() {
   context->pumpMessageLoop();
   return context->waitUntilTasks.onEmpty()
       .exclusiveJoin(kj::mv(timeoutPromise))
-      .exclusiveJoin(context->abortPromise.addBranch().then([] {}, [](kj::Exception&&) {}));
+      .exclusiveJoin(context->abortPromise.addBranch().then(
+          [] {}, [](kj::Exception&& e) { KJ_LOG(INFO, "uncaught exception", e); }));
 }
 
 kj::Promise<IoContext_IncomingRequest::FinishScheduledResult> IoContext::IncomingRequest::

Diff for: src/workerd/jsg/jsg.c++

@@ -4,13 +4,12 @@
 
 #include "jsg.h"
 
+#include "libplatform/libplatform.h"
 #include "setup.h"
 
 #include <workerd/jsg/util.h>
 #include <workerd/util/thread-scopes.h>
 
-#include "libplatform/libplatform.h"
-
 namespace workerd::jsg {
 
 kj::String stringifyHandle(v8::Local<v8::Value> value) {

Diff for: src/workerd/jsg/jsg.h

@@ -2715,7 +2715,7 @@ class Lock {
   // Returns the env base object.
   virtual JsObject getEnv(bool release = false) = 0;
 
-protected:
+ protected:
   virtual const V8System& getV8System() = 0;
 
  private:

Diff for: src/workerd/jsg/setup.c++

@@ -77,14 +77,19 @@ static kj::Own<v8::Platform> userPlatform(v8::Platform& platform) {
 V8System::V8System(): V8System(defaultPlatform(0), nullptr) {}
 V8System::V8System(kj::ArrayPtr<const kj::StringPtr> flags): V8System(defaultPlatform(0), flags) {}
 V8System::V8System(v8::Platform& platformParam): V8System(platformParam, nullptr) {}
-V8System::V8System(v8::Platform& platformParam, kj::ArrayPtr<const kj::StringPtr> flags, v8::Platform* defaultPlatformPtr)
+V8System::V8System(v8::Platform& platformParam,
+    kj::ArrayPtr<const kj::StringPtr> flags,
+    v8::Platform* defaultPlatformPtr)
     : V8System(userPlatform(platformParam), flags, defaultPlatformPtr) {}
-V8System::V8System(kj::Own<v8::Platform> platformParam, kj::ArrayPtr<const kj::StringPtr> flags, v8::Platform* defaultPlatformPtr)
+V8System::V8System(kj::Own<v8::Platform> platformParam,
+    kj::ArrayPtr<const kj::StringPtr> flags,
+    v8::Platform* defaultPlatformPtr)
     : platformInner(kj::mv(platformParam)),
-      platformWrapper(*platformInner), defaultPlatformPtr_{defaultPlatformPtr} {
-    if (!defaultPlatformPtr_) {
-      defaultPlatformPtr_ = platformInner.get();
-    }
+      platformWrapper(*platformInner),
+      defaultPlatformPtr_{defaultPlatformPtr} {
+  if (!defaultPlatformPtr_) {
+    defaultPlatformPtr_ = platformInner.get();
+  }
 #if V8_HAS_STACK_START_MARKER
   v8::StackStartMarker::EnableForProcess();
 #endif

Diff for: src/workerd/jsg/setup.h

@@ -56,22 +56,28 @@ class V8System {
   explicit V8System(v8::Platform& platform);
 
   // Use a possibly-custom v8::Platform implementation, and apply flags.
-  explicit V8System(v8::Platform& platform, kj::ArrayPtr<const kj::StringPtr> flags, v8::Platform* defaultPlatformPtr = nullptr);
+  explicit V8System(v8::Platform& platform,
+      kj::ArrayPtr<const kj::StringPtr> flags,
+      v8::Platform* defaultPlatformPtr = nullptr);
 
   ~V8System() noexcept(false);
 
   typedef void FatalErrorCallback(kj::StringPtr location, kj::StringPtr message);
   static void setFatalErrorCallback(FatalErrorCallback* callback);
 
-  auto& getDefaultPlatform() { return *defaultPlatformPtr_; }
+  auto& getDefaultPlatform() {
+    return *defaultPlatformPtr_;
+  }
 
  private:
   kj::Own<v8::Platform> platformInner;
   V8PlatformWrapper platformWrapper;
   friend class IsolateBase;
   v8::Platform* defaultPlatformPtr_;
 
-  explicit V8System(kj::Own<v8::Platform>, kj::ArrayPtr<const kj::StringPtr>, v8::Platform* defaultPlatformPtr = nullptr);
+  explicit V8System(kj::Own<v8::Platform>,
+      kj::ArrayPtr<const kj::StringPtr>,
+      v8::Platform* defaultPlatformPtr = nullptr);
 };
 
 // Base class of Isolate<T> containing parts that don't need to be templated, to avoid code
@@ -687,10 +693,6 @@ class Isolate: public IsolateBase {
             *this, value.toString(*this), value, JsMessage::create(*this, value));
       }
     }
-  protected:
-    virtual const V8System& getV8System() override {
-      return jsgIsolate.getV8System();
-    }
 
     // Sets an env value that will be expressed on the process.env
     // if/when nodejs-compat mode is used.
@@ -710,6 +712,11 @@ class Isolate: public IsolateBase {
       return JsObject(jsgIsolate.envObj.Get(v8Isolate));
     }
 
+   protected:
+    virtual const V8System& getV8System() override {
+      return jsgIsolate.getV8System();
+    }
+
    private:
     Isolate& jsgIsolate;
 

Diff for: src/workerd/server/tests/weakref/BUILD.bazel

@@ -0,0 +1,17 @@
+load("@aspect_rules_js//js:defs.bzl", "js_test")
+
+js_test(
+    name = "js-weak-ref-test",
+    data = [
+        ":config.capnp",
+        ":index.mjs",
+        "//src/workerd/server:workerd",
+        "//src/workerd/server/tests:server-harness_js_lib",
+    ],
+    entry_point = "test.mjs",
+    env = {
+        "WORKERD_BINARY": "$(rootpath //src/workerd/server:workerd)",
+        "WORKERD_CONFIG": "$(rootpath :config.capnp)",
+    },
+    tags = ["js-test"],
+)

Diff for: src/workerd/server/tests/weakref/config.capnp

@@ -0,0 +1,21 @@
+# config.capnp
+using Workerd = import "/workerd/workerd.capnp";
+
+const config :Workerd.Config = (
+  v8Flags = [ "--expose-gc" ],
+  services = [
+    ( name = "main", worker = .worker ),
+  ],
+  sockets = [
+    ( name = "http", address = "*:0", http = (), service = "main" ),
+  ]
+);
+
+const worker :Workerd.Worker = (
+  modules = [
+    ( name = "./index.mjs", esModule = embed "index.mjs" )
+  ],
+  compatibilityDate = "2024-01-01",
+  compatibilityFlags = ["enable_weak_ref"],
+);
+

Diff for: src/workerd/server/tests/weakref/index.mjs

@@ -0,0 +1,19 @@
+let counter = 0;
+const fr = new FinalizationRegistry(() => {
+  ++counter;
+});
+
+export default {
+  async fetch(request, env, ctx) {
+    (function () {
+      let obj = {};
+      fr.register(obj, '');
+      obj = undefined;
+    })();
+
+    // Ensure obj gets GC'd
+    gc();
+
+    return new Response(counter);
+  },
+};

Diff for: src/workerd/server/tests/weakref/test.mjs

@@ -0,0 +1,48 @@
+import { env } from 'node:process';
+import { beforeEach, afterEach, test } from 'node:test';
+import assert from 'node:assert';
+import { WorkerdServerHarness } from '../server-harness.mjs';
+
+// Global that is reset for each test.
+let workerd;
+
+assert(
+  env.WORKERD_BINARY !== undefined,
+  'You must set the WORKERD_BINARY environment variable.'
+);
+assert(
+  env.WORKERD_CONFIG !== undefined,
+  'You must set the WORKERD_CONFIG environment variable.'
+);
+
+// Start workerd.
+beforeEach(async () => {
+  workerd = new WorkerdServerHarness({
+    workerdBinary: env.WORKERD_BINARY,
+    workerdConfig: env.WORKERD_CONFIG,
+
+    // Hard-coded to match a socket name expected in the `workerdConfig` file.
+    listenPortNames: ['http'],
+  });
+
+  await workerd.start();
+
+  await workerd.getListenPort('http');
+});
+
+// Stop workerd.
+afterEach(async () => {
+  const [code, signal] = await workerd.stop();
+  assert(code === 0 || signal === 'SIGTERM');
+  workerd = null;
+});
+
+// FinalizationRegistry callbacks only run after the exported handler returns
+// So we should see its effects in a follow-up request
+test('JS FinalizationRegistry', async () => {
+  let httpPort = await workerd.getListenPort('http');
+  for (let i = 0; i < 3; ++i) {
+    const response = await fetch(`http://localhost:${httpPort}`);
+    assert.equal(await response.text(), i);
+  }
+});

Diff for: src/workerd/server/workerd-api.c++

@@ -271,9 +271,7 @@ struct WorkerdApi::Impl final {
         auto version = getPythonBundleName(pythonRelease);
         auto bundle = KJ_ASSERT_NONNULL(
             fetchPyodideBundle(pythonConfig, version), "Failed to get Pyodide bundle");
-        jsg::NewContextOptions options{
-          .enableWeakRef = features->getJsWeakRef()
-        };
+        jsg::NewContextOptions options{.enableWeakRef = features->getJsWeakRef()};
         auto context = lock.newContext<api::ServiceWorkerGlobalScope>(options, lock.v8Isolate);
         v8::Context::Scope scope(context.getHandle(lock));
         // Init emscripten synchronously, the python script will import setup-emscripten and
@@ -344,10 +342,8 @@ CompatibilityFlags::Reader WorkerdApi::getFeatureFlags() const {
   return *impl->features;
 }
 jsg::JsContext<api::ServiceWorkerGlobalScope> WorkerdApi::newContext(jsg::Lock& lock) const {
-  jsg::NewContextOptions options{
-    .newModuleRegistry = impl->tryGetModuleRegistry(),
-    .enableWeakRef = getFeatureFlags().getJsWeakRef()
-  };
+  jsg::NewContextOptions options{.newModuleRegistry = impl->tryGetModuleRegistry(),
+    .enableWeakRef = getFeatureFlags().getJsWeakRef()};
   return kj::downcast<JsgWorkerdIsolate::Lock>(lock).newContext<api::ServiceWorkerGlobalScope>(
       kj::mv(options), lock.v8Isolate);
 }

Diff for: src/workerd/server/workerd.c++

@@ -1335,8 +1335,8 @@ class CliMain final: public SchemaFileImpl::ErrorReporter {
       auto config = getConfig();
       auto platform = jsg::defaultPlatform(0);
       WorkerdPlatform v8Platform(*platform);
-      jsg::V8System v8System(
-          v8Platform, KJ_MAP(flag, config.getV8Flags()) -> kj::StringPtr { return flag; }, platform.get());
+      jsg::V8System v8System(v8Platform,
+          KJ_MAP(flag, config.getV8Flags()) -> kj::StringPtr { return flag; }, platform.get());
       auto promise = func(v8System, config);
       KJ_IF_SOME(w, watcher) {
         promise = promise.exclusiveJoin(waitForChanges(w).then([this]() {