test: add VFS internals coverage tests

Add tests for internal VFS utility functions and provider base class
to improve code coverage:
- router.js: splitPath, getParentPath, getBaseName
- provider.js: readonly EROFS checks for all write operations
- provider.js: ERR_METHOD_NOT_IMPLEMENTED for unimplemented methods

PR-URL: #61478

Author: mcollina

test/parallel/test-vfs-internals.js

@@ -0,0 +1,151 @@
+// Flags: --expose-internals
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+// Test internal VFS utility functions for coverage.
+
+// === Router utility functions ===
+const {
+  splitPath,
+  getParentPath,
+  getBaseName,
+  isUnderMountPoint,
+  getRelativePath,
+  isAbsolutePath,
+} = require('internal/vfs/router');
+
+// splitPath
+assert.deepStrictEqual(splitPath('/'), []);
+assert.deepStrictEqual(splitPath('/foo'), ['foo']);
+assert.deepStrictEqual(splitPath('/foo/bar'), ['foo', 'bar']);
+assert.deepStrictEqual(splitPath('/a/b/c/d'), ['a', 'b', 'c', 'd']);
+
+// getParentPath
+assert.strictEqual(getParentPath('/'), null);
+assert.strictEqual(getParentPath('/foo'), '/');
+assert.strictEqual(getParentPath('/foo/bar'), '/foo');
+assert.strictEqual(getParentPath('/a/b/c'), '/a/b');
+
+// getBaseName
+assert.strictEqual(getBaseName('/foo'), 'foo');
+assert.strictEqual(getBaseName('/foo/bar'), 'bar');
+assert.strictEqual(getBaseName('/a/b/c.txt'), 'c.txt');
+
+// isAbsolutePath
+assert.strictEqual(isAbsolutePath('/foo'), true);
+assert.strictEqual(isAbsolutePath('foo'), false);
+assert.strictEqual(isAbsolutePath('./foo'), false);
+
+// isUnderMountPoint (already tested indirectly but exercised here directly)
+assert.strictEqual(isUnderMountPoint('/mount', '/mount'), true);
+assert.strictEqual(isUnderMountPoint('/mount/file', '/mount'), true);
+assert.strictEqual(isUnderMountPoint('/mountx', '/mount'), false);
+assert.strictEqual(isUnderMountPoint('/other', '/mount'), false);
+// Root mount point
+assert.strictEqual(isUnderMountPoint('/anything', '/'), true);
+
+// getRelativePath
+assert.strictEqual(getRelativePath('/mount', '/mount'), '/');
+assert.strictEqual(getRelativePath('/mount/file.js', '/mount'), '/file.js');
+assert.strictEqual(getRelativePath('/mount/a/b', '/mount'), '/a/b');
+// Root mount point
+assert.strictEqual(getRelativePath('/foo/bar', '/'), '/foo/bar');
+
+// === Provider base class readonly checks ===
+const { VirtualProvider } = require('internal/vfs/provider');
+
+class ReadonlyProvider extends VirtualProvider {
+  get readonly() { return true; }
+}
+
+const readonlyProvider = new ReadonlyProvider();
+
+// All write operations should throw EROFS when readonly
+assert.throws(() => readonlyProvider.mkdirSync('/dir'), { code: 'EROFS' });
+assert.throws(() => readonlyProvider.rmdirSync('/dir'), { code: 'EROFS' });
+assert.throws(() => readonlyProvider.unlinkSync('/file'), { code: 'EROFS' });
+assert.throws(() => readonlyProvider.renameSync('/a', '/b'), { code: 'EROFS' });
+assert.throws(() => readonlyProvider.writeFileSync('/f', 'data'), { code: 'EROFS' });
+assert.throws(() => readonlyProvider.appendFileSync('/f', 'data'), { code: 'EROFS' });
+assert.throws(() => readonlyProvider.copyFileSync('/a', '/b'), { code: 'EROFS' });
+assert.throws(() => readonlyProvider.symlinkSync('/target', '/link'), { code: 'EROFS' });
+
+// Async versions
+assert.rejects(readonlyProvider.mkdir('/dir'), { code: 'EROFS' }).then(common.mustCall());
+assert.rejects(readonlyProvider.rmdir('/dir'), { code: 'EROFS' }).then(common.mustCall());
+assert.rejects(readonlyProvider.unlink('/file'), { code: 'EROFS' }).then(common.mustCall());
+assert.rejects(readonlyProvider.rename('/a', '/b'), { code: 'EROFS' }).then(common.mustCall());
+assert.rejects(readonlyProvider.writeFile('/f', 'data'), { code: 'EROFS' }).then(common.mustCall());
+assert.rejects(readonlyProvider.appendFile('/f', 'data'), { code: 'EROFS' }).then(common.mustCall());
+assert.rejects(readonlyProvider.copyFile('/a', '/b'), { code: 'EROFS' }).then(common.mustCall());
+assert.rejects(readonlyProvider.symlink('/target', '/link'), { code: 'EROFS' }).then(common.mustCall());
+
+// === Provider base class ERR_METHOD_NOT_IMPLEMENTED for non-readonly ===
+const baseProvider = new VirtualProvider();
+
+// These should throw ERR_METHOD_NOT_IMPLEMENTED (not readonly, just unimplemented)
+assert.throws(() => baseProvider.mkdirSync('/dir'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.rmdirSync('/dir'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.unlinkSync('/file'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.renameSync('/a', '/b'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.symlinkSync('/t', '/l'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.readdirSync('/dir'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.readlinkSync('/link'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.watch('/path'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.watchAsync('/path'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.watchFile('/path'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+assert.throws(() => baseProvider.unwatchFile('/path'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' });
+
+// Async unimplemented methods
+assert.rejects(baseProvider.mkdir('/dir'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' }).then(common.mustCall());
+assert.rejects(baseProvider.rmdir('/dir'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' }).then(common.mustCall());
+assert.rejects(baseProvider.unlink('/file'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' }).then(common.mustCall());
+assert.rejects(baseProvider.rename('/a', '/b'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' }).then(common.mustCall());
+assert.rejects(baseProvider.readlink('/link'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' }).then(common.mustCall());
+assert.rejects(baseProvider.symlink('/t', '/l'), { code: 'ERR_METHOD_NOT_IMPLEMENTED' }).then(common.mustCall());
+
+// === Provider default implementations via VFS (covers realpath, access, exists, etc.) ===
+const vfs = require('node:vfs');
+
+{
+  const myVfs = vfs.create();
+  myVfs.writeFileSync('/file.txt', 'hello');
+  myVfs.mkdirSync('/dir');
+  myVfs.mount('/internals-test');
+
+  // realpath (default provider impl returns path as-is after stat check)
+  assert.strictEqual(myVfs.realpathSync('/internals-test/file.txt'), '/internals-test/file.txt');
+  assert.strictEqual(myVfs.realpathSync('/internals-test/dir'), '/internals-test/dir');
+
+  // realpath for non-existent path should throw
+  assert.throws(() => myVfs.realpathSync('/internals-test/nonexistent'), { code: 'ENOENT' });
+
+  // access (default provider impl just checks stat)
+  myVfs.accessSync('/internals-test/file.txt');
+  assert.throws(() => myVfs.accessSync('/internals-test/nonexistent'), { code: 'ENOENT' });
+
+  // existsSync
+  assert.strictEqual(myVfs.existsSync('/internals-test/file.txt'), true);
+  assert.strictEqual(myVfs.existsSync('/internals-test/nonexistent'), false);
+  assert.strictEqual(myVfs.existsSync('/internals-test/dir'), true);
+
+  // internalModuleStat (0 = file, 1 = dir, -2 = not found)
+  assert.strictEqual(myVfs.internalModuleStat('/internals-test/file.txt'), 0);
+  assert.strictEqual(myVfs.internalModuleStat('/internals-test/dir'), 1);
+  assert.strictEqual(myVfs.internalModuleStat('/internals-test/nope'), -2);
+
+  // Callback-based realpath (returns mounted path)
+  myVfs.realpath('/internals-test/file.txt', common.mustCall((err, resolved) => {
+    assert.ifError(err);
+    assert.ok(resolved);
+  }));
+
+  // Callback-based access
+  myVfs.access('/internals-test/file.txt', common.mustCall((err) => {
+    assert.ifError(err);
+  }));
+
+  myVfs.unmount();
+}