@zenfs/core 1.1.4 → 1.1.5

package/tests/fs/readdir.test.ts

@@ -0,0 +1,87 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+const testDir = 'test-dir';
+const testFiles = ['file1.txt', 'file2.txt', 'file3.txt'];
+const testDirectories = ['subdir1', 'subdir2'];
+
+await fs.promises.mkdir(testDir);
+for (const file of testFiles) {
+	await fs.promises.writeFile(`${testDir}/${file}`, 'Sample content');
+}
+for (const dir of testDirectories) {
+	await fs.promises.mkdir(`${testDir}/${dir}`);
+	for (const file of ['file4.txt', 'file5.txt']) {
+		await fs.promises.writeFile(`${testDir}/${dir}/${file}`, 'Sample content');
+	}
+}
+
+suite('readdir and readdirSync', () => {
+	test('readdir returns files and directories', async () => {
+		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
+		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
+		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
+
+		assert(testFiles.every(file => files.includes(file)));
+		assert(testDirectories.every(dir => dirs.includes(dir)));
+	});
+
+	test('readdirSync returns files and directories', () => {
+		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
+		const files = dirents.filter(dirent => dirent.isFile()).map(dirent => dirent.name);
+		const dirs = dirents.filter(dirent => dirent.isDirectory()).map(dirent => dirent.name);
+
+		assert(testFiles.every(file => files.includes(file)));
+		assert(testDirectories.every(dir => dirs.includes(dir)));
+	});
+
+	test('readdir returns Dirent objects', async () => {
+		const dirents = await fs.promises.readdir(testDir, { withFileTypes: true });
+		assert(dirents[0] instanceof fs.Dirent);
+	});
+
+	test('readdirSync returns Dirent objects', () => {
+		const dirents = fs.readdirSync(testDir, { withFileTypes: true });
+		assert(dirents[0] instanceof fs.Dirent);
+	});
+
+	test('readdir works without withFileTypes option', async () => {
+		const files = await fs.promises.readdir(testDir);
+		assert(testFiles.every(entry => files.includes(entry)));
+		assert(testDirectories.every(entry => files.includes(entry)));
+	});
+
+	test('readdirSync works without withFileTypes option', () => {
+		const files = fs.readdirSync(testDir);
+		assert(testFiles.every(entry => files.includes(entry)));
+		assert(testDirectories.every(entry => files.includes(entry)));
+	});
+
+	test('readdir returns files recursively', async () => {
+		const entries = await fs.promises.readdir(testDir, { recursive: true });
+		assert(entries.includes('file1.txt'));
+		assert(entries.includes('subdir1/file4.txt'));
+		assert(entries.includes('subdir2/file5.txt'));
+	});
+
+	test('readdir returns Dirent recursively', async () => {
+		const entries = await fs.promises.readdir(testDir, { recursive: true, withFileTypes: true });
+		assert.equal(entries[0].path, 'file1.txt');
+		assert.equal(entries[4].path, 'subdir1/file4.txt');
+		assert.equal(entries[entries.length - 1].path, 'subdir2/file5.txt');
+	});
+
+	// New test for readdirSync with recursive: true
+	test('readdirSync returns files recursively', () => {
+		const entries = fs.readdirSync(testDir, { recursive: true });
+		assert(entries.includes('file1.txt'));
+		assert(entries.includes('subdir1/file4.txt'));
+		assert(entries.includes('subdir2/file5.txt'));
+	});
+
+	test('Cyrillic file names', () => {
+		fs.writeFileSync('/мой-файл.txt', 'HELLO!', 'utf-8');
+		assert(fs.readdirSync('/').includes('мой-файл.txt'));
+	});
+});

package/tests/fs/rename.test.ts

