@zenfs/core 1.1.4 → 1.1.6

package/tests/fs/dir.test.ts

@@ -0,0 +1,156 @@
+import assert, { rejects } from 'node:assert';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+const testFile = 'test-file.txt';
+await fs.promises.writeFile(testFile, 'Sample content');
+await fs.promises.mkdir('test-directory');
+await fs.promises.symlink(testFile, 'test-symlink');
+const testDirPath = 'test-dir';
+const testFiles = ['file1.txt', 'file2.txt'];
+await fs.promises.mkdir(testDirPath);
+for (const file of testFiles) {
+	await fs.promises.writeFile(`${testDirPath}/${file}`, 'Sample content');
+}
+
+suite('Dirent', () => {
+	test('Dirent name and parentPath getters', async () => {
+		const stats = await fs.promises.lstat(testFile);
+		const dirent = new fs.Dirent(testFile, stats);
+
+		assert(dirent.name === testFile);
+		assert(dirent.parentPath === testFile);
+	});
+
+	test('Dirent.isFile', async () => {
+		const fileStats = await fs.promises.lstat(testFile);
+		const fileDirent = new fs.Dirent(testFile, fileStats);
+
+		assert(fileDirent.isFile());
+		assert(!fileDirent.isDirectory());
+	});
+
+	test('Dirent.isDirectory', async () => {
+		const dirStats = await fs.promises.lstat('test-directory');
+		const dirDirent = new fs.Dirent('test-directory', dirStats);
+
+		assert(!dirDirent.isFile());
+		assert(dirDirent.isDirectory());
+	});
+
+	test('Dirent.isSymbolicLink', async () => {
+		const symlinkStats = await fs.promises.lstat('test-symlink');
+		const symlinkDirent = new fs.Dirent('test-symlink', symlinkStats);
+
+		assert(symlinkDirent.isSymbolicLink());
+	});
+
+	test('Dirent other methods return false', async () => {
+		const fileStats = await fs.promises.lstat(testFile);
+		const fileDirent = new fs.Dirent(testFile, fileStats);
+
+		assert(!fileDirent.isBlockDevice());
+		assert(!fileDirent.isCharacterDevice());
+		assert(!fileDirent.isSocket());
+	});
+});
+
+suite('Dir', () => {
+	test('Dir read() method (Promise varient)', async () => {
+		const dir = new fs.Dir(testDirPath);
+
+		const dirent1 = await dir.read();
+		assert(dirent1 instanceof fs.Dirent);
+		assert(testFiles.includes(dirent1?.name));
+
+		const dirent2 = await dir.read();
+		assert(dirent2 instanceof fs.Dirent);
+		assert(testFiles.includes(dirent2?.name));
+
+		const dirent3 = await dir.read();
+		assert(dirent3 === null);
+
+		await dir.close();
+	});
+
+	test('Dir read() method (Callback varient)', (_, done) => {
+		const dir = new fs.Dir(testDirPath);
+		dir.read((err, dirent) => {
+			assert(err === undefined);
+			assert(dirent != undefined);
+			assert(dirent instanceof fs.Dirent);
+			assert(testFiles.includes(dirent?.name));
+			dir.closeSync();
+			done();
+		});
+	});
+
+	test('Dir readSync() method', () => {
+		const dir = new fs.Dir(testDirPath);
+
+		const dirent1 = dir.readSync();
+		assert(dirent1 instanceof fs.Dirent);
+		assert(testFiles.includes(dirent1?.name));
+
+		const dirent2 = dir.readSync();
+		assert(dirent2 instanceof fs.Dirent);
+		assert(testFiles.includes(dirent2?.name));
+
+		const dirent3 = dir.readSync();
+		assert(dirent3 === null);
+
+		dir.closeSync();
+	});
+
+	test('Dir close() method (Promise version)', async () => {
+		const dir = new fs.Dir(testDirPath);
+		await dir.close();
+		rejects(dir.read(), 'Can not use closed Dir');
+	});
+
+	test('Dir closeSync() method', () => {
+		const dir = new fs.Dir(testDirPath);
+		dir.closeSync();
+		assert.throws(() => dir.readSync(), 'Can not use closed Dir');
+	});
+
+	test('Dir asynchronous iteration', async () => {
+		const dir = new fs.Dir(testDirPath);
+		const dirents: fs.Dirent[] = [];
+
+		for await (const dirent of dir) {
+			dirents.push(dirent);
+		}
+
+		assert(dirents.length === 2);
+		assert(dirents[0] instanceof fs.Dirent);
+		assert(testFiles.includes(dirents[0].name));
+		assert(testFiles.includes(dirents[1].name));
+	});
+
+	test('Dir read after directory is closed', async () => {
+		const dir = new fs.Dir(testDirPath);
+		await dir.close();
+		await assert.rejects(dir.read(), 'Can not use closed Dir');
+	});
+
+	test('Dir readSync after directory is closed', () => {
+		const dir = new fs.Dir(testDirPath);
+		dir.closeSync();
+		assert.throws(() => dir.readSync(), 'Can not use closed Dir');
+	});
+
+	test('Dir close multiple times', async () => {
+		const dir = new fs.Dir(testDirPath);
+		await dir.close();
+		await dir.close(); // Should not throw an error
+		assert(dir['closed']);
+	});
+
+	test('Dir closeSync multiple times', () => {
+		const dir = new fs.Dir(testDirPath);
+		dir.closeSync();
+		dir.closeSync(); // Should not throw an error
+		assert(dir['closed']);
+	});
+});

