@zenfs/core 2.6.2 → 2.6.4

package/tests/common.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { fs as defaultFS } from '@zenfs/core';
-import type { NodeFS } from '@zenfs/core/node/types.js';
+import type { NodeFS } from '@zenfs/core/node/types';
 import { join, resolve } from 'node:path';
 import { styleText } from 'node:util';
 import { setupLogs } from './logs.js';
@@ -41,7 +41,9 @@ export type TestFlag =
 	| 'xattr'
 	| 'times'
 	| 'tempdir'
-	| 'lchmod';
+	| 'lchmod'
+	| 'promises.exists'
+	| 'root';
 
 /**
  * Whether a backend supports a flag.

package/tests/fetch/fetch.ts

@@ -1,6 +1,6 @@
 import { configure, Fetch } from '@zenfs/core';
 import { log } from 'kerium';
-import type { TestFlag, TestFlagState } from '../common.js';
+import type { TestFlag, TestFlagState } from '../common.ts';
 import { baseUrl } from './config.js';
 
 await configure({

package/tests/fetch/run.sh

@@ -12,6 +12,6 @@ until nc -z localhost 26514; do
   sleep 0.25
 done
 
-npx --silent zenfs-test $SCRIPT_DIR/fetch.ts --preserve --force "$@"
+npx --silent zenfs-test $SCRIPT_DIR/fetch.ts --preserve --force --node "$@"
 
 kill $PID

package/tests/fs/append.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs, config } from '../common.js';
+import { fs, config } from '../common.ts';
 
 const content = 'Sample content',
 	original = 'ABCD';

package/tests/fs/concurrency.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Concurrency', config('write', 'async'), () => {
 	test('parallel writeFile in the same directory does not lose entries #256', async () => {

package/tests/fs/dir.test.ts

@@ -2,7 +2,7 @@
 import { sync, type Dirent } from '@zenfs/core';
 import assert, { rejects } from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const testFile = 'test-file.txt';
 fs.writeFileSync(testFile, 'Sample content');

package/tests/fs/directory.test.ts

@@ -2,7 +2,7 @@
 import assert from 'node:assert/strict';
 import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const testDir = 'test-dir';
 const testFiles = ['file1.txt', 'file2.txt', 'file3.txt'];
@@ -22,7 +22,7 @@ for (const dir of testDirectories) {
 suite('Directories', config('directories'), () => {
 	test('mkdir', config('async'), async () => {
 		await fs.promises.mkdir('/one', 0o755);
-		assert(await fs.promises.exists('/one'));
+		assert(await fs.promises.stat('/one', { throwIfNoEntry: false }));
 		await assert.rejects(fs.promises.mkdir('/one', 0o755), { code: 'EEXIST' });
 	});
 
@@ -30,7 +30,7 @@ suite('Directories', config('directories'), () => {
 
 	test('mkdir, nested', config('async'), async () => {
 		await assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested/dir' });
-		assert(!(await fs.promises.exists('/nested/dir')));
+		assert(!(await fs.promises.stat('/nested/dir', { throwIfNoEntry: false })));
 	});
 
 	test('mkdir, recursive', config('async'), async () => {

package/tests/fs/errors.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import test, { suite } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const existingFile = '/exit.js';
 const path = '/non-existent';

package/tests/fs/exists.test.ts

@@ -1,17 +1,17 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('exists', () => {
 	const f = 'x.txt';
 
-	test('return true for an existing file', config('async'), async () => {
+	test('return true for an existing file', config('async', 'promises.exists'), async () => {
 		const exists = await fs.promises.exists(f);
 		assert(exists);
 	});
 
-	test('return false for a non-existent file', config('async'), async () => {
+	test('return false for a non-existent file', config('async', 'promises.exists'), async () => {
 		const exists = await fs.promises.exists(f + '-NO');
 		assert(!exists);
 	});

package/tests/fs/links.test.ts

@@ -2,7 +2,7 @@
 import { join } from '@zenfs/core/path';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Links', config('symlinks'), () => {
 	const target = '/a1.js',
@@ -64,8 +64,8 @@ suite('Links', config('symlinks'), () => {
 
 	test('unlink', async () => {
 		await fs.promises.unlink(symlink);
-		assert(!(await fs.promises.exists(symlink)));
-		assert(await fs.promises.exists(target));
+		assert(!(await fs.promises.stat(symlink, { throwIfNoEntry: false })));
+		assert(await fs.promises.stat(target, { throwIfNoEntry: false }));
 	});
 
 	test('link', config('links'), async () => {
@@ -99,7 +99,7 @@ suite('Links', config('symlinks'), () => {
 		// A link pointing at a directory satisfies a recursive mkdir and is left as a link
 		assert.equal(await fs.promises.mkdir('/mkdir-link', { recursive: true }), undefined);
 		assert((await fs.promises.lstat('/mkdir-link')).isSymbolicLink());
-		assert(!(await fs.promises.exists('/mkdir-missing')));
+		assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
 	});
 
 	test('mkdir follows symlinks for intermediate components', config('async'), async () => {
@@ -113,7 +113,7 @@ suite('Links', config('symlinks'), () => {
 
 		// Node reports the link itself here, unlike `mkdirSync` which reports the requested path with ENOENT
 		await assert.rejects(fs.promises.mkdir('/mkdir-dangling/x', { recursive: true }), { code: 'ENOTDIR', path: '/mkdir-dangling' });
-		assert(!(await fs.promises.exists('/mkdir-missing')));
+		assert(!(await fs.promises.stat('/mkdir-missing', { throwIfNoEntry: false })));
 	});
 
 	test('mkdirSync does not follow a symlink at the final component', config('sync'), () => {

package/tests/fs/open.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Opening files', () => {
 	const filename = 'a.js';
@@ -12,12 +12,12 @@ suite('Opening files', () => {
 	});
 
 	test('open file with mode "r"', config('async'), async () => {
-		const { fd } = await fs.promises.open(filename, 'r');
-		assert(fd >= -Infinity);
+		await using handle = await fs.promises.open(filename, 'r');
+		assert(handle.fd >= -Infinity);
 	});
 
 	test('open file with mode "rs"', config('async'), async () => {
-		const { fd } = await fs.promises.open(filename, 'rs');
-		assert(fd >= -Infinity);
+		await using handle = await fs.promises.open(filename, 'rs');
+		assert(handle.fd >= -Infinity);
 	});
 });

package/tests/fs/permissions.test.ts

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { R_OK, W_OK, X_OK } from '@zenfs/core/constants';
-import { defaultContext } from '@zenfs/core/internal/contexts.js';
-import { hasAccess } from '@zenfs/core/internal/inode.js';
+import { defaultContext } from '@zenfs/core/internal/contexts';
+import { hasAccess } from '@zenfs/core/internal/inode';
 import { join } from '@zenfs/core/path';
 import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { encodeUTF8 } from 'utilium';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const asyncMode = 0o777;
 const syncMode = 0o644;
@@ -25,7 +25,7 @@ suite('Permissions', config('permissions'), () => {
 	});
 
 	test('fchmod', config('sync', 'async'), async () => {
-		const handle = await fs.promises.open(file, 'a', 0o644);
+		await using handle = await fs.promises.open(file, 'a', 0o644);
 
 		await handle.chmod(asyncMode);
 		const stats = await handle.stat();
@@ -58,7 +58,7 @@ suite('Permissions', config('permissions'), () => {
 
 		function checkError(access: number) {
 			return function (error: Exception) {
-				assert(error instanceof Error);
+				assert(Error.isError(error));
 				assert(!hasAccess(defaultContext, stats!, access));
 			};
 		}

package/tests/fs/read.test.ts

@@ -5,7 +5,7 @@ import assert from 'node:assert/strict';
 import type { OpenMode, PathLike } from 'node:fs';
 import { suite, test } from 'node:test';
 import { promisify } from 'node:util';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
@@ -13,7 +13,7 @@ const ellipses = '…'.repeat(10_000);
 
 suite('read', () => {
 	test('read file asynchronously', config('async'), async () => {
-		const handle = await fs.promises.open(filepath, 'r');
+		await using handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
 		assert.equal(bytesRead, expected.length);
 		assert.equal(buffer.toString(), expected);
@@ -46,7 +46,7 @@ suite('read', () => {
 	const bufferSync = Buffer.alloc(expected.length);
 
 	test('read file from handle asynchronously', config('async'), async () => {
-		const handle = await fs.promises.open(filepath, 'r');
+		await using handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
 		assert.equal(bytesRead, expected.length);

package/tests/fs/readFile.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Reading', () => {
 	test('Cannot read a file with an invalid encoding', config('sync'), () => {
@@ -9,7 +9,7 @@ suite('Reading', () => {
 	});
 
 	test('Reading past the end of a file should not be an error', config('async'), async () => {
-		const handle = await fs.promises.open('a.js', 'r');
+		await using handle = await fs.promises.open('a.js', 'r');
 		const { bytesRead } = await handle.read(new Uint8Array(10), 0, 10, 10000);
 		assert.equal(bytesRead, 0);
 	});

package/tests/fs/rename.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Rename', config('rename'), () => {
 	/**
@@ -26,8 +26,8 @@ suite('Rename', config('rename'), () => {
 		const subContents = await fs.promises.readdir(dir + '/_rename_me');
 		assert.equal(subContents.length, 1);
 
-		assert(await fs.promises.exists(dir + '/file.dat'));
-		assert(await fs.promises.exists(dir + '/_rename_me/lol.txt'));
+		assert(await fs.promises.stat(dir + '/file.dat', { throwIfNoEntry: false }));
+		assert(await fs.promises.stat(dir + '/_rename_me/lol.txt', { throwIfNoEntry: false }));
 	}
 
 	test('rename directory', config('async'), async () => {
@@ -46,7 +46,7 @@ suite('Rename', config('rename'), () => {
 
 		await check_directory(newDir);
 
-		assert(!(await fs.promises.exists(oldDir)));
+		assert(!(await fs.promises.stat(oldDir, { throwIfNoEntry: false })));
 
 		await fs.promises.mkdir(oldDir);
 		await populate(oldDir);
@@ -67,7 +67,7 @@ suite('Rename', config('rename'), () => {
 		await fs.promises.rename(one, two);
 
 		assert.equal(await fs.promises.readFile(two, 'utf8'), 'hey');
-		assert(!(await fs.promises.exists(one)));
+		assert(!(await fs.promises.stat(one, { throwIfNoEntry: false })));
 	});
 
 	test('File to Directory and Directory to File Rename', config('sync', 'async'), async () => {

package/tests/fs/scaling.test.ts

@@ -2,7 +2,7 @@
 import { sync } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const n_files = 130;
 const huge_size = 0x1000000;

package/tests/fs/stat.test.ts

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { defaultContext, hasAccess } from '@zenfs/core';
+import { defaultContext, hasAccess, type Stats } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Stats', () => {
 	const existing_file = 'x.txt';
@@ -35,7 +35,7 @@ suite('Stats', () => {
 		fs.close(fd);
 	});
 
-	test('hasAccess for non-root access', config('sync', 'permissions'), () => {
+	test('hasAccess for non-root access', config('sync', 'permissions', 'root'), () => {
 		const newFile = 'new.txt';
 
 		fs.writeFileSync(newFile, 'hello', { mode: 0o640 });
@@ -72,6 +72,35 @@ suite('Stats', () => {
 		Object.assign(defaultContext.credentials, prevCredentials);
 	});
 
+	const missing = '/does-not-exist';
+
+	test('statSync throws for a missing entry', config('sync'), () => {
+		assert.throws(() => fs.statSync(missing), { code: 'ENOENT' });
+		assert.throws(() => fs.statSync(missing, { throwIfNoEntry: true }), { code: 'ENOENT' });
+	});
+
+	test('statSync with throwIfNoEntry: false', config('sync'), () => {
+		assert.equal(fs.statSync(missing, { throwIfNoEntry: false }), undefined);
+		assert.equal(fs.statSync(existing_file + '/nope', { throwIfNoEntry: false }), undefined);
+	});
+
+	test('lstatSync with throwIfNoEntry: false', config('sync'), () => {
+		assert.throws(() => fs.lstatSync(missing), { code: 'ENOENT' });
+		assert.equal(fs.lstatSync(missing, { throwIfNoEntry: false }), undefined);
+	});
+
+	test('stat with throwIfNoEntry: false', config('async'), async () => {
+		await assert.rejects(fs.promises.stat(missing), { code: 'ENOENT' });
+		assert.equal(await fs.promises.stat(missing, { throwIfNoEntry: false }), undefined);
+		assert.equal(await fs.promises.stat(existing_file + '/nope', { throwIfNoEntry: false }), undefined);
+	});
+
+	test('stat callback with throwIfNoEntry: false', config('async'), async () => {
+		const { promise, resolve, reject } = Promise.withResolvers<Stats | undefined>();
+		fs.stat(missing, { throwIfNoEntry: false }, (error, stats) => (error ? reject(error) : resolve(stats)));
+		assert.equal(await promise, undefined);
+	});
+
 	test('stat file', config('async'), async () => {
 		const stats = await fs.promises.stat(existing_file);
 		assert(!stats.isDirectory());

package/tests/fs/streams.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 // Top-level initialization
 const testFilePath = 'test-file.txt';

package/tests/fs/tempdir.test.ts

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { test, suite } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 import assert from 'node:assert/strict';
 import { basename } from 'node:path/posix';
 

package/tests/fs/times.test.ts

@@ -4,7 +4,7 @@ import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const path = 'x.txt';
 
@@ -33,7 +33,7 @@ suite('Times', config('times'), () => {
 		assert.deepEqual(unixTimestamps(await fs.promises.stat(path)), times);
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: Exception) => {
-			assert(error instanceof Error);
+			assert(Error.isError(error));
 			assert.equal(error.code, 'ENOENT');
 		});
 

package/tests/fs/truncate.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const path: string = 'truncate-file.txt',
 	size = 1024 * 16,

package/tests/fs/watch.test.ts

@@ -2,7 +2,7 @@
 import type { Stats } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 const testDir = '/test-watch-dir';
 const testFile = testDir + '/test.txt';

package/tests/fs/write.test.ts

@@ -3,8 +3,8 @@ import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
-import { data as dataPath } from '../setup.js';
+import { config, fs } from '../common.ts';
+import { data as dataPath } from '../setup.ts';
 
 const fileName = 'write.txt';
 const utf8example = readFileSync(join(dataPath, 'utf8.txt'), 'utf8');

package/tests/fs/xattr.test.ts

@@ -2,7 +2,7 @@
 import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { config, fs } from '../common.js';
+import { config, fs } from '../common.ts';
 
 suite('Extended Attributes', config('xattr'), () => {
 	const testFile = 'xattr-test.txt';

package/tests/{native/setup.ts → native-setup.ts}

@@ -2,11 +2,12 @@
 /* Run the FS test suite against native node:fs.
 Since the tests use absolute paths, everything is contained to a scratch directory using chroot-style path mapping. */
 import * as native from 'node:fs';
