@zenfs/core 2.5.8 → 2.6.1

package/tests/fs/readFile.test.ts

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 suite('Reading', () => {
-	test('Cannot read a file with an invalid encoding', () => {
+	test('Cannot read a file with an invalid encoding', config('sync'), () => {
 		assert.throws(() => fs.readFileSync('a.js', 'wrong-encoding' as BufferEncoding));
 	});
 
-	test('Reading past the end of a file should not be an error', async () => {
+	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');
 		const { bytesRead } = await handle.read(new Uint8Array(10), 0, 10, 10000);
 		assert.equal(bytesRead, 0);
@@ -18,35 +18,35 @@ suite('Reading', () => {
 	const file = 'test-readfile-unlink/test.bin';
 	const data = new Uint8Array(512).fill(42);
 
-	test('create directory and write file', async () => {
+	test('create directory and write file', config('async', 'write', 'directories'), async () => {
 		await fs.promises.mkdir(dir);
 		await fs.promises.writeFile(file, data);
 	});
 
-	test('read file and verify its content', async () => {
+	test('read file and verify its content', config('async'), async () => {
 		const read: Uint8Array = await fs.promises.readFile(file);
 		assert.equal(read.length, data.length);
 		assert.equal(read[0], 42);
 	});
 
-	test('unlink file and remove directory', async () => {
+	test('unlink file and remove directory', config('async', 'write', 'directories'), async () => {
 		await fs.promises.unlink(file);
 		await fs.promises.rmdir(dir);
 	});
 
 	const fileName = 'empty.txt';
 
-	test('read file', async () => {
+	test('read file', config('sync', 'async'), async () => {
 		assert.equal((await fs.promises.readFile(fileName)).toString(), '');
 		assert.equal(fs.readFileSync(fileName).toString(), '');
 	});
 
-	test('read file with utf-8 encoding', async () => {
+	test('read file with utf-8 encoding', config('sync', 'async'), async () => {
 		assert.equal(await fs.promises.readFile(fileName, 'utf8'), '');
 		assert.equal(fs.readFileSync(fileName, 'utf8'), '');
 	});
 
-	test('read file synchronously and verify the content', () => {
+	test('read file synchronously and verify the content', config('sync'), () => {
 		const content = fs.readFileSync('elipses.txt', 'utf8');
 
 		assert.equal(content.length, 10000);

package/tests/fs/rename.test.ts

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
-suite('Rename', () => {
+suite('Rename', config('rename'), () => {
 	/**
 	 * Creates the following directory structure within `dir`:
 	 * - _rename_me
@@ -30,7 +30,7 @@ suite('Rename', () => {
 		assert(await fs.promises.exists(dir + '/_rename_me/lol.txt'));
 	}
 
-	test('rename directory', async () => {
+	test('rename directory', config('async'), async () => {
 		const oldDir = '/rename_test';
 		const newDir = '/rename_test2';
 
@@ -53,7 +53,7 @@ suite('Rename', () => {
 		await fs.promises.rename(oldDir, newDir + '/newDir');
 	});
 
-	test('rename file', async () => {
+	test('rename file', config('async'), async () => {
 		const dir = '/rename_file_test';
 		const one = dir + '/fun.js';
 		const two = dir + '/fun2.js';
@@ -70,7 +70,7 @@ suite('Rename', () => {
 		assert(!(await fs.promises.exists(one)));
 	});
 
-	test('File to Directory and Directory to File Rename', async () => {
+	test('File to Directory and Directory to File Rename', config('sync', 'async'), async () => {
 		const dir = '/rename_file_dir_test';
 		const file = '/rename_file_dir_test.txt';
 
@@ -81,13 +81,13 @@ suite('Rename', () => {
 		assert.throws(() => fs.renameSync(file, dir), { code: 'EISDIR' });
 	});
 
-	test('rename directory inside itself', async () => {
+	test('rename directory inside itself', config('sync', 'async'), async () => {
 		const renDir1 = '/rename_dir_1';
 		const renDir2 = '/rename_dir_1/lol';
 
 		await fs.promises.mkdir(renDir1);
 
-		await assert.rejects(fs.promises.rename(renDir1, renDir2), { code: 'EBUSY' });
-		assert.throws(() => fs.renameSync(renDir1, renDir2), { code: 'EBUSY' });
+		await assert.rejects(fs.promises.rename(renDir1, renDir2), { code: 'EINVAL' });
+		assert.throws(() => fs.renameSync(renDir1, renDir2), { code: 'EINVAL' });
 	});
 });

package/tests/fs/scaling.test.ts

@@ -2,14 +2,14 @@
 import { sync } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const n_files = 130;
 const huge_size = 0x1000000;
 
 // Tests for having a lot of various things (number of inodes/files, individual file size, etc.).
-suite('Scaling', () => {
-	test('Lots of inodes/files', async () => {
+suite('Scaling', config('write'), () => {
+	test('Lots of inodes/files', config('sync', 'async'), async () => {
 		fs.mkdirSync('/n');
 
 		for (let i = 0; i < n_files; i++) {
@@ -28,7 +28,7 @@ suite('Scaling', () => {
 		await Promise.all(results);
 	});
 
-	test('Singular file size', () => {
+	test('Singular file size', config('sync'), () => {
 		fs.writeFileSync('/huge', new Uint8Array(huge_size));
 		assert.equal(fs.statSync('/huge').size, huge_size);
 	});

package/tests/fs/stat.test.ts

@@ -1,41 +1,41 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { defaultContext, Stats } from '@zenfs/core';
+import { defaultContext, hasAccess } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 suite('Stats', () => {
 	const existing_file = 'x.txt';
 
-	test('stat empty path', async () => {
+	test('stat empty path', config('async'), async () => {
 		await assert.rejects(fs.promises.stat(''));
 	});
 
-	test('stat directory', async () => {
+	test('stat directory', config('async'), async () => {
 		const stats = await fs.promises.stat('/');
-		assert(stats instanceof Stats);
+		assert(stats instanceof fs.Stats);
 	});
 
-	test('lstat directory', async () => {
+	test('lstat directory', config('async'), async () => {
 		const stats = await fs.promises.lstat('/');
-		assert(stats instanceof Stats);
+		assert(stats instanceof fs.Stats);
 	});
 
-	test('FileHandle.stat', async () => {
+	test('FileHandle.stat', config('async'), async () => {
 		const handle = await fs.promises.open(existing_file, 'r');
 		const stats = await handle.stat();
-		assert(stats instanceof Stats);
+		assert(stats instanceof fs.Stats);
 		await handle.close();
 	});
 
-	test('fstatSync file', () => {
+	test('fstatSync file', config('sync'), () => {
 		const fd = fs.openSync(existing_file, 'r');
 		const stats = fs.fstatSync(fd);
-		assert(stats instanceof Stats);
+		assert(stats instanceof fs.Stats);
 		fs.close(fd);
 	});
 
-	test('hasAccess for non-root access', () => {
+	test('hasAccess for non-root access', config('sync', 'permissions'), () => {
 		const newFile = 'new.txt';
 
 		fs.writeFileSync(newFile, 'hello', { mode: 0o640 });
@@ -58,21 +58,21 @@ suite('Stats', () => {
 
 		assert.equal(stat.gid, nonRootCredentials.gid);
 		assert.equal(stat.uid, 0);
-		assert.equal(stat.hasAccess(fs.constants.R_OK), true);
-		assert.equal(stat.hasAccess(fs.constants.W_OK), false);
-		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
+		assert.equal(hasAccess(defaultContext, stat, fs.constants.R_OK), true);
+		assert.equal(hasAccess(defaultContext, stat, fs.constants.W_OK), false);
+		assert.equal(hasAccess(defaultContext, stat, fs.constants.X_OK), false);
 		// changing group
 
 		Object.assign(defaultContext.credentials, { ...nonRootCredentials, gid: 44 });
 
-		assert.equal(stat.hasAccess(fs.constants.R_OK), false);
-		assert.equal(stat.hasAccess(fs.constants.W_OK), false);
-		assert.equal(stat.hasAccess(fs.constants.X_OK), false);
+		assert.equal(hasAccess(defaultContext, stat, fs.constants.R_OK), false);
+		assert.equal(hasAccess(defaultContext, stat, fs.constants.W_OK), false);
+		assert.equal(hasAccess(defaultContext, stat, fs.constants.X_OK), false);
 
 		Object.assign(defaultContext.credentials, prevCredentials);
 	});
 
-	test('stat file', async () => {
+	test('stat file', config('async'), async () => {
 		const stats = await fs.promises.stat(existing_file);
 		assert(!stats.isDirectory());
 		assert(stats.isFile());
@@ -81,6 +81,6 @@ suite('Stats', () => {
 		assert(!stats.isCharacterDevice());
 		assert(!stats.isFIFO());
 		assert(!stats.isSymbolicLink());
-		assert(stats instanceof Stats);
+		assert(stats instanceof fs.Stats);
 	});
 });

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 { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 // Top-level initialization
 const testFilePath = 'test-file.txt';
@@ -11,7 +11,7 @@ await fs.promises.writeFile(testFilePath, testData);
 const testFilePathWrite = 'test-file-write.txt';
 await fs.promises.writeFile(testFilePathWrite, ''); // Ensure the file exists
 
-suite('Streams', () => {
+suite('Streams', config('streams'), () => {
 	test('ReadStream reads data correctly', (_, done) => {
 		const readStream = fs.createReadStream(testFilePath);
 
@@ -36,8 +36,9 @@ suite('Streams', () => {
 			closed = true;
 		});
 
+		// Closing before the stream has finished reading is a premature close
 		readStream.close(err => {
-			assert.ifError(err);
+			assert.equal((err as NodeJS.ErrnoException | null)?.code, 'ERR_STREAM_PREMATURE_CLOSE');
 			assert(closed);
 			done();
 		});
@@ -81,7 +82,7 @@ suite('Streams', () => {
 	test('createReadStream with end', async () => {
 		await fs.promises.writeFile('hello.txt', 'Hello world');
 
-		const stream = fs.createReadStream('hello.txt', { end: 5, encoding: 'utf-8' });
+		const stream = fs.createReadStream('hello.txt', { end: 4, encoding: 'utf-8' });
 
 		const data = (await stream.toArray()).join('');
 
@@ -130,12 +131,14 @@ suite('Streams', () => {
 	test('FileHandle.createReadStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePath, 'r');
 		await fileHandle.close();
-		assert.throws(() => fileHandle.createReadStream(), { code: 'EBADF' });
+		// Closing invalidates the descriptor, so it fails range validation
+		assert.throws(() => fileHandle.createReadStream(), { code: 'ERR_OUT_OF_RANGE' });
 	});
 
 	test('FileHandle.createWriteStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePathWrite, 'w');
 		await fileHandle.close();
-		assert.throws(() => fileHandle.createWriteStream(), { code: 'EBADF' });
+		// Closing invalidates the descriptor, so it fails range validation
+		assert.throws(() => fileHandle.createWriteStream(), { code: 'ERR_OUT_OF_RANGE' });
 	});
 });

package/tests/fs/tempdir.test.ts

@@ -1,41 +1,64 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { test, suite } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 import assert from 'node:assert/strict';
 import { basename } from 'node:path/posix';
 
 await fs.promises.mkdir('/tmp');
 
-suite('Temporary Directories', () => {
-	test('mkdtempSync', () => {
-		const path = fs.mkdtempSync('test-', { encoding: 'utf8' });
+suite('Temporary Directories', config('tempdir'), () => {
+	test('mkdtempSync', config('sync'), () => {
+		const path = fs.mkdtempSync('/tmp/test-', { encoding: 'utf8' });
 
 		assert.deepEqual(fs.readdirSync('/tmp'), [basename(path)]);
 
 		fs.rmdirSync(path);
 	});
 
-	test('mkdtemp', async () => {
-		const path = await fs.promises.mkdtemp('test-', { encoding: 'utf8' });
+	test('mkdtemp', config('async'), async () => {
+		const path = await fs.promises.mkdtemp('/tmp/test-', { encoding: 'utf8' });
 
 		assert.deepEqual(await fs.promises.readdir('/tmp'), [basename(path)]);
 
 		await fs.promises.rmdir(path);
 	});
 
-	test('mkdtempDisposableSync', () => {
-		using result = fs.mkdtempDisposableSync('test-', { encoding: 'utf8' });
+	test('mkdtempDisposableSync', config('sync'), () => {
+		using result = fs.mkdtempDisposableSync('/tmp/test-', { encoding: 'utf8' });
 
 		assert.deepEqual(fs.readdirSync('/tmp'), [basename(result.path)]);
 
 		fs.rmdirSync(result.path);
 	});
 
-	test('mkdtempDisposable', async () => {
-		await using result = await fs.promises.mkdtempDisposable('test-', { encoding: 'utf8' });
+	test('mkdtempDisposable', config('async'), async () => {
+		await using result = await fs.promises.mkdtempDisposable('/tmp/test-', { encoding: 'utf8' });
 
 		assert.deepEqual(await fs.promises.readdir('/tmp'), [basename(result.path)]);
 
 		await fs.promises.rmdir(result.path);
 	});
+
+	/* A relative prefix is resolved against the working directory, rather than always being placed in `/tmp`.
+	Note the returned path keeps the prefix it was given, so it is only compared by basename here. */
+
+	test('mkdtempSync with a relative prefix', config('sync'), () => {
+		const path = fs.mkdtempSync('tmp/relative-', { encoding: 'utf8' });
+
+		assert(basename(path).startsWith('relative-'));
+		assert(fs.statSync(path).isDirectory());
+		assert(fs.readdirSync('/tmp').includes(basename(path)));
+
+		fs.rmdirSync(path);
+	});
+
+	test('mkdtemp with a relative prefix', config('async'), async () => {
+		const path = await fs.promises.mkdtemp('tmp/relative-', { encoding: 'utf8' });
+
+		assert(basename(path).startsWith('relative-'));
+		assert((await fs.promises.stat(path)).isDirectory());
+		assert((await fs.promises.readdir('/tmp')).includes(basename(path)));
+
+		await fs.promises.rmdir(path);
+	});
 });

package/tests/fs/times.test.ts

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import type { StatsLike } from '@zenfs/core';
-import { Exception } from 'kerium';
+import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const path = 'x.txt';
 
@@ -20,11 +20,12 @@ export function unixTimestamps(stats: StatsLike<number>): Record<'atime' | 'mtim
 	};
 }
 
-suite('Times', () => {
+suite('Times', config('times'), () => {
 	async function runTest(atime: Date | number, mtime: Date | number): Promise<void> {
+		// Numbers are seconds since the epoch, while `Date`s and stats are in milliseconds
 		const times = {
-			atime: typeof atime == 'number' ? Math.floor(atime) : atime.getTime(),
-			mtime: typeof mtime == 'number' ? Math.floor(mtime) : mtime.getTime(),
+			atime: typeof atime == 'number' ? Math.floor(atime * 1000) : atime.getTime(),
+			mtime: typeof mtime == 'number' ? Math.floor(mtime * 1000) : mtime.getTime(),
 		};
 
 		await fs.promises.utimes(path, atime, mtime);
@@ -32,7 +33,7 @@ suite('Times', () => {
 		assert.deepEqual(unixTimestamps(await fs.promises.stat(path)), times);
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: Exception) => {
-			assert(error instanceof Exception);
+			assert(error instanceof Error);
 			assert.equal(error.code, 'ENOENT');
 		});
 
@@ -47,15 +48,14 @@ suite('Times', () => {
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);
 		} catch (error: any) {
-			assert(error instanceof Exception);
 			assert.equal(error.code, 'ENOENT');
 		}
 
 		try {
 			fs.futimesSync(-1, atime, mtime);
 		} catch (error: any) {
-			assert(error instanceof Exception);
-			assert.equal(error.code, 'EBADF');
+			// A negative descriptor fails range validation before it is looked up
+			assert.equal(error.code, 'ERR_OUT_OF_RANGE');
 		}
 	}
 
@@ -67,7 +67,7 @@ suite('Times', () => {
 		await test('from stats', () => runTest(stats.atime, stats.mtime));
 	});
 
-	test('read changes atime', async () => {
+	test('read changes atime', config('sync'), async () => {
 		const before = fs.statSync(path).atimeMs;
 		fs.readFileSync(path);
 		await wait(25);
@@ -75,7 +75,7 @@ suite('Times', () => {
 		assert(before < after);
 	});
 
-	test('write changes mtime', async () => {
+	test('write changes mtime', config('sync', 'write'), async () => {
 		const before = fs.statSync(path).mtimeMs;
 		fs.writeFileSync(path, 'cool');
 		await wait(25);

package/tests/fs/truncate.test.ts

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const path: string = 'truncate-file.txt',
 	size = 1024 * 16,
 	data = new Uint8Array(size).fill('x'.charCodeAt(0));
 
-suite('Truncating', () => {
-	test('Sync path functions', () => {
+suite('Truncating', config('truncate'), () => {
+	test('Sync path functions', config('sync'), () => {
 		fs.writeFileSync(path, data);
 		assert.equal(fs.statSync(path).size, size);
 
@@ -22,7 +22,7 @@ suite('Truncating', () => {
 		assert.equal(fs.statSync(path).size, size);
 	});
 
-	test('FD functions', () => {
+	test('FD functions', config('sync'), () => {
 		const fd = fs.openSync(path, 'r+');
 
 		fs.ftruncateSync(fd, 1024);
@@ -36,7 +36,7 @@ suite('Truncating', () => {
 
 	const statSize = async (path: string) => (await fs.promises.stat(path)).size;
 
-	test('Async path functions', async () => {
+	test('Async path functions', config('async'), async () => {
 		await fs.promises.writeFile(path, data);
 
 		assert.equal(await statSize(path), 1024 * 16);
@@ -51,7 +51,7 @@ suite('Truncating', () => {
 		assert.equal(await statSize(path), size);
 	});
 
-	test('FileHandle', async () => {
+	test('FileHandle', config('async'), async () => {
 		const handle = await fs.promises.open(path, 'w');
 
 		await handle.truncate(1024);