vfs: split followup tests into named test files

Replace the monolithic test-vfs-followups.js with individual test files:
- test-vfs-overlapping-mounts.js
- test-vfs-promises-open.js
- test-vfs-stream-properties.js
- test-vfs-dir-disposal.js
- test-vfs-stats-ino-dev.js
- test-vfs-append-write.js
- test-vfs-cross-device.js
- test-vfs-readdir-symlink-recursive.js
- test-vfs-package-json-cache.js
- test-vfs-readfile-async.js

Author: mcollina

lib/internal/fs/promises.js

@@ -643,7 +643,7 @@ async function copyFile(src, dest, mode) {
 async function open(path, flags, mode) {
   const h = vfsState.handlers;
   if (h !== null) {
-    const result = h.open(path, flags, mode);
+    const result = h.promisesOpen(path, flags, mode);
     if (result !== undefined) return result;
   }
   path = getValidatedPath(path);

lib/internal/vfs/file_system.js

@@ -46,7 +46,6 @@ const kVirtualCwd = Symbol('kVirtualCwd');
 const kVirtualCwdEnabled = Symbol('kVirtualCwdEnabled');
 const kOriginalChdir = Symbol('kOriginalChdir');
 const kOriginalCwd = Symbol('kOriginalCwd');
-const kAllowWithPermissionModel = Symbol('kAllowWithPermissionModel');
 
 // Lazy-loaded VFS setup
 let registerVFS;
@@ -109,7 +108,6 @@ class VirtualFileSystem {
     this[kVirtualCwd] = null; // Set when chdir() is called
     this[kOriginalChdir] = null; // Saved process.chdir
     this[kOriginalCwd] = null; // Saved process.cwd
-    this[kAllowWithPermissionModel] = options.allowWithPermissionModel === true;
   }
 
   /**
@@ -162,14 +160,6 @@ class VirtualFileSystem {
     return this[kVirtualCwdEnabled];
   }
 
-  /**
-   * Returns true if this VFS allows being used with the permission model.
-   * @returns {boolean}
-   */
-  get allowWithPermissionModel() {
-    return this[kAllowWithPermissionModel];
-  }
-
   // ==================== Virtual Working Directory ====================
 
   /**

lib/internal/vfs/providers/memory.js

@@ -985,7 +985,7 @@ class MemoryProvider extends VirtualProvider {
     }
 
     if (listener) {
-      watcher.addListener(listener);
+      watcher.addListener('change', listener);
     }
 
     return watcher;
@@ -1005,7 +1005,7 @@ class MemoryProvider extends VirtualProvider {
     }
 
     if (listener) {
-      watcher.removeListener(listener);
+      watcher.removeListener('change', listener);
     } else {
       // Remove all listeners
       watcher.removeAllListeners('change');

lib/internal/vfs/setup.js

@@ -30,6 +30,7 @@ const { createENOENT, createEXDEV } = require('internal/vfs/errors');
 const { getVirtualFd, closeVirtualFd } = require('internal/vfs/fd');
 const { vfsState, setVfsHandlers } = require('internal/fs/utils');
 const permission = require('internal/process/permission');
+const { getOptionValue } = require('internal/options');
 
 /**
  * Converts a path argument (string or URL) to a string path.
@@ -72,10 +73,10 @@ let vfsHandlerObj;
  * @param {VirtualFileSystem} vfs The VFS instance to register
  */
 function registerVFS(vfs) {
-  if (permission.isEnabled() && !vfs.allowWithPermissionModel) {
+  if (permission.isEnabled() && !getOptionValue('--allow-fs-vfs')) {
     throw new ERR_INVALID_STATE(
       'VFS cannot be used when the permission model is enabled. ' +
-      'Set allowWithPermissionModel: true to override.',
+      'Use --allow-fs-vfs to allow it.',
     );
   }
   if (ArrayPrototypeIndexOf(activeVFSList, vfs) === -1) {
@@ -85,8 +86,11 @@ function registerVFS(vfs) {
       for (let i = 0; i < activeVFSList.length; i++) {
         const existingMount = activeVFSList[i].mountPoint;
         if (existingMount == null) continue;
-        if (StringPrototypeStartsWith(newMount, existingMount) ||
-            StringPrototypeStartsWith(existingMount, newMount)) {
+        const newPrefix = newMount === '/' ? '/' : newMount + '/';
+        const existingPrefix = existingMount === '/' ? '/' : existingMount + '/';
+        if (newMount === existingMount ||
+            StringPrototypeStartsWith(newMount, existingPrefix) ||
+            StringPrototypeStartsWith(existingMount, newPrefix)) {
           throw new ERR_INVALID_STATE(
             `VFS mount '${newMount}' overlaps with existing mount '${existingMount}'`,
           );
@@ -884,6 +888,9 @@ function createVfsHandlers() {
     chmod: (path, mode) => vfsOp(path, (vfs, n) => vfs.promises.chmod(n, mode).then(() => true)),
     utimes: (path, atime, mtime) => vfsOp(path, (vfs, n) => vfs.promises.utimes(n, atime, mtime).then(() => true)),
     open(path, flags, mode) {
+      return vfsOp(path, (vfs, n) => PromiseResolve(vfs.openSync(n, flags, mode)));
+    },
+    promisesOpen(path, flags, mode) {
       const pathStr = toPathStr(path);
       if (pathStr !== null) {
         const r = findVFSForPath(pathStr);

src/node_options.cc

@@ -663,6 +663,12 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             kAllowedInEnvvar,
             false,
             OptionNamespaces::kPermissionNamespace);
+  AddOption("--allow-fs-vfs",
+            "allow use of virtual filesystem when any permissions are set",
+            &EnvironmentOptions::allow_fs_vfs,
+            kAllowedInEnvvar,
+            false,
+            OptionNamespaces::kPermissionNamespace);
   AddOption("--allow-child-process",
             "allow use of child process when any permissions are set",
             &EnvironmentOptions::allow_child_process,

src/node_options.h

@@ -142,6 +142,7 @@ class EnvironmentOptions : public Options {
   std::vector<std::string> allow_fs_read;
   std::vector<std::string> allow_fs_write;
   bool allow_addons = false;
+  bool allow_fs_vfs = false;
   bool allow_inspector = false;
   bool allow_child_process = false;
   bool allow_net = false;

test/parallel/test-vfs-append-write.js

@@ -0,0 +1,18 @@
+'use strict';
+
+// writeSync in append mode must append, not overwrite.
+
+require('../common');
+const assert = require('assert');
+const vfs = require('node:vfs');
+
+const myVfs = vfs.create();
+myVfs.writeFileSync('/append.txt', 'init');
+
+const fd = myVfs.openSync('/append.txt', 'a');
+const buf = Buffer.from(' more');
+myVfs.writeSync(fd, buf, 0, buf.length);
+myVfs.closeSync(fd);
+
+const content = myVfs.readFileSync('/append.txt', 'utf8');
+assert.strictEqual(content, 'init more');

test/parallel/test-vfs-cross-device.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// Cross-VFS rename, copyFile, and link must throw EXDEV.
+
+require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const vfs = require('node:vfs');
+
+const vfs1 = vfs.create();
+vfs1.writeFileSync('/src.txt', 'data');
+vfs1.mount('/xdev_a');
+
+const vfs2 = vfs.create();
+vfs2.mkdirSync('/dest');
+vfs2.mount('/xdev_b');
+
+assert.throws(() => fs.renameSync('/xdev_a/src.txt', '/xdev_b/dest/src.txt'), {
+  code: 'EXDEV',
+});
+
+assert.throws(() => fs.copyFileSync('/xdev_a/src.txt', '/xdev_b/dest/src.txt'), {
+  code: 'EXDEV',
+});
+
+assert.throws(() => fs.linkSync('/xdev_a/src.txt', '/xdev_b/dest/link.txt'), {
+  code: 'EXDEV',
+});
+
+vfs2.unmount();
+vfs1.unmount();

test/parallel/test-vfs-dir-disposal.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// VirtualDir must support Symbol.dispose and Symbol.asyncDispose.
+
+const common = require('../common');
+const assert = require('assert');
+const fs = require('fs');
+const vfs = require('node:vfs');
+
+const myVfs = vfs.create();
+myVfs.mkdirSync('/dir');
+myVfs.writeFileSync('/dir/a.txt', 'a');
+myVfs.mount('/mnt_dirdispose');
+
+// Symbol.dispose via closeSync
+{
+  const dir = fs.opendirSync('/mnt_dirdispose/dir');
+  dir[Symbol.dispose]();
+  assert.throws(() => dir.closeSync(), { code: 'ERR_DIR_CLOSED' });
+}
+
+// Symbol.asyncDispose via close
+{
+  const dir = fs.opendirSync('/mnt_dirdispose/dir');
+  dir[Symbol.asyncDispose]().then(common.mustCall(() => {
+    assert.throws(() => dir.closeSync(), { code: 'ERR_DIR_CLOSED' });
+  }));
+}
+
+myVfs.unmount();