-import type { TestFlag, TestFlagState } from '../common.js';
+import type { TestFlag, TestFlagState } from './common.ts';
 import { isAbsolute, join, relative, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { copySync, data, tmp } from '../setup.js';
+import { copySync, data, tmp } from './setup.ts';
 import { styleText } from 'node:util';
+import { isRoot } from 'utilium/node';
 
 // The tests assume modes are used as-is, but native fs applies the process umask
 process.umask(0);
@@ -205,9 +206,6 @@ for (const [key, value] of Object.entries(native.promises)) {
 promises.watch = (...args: Parameters<typeof native.promises.watch>) =>
 	native.promises.watch(...(mapArgs('watch', args) as Parameters<typeof native.promises.watch>));
 
-// ZenFS API extension
-promises.exists = (path: PathLike) => Promise.resolve(native.existsSync(toNative(path)));
-
 wrapped.promises = promises;
 
 export const fs = wrapped as unknown as typeof native;
@@ -220,6 +218,8 @@ export const flags: Partial<Record<TestFlag, TestFlagState>> = {
 	lchmod: process.platform == 'darwin',
 	// The suite uses ZenFS' own extended attribute API, which `node:fs` does not have
 	xattr: false,
+	'promises.exists': false,
+	root: isRoot || 'skip',
 };
 
 copySync(data, fs);

package/tests/setup/context.ts

@@ -1,5 +1,5 @@
 import { fs as _fs, bindContext } from '@zenfs/core';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 _fs.mkdirSync('/new_root');
 

package/tests/setup/cow.ts

@@ -1,5 +1,5 @@
 import { configureSingle, CopyOnWrite, fs, InMemory, resolveMountConfig } from '@zenfs/core';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 fs.umount('/');
 const readable = await resolveMountConfig({ backend: InMemory, label: 'ro' });

package/tests/setup/index.ts

@@ -2,7 +2,7 @@ import { readFileSync } from 'node:fs';
 import { join } from 'node:path/posix';
 import { configureSingle, CopyOnWrite, InMemory, InMemoryStore, mounts, Readonly, StoreFS } from '@zenfs/core';
 import { S_IFDIR } from '@zenfs/core/constants';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 copySync(data);
 

package/tests/setup/memory.ts

@@ -1,3 +1,3 @@
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 copySync(data);

package/tests/setup/port.ts

@@ -1,7 +1,7 @@
 import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount, sync } from '@zenfs/core';
 import { after, afterEach } from 'node:test';
 import { MessageChannel } from 'node:worker_threads';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 const { port1: localPort, port2: remotePort } = new MessageChannel();
 

package/tests/setup/single-buffer.ts

@@ -1,5 +1,5 @@
 import { SingleBuffer, configureSingle } from '@zenfs/core';
-import { copySync, data } from '../setup.js';
+import { copySync, data } from '../setup.ts';
 
 await configureSingle({
 	backend: SingleBuffer,

package/tests/setup.ts

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { fs as _fs } from '@zenfs/core';
+import type { NodeFS } from '@zenfs/core/node/types';
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import type { NodeFS } from '@zenfs/core/node/types.js';
 
 export const data = join(import.meta.dirname, 'data');
 

package/tests/tsconfig.json

@@ -7,7 +7,8 @@
 		"esModuleInterop": true,
 		"allowSyntheticDefaultImports": true,
 		"allowJs": true,
-		"rootDir": ".."
+		"rootDir": "..",
+		"allowImportingTsExtensions": true
 	},
 	"include": ["**/*.ts", "*.ts", "**/*.js", "../types/uint8array.d.ts"]
 }

package/tests/native/run.sh

@@ -1,3 +0,0 @@
-#!/usr/bin/env bash
-
-sudo npx zenfs-test -v tests/native/setup.ts