fix(core): pin pool worker node runtime to parent execPath

packages/core/src/core/globalSetup.ts

@@ -22,6 +22,7 @@ const __dirname = dirname(__filename);
 function createSetupPool() {
   const options: Options = {
     runtime: 'child_process',
+    execPath: process.execPath,
     filename: resolve(__dirname, './globalSetupWorker.js'),
     execArgv: [
       ...process.execArgv,

packages/core/src/pool/forks.ts

@@ -93,6 +93,7 @@ export const createForksPool = (poolOptions: {
 
   const options: Options = {
     runtime: 'child_process',
+    execPath: process.execPath,
     filename: resolve(__dirname, './worker.js'),
     env,
     execArgv,

packages/core/tests/core/globalSetupExecPath.test.ts

@@ -0,0 +1,65 @@
+var tinypoolRunMock: ReturnType<typeof rs.fn>;
+var tinypoolDestroyMock: ReturnType<typeof rs.fn>;
+var tinypoolConstructorMock: ReturnType<typeof rs.fn>;
+
+function getTinypoolRunMock() {
+  if (!tinypoolRunMock) {
+    tinypoolRunMock = rs.fn(async () => ({ success: false }));
+  }
+
+  return tinypoolRunMock;
+}
+
+function getTinypoolDestroyMock() {
+  if (!tinypoolDestroyMock) {
+    tinypoolDestroyMock = rs.fn(async () => undefined);
+  }
+
+  return tinypoolDestroyMock;
+}
+
+function getTinypoolConstructorMock() {
+  if (!tinypoolConstructorMock) {
+    tinypoolConstructorMock = rs.fn(() => {
+      return {
+        run: getTinypoolRunMock(),
+        destroy: getTinypoolDestroyMock(),
+        threads: [],
+      };
+    });
+  }
+
+  return tinypoolConstructorMock;
+}
+
+rs.mock('tinypool', () => ({
+  Tinypool: getTinypoolConstructorMock(),
+}));
+
+import { runGlobalSetup } from '../../src/core/globalSetup';
+
+describe('runGlobalSetup', () => {
+  beforeEach(() => {
+    tinypoolConstructorMock?.mockClear();
+    tinypoolRunMock?.mockClear();
+    tinypoolDestroyMock?.mockClear();
+  });
+
+  it('should pin global setup worker execPath to the current Node runtime', async () => {
+    await runGlobalSetup({
+      globalSetupEntries: [],
+      assetFiles: {},
+      sourceMaps: {},
+      interopDefault: false,
+      outputModule: false,
+    });
+
+    expect(tinypoolConstructorMock).toHaveBeenCalledTimes(1);
+    expect(tinypoolConstructorMock.mock.calls[0]?.[0]).toEqual(
+      expect.objectContaining({
+        runtime: 'child_process',
+        execPath: process.execPath,
+      }),
+    );
+  });
+});

packages/core/tests/pool/forksExecPath.test.ts

@@ -0,0 +1,45 @@
+var tinypoolConstructorMock: ReturnType<typeof rs.fn>;
+
+function getTinypoolConstructorMock() {
+  if (!tinypoolConstructorMock) {
+    tinypoolConstructorMock = rs.fn(() => ({
+      run: rs.fn(),
+      destroy: rs.fn(),
+      threads: [],
+    }));
+  }
+
+  return tinypoolConstructorMock;
+}
+
+rs.mock('tinypool', () => ({
+  Tinypool: getTinypoolConstructorMock(),
+}));
+
+import { createForksPool } from '../../src/pool/forks';
+
+describe('createForksPool', () => {
+  beforeEach(() => {
+    tinypoolConstructorMock.mockClear();
+  });
+
+  it('should pin worker execPath to the current Node runtime', () => {
+    const pool = createForksPool({
+      env: {},
+      execArgv: [],
+      isolate: true,
+      maxWorkers: 1,
+      minWorkers: 1,
+    });
+
+    expect(tinypoolConstructorMock).toHaveBeenCalledTimes(1);
+    expect(tinypoolConstructorMock.mock.calls[0]?.[0]).toEqual(
+      expect.objectContaining({
+        runtime: 'child_process',
+        execPath: process.execPath,
+      }),
+    );
+
+    return pool.close();
+  });
+});