package/tests/fs/directory.test.ts

@@ -0,0 +1,129 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { ErrnoError } from '../../src/error.js';
+import { fs } from '../common.js';
+
+suite('Directory', () => {
+	test('mkdir', async () => {
+		await fs.promises.mkdir('/one', 0o755);
+		assert(await fs.promises.exists('/one'));
+		await assert.rejects(fs.promises.mkdir('/one', 0o755), /EEXIST/);
+	});
+
+	test('mkdirSync', () => fs.mkdirSync('/two', 0o000));
+
+	test('mkdir, nested', async () => {
+		try {
+			await fs.promises.mkdir('/nested/dir');
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'ENOENT');
+		}
+		assert(!(await fs.promises.exists('/nested/dir')));
+	});
+
+	test('mkdir, recursive', async () => {
+		assert((await fs.promises.mkdir('/recursiveP/A/B', { recursive: true, mode: 0o755 })) == '/recursiveP');
+		assert((await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o777 })) == '/recursiveP/A/B/C');
+		assert((await fs.promises.mkdir('/recursiveP/A/B/C/D', { recursive: true, mode: 0o700 })) == undefined);
+
+		assert((await fs.promises.stat('/recursiveP')).mode == (fs.constants.S_IFDIR | 0o755));
+		assert((await fs.promises.stat('/recursiveP/A')).mode == (fs.constants.S_IFDIR | 0o755));
+		assert((await fs.promises.stat('/recursiveP/A/B')).mode == (fs.constants.S_IFDIR | 0o755));
+		assert((await fs.promises.stat('/recursiveP/A/B/C')).mode == (fs.constants.S_IFDIR | 0o777));
+		assert((await fs.promises.stat('/recursiveP/A/B/C/D')).mode == (fs.constants.S_IFDIR | 0o777));
+	});
+
+	test('mkdirSync, recursive', () => {
+		assert(fs.mkdirSync('/recursiveS/A/B', { recursive: true, mode: 0o755 }) === '/recursiveS');
+		assert(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o777 }) === '/recursiveS/A/B/C');
+		assert(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o700 }) === undefined);
+
+		assert(fs.statSync('/recursiveS').mode == (fs.constants.S_IFDIR | 0o755));
+		assert(fs.statSync('/recursiveS/A').mode == (fs.constants.S_IFDIR | 0o755));
+		assert(fs.statSync('/recursiveS/A/B').mode == (fs.constants.S_IFDIR | 0o755));
+		assert(fs.statSync('/recursiveS/A/B/C').mode == (fs.constants.S_IFDIR | 0o777));
+		assert(fs.statSync('/recursiveS/A/B/C/D').mode == (fs.constants.S_IFDIR | 0o777));
+	});
+
+	test('readdirSync without permission', () => {
+		try {
+			fs.readdirSync('/two');
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'EACCES');
+		}
+	});
+
+	test('rmdir (non-empty)', async () => {
+		await fs.promises.mkdir('/rmdirTest');
+		await fs.promises.mkdir('/rmdirTest/rmdirTest2');
+
+		try {
+			await fs.promises.rmdir('/rmdirTest');
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'ENOTEMPTY');
+		}
+	});
+
+	test('readdirSync on file', () => {
+		let wasThrown = false;
+
+		try {
+			fs.readdirSync('a.js');
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			wasThrown = true;
+			assert(error.code === 'ENOTDIR');
+		}
+		assert(wasThrown);
+	});
+
+	test('readdir on file', async () => {
+		try {
+			await fs.promises.readdir('a.js');
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'ENOTDIR');
+		}
+	});
+
+	test('readdirSync on non-existant directory', () => {
+		let wasThrown = false;
+
+		try {
+			fs.readdirSync('/does/not/exist');
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			wasThrown = true;
+			assert(error.code === 'ENOENT');
+		}
+		assert(wasThrown);
+	});
+
+	test('readdir on non-existant directory', async () => {
+		try {
+			await fs.promises.readdir('/does/not/exist');
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'ENOENT');
+		}
+	});
+
+	test('rm recursively asynchronously', async () => {
+		await fs.promises.mkdir('/rmDirRecusrively');
+		await fs.promises.mkdir('/rmDirRecusrively/rmDirNested');
+		await fs.promises.writeFile('/rmDirRecusrively/rmDirNested/test.txt', 'hello world!');
+
+		await fs.promises.rm('/rmDirRecusrively', { recursive: true });
+	});
+
+	test('rm recursively synchronously', () => {
+		fs.mkdirSync('/rmDirRecusrively');
+		fs.mkdirSync('/rmDirRecusrively/rmDirNested');
+		fs.writeFileSync('/rmDirRecusrively/rmDirNested/test.txt', 'hello world!');
+
+		fs.rmSync('/rmDirRecusrively', { recursive: true });
+	});
+});