@@ -0,0 +1,107 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { ErrnoError } from '../../src/error.js';
+import { fs } from '../common.js';
+
+suite('Rename', () => {
+	/**
+	 * Creates the following directory structure within `dir`:
+	 * - _rename_me
+	 *   - lol.txt
+	 * - file.dat
+	 */
+	async function populate(dir: string) {
+		await fs.promises.mkdir(dir + '/_rename_me');
+		await fs.promises.writeFile(dir + '/file.dat', 'filedata');
+		await fs.promises.writeFile(dir + '/_rename_me/lol.txt', 'lololol');
+	}
+
+	/**
+	 * Check that the directory structure created in populate_directory remains.
+	 */
+	async function check_directory(dir: string) {
+		const contents = await fs.promises.readdir(dir);
+		assert(contents.length === 2);
+
+		const subContents = await fs.promises.readdir(dir + '/_rename_me');
+		assert(subContents.length === 1);
+
+		assert(await fs.promises.exists(dir + '/file.dat'));
+		assert(await fs.promises.exists(dir + '/_rename_me/lol.txt'));
+	}
+
+	test('rename directory', async () => {
+		const oldDir = '/rename_test';
+		const newDir = '/rename_test2';
+
+		await fs.promises.mkdir(oldDir);
+
+		await populate(oldDir);
+
+		await fs.promises.rename(oldDir, oldDir);
+
+		await check_directory(oldDir);
+
+		await fs.promises.rename(oldDir, newDir);
+
+		await check_directory(newDir);
+
+		assert(!(await fs.promises.exists(oldDir)));
+
+		await fs.promises.mkdir(oldDir);
+		await populate(oldDir);
+		await fs.promises.rename(oldDir, newDir + '/newDir');
+	});
+
+	test('rename file', async () => {
+		const dir = '/rename_file_test';
+		const one = dir + '/fun.js';
+		const two = dir + '/fun2.js';
+
+		await fs.promises.mkdir(dir);
+		await fs.promises.writeFile(one, 'while(1) alert("Hey! Listen!");');
+		await fs.promises.rename(one, one);
+		await fs.promises.rename(one, two);
+
+		await fs.promises.writeFile(one, 'hey');
+		await fs.promises.rename(one, two);
+
+		assert((await fs.promises.readFile(two, 'utf8')) === 'hey');
+		assert(!(await fs.promises.exists(one)));
+	});
+
+	test('File to Directory and Directory to File Rename', async () => {
+		const dir = '/rename_filedir_test';
+		const file = '/rename_filedir_test.txt';
+
+		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(error.code === 'EISDIR' || error.code === 'EPERM');
+		});
+
+		// JV: Removing test for now. I noticed that you can do that in Node v0.12 on Mac,
+		// but it might be FS independent.
+		/*fs.rename(dir, file, function (e) {
+		  if (e == null) {
+			throw new Error("Failed invariant: Cannot rename a directory over a file.");
+		  } else {
+			assert(e.code === 'ENOTDIR');
+		  }
+		});*/
+	});
+
+	test('rename directory inside itself', async () => {
+		const renDir1 = '/renamedir_1';
+		const renDir2 = '/renamedir_1/lol';
+
+		await fs.promises.mkdir(renDir1);
+
+		await fs.promises.rename(renDir1, renDir2).catch((error: ErrnoError) => {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'EBUSY');
+		});
+	});
+});

package/tests/fs/stat.test.ts

@@ -0,0 +1,48 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { Stats } from '../../src/stats.js';
+import { fs } from '../common.js';
+
+suite('Stats', () => {
+	const existing_file = 'x.txt';
+
+	test('stat empty path', () => {
+		assert.rejects(fs.promises.stat(''));
+	});
+
+	test('stat directory', async () => {
+		const stats = await fs.promises.stat('/');
+		assert(stats instanceof Stats);
+	});
+
+	test('lstat directory', async () => {
+		const stats = await fs.promises.lstat('/');
+		assert(stats instanceof Stats);
+	});
+
+	test('FileHandle.stat', async () => {
+		const handle = await fs.promises.open(existing_file, 'r');
+		const stats = await handle.stat();
+		assert(stats instanceof Stats);
+		await handle.close();
+	});
+
+	test('fstatSync file', () => {
+		const fd = fs.openSync(existing_file, 'r');
+		const stats = fs.fstatSync(fd);
+		assert(stats instanceof Stats);
+		fs.close(fd);
+	});
+
+	test('stat file', async () => {
+		const stats = await fs.promises.stat(existing_file);
+		assert(!stats.isDirectory());
+		assert(stats.isFile());
+		assert(!stats.isSocket());
+		assert(!stats.isBlockDevice());
+		assert(!stats.isCharacterDevice());
+		assert(!stats.isFIFO());
+		assert(!stats.isSymbolicLink());
+		assert(stats instanceof Stats);
+	});
+});

package/tests/fs/streams.test.ts

