vfs: address test review feedback

- Add VFS docs link in test.md mock-fs section
- Update TODO precision in test-runner-mock-fs.js
- Move async truncate test to test-vfs-promises.js
- Expand promise tests with full method coverage
- Remove trivial assertion and clean up comments in test-vfs-chdir.js
- Add ESM cache explanation in test-vfs-import.mjs
- Split overlay worker code into test/fixtures/vfs-overlay-worker.js
- Reorganize test-vfs-provider-memory.js to provider-specific tests
- Add ESM require tests to test-vfs-require.js

Author: mcollina

doc/api/test.md

@@ -2358,7 +2358,7 @@ added: REPLACEME
 * Returns: {MockFSContext} An object that can be used to manage the mock file
   system.
 
-This function creates a mock file system using the Virtual File System (VFS).
+This function creates a mock file system using the [Virtual File System (VFS)][].
 The mock file system is automatically cleaned up when the test completes.
 
 ## Class: `MockFSContext`
@@ -4228,3 +4228,4 @@ Can be used to abort test subtasks when the test has been aborted.
 [suite options]: #suitename-options-fn
 [test reporters]: #test-reporters
 [test runner execution model]: #test-runner-execution-model
+[virtual file system (vfs)]: vfs.md

test/fixtures/vfs-overlay-worker.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { workerData, parentPort } = require('worker_threads');
+const vfs = require('node:vfs');
+const fs = require('fs');
+const path = require('path');
+
+const testDir = workerData.testDir;
+
+// In worker: create overlay VFS that mocks specific files
+const overlayVfs = vfs.create(new vfs.MemoryProvider(), {
+  overlay: true,
+  virtualCwd: true,
+});
+
+// Mock a specific config file
+overlayVfs.mkdirSync('/config');
+overlayVfs.writeFileSync('/config/app.json', '{"env": "test"}');
+
+overlayVfs.mount(testDir);
+
+// Read mocked file
+const mockedConfig = fs.readFileSync(path.join(testDir, 'config', 'app.json'), 'utf8');
+
+// Read real file (not mocked) - should work in overlay mode
+const realFile = fs.readFileSync(path.join(testDir, 'real.txt'), 'utf8');
+
+// Test chdir to VFS directory
+overlayVfs.chdir(path.join(testDir, 'config'));
+const cwd = overlayVfs.cwd();
+
+overlayVfs.unmount();
+
+parentPort.postMessage({
+  mockedConfig,
+  realFile,
+  cwd,
+});

test/parallel/test-runner-mock-fs.js

@@ -157,7 +157,7 @@ test('mock.fs() exposes vfs property', (t) => {
 });
 
 // Test mock.fs() with dynamic file content
