fix(test): spawn one via run.mjs in standalone tests so they run on Windows

YevheniiKotyrlo · YevheniiKotyrlo · commit 96b73a427a86 · 2026-06-13T00:26:47.000+03:00
metro-compiler, metro-startup-order, and process-cleanup spawned
`node node_modules/.bin/one` - on Windows the .bin shim is a .cmd/.exe
wrapper that node cannot load (MODULE_NOT_FOUND), so the dev server never
started and all three suites failed before testing anything. Resolve one's
real JS entry via createRequire (the same pattern as
packages/test/src/setupTest.ts and the test-warm-routes fix) and kill the
spawned tree with taskkill /T on Windows so dev-server workers don't orphan.
POSIX kill behavior is unchanged in the metro tests (SIGTERM then delayed
SIGKILL, as before); process-cleanup's final cleanup now force-kills on
POSIX too, matching what its own afterEach already did.

The orphan-detection test is now skipIf(win32): setupOrphanDetection in
packages/vxrn/src/exports/dev.ts is POSIX-only by design (returns early on
win32) and the test discovers the grandchild via pgrep, which doesn't exist
on Windows. Its spawn site is still fixed so the test stays correct where it
runs.

Also give packages/test/src/setup.ts's killProcessTree a Windows branch -
negative-pid process groups don't exist there, so the previous fallback
killed only the direct child and orphaned its workers.

