test: use WeakRef instead of weak-napi for GC tests

Author: rotu

CONTRIBUTING.md

@@ -38,13 +38,3 @@ tool similar to Cmake. GYP was originally created to generate native IDE project
 files (Visual Studio, Xcode) for building Chromium.
 
 The `.gyp` file is structured as a Python dictionary.
-
-## Weak-napi
-
-https://www.npmjs.com/package/weak-napi On certain rarer occasions, you run into
-the need to be notified when a JavaScript object is going to be garbage
-collected. This feature is exposed to V8's C++ API, but not to JavaScript.
-
-That's where weak-napi comes in! This module exports the JS engine's GC tracking
-functionality to JavaScript. This allows you to create weak references, and
-optionally attach a callback function to any arbitrary JS object.

package.json

@@ -95,10 +95,9 @@
     "build.native.debug": "node-gyp configure --debug && node-gyp configure --debug -- -f compile_commands_json && cross-env CMAKE_BUILD_TYPE=Debug node-gyp build --debug",
     "build": "run-s build.js build.native",
     "build.debug": "run-s build.js build.native.debug",
-    "test.deps": "cd test && pnpm install && cd ..",
-    "test": "run-s clean.temp test.deps build && mocha",
-    "test.skip_gc_tests": "run-s clean.temp test.deps build.debug && cross-env SKIP_GC_TESTS=true mocha",
-    "test.electron.main": "run-s clean.temp test.deps build && electron-mocha",
+    "test": "run-s clean.temp build && mocha",
+    "test.skip_gc_tests": "run-s clean.temp build.debug && cross-env SKIP_GC_TESTS=true mocha",
+    "test.electron.main": "run-s clean.temp build && electron-mocha",
     "format": "prettier --write .",
     "test.electron.renderer": "run-s build && electron-mocha --renderer",
     "lint.clang-format": "clang-format -i -style=file ./src/*.cc ./src/*.h ./src/util/*.h",

test/package.json

@@ -1,4 +1,6 @@
 {
   "extends": "../tsconfig.json",
-  "include": ["**/*.ts"]
+  "include": [
+    "**/*.ts"
+  ]
 }

test/pnpm-lock.yaml

@@ -235,3 +235,43 @@ export async function captureEventsUntil(
 
   return events
 }
+
+// REAL typings for global.gc per
+// https://github.com/nodejs/node/blob/v20.0.0/deps/v8/src/extensions/gc-extension.cc
+interface GCFunction {
+  (options: {
+    execution?: "sync"
+    flavor?: "regular" | "last-resort"
+    type?: "major-snapshot" | "major" | "minor"
+    filename?: string
+  }): void
+  (options: {
+    execution?: "async"
+    flavor?: "regular" | "last-resort"
+    type?: "major-snapshot" | "major" | "minor"
+    filename?: string
+  }): Promise<void>
+  (options: {
+    execution?: "async" | "sync"
+    flavor?: "regular" | "last-resort"
+    type?: "major-snapshot" | "major" | "minor"
+    filename?: string
+  }): void | Promise<void>
+}
+
+export function getGcOrSkipTest(test: Mocha.Context) {
+  if (process.env.SKIP_GC_TESTS === "true") {
+    test.skip()
+  }
+
+  const gc = globalThis.gc as undefined | GCFunction
+  if (typeof gc !== "function") {
+    throw new Error(
+      "Garbage collection is not exposed. It may be enabled by the node --expose-gc flag. To skip GC tests, set the environment variable `SKIP_GC_TESTS`",
+    )
+  }
+  // https://github.com/nodejs/node/blob/v20.0.0/deps/v8/src/extensions/gc-extension.h
+  // per docs, we we're using use case 2 (Test that certain objects indeed are reclaimed)
+  const asyncMajorGc = () => gc({type: "major", execution: "async"})
+  return asyncMajorGc
+}

test/tsconfig.json

@@ -1,8 +1,9 @@
-/* eslint-disable @typescript-eslint/no-var-requires */
+/// <reference lib="ESNext" />
+
 import * as zmq from "../../src"
 
 import {assert} from "chai"
-import {testProtos, uniqAddress} from "./helpers"
+import {testProtos, uniqAddress, getGcOrSkipTest} from "./helpers"
 import {isFullError} from "../../src/errors"
 
 for (const proto of testProtos("tcp", "ipc", "inproc")) {
@@ -107,75 +108,49 @@ for (const proto of testProtos("tcp", "ipc", "inproc")) {
       })
 
       it("should release reference to context", async function () {
-        if (process.env.SKIP_GC_TESTS === "true") {
-          this.skip()
-        }
-        if (global.gc === undefined) {
-          console.warn("gc is not exposed by the runtime")
-          this.skip()
-        }
-
+        const gc = getGcOrSkipTest(this)
         this.slow(200)
 
-        const weak = require("weak-napi") as typeof import("weak-napi")
+        let weakRef: undefined | WeakRef<any>
 
-        let released = false
         const task = async () => {
-          let context: zmq.Context | undefined = new zmq.Context()
+          const context: zmq.Context | undefined = new zmq.Context()
           const socket = new zmq.Dealer({context, linger: 0})
+          weakRef = new WeakRef(context)
 
-          weak(context, () => {
-            released = true
-          })
-          context = undefined
-
-          global.gc!()
           socket.connect(await uniqAddress(proto))
           await socket.send(Buffer.from("foo"))
           socket.close()
         }
 
         await task()
-        global.gc()
-        await new Promise(resolve => {
-          setTimeout(resolve, 5)
-        })
-        assert.equal(released, true)
+        await gc()
+
+        assert.isDefined(weakRef)
+        assert.isUndefined(weakRef!.deref())
       })
     })
 
     describe("in gc finalizer", function () {
       it("should release reference to context", async function () {
-        if (process.env.SKIP_GC_TESTS === "true") {
-          this.skip()
-        }
-        if (global.gc === undefined) {
-          console.warn("gc is not exposed by the runtime")
+        const gc = getGcOrSkipTest(this)
+        if (process.env.SKIP_GC_FINALIZER_TESTS) {
           this.skip()
         }
         this.slow(200)
 
-        const weak = require("weak-napi") as typeof import("weak-napi")
-
-        let released = false
+        let weakRef: undefined | WeakRef<any>
         const task = async () => {
-          let context: zmq.Context | undefined = new zmq.Context()
-
+          const context: zmq.Context | undefined = new zmq.Context()
           const _dealer = new zmq.Dealer({context, linger: 0})
-
-          weak(context, () => {
-            released = true
-          })
-          context = undefined
-          global.gc!()
+          weakRef = new WeakRef(context)
         }
 
         await task()
-        global.gc()
-        await new Promise(resolve => {
-          setTimeout(resolve, 5)
-        })
-        assert.equal(released, true)
+        await gc()
+
+        assert.isDefined(weakRef)
+        assert.isUndefined(weakRef!.deref())
       })
     })
   })