@zenfs/core 2.0.0 → 2.1.0

package/tests/fs/errors.test.ts

@@ -1,36 +1,32 @@
 import assert from 'node:assert/strict';
 import test, { suite } from 'node:test';
 import { fs } from '../common.js';
-import type { ErrnoError } from '../../dist/index.js';
 
 const existingFile = '/exit.js';
 
 suite('Error messages', () => {
 	const path = '/non-existent';
 
-	fs.promises.stat(path).catch((error: ErrnoError) => {
-		assert.equal(error.bufferSize(), 4 + JSON.stringify(error.toJSON()).length);
-	});
-
 	const missing = { path, code: 'ENOENT' };
-	const existing = { path: existingFile };
+	const existing = { path: existingFile, code: 'EEXIST' };
+	const notDir = { path: existingFile, code: 'ENOTDIR' };
 
-	test('stat', () => assert.rejects(() => fs.promises.stat(path), missing));
-	test('mkdir', () => assert.rejects(() => fs.promises.mkdir(existingFile, 0o666), existing));
-	test('rmdir', () => assert.rejects(() => fs.promises.rmdir(path), missing));
-	test('rmdir', () => assert.rejects(() => fs.promises.rmdir(existingFile), existing));
-	test('rename', () => assert.rejects(() => fs.promises.rename(path, 'foo'), missing));
-	test('open', () => assert.rejects(() => fs.promises.open(path, 'r'), missing));
-	test('readdir', () => assert.rejects(() => fs.promises.readdir(path), missing));
-	test('unlink', () => assert.rejects(() => fs.promises.unlink(path), missing));
-	test('link', () => assert.rejects(() => fs.promises.link(path, 'foo'), missing));
-	test('chmod', () => assert.rejects(() => fs.promises.chmod(path, 0o666), missing));
-	test('lstat', () => assert.rejects(() => fs.promises.lstat(path), missing));
-	test('readlink', () => assert.rejects(() => fs.promises.readlink(path), missing));
+	test('stat', async () => await assert.rejects(() => fs.promises.stat(path), missing));
+	test('mkdir', async () => await assert.rejects(() => fs.promises.mkdir(existingFile, 0o666), existing));
+	test('rmdir (missing)', async () => await assert.rejects(() => fs.promises.rmdir(path), missing));
+	test('rmdir (existing)', async () => await assert.rejects(() => fs.promises.rmdir(existingFile), notDir));
+	test('rename', async () => await assert.rejects(() => fs.promises.rename(path, 'foo'), missing));
+	test('open', async () => await assert.rejects(() => fs.promises.open(path, 'r'), missing));
+	test('readdir', async () => await assert.rejects(() => fs.promises.readdir(path), missing));
+	test('unlink', async () => await assert.rejects(() => fs.promises.unlink(path), missing));
+	test('link', async () => await assert.rejects(() => fs.promises.link(path, 'foo'), missing));
+	test('chmod', async () => await assert.rejects(() => fs.promises.chmod(path, 0o666), missing));
+	test('lstat', async () => await assert.rejects(() => fs.promises.lstat(path), missing));
+	test('readlink', async () => await assert.rejects(() => fs.promises.readlink(path), missing));
 	test('statSync', () => assert.throws(() => fs.statSync(path), missing));
 	test('mkdirSync', () => assert.throws(() => fs.mkdirSync(existingFile, 0o666), existing));
 	test('rmdirSync', () => assert.throws(() => fs.rmdirSync(path), missing));
-	test('rmdirSync', () => assert.throws(() => fs.rmdirSync(existingFile), existing));
+	test('rmdirSync', () => assert.throws(() => fs.rmdirSync(existingFile), notDir));
 	test('renameSync', () => assert.throws(() => fs.renameSync(path, 'foo'), missing));
 	test('openSync', () => assert.throws(() => fs.openSync(path, 'r'), missing));
 	test('readdirSync', () => assert.throws(() => fs.readdirSync(path), missing));

package/tests/fs/links.test.ts

@@ -1,8 +1,8 @@
+import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { join } from '../../dist/path.js';
 import { fs } from '../common.js';
-import type { ErrnoError } from '../../dist/index.js';
 
 suite('Links', () => {
 	const target = '/a1.js',
@@ -21,6 +21,7 @@ suite('Links', () => {
 	test('readlink', async () => {
 		const destination = await fs.promises.readlink(symlink);
 		assert.equal(destination, target);
+		assert.throws(() => fs.readlinkSync(destination));
 	});
 
 	test('read target contents', async () => {
@@ -59,7 +60,7 @@ suite('Links', () => {
 	});
 
 	test('link', async t => {
-		const _ = await fs.promises.link(target, hardlink).catch((e: ErrnoError) => {
+		const _ = await fs.promises.link(target, hardlink).catch((e: Exception) => {
 			if (e.code == 'ENOSYS') return e;
 			throw e;
 		});

package/tests/fs/open.test.ts

@@ -1,30 +1,13 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/index.js';
 import { fs } from '../common.js';
 
-suite('fs file opening', () => {
+suite('Opening files', () => {
 	const filename = 'a.js';
 
-	test('throw ENOENT when opening non-existent file (sync)', () => {
-		let caughtException = false;
-		try {
-			fs.openSync('/path/to/file/that/does/not/exist', 'r');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error?.code, 'ENOENT');
-			caughtException = true;
-		}
-		assert(caughtException);
-	});
-
-	test('throw ENOENT when opening non-existent file (async)', async () => {
-		try {
-			await fs.promises.open('/path/to/file/that/does/not/exist', 'r');
-		} catch (error: any) {
-			assert(error instanceof ErrnoError);
-			assert.equal(error?.code, 'ENOENT');
-		}
+	test('throw ENOENT when opening non-existent file', async () => {
+		assert.throws(() => fs.openSync('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
+		await assert.rejects(fs.promises.open('/path/to/file/that/does/not/exist', 'r'), { code: 'ENOENT' });
 	});
 
 	test('open file with mode "r"', async () => {

package/tests/fs/permissions.test.ts

@@ -1,7 +1,7 @@
+import { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { encodeUTF8 } from 'utilium';
-import { ErrnoError } from '../../dist/index.js';
 import { defaultContext } from '../../dist/internal/contexts.js';
 import { join } from '../../dist/path.js';
 import { R_OK, W_OK, X_OK } from '../../dist/vfs/constants.js';
@@ -48,19 +48,16 @@ suite('Permissions', () => {
 	});
 
 	async function test_item(path: string): Promise<void> {
-		const stats = await fs.promises.stat(path).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
+		const stats = await fs.promises.stat(path).catch((error: Exception) => {
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'EACCES');
 		});
-		if (!stats) {
-			return;
-		}
+		if (!stats) return;
 		assert(stats.hasAccess(X_OK));
 
 		function checkError(access: number) {
-			return function (error: ErrnoError) {
-				assert(error instanceof ErrnoError);
-				assert(error);
+			return function (error: Exception) {
+				assert(error instanceof Exception);
 				assert(!stats!.hasAccess(access));
 			};
 		}
@@ -80,12 +77,10 @@ suite('Permissions', () => {
 			await fs.promises.unlink(testFile).catch(checkError(W_OK));
 		} else {
 			const handle = await fs.promises.open(path, 'a').catch(checkError(W_OK));
-			if (!handle) {
-				return;
-			}
+			if (!handle) return;
 			await handle.close();
 		}
-		assert(stats.hasAccess(R_OK));
+		assert(stats.hasAccess(W_OK));
 	}
 
 	const copy = { ...defaultContext.credentials };

package/tests/fs/read.test.ts

@@ -1,10 +1,11 @@
+import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-import { Buffer } from 'buffer';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
+const ellipses = '…'.repeat(10_000);
 
 suite('read', () => {
 	test('read file asynchronously', async () => {
@@ -22,25 +23,25 @@ suite('read', () => {
 		assert.equal(bytesRead, expected.length);
 		assert.equal(buffer.toString(), expected);
 	});
-});
 
-suite('read binary', () => {
-	test('Read a file and check its binary bytes (asynchronous)', async () => {
+	test('Read a file and check its binary bytes asynchronously', async () => {
 		const buff = await fs.promises.readFile('elipses.txt');
+		assert.equal(buff.length, 30_000);
+		assert.equal(buff.toString(), ellipses);
 		assert.equal((buff[1] << 8) | buff[0], 32994);
 	});
 
-	test('Read a file and check its binary bytes (synchronous)', () => {
+	test('Read a file and check its binary bytes synchronously', () => {
 		const buff = fs.readFileSync('elipses.txt');
+		assert.equal(buff.length, 30_000);
+		assert.equal(buff.toString(), ellipses);
 		assert.equal((buff[1] << 8) | buff[0], 32994);
 	});
-});
 
-suite('read buffer', () => {
 	const bufferAsync = Buffer.alloc(expected.length);
 	const bufferSync = Buffer.alloc(expected.length);
 
-	test('read file asynchronously', async () => {
+	test('read file from handle asynchronously', async () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
@@ -48,7 +49,7 @@ suite('read buffer', () => {
 		assert.equal(bufferAsync.toString(), expected);
 	});
 
-	test('read file synchronously', () => {
+	test('read file from handle synchronously', () => {
 		const fd = fs.openSync(filepath, 'r');
 		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);
 

package/tests/fs/readFile.test.ts

@@ -4,7 +4,7 @@ import { fs } from '../common.js';
 
 suite('Reading', () => {
 	test('Cannot read a file with an invalid encoding', () => {
-		assert.throws(() => fs.readFileSync('a.js', 'wrongencoding' as BufferEncoding));
+		assert.throws(() => fs.readFileSync('a.js', 'wrong-encoding' as BufferEncoding));
 	});
 
 	test('Reading past the end of a file should not be an error', async () => {
@@ -12,9 +12,7 @@ suite('Reading', () => {
 		const { bytesRead } = await handle.read(new Uint8Array(10), 0, 10, 10000);
 		assert.equal(bytesRead, 0);
 	});
-});
 
-suite('Read and Unlink', () => {
 	const dir = 'test-readfile-unlink';
 	const file = 'test-readfile-unlink/test.bin';
 	const data = new Uint8Array(512).fill(42);
@@ -34,33 +32,19 @@ suite('Read and Unlink', () => {
 		await fs.promises.unlink(file);
 		await fs.promises.rmdir(dir);
 	});
-});
 
-suite('Read File', () => {
-	const fn = 'empty.txt';
-
-	test('read file asynchronously', async () => {
-		const data: Uint8Array = await fs.promises.readFile(fn);
-		assert(data != undefined);
-	});
+	const fileName = 'empty.txt';
 
-	test('read file with utf-8 encoding asynchronously', async () => {
-		const data: string = await fs.promises.readFile(fn, 'utf8');
-		assert.equal(data, '');
+	test('read file', async () => {
+		assert.equal((await fs.promises.readFile(fileName)).toString(), '');
+		assert.equal(fs.readFileSync(fileName).toString(), '');
 	});
 
-	test('read file synchronously', () => {
-		const data: Uint8Array = fs.readFileSync(fn);
-		assert(data != undefined);
+	test('read file with utf-8 encoding', async () => {
+		assert.equal(await fs.promises.readFile(fileName, 'utf8'), '');
+		assert.equal(fs.readFileSync(fileName, 'utf8'), '');
 	});
 
-	test('read file with utf-8 encoding synchronously', () => {
-		const data: string = fs.readFileSync(fn, 'utf8');
-		assert.equal(data, '');
-	});
-});
-
-suite('fs file reading', () => {
 	test('read file synchronously and verify the content', () => {
 		const content = fs.readFileSync('elipses.txt', 'utf8');
 

package/tests/fs/rename.test.ts

@@ -1,6 +1,5 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { ErrnoError } from '../../dist/index.js';
 import { fs } from '../common.js';
 
 suite('Rename', () => {
@@ -77,10 +76,8 @@ suite('Rename', () => {
 		await fs.promises.mkdir(dir);
 		await fs.promises.writeFile(file, 'file contents go here');
 
-		await fs.promises.rename(file, dir).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
-			assert.match(error.code, /EISDIR|EPERM/);
-		});
+		await assert.rejects(fs.promises.rename(file, dir), { code: 'EISDIR' });
+		assert.throws(() => fs.renameSync(file, dir), { code: 'EISDIR' });
 	});
 
 	test('rename directory inside itself', async () => {
@@ -89,9 +86,7 @@ suite('Rename', () => {
 
 		await fs.promises.mkdir(renDir1);
 
-		await fs.promises.rename(renDir1, renDir2).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
-			assert.equal(error.code, 'EBUSY');
-		});
+		await assert.rejects(fs.promises.rename(renDir1, renDir2), { code: 'EBUSY' });
+		assert.throws(() => fs.renameSync(renDir1, renDir2), { code: 'EBUSY' });
 	});
 });

package/tests/fs/stat.test.ts

@@ -7,8 +7,8 @@ import { fs } from '../common.js';
 suite('Stats', () => {
 	const existing_file = 'x.txt';
 
-	test('stat empty path', () => {
-		assert.rejects(fs.promises.stat(''));
+	test('stat empty path', async () => {
+		await assert.rejects(fs.promises.stat(''));
 	});
 
 	test('stat directory', async () => {

package/tests/fs/times.test.ts

@@ -1,7 +1,7 @@
+import { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import { ErrnoError } from '../../dist/index.js';
 import type { StatsLike } from '../../dist/vfs/stats.js';
 import { fs } from '../common.js';
 
@@ -19,7 +19,7 @@ export function unixTimestamps(stats: StatsLike<number>): Record<'atime' | 'mtim
 	};
 }
 
-suite('times', () => {
+suite('Times', () => {
 	async function runTest(atime: Date | number, mtime: Date | number): Promise<void> {
 		const times = {
 			atime: typeof atime == 'number' ? Math.floor(atime) : atime.getTime(),
@@ -30,8 +30,8 @@ suite('times', () => {
 
 		assert.deepEqual(unixTimestamps(await fs.promises.stat(path)), times);
 
-		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
-			assert(error instanceof ErrnoError);
+		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: Exception) => {
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'ENOENT');
 		});
 
@@ -46,14 +46,14 @@ suite('times', () => {
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);
 		} catch (error: any) {
-			assert(error instanceof ErrnoError);
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'ENOENT');
 		}
 
 		try {
 			fs.futimesSync(-1, atime, mtime);
 		} catch (error: any) {
-			assert(error instanceof ErrnoError);
+			assert(error instanceof Exception);
 			assert.equal(error.code, 'EBADF');
 		}
 	}

package/tests/fs/truncate.test.ts

@@ -1,94 +1,66 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-import type { FileHandle } from '../../dist/vfs/promises.js';
 
 const path: string = 'truncate-file.txt',
 	size = 1024 * 16,
 	data = new Uint8Array(size).fill('x'.charCodeAt(0));
 
-suite('Truncate, sync', () => {
-	test('initial write', () => {
+suite('Truncating', () => {
+	test('Sync path functions', () => {
 		fs.writeFileSync(path, data);
 		assert.equal(fs.statSync(path).size, size);
-	});
 
-	test('truncate to 1024', () => {
 		fs.truncateSync(path, 1024);
 		assert.equal(fs.statSync(path).size, 1024);
-	});
 
-	test('truncate to 0', () => {
 		fs.truncateSync(path);
 		assert.equal(fs.statSync(path).size, 0);
-	});
 
-	test('write', () => {
 		fs.writeFileSync(path, data);
 		assert.equal(fs.statSync(path).size, size);
 	});
 
-	let fd: number;
-	test('open r+', () => {
-		fd = fs.openSync(path, 'r+');
-	});
+	test('FD functions', () => {
+		const fd = fs.openSync(path, 'r+');
 
-	test('ftruncate to 1024', () => {
 		fs.ftruncateSync(fd, 1024);
 		assert.equal(fs.fstatSync(fd).size, 1024);
-	});
 
-	test('ftruncate to 0', () => {
 		fs.ftruncateSync(fd);
 		assert.equal(fs.fstatSync(fd).size, 0);
-	});
 
-	test('close fd', () => {
 		fs.closeSync(fd);
 	});
-});
-suite('Truncate, async', () => {
+
 	const statSize = async (path: string) => (await fs.promises.stat(path)).size;
 
-	test('initial write', async () => {
+	test('Async path functions', async () => {
 		await fs.promises.writeFile(path, data);
 
 		assert.equal(await statSize(path), 1024 * 16);
-	});
 
-	test('truncate to 1024', async () => {
 		await fs.promises.truncate(path, 1024);
 		assert.equal(await statSize(path), 1024);
-	});
 
-	test('truncate to 0', async () => {
 		await fs.promises.truncate(path);
 		assert.equal(await statSize(path), 0);
-	});
 
-	test('write', async () => {
 		await fs.promises.writeFile(path, data);
 		assert.equal(await statSize(path), size);
 	});
 
-	let handle: FileHandle;
-	test('open w', async () => {
-		handle = await fs.promises.open(path, 'w');
-	});
+	test('FileHandle', async () => {
+		const handle = await fs.promises.open(path, 'w');
 
-	test('handle.truncate to 1024', async () => {
 		await handle.truncate(1024);
 		await handle.sync();
 		assert.equal(await statSize(path), 1024);
-	});
 
-	test('handle.truncate to 0', async () => {
 		await handle.truncate();
 		await handle.sync();
 		assert.equal(await statSize(path), 0);
-	});
 
-	test('close handle', async () => {
 		await handle.close();
 	});
 });

package/tests/fs/watch.test.ts

@@ -11,8 +11,8 @@ await fs.promises.writeFile(testFile, 'Initial content');
 /**
  * @todo convert using watcher to void discards pending ES proposal
  */
-await suite('Watch Features', () => {
-	test('fs.watch should emit events on file change', async () => {
+await suite('Watch', () => {
+	test('Events emitted on file change', async () => {
 		const { promise, resolve } = Promise.withResolvers<[string, string]>();
 
 		using watcher = fs.watch(testFile, (eventType, filename) => {
@@ -27,7 +27,7 @@ await suite('Watch Features', () => {
 		assert.equal(filename, 'test.txt');
 	});
 
-	test('fs.watch should emit events on file rename (delete)', async () => {
+	test('Events are emitted on delete', async () => {
 		using watcher = fs.watch(testFile, (eventType, filename) => {
 			assert.equal(eventType, 'rename');
 			assert.equal(filename, 'test.txt');
@@ -37,7 +37,7 @@ await suite('Watch Features', () => {
 		await fs.promises.unlink(testFile);
 	});
 
-	test('fs.watchFile should detect changes to a file', async () => {
+	test('Changes are detected with watchFile()', async () => {
 		const listener = (curr: Stats, prev: Stats) => {
 			assert(curr.mtimeMs != prev.mtimeMs);
 			fs.unwatchFile(testFile, listener);
@@ -49,7 +49,7 @@ await suite('Watch Features', () => {
 		await fs.promises.writeFile(testFile, 'Changed content');
 	});
 
-	test('fs.unwatchFile should stop watching the file', async () => {
+	test('unwatchFile() works', async () => {
 		let changeDetected = false;
 
 		const listener = () => {
@@ -66,7 +66,7 @@ await suite('Watch Features', () => {
 		assert(!changeDetected);
 	});
 
-	test('fs.watch should work with directories', async () => {
+	test('Directories can be watched', async () => {
 		using watcher = fs.watch(testDir, (eventType, filename) => {
 			assert.equal(eventType, 'change');
 			assert.equal(filename, 'newFile.txt');
@@ -75,7 +75,7 @@ await suite('Watch Features', () => {
 		await fs.promises.writeFile(testDir + '/newFile.txt', 'Content');
 	});
 
-	test('fs.watch should detect file renames', async () => {
+	test('File renames are detected', async () => {
 		const oldFileName = 'oldFile.txt';
 		const newFileName = 'newFile.txt';
 		const oldFile = testDir + '/' + oldFileName;
@@ -102,7 +102,7 @@ await suite('Watch Features', () => {
 		await Promise.all([newFileResolver.promise, oldFileResolver.promise]);
 	});
 
-	test('fs.watch should detect file deletions', async () => {
+	test('File deletions are detected', async () => {
 		const tempFile = `${testDir}/tempFile.txt`;
 
 		await fs.promises.writeFile(tempFile, 'Temporary content');
@@ -115,7 +115,7 @@ await suite('Watch Features', () => {
 		await fs.promises.unlink(tempFile);
 	});
 
-	test('fs.promises.watch should detect file deletions', async () => {
+	test('File deletions are detected by promises API', async () => {
 		const tempFile = `${testDir}/tempFile.txt`;
 
 		await fs.promises.writeFile(tempFile, 'Temporary content');
@@ -135,7 +135,7 @@ await suite('Watch Features', () => {
 		await promise;
 	});
 
-	test('fs.promises.watch should detect file creations recursively', async () => {
+	test('File creations are detected recursively', async () => {
 		const subDir = `${testDir}/sub-dir`;
 		const tempFile = `${subDir}/tempFile.txt`;
 		await fs.promises.mkdir(subDir);