@@ -0,0 +1,177 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+// Top-level initialization
+const testFilePath = 'test-file.txt';
+const testData = 'Hello, World!';
+await fs.promises.writeFile(testFilePath, testData);
+
+const testFilePathWrite = 'test-file-write.txt';
+await fs.promises.writeFile(testFilePathWrite, ''); // Ensure the file exists
+
+suite('ReadStream', () => {
+	test('ReadStream reads data correctly', (_, done) => {
+		const readStream = fs.createReadStream(testFilePath);
+		let data = '';
+		readStream.on('data', chunk => {
+			data += chunk;
+		});
+		readStream.on('end', () => {
+			assert(data == testData);
+			done();
+		});
+		readStream.on('error', err => {
+			done(err);
+		});
+	});
+
+	test('ReadStream close method works', (_, done) => {
+		const readStream = fs.createReadStream(testFilePath);
+		let closed = false;
+		readStream.on('close', () => {
+			closed = true;
+		});
+		readStream.close(err => {
+			assert(err === undefined);
+			assert(closed);
+			done();
+		});
+	});
+
+	test('ReadStream declared properties', () => {
+		const readStream = new fs.ReadStream();
+		assert(readStream.bytesRead === undefined);
+		assert(readStream.path === undefined);
+		assert(readStream.pending === undefined);
+
+		// Assign values
+		readStream.bytesRead = 10;
+		readStream.path = testFilePath;
+		readStream.pending = false;
+
+		assert(readStream.bytesRead === 10);
+		assert(readStream.path === testFilePath);
+		assert(!readStream.pending);
+	});
+
+	test('ReadStream close method can be called multiple times', (_, done) => {
+		const readStream = new fs.ReadStream();
+		readStream.close(err => {
+			assert(err === undefined);
+			// Call close again
+			readStream.close(err2 => {
+				assert(err2 === undefined);
+				done();
+			});
+		});
+	});
+});
+
+suite('WriteStream', () => {
+	test.skip('WriteStream writes data correctly', (_, done) => {
+		const writeStream = fs.createWriteStream(testFilePathWrite);
+		writeStream.write(testData, 'utf8', err => {
+			if (err) {
+				done(err);
+				return;
+			}
+			writeStream.end();
+		});
+		writeStream.on('finish', () => {
+			assert(fs.readFileSync(testFilePathWrite, 'utf8') == testData);
+			done();
+		});
+		writeStream.on('error', err => {
+			done(err);
+		});
+	});
+
+	test('WriteStream close method works', (_, done) => {
+		const writeStream = fs.createWriteStream(testFilePathWrite);
+		let closed = false;
+		writeStream.on('close', () => {
+			closed = true;
+		});
+		writeStream.close(err => {
+			assert(err === undefined);
+			assert(closed);
+			done();
+		});
+	});
+
+	test('WriteStream declared properties', () => {
+		const writeStream = new fs.WriteStream();
+		assert(writeStream.bytesWritten === undefined);
+		assert(writeStream.path === undefined);
+		assert(writeStream.pending === undefined);
+
+		// Assign values
+		writeStream.bytesWritten = 20;
+		writeStream.path = testFilePathWrite;
+		writeStream.pending = true;
+
+		assert(writeStream.bytesWritten === 20);
+		assert(writeStream.path === testFilePathWrite);
+		assert(writeStream.pending);
+	});
+
+	test('WriteStream close method can be called multiple times', (_, done) => {
+		const writeStream = new fs.WriteStream();
+		writeStream.close(err => {
+			assert(err === undefined);
+			// Call close again
+			writeStream.close(err2 => {
+				assert(err2 === undefined);
+				done();
+			});
+		});
+	});
+});
+
+suite('FileHandle', () => {
+	test.skip('FileHandle.createReadStream reads data correctly', async () => {
+		const fileHandle = await fs.promises.open(testFilePath, 'r');
+		const readStream = fileHandle.createReadStream();
+		let data = '';
+		await new Promise<void>((resolve, reject) => {
+			readStream.on('data', chunk => {
+				data += chunk;
+			});
+			readStream.on('end', () => {
+				assert(data == testData);
+				resolve();
+			});
+			readStream.on('error', reject);
+		});
+		await fileHandle.close();
+	});
+
+	test.skip('FileHandle.createWriteStream writes data correctly', async () => {
+		const fileHandle = await fs.promises.open(testFilePathWrite, 'w');
+		const writeStream = fileHandle.createWriteStream();
+		await new Promise<void>((resolve, reject) => {
+			writeStream.write(testData, 'utf8', err => {
+				if (err) return reject(err);
+				writeStream.end();
+			});
+			writeStream.on('finish', resolve);
+			writeStream.on('error', reject);
+		});
+		const data = await fs.promises.readFile(testFilePathWrite, 'utf8');
+		assert(data == testData);
+		await fileHandle.close();
+	});
+
+	test('FileHandle.createReadStream after close should throw', async () => {
+		const fileHandle = await fs.promises.open(testFilePath, 'r');
+		await fileHandle.close();
+		assert.throws(() => fileHandle.createReadStream());
+	});
+
+	test.skip('FileHandle.createWriteStream after close should throw', async () => {
+		const fileHandle = await fs.promises.open(testFilePathWrite, 'w');
+		await fileHandle.close();
+		assert.throws(() => fileHandle.createWriteStream());
+	});
+});

package/tests/fs/times.test.ts

