test: add escapePathsFromShellCommand util

Author: aduh95

test/common/index.js

@@ -944,13 +944,45 @@ function expectRequiredModule(mod, expectation, checkESModule = true) {
   assert.deepStrictEqual(clone, { ...expectation });
 }
 
+
+/**
+ * Escape quoted values in a string template literal. On Windows, this function
+ * does not escape anything (which is fine for paths, as `"` is not a valid char
+ * in a path on Windows), so you should use it only to escape paths – or other
+ * values on tests which are skipped on Windows.
+ * @returns {[string, object | undefined]} An array that can be passed as
+ *                                         arguments to `exec` or `execSync`.
+ */
+function escapePathsFromShellCommand(cmdParts, ...args) {
+  if (common.isWindows) {
+    // On Windows, paths cannot contain `"`, so we can return the string unchanged.
+    return [String.raw({ raw: cmdParts }, ...args)];
+  }
+  // On POSIX shells, we can pass values via the env, as there's a standard way for referencing a variable.
+  const env = {...process.env}
+  let cmd = cmdParts[0];
+  for (let i = 0; i < args.length; i++) {
+    if (cmdParts[i].at(-1) === '"' && cmdParts[i + 1][0] === '"') {
+      const envVarName = `ESCAPED_${i}`
+      cmd += '$' + envVarName;
+      env[envVarName] = args[i];
+    } else {
+      cmd += args[i];
+    }
+    cmd += cmdParts[i + 1]
+  }
+
+  return [cmd, { env }]
+}
+
 const common = {
   allowGlobals,
   buildType,
   canCreateSymLink,
   childShouldThrowAndAbort,
   createZeroFilledFile,
   defaultAutoSelectFamilyAttemptTimeout,
+  escapePathsFromShellCommand,
   expectsError,
   expectRequiredModule,
   expectWarning,

test/sequential/test-cli-syntax-bad.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('../common');
+const common = require('../common');
 const { exec } = require('child_process');
 const { test } = require('node:test');
 const fixtures = require('../common/fixtures');
@@ -9,8 +9,8 @@ const node = process.execPath;
 
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
-  ['-c'],
-  ['--check'],
+  '-c',
+  '--check',
 ];
 
 // Match on the name of the `Error` but not the message as it is different
@@ -27,13 +27,10 @@ const syntaxErrorRE = /^SyntaxError: \b/m;
   const path = fixtures.path(file);
 
   // Loop each possible option, `-c` or `--check`
-  syntaxArgs.forEach((args) => {
-    test(`Checking syntax for ${file} with ${args.join(' ')}`, async (t) => {
-      const _args = args.concat(path);
-      const cmd = [node, ..._args].join(' ');
-
+  syntaxArgs.forEach((flag) => {
+    test(`Checking syntax for ${file} with ${flag}`, async (t) => {
       try {
-        const { stdout, stderr } = await execPromise(cmd);
+        const { stdout, stderr } = await execNode(flag, path);
 
         // No stdout should be produced
         t.assert.strictEqual(stdout, '');
@@ -51,9 +48,11 @@ const syntaxErrorRE = /^SyntaxError: \b/m;
 });
 
 // Helper function to promisify exec
-function execPromise(cmd) {
+function execNode(flag, path) {
   const { promise, resolve, reject } = Promise.withResolvers();
-  exec(cmd, (err, stdout, stderr) => {
+  exec(`"${common.isWindows ? node : '$NODE'}" ${flag} "${common.isWindows ? path : '$PATH'}"`, {
+    env: common.isWindows ? process.env : { ...process.env, NODE: node, PATH: path },
+  }, (err, stdout, stderr) => {
     if (err) return reject({ ...err, stdout, stderr });
     resolve({ stdout, stderr });
   });

test/sequential/test-cli-syntax-good.js

@@ -1,19 +1,10 @@
 'use strict';
 
-const common = require('../common');
+const { escapePathsFromShellCommand } = require('../common');
 const assert = require('assert');
 const { exec } = require('child_process');
 const fixtures = require('../common/fixtures');
 
-// The execPath might contain chars that should be escaped in a shell context.
-// On non-Windows, we can pass the path via the env; `"` is not a valid char on
-// Windows, so we can simply pass the path.
-const execNode = (flag, file, callback) => exec(
-  `"${common.isWindows ? process.execPath : '$NODE'}" ${flag} "${common.isWindows ? file : '$FILE'}"`,
-  common.isWindows ? undefined : { env: { ...process.env, NODE: process.execPath, FILE: file } },
-  callback,
-);
-
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
   '-c',
@@ -33,7 +24,7 @@ const syntaxArgs = [
 
   // Loop each possible option, `-c` or `--check`
   syntaxArgs.forEach(function(flag) {
-    execNode(flag, file, common.mustCall((err, stdout, stderr) => {
+    exec(...escapePathsFromShellCommand`"${process.execPath}" ${flag} "${file}"`, common.mustCall((err, stdout, stderr) => {
       if (err) {
         console.log('-- stdout --');
         console.log(stdout);