package/tests/fs/errors.test.ts

@@ -0,0 +1,53 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { ErrnoError } from '../../src/error.js';
+import { fs } from '../common.js';
+
+const existingFile = '/exit.js';
+
+async function expectError(fn: (...args: any[]) => unknown, path: string, ...args: any[]) {
+	let error: ErrnoError | undefined;
+	try {
+		await fn(path, ...args);
+	} catch (err: any) {
+		assert(err instanceof ErrnoError);
+		error = err;
+	}
+	assert(error);
+	assert.equal(error.path, path);
+	assert(error.message.includes(path));
+}
+
+suite('Error messages', () => {
+	const path = '/non-existent';
+
+	fs.promises.stat(path).catch((error: ErrnoError) => {
+		assert.equal(error.toString(), error.message);
+		assert.equal(error.bufferSize(), 4 + JSON.stringify(error.toJSON()).length);
+	});
+
+	test('stat', () => expectError(fs.promises.stat, path));
+	test('mkdir', () => expectError(fs.promises.mkdir, existingFile, 0o666));
+	test('rmdir', () => expectError(fs.promises.rmdir, path));
+	test('rmdir', () => expectError(fs.promises.rmdir, existingFile));
+	test('rename', () => expectError(fs.promises.rename, path, 'foo'));
+	test('open', () => expectError(fs.promises.open, path, 'r'));
+	test('readdir', () => expectError(fs.promises.readdir, path));
+	test('unlink', () => expectError(fs.promises.unlink, path));
+	test('link', () => expectError(fs.promises.link, path, 'foo'));
+	test('chmod', () => expectError(fs.promises.chmod, path, 0o666));
+	test('lstat', () => expectError(fs.promises.lstat, path));
+	test('readlink', () => expectError(fs.promises.readlink, path));
+	test('statSync', () => expectError(fs.statSync, path));
+	test('mkdirSync', () => expectError(fs.mkdirSync, existingFile, 0o666));
+	test('rmdirSync', () => expectError(fs.rmdirSync, path));
+	test('rmdirSync', () => expectError(fs.rmdirSync, existingFile));
+	test('renameSync', () => expectError(fs.renameSync, path, 'foo'));
+	test('openSync', () => expectError(fs.openSync, path, 'r'));
+	test('readdirSync', () => expectError(fs.readdirSync, path));
+	test('unlinkSync', () => expectError(fs.unlinkSync, path));
+	test('linkSync', () => expectError(fs.linkSync, path, 'foo'));
+	test('chmodSync', () => expectError(fs.chmodSync, path, 0o666));
+	test('lstatSync', () => expectError(fs.lstatSync, path));
+	test('readlinkSync', () => expectError(fs.readlinkSync, path));
+});