@@ -0,0 +1,84 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { wait } from 'utilium';
+import { ErrnoError } from '../../src/error.js';
+import { _toUnixTimestamp } from '../../src/utils.js';
+import { fs } from '../common.js';
+
+suite('times', () => {
+	const path = 'x.txt';
+
+	function expect_assert(resource: string | number, atime: Date | number, mtime: Date | number) {
+		const stats = typeof resource == 'string' ? fs.statSync(resource) : fs.fstatSync(resource);
+		// check up to single-second precision since sub-second precision is OS and fs dependent
+		assert(_toUnixTimestamp(atime) == _toUnixTimestamp(stats.atime));
+		assert(_toUnixTimestamp(mtime) == _toUnixTimestamp(stats.mtime));
+	}
+
+	async function runTest(atime: Date | number, mtime: Date | number): Promise<void> {
+		await fs.promises.utimes(path, atime, mtime);
+		expect_assert(path, atime, mtime);
+
+		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'ENOENT');
+		});
+
+		// don't close this fd
+		const handle = await fs.promises.open(path, 'r');
+
+		await handle.utimes(atime, mtime);
+		expect_assert(handle.fd, atime, mtime);
+
+		fs.utimesSync(path, atime, mtime);
+		expect_assert(path, atime, mtime);
+
+		// some systems don't have futimes
+		// if there's an error, it be ENOSYS
+		try {
+			fs.futimesSync(handle.fd, atime, mtime);
+			expect_assert(handle.fd, atime, mtime);
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'ENOSYS');
+		}
+
+		try {
+			fs.utimesSync('foobarbaz', atime, mtime);
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code === 'ENOENT');
+		}
+
+		try {
+			fs.futimesSync(-1, atime, mtime);
+		} catch (error: any) {
+			assert(error instanceof ErrnoError);
+			assert(error.code == 'EBADF');
+		}
+	}
+
+	test('utimes works', async () => {
+		await runTest(new Date('1982/09/10 13:37:00'), new Date('1982/09/10 13:37:00'));
+		await runTest(new Date(), new Date());
+		await runTest(123456.789, 123456.789);
+		const stats = fs.statSync(path);
+		await runTest(stats.atime, stats.mtime);
+	});
+
+	test('read changes atime', async () => {
+		const before = fs.statSync(path).atimeMs;
+		fs.readFileSync(path);
+		await wait(100);
+		const after = fs.statSync(path).atimeMs;
+		assert(before < after);
+	});
+
+	test('write changes mtime', async () => {
+		const before = fs.statSync(path).mtimeMs;
+		fs.writeFileSync(path, 'cool');
+		await wait(100);
+		const after = fs.statSync(path).mtimeMs;
+		assert(before < after);
+	});
+});

package/tests/fs/truncate.test.ts

@@ -0,0 +1,94 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import type { FileHandle } from '../../src/emulation/promises.js';
+import { fs } from '../common.js';
+
+const path: string = 'truncate-file.txt',
+	size = 1024 * 16,
+	data = new Uint8Array(size).fill('x'.charCodeAt(0));
+
+suite('Truncate, sync', () => {
+	test('initial write', () => {
+		fs.writeFileSync(path, data);
+		assert(fs.statSync(path).size === size);
+	});
+
+	test('truncate to 1024', () => {
+		fs.truncateSync(path, 1024);
+		assert(fs.statSync(path).size === 1024);
+	});
+
+	test('truncate to 0', () => {
+		fs.truncateSync(path);
+		assert(fs.statSync(path).size === 0);
+	});
+
+	test('write', () => {
+		fs.writeFileSync(path, data);
+		assert(fs.statSync(path).size === size);
+	});
+
+	let fd: number;
+	test('open r+', () => {
+		fd = fs.openSync(path, 'r+');
+	});
+
+	test('ftruncate to 1024', () => {
+		fs.ftruncateSync(fd, 1024);
+		assert(fs.fstatSync(fd).size === 1024);
+	});
+
+	test('ftruncate to 0', () => {
+		fs.ftruncateSync(fd);
+		assert(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 () => {
+		await fs.promises.writeFile(path, data);
+
+		assert((await statSize(path)) === 1024 * 16);
+	});
+
+	test('truncate to 1024', async () => {
+		await fs.promises.truncate(path, 1024);
+		assert((await statSize(path)) === 1024);
+	});
+
+	test('truncate to 0', async () => {
+		await fs.promises.truncate(path);
+		assert((await statSize(path)) === 0);
+	});
+
+	test('write', async () => {
+		await fs.promises.writeFile(path, data);
+		assert((await statSize(path)) === size);
+	});
+
+	let handle: FileHandle;
+	test('open w', async () => {
+		handle = await fs.promises.open(path, 'w');
+	});
+
+	test('handle.truncate to 1024', async () => {
+		await handle.truncate(1024);
+		await handle.sync();
+		assert((await statSize(path)) === 1024);
+	});
+
+	test('handle.truncate to 0', async () => {
+		await handle.truncate();
+		await handle.sync();
+		assert((await statSize(path)) === 0);
+	});
+
+	test('close handle', async () => {
+		await handle.close();
+	});
+});