-// TODO(vfs): Dynamic file content (functions) not yet supported in provider-based VFS
+// TODO(vfs): Dynamic file content (functions) not yet exposed through mock.fs() API
 test('mock.fs() supports dynamic file content', { skip: true }, (t) => {
   let counter = 0;
   const mockFs = t.mock.fs({ prefix: '/dynamic-test' });

test/parallel/test-vfs-basic.js

@@ -1,7 +1,7 @@
 // Flags: --expose-internals
 'use strict';
 
-const common = require('../common');
+require('../common');
 const assert = require('assert');
 const vfs = require('node:vfs');
 
@@ -260,20 +260,6 @@ const vfs = require('node:vfs');
   assert.strictEqual(content.slice(0, 2).toString(), 'hi');
 }
 
-// Test async truncate
-{
-  const myVfs = vfs.create();
-  myVfs.writeFileSync('/async-truncate.txt', 'async content');
-
-  const fd = myVfs.openSync('/async-truncate.txt', 'r+');
-  const handle = require('internal/vfs/fd').getVirtualFd(fd);
-
-  handle.entry.truncate(5).then(common.mustCall(() => {
-    myVfs.closeSync(fd);
-    assert.strictEqual(myVfs.readFileSync('/async-truncate.txt', 'utf8'), 'async');
-  }));
-}
-
 // Test rename operation
 {
   const myVfs = vfs.create();
@@ -298,6 +284,41 @@ const vfs = require('node:vfs');
   assert.strictEqual(myVfs.readFileSync('/dest.txt', 'utf8'), 'copy me');
 }
 
+// Test appendFileSync
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/append.txt', 'hello');
+
+  myVfs.appendFileSync('/append.txt', ' world');
+  assert.strictEqual(myVfs.readFileSync('/append.txt', 'utf8'), 'hello world');
+
+  myVfs.appendFileSync('/append.txt', '!');
+  assert.strictEqual(myVfs.readFileSync('/append.txt', 'utf8'), 'hello world!');
+
+  // Append to non-existent file creates it
+  myVfs.appendFileSync('/newfile.txt', 'new content');
+  assert.strictEqual(myVfs.readFileSync('/newfile.txt', 'utf8'), 'new content');
+
+  // Append with Buffer
+  myVfs.writeFileSync('/buf-append.txt', Buffer.from('start'));
+  myVfs.appendFileSync('/buf-append.txt', Buffer.from('-buffer'));
+  assert.strictEqual(myVfs.readFileSync('/buf-append.txt', 'utf8'), 'start-buffer');
+}
+
+// Test accessSync
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/access-test.txt', 'content');
+
+  // Should not throw for existing file
+  myVfs.accessSync('/access-test.txt');
+
+  // Should throw for non-existent file
+  assert.throws(() => {
+    myVfs.accessSync('/nonexistent.txt');
+  }, { code: 'ENOENT' });
+}
+
 // Test Symbol.dispose unmounts the VFS
 {
   const myVfs = vfs.create();

test/parallel/test-vfs-chdir.js

@@ -168,9 +168,6 @@ const vfs = require('node:vfs');
 
   const originalCwd = process.cwd();
 
-  // Before chdir, process.cwd returns real cwd
-  assert.strictEqual(process.cwd(), originalCwd);
-
   // Set virtual cwd
   myVfs.chdir('/virtual/project');
   assert.strictEqual(process.cwd(), '/virtual/project');
@@ -208,9 +205,7 @@ const vfs = require('node:vfs');
 
   myVfs.unmount();
 
-  // After unmount, cwd should throw (not enabled)
-  // Actually, virtualCwdEnabled is still true, just unmounted
-  // Let's remount and check cwd is reset
+  // After remount, virtual cwd should be reset to null
   myVfs.mount('/virtual');
   assert.strictEqual(myVfs.cwd(), null);
 

test/parallel/test-vfs-import.mjs

@@ -2,6 +2,10 @@ import '../common/index.mjs';
 import assert from 'assert';
 import vfs from 'node:vfs';
 
+// NOTE: Each test uses a different mount path (/virtual, /virtual2, etc.)
+// because ESM imports are cached by URL - using the same mount path would
+// return cached modules from previous tests instead of fresh imports.
+
 // Test importing a simple virtual ES module
 {
   const myVfs = vfs.create();

test/parallel/test-vfs-overlay.js

@@ -185,48 +185,8 @@ fs.writeFileSync(path.join(testDir, 'subdir', 'nested.txt'), 'nested real');
   const { Worker, isMainThread } = require('worker_threads');
 
   if (isMainThread) {
-    // Main thread: create worker with overlay VFS test
-    const workerCode = `
-      const { workerData, parentPort } = require('worker_threads');
-      const vfs = require('node:vfs');
-      const fs = require('fs');
-      const path = require('path');
-
-      const testDir = workerData.testDir;
-
-      // In worker: create overlay VFS that mocks specific files
-      const overlayVfs = vfs.create(new vfs.MemoryProvider(), {
-        overlay: true,
-        virtualCwd: true,
-      });
-
-      // Mock a specific config file
-      overlayVfs.mkdirSync('/config');
-      overlayVfs.writeFileSync('/config/app.json', '{"env": "test"}');
-
-      overlayVfs.mount(testDir);
-
-      // Read mocked file
-      const mockedConfig = fs.readFileSync(path.join(testDir, 'config', 'app.json'), 'utf8');
-
-      // Read real file (not mocked) - should work in overlay mode
-      const realFile = fs.readFileSync(path.join(testDir, 'real.txt'), 'utf8');
-
-      // Test chdir to VFS directory
-      overlayVfs.chdir(path.join(testDir, 'config'));
-      const cwd = overlayVfs.cwd();
-
-      overlayVfs.unmount();
-
-      parentPort.postMessage({
-        mockedConfig,
-        realFile,
-        cwd,
-      });
-    `;
-
-    const worker = new Worker(workerCode, {
-      eval: true,
+    const workerPath = require.resolve('../fixtures/vfs-overlay-worker.js');
+    const worker = new Worker(workerPath, {
       workerData: { testDir },
     });
 

test/parallel/test-vfs-promises.js

@@ -1,3 +1,4 @@
+// Flags: --expose-internals
 'use strict';
 
 const common = require('../common');
@@ -268,3 +269,122 @@ const vfs = require('node:vfs');
     { code: 'ENOENT' }
   );
 })().then(common.mustCall());
+
+// Test promises.writeFile
+(async () => {
+  const myVfs = vfs.create();
+
+  await myVfs.promises.writeFile('/write-test.txt', 'async written');
+  assert.strictEqual(myVfs.readFileSync('/write-test.txt', 'utf8'), 'async written');
+
+  // Overwrite existing file
+  await myVfs.promises.writeFile('/write-test.txt', 'overwritten');
+  assert.strictEqual(myVfs.readFileSync('/write-test.txt', 'utf8'), 'overwritten');
+
+  // Write with Buffer
+  await myVfs.promises.writeFile('/buffer-write.txt', Buffer.from('buffer data'));
+  assert.strictEqual(myVfs.readFileSync('/buffer-write.txt', 'utf8'), 'buffer data');
+})().then(common.mustCall());
+
+// Test promises.appendFile
+(async () => {
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/append-test.txt', 'start');
+
+  await myVfs.promises.appendFile('/append-test.txt', '-end');
+  assert.strictEqual(myVfs.readFileSync('/append-test.txt', 'utf8'), 'start-end');
+
+  // Append to non-existent file creates it
+  await myVfs.promises.appendFile('/new-append.txt', 'new content');
+  assert.strictEqual(myVfs.readFileSync('/new-append.txt', 'utf8'), 'new content');
+})().then(common.mustCall());
+
+// Test promises.mkdir
+(async () => {
+  const myVfs = vfs.create();
+
+  await myVfs.promises.mkdir('/async-dir');
+  const stat = myVfs.statSync('/async-dir');
+  assert.strictEqual(stat.isDirectory(), true);
+
+  // Recursive mkdir
+  await myVfs.promises.mkdir('/async-dir/nested/deep', { recursive: true });
+  assert.strictEqual(myVfs.statSync('/async-dir/nested/deep').isDirectory(), true);
+
+  // Mkdir on existing directory throws without recursive
+  await assert.rejects(
+    myVfs.promises.mkdir('/async-dir'),
+    { code: 'EEXIST' }
+  );
+})().then(common.mustCall());
+
+// Test promises.unlink
+(async () => {
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/unlink-test.txt', 'to delete');
+
+  await myVfs.promises.unlink('/unlink-test.txt');
+  assert.strictEqual(myVfs.existsSync('/unlink-test.txt'), false);
+
+  await assert.rejects(
+    myVfs.promises.unlink('/nonexistent.txt'),
+    { code: 'ENOENT' }
+  );
+})().then(common.mustCall());
+
+// Test promises.rmdir
+(async () => {
+  const myVfs = vfs.create();
+  myVfs.mkdirSync('/rmdir-test');
+
+  await myVfs.promises.rmdir('/rmdir-test');
+  assert.strictEqual(myVfs.existsSync('/rmdir-test'), false);
+
+  // Rmdir on non-empty directory throws
+  myVfs.mkdirSync('/nonempty');
+  myVfs.writeFileSync('/nonempty/file.txt', 'content');
+  await assert.rejects(
+    myVfs.promises.rmdir('/nonempty'),
+    { code: 'ENOTEMPTY' }
+  );
+})().then(common.mustCall());
+
+// Test promises.rename
+(async () => {
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/rename-src.txt', 'rename me');
+
+  await myVfs.promises.rename('/rename-src.txt', '/rename-dest.txt');
+  assert.strictEqual(myVfs.existsSync('/rename-src.txt'), false);
+  assert.strictEqual(myVfs.readFileSync('/rename-dest.txt', 'utf8'), 'rename me');
+})().then(common.mustCall());
+
+// Test promises.copyFile
+(async () => {
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/copy-src.txt', 'copy me');
+
+  await myVfs.promises.copyFile('/copy-src.txt', '/copy-dest.txt');
+  assert.strictEqual(myVfs.readFileSync('/copy-dest.txt', 'utf8'), 'copy me');
+  // Source still exists
+  assert.strictEqual(myVfs.existsSync('/copy-src.txt'), true);
+
+  await assert.rejects(
+    myVfs.promises.copyFile('/nonexistent.txt', '/fail.txt'),
+    { code: 'ENOENT' }
+  );
+})().then(common.mustCall());
+
+// Test async truncate (via file handle)
+(async () => {
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/truncate-test.txt', 'async content');
+
+  const fd = myVfs.openSync('/truncate-test.txt', 'r+');
+  const { getVirtualFd } = require('internal/vfs/fd');
+  const handle = getVirtualFd(fd);
+
+  await handle.entry.truncate(5);
+  myVfs.closeSync(fd);
+  assert.strictEqual(myVfs.readFileSync('/truncate-test.txt', 'utf8'), 'async');
+})().then(common.mustCall());