Temp disable working os/arch combos

Fix failing tests

Author: timfish

module.cc

@@ -18,6 +18,9 @@
 #error "NODE_MAJOR_VERSION is not defined"
 #endif
 
+#define SUPPORTS_ASYNC_CONTEXT_FRAME NODE_MAJOR_VERSION >= 22
+#define GET_CONTINUATION_PRESERVED_EMBEDDER_DATA_V2 V8_MAJOR_VERSION >= 14
+
 using namespace v8;
 using namespace node;
 using namespace std::chrono;
@@ -128,7 +131,7 @@ JsStackFrames GetStackFrames(Isolate *isolate) {
   return frames;
 }
 
-#if NODE_MAJOR_VERSION >= 22
+#if SUPPORTS_ASYNC_CONTEXT_FRAME
 // Function to fetch the thread state from the async context store
 std::string GetThreadState(Isolate *isolate,
                            const AsyncLocalStorageLookup &store) {
@@ -138,7 +141,11 @@ std::string GetThreadState(Isolate *isolate,
   // "ContinuationPreservedEmbedderData" map, keyed by the
   // AsyncLocalStorage instance.
   // https://github.com/nodejs/node/blob/c6316f9db9869864cea84e5f07585fa08e3e06d2/src/async_context_frame.cc#L37
+#if GET_CONTINUATION_PRESERVED_EMBEDDER_DATA_V2
+  auto data = isolate->GetContinuationPreservedEmbedderDataV2().As<Value>();
+#else
   auto data = isolate->GetContinuationPreservedEmbedderData();
+#endif
   auto async_local_storage_local = store.async_local_storage.Get(isolate);
 
   if (data.IsEmpty() || !data->IsMap() || async_local_storage_local.IsEmpty()) {
@@ -193,7 +200,7 @@ static void ExecutionInterrupted(Isolate *isolate, void *data) {
   auto frames = GetStackFrames(isolate);
   std::string state = "";
 
-#if NODE_MAJOR_VERSION >= 22
+#if SUPPORTS_ASYNC_CONTEXT_FRAME
   if (args->store && args->store->has_value()) {
     state = GetThreadState(isolate, args->store->value());
   }
@@ -544,7 +551,7 @@ void GetThreadsLastSeen(const FunctionCallbackInfo<Value> &args) {
 extern "C" NODE_MODULE_EXPORT void
 NODE_MODULE_INITIALIZER(Local<Object> exports, Local<Value> module,
                         Local<Context> context) {
-  auto isolate = context->GetIsolate();
+  auto isolate = v8::Isolate::GetCurrent();
 
   exports
       ->Set(context,

package.json

@@ -29,10 +29,9 @@
     "build:bindings:configure:arm64": "node-gyp configure --arch=arm64 --target_arch=arm64",
     "build:bindings": "node-gyp build && node scripts/copy-target.mjs",
     "build:bindings:arm64": "node-gyp build --arch=arm64 && node scripts/copy-target.mjs",
-    "build:dev": "yarn clean && yarn build:bindings:configure && yarn build",
     "build:tarball": "npm pack",
     "clean": "node-gyp clean && rm -rf lib && rm -rf build && rm -f *.tgz",
-    "test": "yarn test:install && node ./test/prepare.mjs && vitest run --silent=false --disable-console-intercept",
+    "test": "yarn test:install && yarn test:prepare && vitest run --poolOptions.forks.singleFork --silent=false --disable-console-intercept",
     "test:prepare": "node ./test/prepare.mjs",
     "test:install": "cross-env ALWAYS_THROW=true yarn install"
   },

test/e2e.test.mjs

@@ -1,27 +1,74 @@
-import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
 import { join } from 'node:path';
 import { describe, expect, test } from 'vitest';
 
 const __dirname = import.meta.dirname || new URL('.', import.meta.url).pathname;
 
 const NODE_MAJOR_VERSION = parseInt(process.versions.node.split('.')[0], 10);
 
-function runTest(...paths) {
+// macOS emulated x64 in CI is very slow!
+const timeout = process.env.CI && process.platform === 'darwin' ? 60000 : 20000;
+
+async function runTest(...paths) {
+  console.time('Test Run');
   const file = join(...paths);
-  const args = NODE_MAJOR_VERSION === 22 ? [ '--experimental-async-context-frame', file] : [file];
-  const result = spawnSync('node', args);
-  return result;
+  const args = NODE_MAJOR_VERSION === 22 ? ['--experimental-async-context-frame', file] : [file];
+
+  return new Promise((resolve, reject) => {
+    const child = spawn('node', args, { stdio: ['ignore', 'pipe', 'pipe'] });
+
+    let stdoutBuf = '';
+    let stderrBuf = '';
+
+    child.stdout?.on('data', chunk => {
+      stdoutBuf += chunk.toString();
+    });
+    child.stderr?.on('data', chunk => {
+      stderrBuf += chunk.toString();
+    });
+
+    child.on('error', err => reject(err));
+
+    child.on('close', code => {
+      const stdout = stdoutBuf
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line !== '');
+      const stderr = stderrBuf
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line !== '');
+
+      let trace;
+      for (const line of stdout) {
+        try {
+          trace = JSON.parse(line);
+          break;
+        } catch (_) {
+          // ignore non-JSON lines
+        }
+      }
+
+      console.timeEnd('Test Run');
+      if (stdout.length > 0) {
+        console.log('stdout:', stdout);
+      }
+      if (stderr.length > 0) {
+        console.log('stderr:', stderr);
+      }
+
+      resolve({ status: code, stdout, trace });
+    });
+  });
 }
 
-describe('e2e Tests', { timeout: 20000 }, () => {
-  test('Capture stack trace from multiple threads', () => {
-    const result = runTest(__dirname, 'stack-traces.js')
+describe('e2e Tests', { timeout }, () => {
+  test('Capture stack trace from multiple threads', async () => {
+    const result = await runTest(__dirname, 'stack-traces.js')
 
     expect(result.status).toEqual(0);
 
-    const trace = JSON.parse(result.stdout.toString());
-
-    expect(trace).toEqual(expect.objectContaining({
+    expect(result.trace).toEqual(expect.objectContaining({
       '0': {
         frames: expect.arrayContaining([
           {
@@ -69,14 +116,12 @@ describe('e2e Tests', { timeout: 20000 }, () => {
     }));
   });
 
-  test('detect stalled thread', { timeout: 20000 }, () => {
-    const result = runTest(__dirname, 'stalled.js');
+  test('detect stalled thread', async () => {
+    const result = await runTest(__dirname, 'stalled.js');
 
     expect(result.status).toEqual(0);
 
-    const trace = JSON.parse(result.stdout.toString());
-
-    expect(trace).toEqual(expect.objectContaining({
+    expect(result.trace).toEqual(expect.objectContaining({
       '0': {
         frames: expect.arrayContaining([
           {
@@ -106,19 +151,17 @@ describe('e2e Tests', { timeout: 20000 }, () => {
     }));
   });
 
-  test('async storage state', { timeout: 20000 }, (ctx) => {
+  test('async storage state', async (ctx) => {
     if (NODE_MAJOR_VERSION < 22) {
       ctx.skip();
       return;
     }
 
-    const result = runTest(__dirname, 'async-storage.mjs');
+    const result = await runTest(__dirname, 'async-storage.mjs');
 
     expect(result.status).toEqual(0);
 
-    const trace = JSON.parse(result.stdout.toString());
-
-    expect(trace).toEqual(expect.objectContaining({
+    expect(result.trace).toEqual(expect.objectContaining({
       '0': expect.objectContaining({
         frames: expect.arrayContaining([
           {
@@ -145,11 +188,10 @@ describe('e2e Tests', { timeout: 20000 }, () => {
     }));
   });
 
-  test('can be disabled', { timeout: 20000 }, () => {
-    const result = runTest(__dirname, 'stalled-disabled.js');
+  test('can be disabled', async () => {
+    const result = await runTest(__dirname, 'stalled-disabled.js');
 
     expect(result.status).toEqual(0);
-
-    expect(result.stdout.toString()).toContain('complete');
+    expect(result.stdout).toContain('complete');
   });
 });