test: move test-runner-watch-mode helper into common

joyeecheung · aduh95 · commit 8c31cbb99bd0 · 2025-11-05T23:05:01.000+01:00
PR-URL: #60391 Refs: #49605 Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: Luigi Pinca <luigipinca@gmail.com> Reviewed-By: Moshe Atlow <moshe@atlow.co.il> Reviewed-By: Jake Yuesong Li <jake.yuesong@gmail.com> Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
diff --git a/test/common/watch.js b/test/common/watch.js
@@ -1,7 +1,24 @@
 'use strict';
 const common = require('./index.js');
+const tmpdir = require('./tmpdir.js');
+const fixtures = require('./fixtures.js');
+const { writeFileSync, readdirSync, readFileSync, renameSync, unlinkSync } = require('node:fs');
+const { spawn } = require('node:child_process');
+const { once } = require('node:events');
+const assert = require('node:assert');
+const { setTimeout } = require('node:timers/promises');
 
-exports.skipIfNoWatchModeSignals = function() {
+function skipIfNoWatch() {
+  if (common.isIBMi) {
+    common.skip('IBMi does not support `fs.watch()`');
+  }
+
+  if (common.isAIX) {
+    common.skip('folder watch capability is limited in AIX.');
+  }
+}
+
+function skipIfNoWatchModeSignals() {
   if (common.isWindows) {
     common.skip('no signals on Windows');
   }
@@ -13,4 +30,144 @@ exports.skipIfNoWatchModeSignals = function() {
   if (common.isAIX) {
     common.skip('folder watch capability is limited in AIX.');
   }
+}
+
+const fixturePaths = {};
+const fixtureContent = {};
+
+function refreshForTestRunnerWatch() {
+  tmpdir.refresh();
+  const files = readdirSync(fixtures.path('test-runner-watch'));
+  for (const file of files) {
+    const src = fixtures.path('test-runner-watch', file);
+    const dest = tmpdir.resolve(file);
+    fixturePaths[file] = dest;
+    fixtureContent[file] = readFileSync(src, 'utf8');
+    writeFileSync(dest, fixtureContent[file]);
+  }
+}
+
+async function testRunnerWatch({
+  fileToUpdate,
+  file,
+  action = 'update',
+  fileToCreate,
+  isolation,
+}) {
+  const ran1 = Promise.withResolvers();
+  const ran2 = Promise.withResolvers();
+  const child = spawn(process.execPath,
+                      ['--watch', '--test', '--test-reporter=spec',
+                       isolation ? `--test-isolation=${isolation}` : '',
+                       file ? fixturePaths[file] : undefined].filter(Boolean),
+                      { encoding: 'utf8', stdio: ['inherit', 'pipe', 'inherit'], cwd: tmpdir.path });
+  let stdout = '';
+  let currentRun = '';
+  const runs = [];
+
+  child.stdout.on('data', (data) => {
+    stdout += data.toString();
+    currentRun += data.toString();
+    const testRuns = stdout.match(/duration_ms\s\d+/g);
+    if (testRuns?.length >= 1) ran1.resolve();
+    if (testRuns?.length >= 2) ran2.resolve();
+  });
+
+  const testUpdate = async () => {
+    await ran1.promise;
+    runs.push(currentRun);
+    currentRun = '';
+    const content = fixtureContent[fileToUpdate];
+    const path = fixturePaths[fileToUpdate];
+    writeFileSync(path, content);
+    await setTimeout(common.platformTimeout(1000));
+    await ran2.promise;
+    runs.push(currentRun);
+    child.kill();
+    await once(child, 'exit');
+
+    assert.strictEqual(runs.length, 2);
+
+    for (const run of runs) {
+      assert.match(run, /tests 1/);
+      assert.match(run, /pass 1/);
+      assert.match(run, /fail 0/);
+      assert.match(run, /cancelled 0/);
+    }
+  };
+
+  const testRename = async () => {
+    await ran1.promise;
+    runs.push(currentRun);
+    currentRun = '';
+    const fileToRenamePath = tmpdir.resolve(fileToUpdate);
+    const newFileNamePath = tmpdir.resolve(`test-renamed-${fileToUpdate}`);
+    renameSync(fileToRenamePath, newFileNamePath);
+    await setTimeout(common.platformTimeout(1000));
+    await ran2.promise;
+    runs.push(currentRun);
+    child.kill();
+    await once(child, 'exit');
+
+    assert.strictEqual(runs.length, 2);
+
+    for (const run of runs) {
+      assert.match(run, /tests 1/);
+      assert.match(run, /pass 1/);
+      assert.match(run, /fail 0/);
+      assert.match(run, /cancelled 0/);
+    }
+  };
+
+  const testDelete = async () => {
+    await ran1.promise;
+    runs.push(currentRun);
+    currentRun = '';
+    const fileToDeletePath = tmpdir.resolve(fileToUpdate);
+    unlinkSync(fileToDeletePath);
+    await setTimeout(common.platformTimeout(2000));
+    ran2.resolve();
+    runs.push(currentRun);
+    child.kill();
+    await once(child, 'exit');
+
+    assert.strictEqual(runs.length, 2);
+
+    for (const run of runs) {
+      assert.doesNotMatch(run, /MODULE_NOT_FOUND/);
+    }
+  };
+
+  const testCreate = async () => {
+    await ran1.promise;
+    runs.push(currentRun);
+    currentRun = '';
+    const newFilePath = tmpdir.resolve(fileToCreate);
+    writeFileSync(newFilePath, 'module.exports = {};');
+    await setTimeout(common.platformTimeout(1000));
+    await ran2.promise;
+    runs.push(currentRun);
+    child.kill();
+    await once(child, 'exit');
+
+    for (const run of runs) {
+      assert.match(run, /tests 1/);
+      assert.match(run, /pass 1/);
+      assert.match(run, /fail 0/);
+      assert.match(run, /cancelled 0/);
+    }
+  };
+
+  action === 'update' && await testUpdate();
+  action === 'rename' && await testRename();
+  action === 'delete' && await testDelete();
+  action === 'create' && await testCreate();
+}
+
+
+module.exports = {
+  skipIfNoWatch,
+  skipIfNoWatchModeSignals,
+  testRunnerWatch,
+  refreshForTestRunnerWatch,
 };
diff --git a/test/fixtures/test-runner-watch/dependency.js b/test/fixtures/test-runner-watch/dependency.js
@@ -0,0 +1 @@
+module.exports = {};
diff --git a/test/fixtures/test-runner-watch/dependency.mjs b/test/fixtures/test-runner-watch/dependency.mjs
@@ -0,0 +1 @@
+export const a = 1;
diff --git a/test/fixtures/test-runner-watch/test.js b/test/fixtures/test-runner-watch/test.js
@@ -0,0 +1,5 @@
+const test = require('node:test');
+require('./dependency.js');
+import('./dependency.mjs');
+import('data:text/javascript,');
+test('test has ran');
diff --git a/test/parallel/test-runner-watch-mode.mjs b/test/parallel/test-runner-watch-mode.mjs
@@ -1,192 +1,43 @@
-import * as common from '../common/index.mjs';
+import '../common/index.mjs';
+import { skipIfNoWatch, refreshForTestRunnerWatch, testRunnerWatch } from '../common/watch.js';
 import { describe, it, beforeEach } from 'node:test';
-import { once } from 'node:events';
-import assert from 'node:assert';
-import { spawn } from 'node:child_process';
-import { writeFileSync, renameSync, unlinkSync } from 'node:fs';
-import { setTimeout } from 'node:timers/promises';
-import tmpdir from '../common/tmpdir.js';
 
-if (common.isIBMi)
-  common.skip('IBMi does not support `fs.watch()`');
-
-if (common.isAIX)
-  common.skip('folder watch capability is limited in AIX.');
-
-let fixturePaths;
-
-// This test updates these files repeatedly,
-// Reading them from disk is unreliable due to race conditions.
-const fixtureContent = {
-  'dependency.js': 'module.exports = {};',
-  'dependency.mjs': 'export const a = 1;',
-  'test.js': `
-const test = require('node:test');
-require('./dependency.js');
-import('./dependency.mjs');
-import('data:text/javascript,');
-test('test has ran');`,
-};
-
-function refresh() {
-  tmpdir.refresh();
-  fixturePaths = Object.keys(fixtureContent)
-    .reduce((acc, file) => ({ ...acc, [file]: tmpdir.resolve(file) }), {});
-  Object.entries(fixtureContent)
-    .forEach(([file, content]) => writeFileSync(fixturePaths[file], content));
-}
-
-async function testWatch({
-  fileToUpdate,
-  file,
-  action = 'update',
-  fileToCreate,
-  isolation,
-}) {
-  const ran1 = Promise.withResolvers();
-  const ran2 = Promise.withResolvers();
-  const child = spawn(process.execPath,
-                      ['--watch', '--test', '--test-reporter=spec',
-                       isolation ? `--test-isolation=${isolation}` : '',
-                       file ? fixturePaths[file] : undefined].filter(Boolean),
-                      { encoding: 'utf8', stdio: 'pipe', cwd: tmpdir.path });
-  let stdout = '';
-  let currentRun = '';
-  const runs = [];
-
-  child.stdout.on('data', (data) => {
-    stdout += data.toString();
-    currentRun += data.toString();
-    const testRuns = stdout.match(/duration_ms\s\d+/g);
-    if (testRuns?.length >= 1) ran1.resolve();
-    if (testRuns?.length >= 2) ran2.resolve();
-  });
-
-  const testUpdate = async () => {
-    await ran1.promise;
-    runs.push(currentRun);
-    currentRun = '';
-    const content = fixtureContent[fileToUpdate];
-    const path = fixturePaths[fileToUpdate];
-    writeFileSync(path, content);
-    await setTimeout(common.platformTimeout(1000));
-    await ran2.promise;
-    runs.push(currentRun);
-    child.kill();
-    await once(child, 'exit');
-
-    assert.strictEqual(runs.length, 2);
-
-    for (const run of runs) {
-      assert.match(run, /tests 1/);
-      assert.match(run, /pass 1/);
-      assert.match(run, /fail 0/);
-      assert.match(run, /cancelled 0/);
-    }
-  };
-
-  const testRename = async () => {
-    await ran1.promise;
-    runs.push(currentRun);
-    currentRun = '';
-    const fileToRenamePath = tmpdir.resolve(fileToUpdate);
-    const newFileNamePath = tmpdir.resolve(`test-renamed-${fileToUpdate}`);
-    renameSync(fileToRenamePath, newFileNamePath);
-    await setTimeout(common.platformTimeout(1000));
-    await ran2.promise;
-    runs.push(currentRun);
-    child.kill();
-    await once(child, 'exit');
-
-    assert.strictEqual(runs.length, 2);
-
-    for (const run of runs) {
-      assert.match(run, /tests 1/);
-      assert.match(run, /pass 1/);
-      assert.match(run, /fail 0/);
-      assert.match(run, /cancelled 0/);
-    }
-  };
-
-  const testDelete = async () => {
-    await ran1.promise;
-    runs.push(currentRun);
-    currentRun = '';
-    const fileToDeletePath = tmpdir.resolve(fileToUpdate);
-    unlinkSync(fileToDeletePath);
-    await setTimeout(common.platformTimeout(2000));
-    ran2.resolve();
-    runs.push(currentRun);
-    child.kill();
-    await once(child, 'exit');
-
-    assert.strictEqual(runs.length, 2);
-
-    for (const run of runs) {
-      assert.doesNotMatch(run, /MODULE_NOT_FOUND/);
-    }
-  };
-
-  const testCreate = async () => {
-    await ran1.promise;
-    runs.push(currentRun);
-    currentRun = '';
-    const newFilePath = tmpdir.resolve(fileToCreate);
-    writeFileSync(newFilePath, 'module.exports = {};');
-    await setTimeout(common.platformTimeout(1000));
-    await ran2.promise;
-    runs.push(currentRun);
-    child.kill();
-    await once(child, 'exit');
-
-    for (const run of runs) {
-      assert.match(run, /tests 1/);
-      assert.match(run, /pass 1/);
-      assert.match(run, /fail 0/);
-      assert.match(run, /cancelled 0/);
-    }
-  };
-
-  action === 'update' && await testUpdate();
-  action === 'rename' && await testRename();
-  action === 'delete' && await testDelete();
-  action === 'create' && await testCreate();
-}
+skipIfNoWatch();
 
 describe('test runner watch mode', () => {
-  beforeEach(refresh);
+  beforeEach(refreshForTestRunnerWatch);
   for (const isolation of ['none', 'process']) {
     describe(`isolation: ${isolation}`, () => {
       it('should run tests repeatedly', async () => {
-        await testWatch({ file: 'test.js', fileToUpdate: 'test.js', isolation });
+        await testRunnerWatch({ file: 'test.js', fileToUpdate: 'test.js', isolation });
       });
 
       it('should run tests with dependency repeatedly', async () => {
-        await testWatch({ file: 'test.js', fileToUpdate: 'dependency.js', isolation });
+        await testRunnerWatch({ file: 'test.js', fileToUpdate: 'dependency.js', isolation });
       });
 
       it('should run tests with ESM dependency', async () => {
-        await testWatch({ file: 'test.js', fileToUpdate: 'dependency.mjs', isolation });
+        await testRunnerWatch({ file: 'test.js', fileToUpdate: 'dependency.mjs', isolation });
       });
 
       it('should support running tests without a file', async () => {
-        await testWatch({ fileToUpdate: 'test.js', isolation });
+        await testRunnerWatch({ fileToUpdate: 'test.js', isolation });
       });
 
       it('should support a watched test file rename', async () => {
-        await testWatch({ fileToUpdate: 'test.js', action: 'rename', isolation });
+        await testRunnerWatch({ fileToUpdate: 'test.js', action: 'rename', isolation });
       });
 
       it('should not throw when delete a watched test file', async () => {
-        await testWatch({ fileToUpdate: 'test.js', action: 'delete', isolation });
+        await testRunnerWatch({ fileToUpdate: 'test.js', action: 'delete', isolation });
       });
 
       it('should run new tests when a new file is created in the watched directory', {
         todo: isolation === 'none' ?
           'This test is failing when isolation is set to none and must be fixed' :
           undefined,
       }, async () => {
-        await testWatch({ action: 'create', fileToCreate: 'new-test-file.test.js', isolation });
+        await testRunnerWatch({ action: 'create', fileToCreate: 'new-test-file.test.js', isolation });
       });
     });
   }