Validated on Windows 11 (Bun 1.3.13, monorepo at v1.18.0): tests/test goes
from 4 failed suites (MODULE_NOT_FOUND) to 30 test files passed / 1 skipped,
145 tests passed / 10 skipped, 0 failures - Metro bundler boots (600ms),
the React-compiler bundle assertion and the startup-order assertion both
pass. oxlint 0/0, oxfmt clean, tsc --noEmit clean.
diff --git a/packages/test/src/setup.ts b/packages/test/src/setup.ts
@@ -32,6 +32,20 @@ export async function setup(project: TestProject) {
 
 // Kill a process group (for detached processes) or process tree
 async function killProcessTree(pid: number, name: string): Promise<void> {
+  if (process.platform === 'win32') {
+    // negative-pid process groups don't exist on Windows — the POSIX path below
+    // would degrade to killing only the direct child and orphan its workers.
+    // taskkill /T terminates the whole tree (mirrors setupTest.ts).
+    try {
+      const { execSync } = await import('node:child_process')
+      execSync(`taskkill /F /T /PID ${pid}`, { stdio: 'ignore' })
+      console.info(`${name} process (PID: ${pid}) killed successfully.`)
+    } catch {
+      // process may already be gone, which is fine
+    }
+    return
+  }
+
   try {
     // for detached processes, kill the entire process group using negative pid
     try {
diff --git a/tests/test/tests/metro-compiler.test.ts b/tests/test/tests/metro-compiler.test.ts
@@ -1,7 +1,35 @@
 import { spawn, type ChildProcess } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
 import getPort from 'get-port'
 import { describe, expect, it, afterEach } from 'vitest'
 
+// Resolve one's JS entry (run.mjs) instead of node_modules/.bin/one: on Windows
+// the .bin shim is a .cmd/.ps1/.exe wrapper that `node <path>` can't load
+// (MODULE_NOT_FOUND), so the dev server never starts. Resolving via package.json
+// gives the real JS file on every platform (mirrors packages/test/src/setupTest.ts).
+const oneRunEntry = join(
+  dirname(createRequire(import.meta.url).resolve('one/package.json')),
+  'run.mjs'
+)
+
+// node cannot signal a process tree on Windows; taskkill /T kills spawned workers too
+function killTree(proc: ChildProcess) {
+  if (!proc.pid) return
+  if (process.platform === 'win32') {
+    try {
+      spawn('taskkill', ['/F', '/T', '/PID', String(proc.pid)], { stdio: 'ignore' })
+    } catch {}
+  } else {
+    proc.kill('SIGTERM')
+    setTimeout(() => {
+      try {
+        proc.kill('SIGKILL')
+      } catch {}
+    }, 1000)
+  }
+}
+
 /**
  * Test that the React compiler works through the Metro bundling path.
  *
@@ -22,8 +50,7 @@ describe('Metro React compiler', { retry: 1 }, () => {
 
   afterEach(() => {
     if (devServer) {
-      devServer.kill('SIGTERM')
-      setTimeout(() => devServer?.kill('SIGKILL'), 1000)
+      killTree(devServer)
       devServer = null
     }
   })
@@ -35,18 +62,14 @@ describe('Metro React compiler', { retry: 1 }, () => {
     let metroReady = false
     let processExited = false
 
-    devServer = spawn(
-      'node',
-      ['../../node_modules/.bin/one', 'dev', '--port', port.toString()],
-      {
-        cwd: process.cwd(),
-        env: {
-          ...process.env,
-          DEBUG: 'vxrn:*,vite-plugin-metro:*',
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }
-    )
+    devServer = spawn('node', [oneRunEntry, 'dev', '--port', port.toString()], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        DEBUG: 'vxrn:*,vite-plugin-metro:*',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
 
     devServer.on('exit', (code) => {
       processExited = true
diff --git a/tests/test/tests/metro-startup-order.test.ts b/tests/test/tests/metro-startup-order.test.ts
@@ -1,7 +1,35 @@
-import { spawn } from 'node:child_process'
+import { spawn, type ChildProcess } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
 import getPort from 'get-port'
 import { describe, expect, it } from 'vitest'
 
+// Resolve one's JS entry (run.mjs) instead of node_modules/.bin/one: on Windows
+// the .bin shim is a .cmd/.ps1/.exe wrapper that `node <path>` can't load
+// (MODULE_NOT_FOUND), so the dev server never starts. Resolving via package.json
+// gives the real JS file on every platform (mirrors packages/test/src/setupTest.ts).
+const oneRunEntry = join(
+  dirname(createRequire(import.meta.url).resolve('one/package.json')),
+  'run.mjs'
+)
+
+// node cannot signal a process tree on Windows; taskkill /T kills spawned workers too
+function killTree(proc: ChildProcess) {
+  if (!proc.pid) return
+  if (process.platform === 'win32') {
+    try {
+      spawn('taskkill', ['/F', '/T', '/PID', String(proc.pid)], { stdio: 'ignore' })
+    } catch {}
+  } else {
+    proc.kill('SIGTERM')
+    setTimeout(() => {
+      try {
+        proc.kill('SIGKILL')
+      } catch {}
+    }, 1000)
+  }
+}
+
 /**
  * Test that Metro initialization happens AFTER Vite server is fully started.
  *
@@ -23,21 +51,17 @@ describe('Metro startup order', () => {
     let viteReadyPos = -1
     let metroReadyPos = -1
 
-    const devServer = spawn(
-      'node',
-      ['../../node_modules/.bin/one', 'dev', '--port', port.toString()],
-      {
-        cwd: process.cwd(),
-        env: {
-          ...process.env,
-          // Enable Metro mode
-          ONE_METRO_MODE: '1',
-          // Enable debug logging to see Metro ready message
-          DEBUG: 'vxrn:*',
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-      }
-    )
+    const devServer = spawn('node', [oneRunEntry, 'dev', '--port', port.toString()], {
+      cwd: process.cwd(),
+      env: {
+        ...process.env,
+        // Enable Metro mode
+        ONE_METRO_MODE: '1',
+        // Enable debug logging to see Metro ready message
+        DEBUG: 'vxrn:*',
+      },
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
 
     const collectLogs = (data: Buffer) => {
       const text = data.toString()
@@ -80,10 +104,9 @@ describe('Metro startup order', () => {
       }, 100)
     })
 
-    // Kill the server
-    devServer.kill('SIGTERM')
+    // Kill the server (tree-kill on Windows; SIGTERM→SIGKILL on POSIX)
+    killTree(devServer)
     await new Promise((r) => setTimeout(r, 500))
-    devServer.kill('SIGKILL')
 
     // Verify the order - Vite should be ready BEFORE Metro
     console.info('Output captured:\n', allOutput)
diff --git a/tests/test/tests/process-cleanup.test.ts b/tests/test/tests/process-cleanup.test.ts
@@ -1,7 +1,32 @@
 import { spawn, type ChildProcess } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
 import { afterEach, describe, expect, test } from 'vitest'
 import getPort from 'get-port'
 
+// Resolve one's JS entry (run.mjs) instead of node_modules/.bin/one: on Windows
+// the .bin shim is a .cmd/.ps1/.exe wrapper that `node <path>` can't load
+// (MODULE_NOT_FOUND), so the dev server never starts. Resolving via package.json
+// gives the real JS file on every platform (mirrors packages/test/src/setupTest.ts).
+const oneRunEntry = join(
+  dirname(createRequire(import.meta.url).resolve('one/package.json')),
+  'run.mjs'
+)
+
+// node cannot signal a process tree on Windows; taskkill /T kills spawned workers too
+function killTree(proc: ChildProcess) {
+  if (!proc.pid) return
+  if (process.platform === 'win32') {
+    try {
+      spawn('taskkill', ['/F', '/T', '/PID', String(proc.pid)], { stdio: 'ignore' })
+    } catch {}
+  } else {
+    try {
+      process.kill(proc.pid, 'SIGKILL')
+    } catch {}
+  }
+}
+
 // Helper to wait for a process to exit
 function waitForExit(proc: ChildProcess, timeout = 5000): Promise<number | null> {
   return new Promise((resolve) => {
@@ -28,80 +53,83 @@ describe('process cleanup', () => {
   let wrapper: ChildProcess | null = null
 
   afterEach(() => {
-    // Clean up any leftover processes
+    // Clean up any leftover processes (tree-kill so dev-server workers don't orphan)
     if (devServer?.pid && isRunning(devServer.pid)) {
-      process.kill(devServer.pid, 'SIGKILL')
+      killTree(devServer)
     }
     if (wrapper?.pid && isRunning(wrapper.pid)) {
-      process.kill(wrapper.pid, 'SIGKILL')
+      killTree(wrapper)
     }
   })
 
-  test('dev server exits when parent is killed (orphan detection)', async () => {
-    const port = await getPort()
-
-    // Spawn a wrapper process that spawns the dev server
-    // When we kill the wrapper, the dev server should detect it's orphaned and exit
-    wrapper = spawn(
-      'node',
-      [
-        '-e',
-        `
+  // orphan detection is POSIX-only by design (setupOrphanDetection in
+  // packages/vxrn/src/exports/dev.ts returns early on win32), and the test
+  // discovers the grandchild via pgrep — skip on Windows rather than fail
+  test.skipIf(process.platform === 'win32')(
+    'dev server exits when parent is killed (orphan detection)',
+    async () => {
+      const port = await getPort()
+
+      // Spawn a wrapper process that spawns the dev server
+      // When we kill the wrapper, the dev server should detect it's orphaned and exit
+      wrapper = spawn(
+        'node',
+        [
+          '-e',
+          `
         const { spawn } = require('child_process');
-        const dev = spawn('node', ['../../node_modules/.bin/one', 'dev', '--port', '${port}'], {
+        const dev = spawn('node', [${JSON.stringify(oneRunEntry)}, 'dev', '--port', '${port}'], {
           stdio: 'inherit'
         });
         dev.unref();
         // Keep wrapper alive
         setInterval(() => {}, 1000);
         `,
-      ],
-      {
-        cwd: process.cwd(),
-        stdio: 'pipe',
-      }
-    )
-
-    // Wait for dev server to start
-    await new Promise((r) => setTimeout(r, 8000))
-
-    // Find the dev server process
-    const devPid = await new Promise<number | null>((resolve) => {
-      const pgrep = spawn('pgrep', ['-f', `one.*dev.*port.*${port}`])
-      let output = ''
-      pgrep.stdout?.on('data', (d) => (output += d.toString()))
-      pgrep.on('close', () => {
-        const pid = parseInt(output.trim().split('\n')[0], 10)
-        resolve(isNaN(pid) ? null : pid)
+        ],
+        {
+          cwd: process.cwd(),
+          stdio: 'pipe',
+        }
+      )
+
+      // Wait for dev server to start
+      await new Promise((r) => setTimeout(r, 8000))
+
+      // Find the dev server process
+      const devPid = await new Promise<number | null>((resolve) => {
+        const pgrep = spawn('pgrep', ['-f', `one.*dev.*port.*${port}`])
+        let output = ''
+        pgrep.stdout?.on('data', (d) => (output += d.toString()))
+        pgrep.on('close', () => {
+          const pid = parseInt(output.trim().split('\n')[0], 10)
+          resolve(isNaN(pid) ? null : pid)
+        })
       })
-    })
 
-    expect(devPid).toBeTruthy()
+      expect(devPid).toBeTruthy()
 
-    // Kill the wrapper (simulating vitest being killed)
-    if (wrapper.pid) {
-      process.kill(wrapper.pid, 'SIGKILL')
-    }
+      // Kill the wrapper (simulating vitest being killed)
+      if (wrapper.pid) {
+        process.kill(wrapper.pid, 'SIGKILL')
+      }
 
-    // Wait for dev server to detect orphan and exit (should happen within 2 seconds)
-    await new Promise((r) => setTimeout(r, 2000))
+      // Wait for dev server to detect orphan and exit (should happen within 2 seconds)
+      await new Promise((r) => setTimeout(r, 2000))
 
-    // Dev server should have exited
-    const stillRunning = devPid ? isRunning(devPid) : false
-    expect(stillRunning).toBe(false)
-  }, 20000)
+      // Dev server should have exited
+      const stillRunning = devPid ? isRunning(devPid) : false
+      expect(stillRunning).toBe(false)
+    },
+    20000
+  )
 
   test('dev server does not exit prematurely when parent is alive', async () => {
     const port = await getPort()
 
-    devServer = spawn(
-      'node',
-      ['../../node_modules/.bin/one', 'dev', '--port', port.toString()],
-      {
-        cwd: process.cwd(),
-        stdio: 'pipe',
-      }
-    )
+    devServer = spawn('node', [oneRunEntry, 'dev', '--port', port.toString()], {
+      cwd: process.cwd(),
+      stdio: 'pipe',
+    })
 
     // Wait for dev server to start
     await new Promise((r) => setTimeout(r, 6000))
@@ -114,7 +142,7 @@ describe('process cleanup', () => {
     await new Promise((r) => setTimeout(r, 2000))
     expect(isRunning(devServer.pid!)).toBe(true)
 
-    // Clean up
-    devServer.kill('SIGTERM')
+    // Clean up (tree-kill so dev-server workers don't orphan on Windows)
+    killTree(devServer)
   }, 15000)
 })
