test_runner: added coverage support with watch mode

Author: pulkit-30

lib/internal/main/test_runner.js

@@ -69,6 +69,7 @@ const options = {
   setup: setupTestReporters,
   timeout,
   shard,
+  coverage: getOptionValue('--experimental-test-coverage'),
 };
 debug('test runner configuration:', options);
 run(options).on('test:fail', (data) => {

lib/internal/test_runner/runner.js

@@ -112,7 +112,7 @@ function filterExecArgv(arg, i, arr) {
   !ArrayPrototypeSome(kFilterArgValues, (p) => arg === p || (i > 0 && arr[i - 1] === p) || StringPrototypeStartsWith(arg, `${p}=`));
 }
 
-function getRunArgs(path, { inspectPort, testNamePatterns, only }) {
+function getRunArgs(path, { inspectPort, testNamePatterns, only, coverage }) {
   const argv = ArrayPrototypeFilter(process.execArgv, filterExecArgv);
   if (isUsingInspector()) {
     ArrayPrototypePush(argv, `--inspect-port=${getInspectPort(inspectPort)}`);
@@ -123,6 +123,9 @@ function getRunArgs(path, { inspectPort, testNamePatterns, only }) {
   if (only === true) {
     ArrayPrototypePush(argv, '--test-only');
   }
+  if (coverage === true) {
+    ArrayPrototypePush(argv, '--experimental-test-coverage');
+  }
   ArrayPrototypePush(argv, path);
 
   return argv;
@@ -440,7 +443,7 @@ function run(options = kEmptyObject) {
   validateObject(options, 'options');
 
   let { testNamePatterns, shard } = options;
-  const { concurrency, timeout, signal, files, inspectPort, watch, setup, only } = options;
+  const { concurrency, timeout, signal, files, inspectPort, watch, setup, only, coverage } = options;
 
   if (files != null) {
     validateArray(files, 'options.files');
@@ -503,8 +506,8 @@ function run(options = kEmptyObject) {
   let filesWatcher;
   const opts = { __proto__: null, root, signal, inspectPort, testNamePatterns, only };
   if (watch) {
-    filesWatcher = watchFiles(testFiles, opts);
-    postRun = undefined;
+    filesWatcher = watchFiles(testFiles, { __proto__: null, ...opts, coverage });
+    postRun = () => root.postRun(null, false);
   }
   const runFiles = () => {
     root.harness.bootstrapComplete = true;

lib/internal/test_runner/test.js

@@ -674,7 +674,7 @@ class Test extends AsyncResource {
     }
   }
 
-  postRun(pendingSubtestsError) {
+  postRun(pendingSubtestsError, endReporter = true) {
     // If the test was failed before it even started, then the end time will
     // be earlier than the start time. Correct that here.
     if (this.endTime < this.startTime) {
@@ -756,7 +756,9 @@ class Test extends AsyncResource {
         reporter.coverage(nesting, loc, coverage);
       }
 
-      reporter.end();
+      if (endReporter === true) {
+        reporter.end();
+      }
     }
   }
 

test/parallel/test-runner-watch-coverage.mjs

@@ -0,0 +1,86 @@
+// Flags: --expose-internals
+import * as common from '../common/index.mjs';
+import { describe, it } from 'node:test';
+import { spawn } from 'node:child_process';
+import { writeFileSync } from 'node:fs';
+import util from 'internal/util';
+import tmpdir from '../common/tmpdir.js';
+import assert from 'node:assert';
+
+
+if (common.isIBMi)
+  common.skip('IBMi does not support `fs.watch()`');
+
+tmpdir.refresh();
+
+function getCoverageFixtureReport() {
+
+  const report = [
+    '# start of coverage report',
+    '# ---------------------------------------------------------------',
+    '# file           | line % | branch % | funcs % | uncovered lines',
+    '# ---------------------------------------------------------------',
+    '# dependency.js  | 100.00 |   100.00 |  100.00 | ',
+    '# dependency.mjs | 100.00 |   100.00 |  100.00 | ',
+    '# test.js        | 100.00 |   100.00 |  100.00 | ',
+    '# ---------------------------------------------------------------',
+    '# all files      | 100.00 |   100.00 |  100.00 |',
+    '# ---------------------------------------------------------------',
+    '# end of coverage report',
+  ].join('\n');
+
+
+  if (common.isWindows) {
+    return report.replaceAll('/', '\\');
+  }
+
+  return report;
+}
+
+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');`,
+};
+const 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 }) {
+  const ran1 = util.createDeferredPromise();
+  const ran2 = util.createDeferredPromise();
+  const child = spawn(process.execPath,
+                      ['--watch', '--test', '--experimental-test-coverage',
+                       file ? fixturePaths[file] : undefined].filter(Boolean),
+                      { encoding: 'utf8', stdio: 'pipe', cwd: tmpdir.path });
+  let stdout = '';
+
+  child.stdout.on('data', (data) => {
+    stdout += data.toString();
+    const testRuns = stdout.match(/ - test has ran/g);
+    if (testRuns?.length >= 1) ran1.resolve();
+    if (testRuns?.length >= 2) ran2.resolve();
+  });
+
+  await ran1.promise;
+  const content = fixtureContent[fileToUpdate];
+  const path = fixturePaths[fileToUpdate];
+  const interval = setInterval(() => writeFileSync(path, content), common.platformTimeout(1000));
+  await ran2.promise;
+  clearInterval(interval);
+  child.kill();
+  return stdout;
+}
+
+describe('test runner watch mode with coverage report', () => {
+  it('should support running test file', async () => {
+    const stdout = await testWatch({ file: 'test.js', fileToUpdate: 'test.js' });
+    assert(stdout.includes(getCoverageFixtureReport()));
+  });
+});