fs: mention URL in NUL character error message

PR-URL: #48828 Reviewed-By: Mohammed Keyvanzadeh <[email protected]> Reviewed-By: Antoine du Hamel <[email protected]>
nodejs · Aug 17, 2023 · c14ff69 · c14ff69
1 parent d634d78
commit c14ff69
Show file tree

Hide file tree

Showing 3 changed files with 52 additions and 61 deletions.
diff --git a/lib/internal/fs/utils.js b/lib/internal/fs/utils.js
@@ -376,7 +376,7 @@ const nullCheck = hideStackFrames((path, propName, throwError = true) => {
   const err = new ERR_INVALID_ARG_VALUE(
     propName,
     path,
-    'must be a string or Uint8Array without null bytes',
+    'must be a string, Uint8Array, or URL without null bytes',
   );
   if (throwError) {
     throw err;

diff --git a/test/parallel/test-child-process-reject-null-bytes.js b/test/parallel/test-child-process-reject-null-bytes.js
@@ -18,56 +18,56 @@ const {
 
 throws(() => exec(`${process.execPath} ${__filename} AAA BBB\0XXX CCC`, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'command' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => exec('BBB\0XXX AAA CCC', mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'command' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execSync(`${process.execPath} ${__filename} AAA BBB\0XXX CCC`), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'command' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execSync('BBB\0XXX AAA CCC'), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'command' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'file' argument
 
 throws(() => spawn('BBB\0XXX'), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'file' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFile('BBB\0XXX', mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'file' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFileSync('BBB\0XXX'), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'file' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawn('BBB\0XXX'), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'file' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawnSync('BBB\0XXX'), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'file' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'modulePath' argument
 
 throws(() => fork('BBB\0XXX'), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'modulePath' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'args' argument
@@ -77,218 +77,218 @@ throws(() => fork('BBB\0XXX'), {
 
 throws(() => execFile(process.execPath, [__filename, 'AAA', 'BBB\0XXX', 'CCC'], mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'args\[2\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFileSync(process.execPath, [__filename, 'AAA', 'BBB\0XXX', 'CCC']), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'args\[2\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => fork(__filename, ['AAA', 'BBB\0XXX', 'CCC']), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'args\[2\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawn(process.execPath, [__filename, 'AAA', 'BBB\0XXX', 'CCC']), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'args\[2\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawnSync(process.execPath, [__filename, 'AAA', 'BBB\0XXX', 'CCC']), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The argument 'args\[2\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'options.cwd' argument
 
 throws(() => exec(process.execPath, { cwd: 'BBB\0XXX' }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.cwd' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFile(process.execPath, { cwd: 'BBB\0XXX' }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.cwd' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFileSync(process.execPath, { cwd: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.cwd' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execSync(process.execPath, { cwd: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.cwd' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => fork(__filename, { cwd: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.cwd' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawn(process.execPath, { cwd: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.cwd' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawnSync(process.execPath, { cwd: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.cwd' must be a string or Uint8Array without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'options.argv0' argument
 
 throws(() => exec(process.execPath, { argv0: 'BBB\0XXX' }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.argv0' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFile(process.execPath, { argv0: 'BBB\0XXX' }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.argv0' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFileSync(process.execPath, { argv0: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.argv0' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execSync(process.execPath, { argv0: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.argv0' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => fork(__filename, { argv0: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.argv0' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawn(process.execPath, { argv0: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.argv0' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawnSync(process.execPath, { argv0: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.argv0' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'options.shell' argument
 
 throws(() => exec(process.execPath, { shell: 'BBB\0XXX' }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.shell' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFile(process.execPath, { shell: 'BBB\0XXX' }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.shell' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFileSync(process.execPath, { shell: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.shell' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execSync(process.execPath, { shell: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.shell' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Not testing fork() because it doesn't accept the shell option (internally it
 // explicitly sets shell to false).
 
 throws(() => spawn(process.execPath, { shell: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.shell' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawnSync(process.execPath, { shell: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.shell' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'options.env' argument
 
 throws(() => exec(process.execPath, { env: { 'AAA': 'BBB\0XXX' } }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['AAA'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => exec(process.execPath, { env: { 'BBB\0XXX': 'AAA' } }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['BBB\0XXX'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFile(process.execPath, { env: { 'AAA': 'BBB\0XXX' } }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['AAA'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFile(process.execPath, { env: { 'BBB\0XXX': 'AAA' } }, mustNotCall()), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['BBB\0XXX'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFileSync(process.execPath, { env: { 'AAA': 'BBB\0XXX' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['AAA'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execFileSync(process.execPath, { env: { 'BBB\0XXX': 'AAA' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['BBB\0XXX'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execSync(process.execPath, { env: { 'AAA': 'BBB\0XXX' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['AAA'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => execSync(process.execPath, { env: { 'BBB\0XXX': 'AAA' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['BBB\0XXX'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => fork(__filename, { env: { 'AAA': 'BBB\0XXX' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['AAA'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => fork(__filename, { env: { 'BBB\0XXX': 'AAA' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['BBB\0XXX'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawn(process.execPath, { env: { 'AAA': 'BBB\0XXX' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['AAA'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawn(process.execPath, { env: { 'BBB\0XXX': 'AAA' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['BBB\0XXX'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawnSync(process.execPath, { env: { 'AAA': 'BBB\0XXX' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['AAA'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 throws(() => spawnSync(process.execPath, { env: { 'BBB\0XXX': 'AAA' } }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.env\['BBB\0XXX'\]' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'options.execPath' argument
 throws(() => fork(__filename, { execPath: 'BBB\0XXX' }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.execPath' must be a string without null bytes/
+  name: 'TypeError',
 });
 
 // Tests for the 'options.execArgv' argument
 throws(() => fork(__filename, { execArgv: ['AAA', 'BBB\0XXX', 'CCC'] }), {
   code: 'ERR_INVALID_ARG_VALUE',
-  message: /The property 'options\.execArgv\[1\]' must be a string without null bytes/
+  name: 'TypeError',
 });
diff --git a/test/parallel/test-fs-whatwg-url.js b/test/parallel/test-fs-whatwg-url.js
@@ -5,7 +5,6 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const path = require('path');
 const fs = require('fs');
-const os = require('os');
 
 function pathToFileURL(p) {
   if (!path.isAbsolute(p))
@@ -35,7 +34,6 @@ assert.throws(
   {
     code: 'ERR_INVALID_URL_SCHEME',
     name: 'TypeError',
-    message: 'The URL must be of scheme file'
   });
 
 // pct-encoded characters in the path will be decoded and checked
@@ -49,7 +47,6 @@ if (common.isWindows) {
       {
         code: 'ERR_INVALID_FILE_URL_PATH',
         name: 'TypeError',
-        message: 'File URL path must not include encoded \\ or / characters'
       }
     );
   });
@@ -60,8 +57,6 @@ if (common.isWindows) {
     {
       code: 'ERR_INVALID_ARG_VALUE',
       name: 'TypeError',
-      message: 'The argument \'path\' must be a string or Uint8Array without ' +
-               "null bytes. Received 'c:\\\\tmp\\\\\\x00test'"
     }
   );
 } else {
@@ -74,7 +69,6 @@ if (common.isWindows) {
       {
         code: 'ERR_INVALID_FILE_URL_PATH',
         name: 'TypeError',
-        message: 'File URL path must not include encoded / characters'
       });
   });
   assert.throws(
@@ -84,7 +78,6 @@ if (common.isWindows) {
     {
       code: 'ERR_INVALID_FILE_URL_HOST',
       name: 'TypeError',
-      message: `File URL host must be "localhost" or empty on ${os.platform()}`
     }
   );
   assert.throws(
@@ -94,8 +87,6 @@ if (common.isWindows) {
     {
       code: 'ERR_INVALID_ARG_VALUE',
       name: 'TypeError',
-      message: "The argument 'path' must be a string or Uint8Array without " +
-               "null bytes. Received '/tmp/\\x00test'"
     }
   );
 }