package/tests/fs/exists.test.ts

@@ -0,0 +1,22 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+suite('exists', () => {
+	const f = 'x.txt';
+
+	test('return true for an existing file', async () => {
+		const exists = await fs.promises.exists(f);
+		assert(exists);
+	});
+
+	test('return false for a non-existent file', async () => {
+		const exists = await fs.promises.exists(f + '-NO');
+		assert(!exists);
+	});
+
+	test('have sync methods that behave the same', () => {
+		assert(fs.existsSync(f));
+		assert(!fs.existsSync(f + '-NO'));
+	});
+});

package/tests/fs/links.test.ts

@@ -0,0 +1,46 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { join } from '../../src/emulation/path.js';
+import { fs } from '../common.js';
+
+suite('Links', () => {
+	const target = '/a1.js',
+		symlink = 'symlink1.js',
+		hardlink = 'link1.js';
+
+	test('symlink', async () => {
+		await fs.promises.symlink(target, symlink);
+	});
+
+	test('lstat', async () => {
+		const stats = await fs.promises.lstat(symlink);
+		assert(stats.isSymbolicLink());
+	});
+
+	test('readlink', async () => {
+		const destination = await fs.promises.readlink(symlink);
+		assert(destination === target);
+	});
+
+	test('unlink', async () => {
+		await fs.promises.unlink(symlink);
+		assert(!(await fs.promises.exists(symlink)));
+		assert(await fs.promises.exists(target));
+	});
+
+	test('link', async () => {
+		await fs.promises.link(target, hardlink);
+		const targetContent = await fs.promises.readFile(target, 'utf8');
+		const linkContent = await fs.promises.readFile(hardlink, 'utf8');
+		assert(targetContent === linkContent);
+	});
+
+	test('file inside symlinked directory', async () => {
+		await fs.promises.symlink('.', 'link');
+		const targetContent = await fs.promises.readFile(target, 'utf8');
+		const link = join('link', target);
+		assert((await fs.promises.realpath(link)) === target);
+		const linkContent = await fs.promises.readFile(link, 'utf8');
+		assert(targetContent === linkContent);
+	});
+});

package/tests/fs/open.test.ts

@@ -0,0 +1,39 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { ErrnoError } from '../../src/error.js';
+import { fs } from '../common.js';
+
+suite('fs file opening', () => {
+	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(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(error?.code === 'ENOENT');
+		}
+	});
+
+	test('open file with mode "r"', async () => {
+		const { fd } = await fs.promises.open(filename, 'r');
+		assert(fd >= -Infinity);
+	});
+
+	test('open file with mode "rs"', async () => {
+		const { fd } = await fs.promises.open(filename, 'rs');
+		assert(fd >= -Infinity);
+	});
+});

package/tests/fs/permissions.test.ts

@@ -0,0 +1,52 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { R_OK, W_OK, X_OK } from '../../src/emulation/constants.js';
+import { join } from '../../src/emulation/path.js';
+import { ErrnoError } from '../../src/error.js';
+import { encodeUTF8 } from '../../src/utils.js';
+import { fs } from '../common.js';
+
+suite('Permissions', () => {
+	async function test_item(path: string): Promise<void> {
+		const stats = await fs.promises.stat(path).catch((error: ErrnoError) => {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'EACCES');
+		});
+		if (!stats) {
+			return;
+		}
+		assert(stats.hasAccess(X_OK));
+
+		function checkError(access: number) {
+			return function (error: ErrnoError) {
+				assert(error instanceof ErrnoError);
+				assert(error);
+				assert(!stats!.hasAccess(access));
+			};
+		}
+
+		if (stats.isDirectory()) {
+			for (const dir of await fs.promises.readdir(path)) {
+				await test_item(join(path, dir));
+			}
+		} else {
+			await fs.promises.readFile(path).catch(checkError(R_OK));
+		}
+		assert(stats.hasAccess(R_OK));
+
+		if (stats.isDirectory()) {
+			const testFile = join(path, '__test_file_plz_ignore.txt');
+			await fs.promises.writeFile(testFile, encodeUTF8('this is a test file, please ignore.')).catch(checkError(W_OK));
+			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;
+			}
+			await handle.close();
+		}
+		assert(stats.hasAccess(R_OK));
+	}
+
+	test('recursive', () => test_item('/'));
+});

package/tests/fs/read.test.ts

@@ -0,0 +1,67 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+const filepath: string = 'x.txt';
+const expected: string = 'xyz\n';
+
+suite('read', () => {
+	test('read file asynchronously', async () => {
+		const handle = await fs.promises.open(filepath, 'r');
+		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
+
+		assert(bytesRead == expected.length);
+		assert(buffer.toString() == expected);
+	});
+
+	test('read file synchronously', () => {
+		const fd = fs.openSync(filepath, 'r');
+		const buffer = Buffer.alloc(expected.length);
+		const bytesRead = fs.readSync(fd, buffer, 0, expected.length, 0);
+
+		assert(bytesRead == expected.length);
+		assert(buffer.toString() == expected);
+	});
+});
+
+suite('read binary', () => {
+	test('Read a file and check its binary bytes (asynchronous)', async () => {
+		const buff = await fs.promises.readFile('elipses.txt');
+		assert(((buff[1] << 8) | buff[0]) === 32994);
+	});
+
+	test('Read a file and check its binary bytes (synchronous)', () => {
+		const buff = fs.readFileSync('elipses.txt');
+		assert(((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 () => {
+		const handle = await fs.promises.open(filepath, 'r');
+		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
+
+		assert(bytesRead === expected.length);
+		assert(bufferAsync.toString() === expected);
+	});
+
+	test('read file synchronously', () => {
+		const fd = fs.openSync(filepath, 'r');
+		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);
+
+		assert(bufferSync.toString() === expected);
+		assert(bytesRead === expected.length);
+	});
+
+	test('read file synchronously to non-zero offset', () => {
+		const fd = fs.openSync(filepath, 'r');
+		const buffer = Buffer.alloc(expected.length + 10);
+		const bytesRead = fs.readSync(fd, buffer, 10, expected.length, 0);
+
+		assert(buffer.subarray(10, buffer.length).toString() === expected);
+		assert(bytesRead === expected.length);
+	});
+});

package/tests/fs/readFile.test.ts

@@ -0,0 +1,73 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+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));
+	});
+
+	test('Reading past the end of a file should not be an error', async () => {
+		const handle = await fs.promises.open('a.js', 'r');
+		const { bytesRead } = await handle.read(new Uint8Array(10), 0, 10, 10000);
+		assert.strictEqual(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);
+
+	test('create directory and write file', async () => {
+		await fs.promises.mkdir(dir);
+		await fs.promises.writeFile(file, data);
+	});
+
+	test('read file and verify its content', 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 () => {
+		await fs.promises.unlink(file);
+		await fs.promises.rmdir(dir);
+	});
+});
+
+suite('Read File Test', () => {
+	const fn = 'empty.txt';
+
+	test('read file asynchronously', async () => {
+		const data: Uint8Array = await fs.promises.readFile(fn);
+		assert(data != undefined);
+	});
+
+	test('read file with utf-8 encoding asynchronously', async () => {
+		const data: string = await fs.promises.readFile(fn, 'utf8');
+		assert.strictEqual(data, '');
+	});
+
+	test('read file synchronously', () => {
+		const data: Uint8Array = fs.readFileSync(fn);
+		assert(data != undefined);
+	});
+
+	test('read file with utf-8 encoding synchronously', () => {
+		const data: string = fs.readFileSync(fn, 'utf8');
+		assert.strictEqual(data, '');
+	});
+});
+
+suite('fs file reading', () => {
+	test('read file synchronously and verify the content', () => {
+		const content = fs.readFileSync('elipses.txt', 'utf8');
+
+		for (let i = 0; i < content.length; i++) {
+			assert(content[i] === '…');
+		}
+
+		assert(content.length === 10000);
+	});
+});