@zenfs/core 2.6.1 → 2.6.3

package/tests/common/utf8stream.test.ts

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import { Buffer } from 'buffer';
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { config, fs } from '../common.js';
+
+suite('Utf8Stream', config('write'), () => {
+	test('writes synchronously', config('sync'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-sync.log', sync: true });
+
+		assert.equal(stream.write('hello '), true);
+		assert.equal(stream.write('wörld\n'), true);
+		assert.equal(fs.readFileSync('u8-sync.log', 'utf8'), 'hello wörld\n');
+
+		stream.destroy();
+	});
+
+	test('exposes its options', config('sync'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-props.log', sync: true, minLength: 16, maxLength: 32 });
+
+		assert.equal(stream.file, 'u8-props.log');
+		assert.equal(stream.contentMode, 'utf8');
+		assert.equal(stream.sync, true);
+		assert.equal(stream.append, true);
+		assert.equal(stream.minLength, 16);
+		assert.equal(stream.maxLength, 32);
+		assert.equal(stream.periodicFlush, 0);
+		assert.equal(stream.mkdir, false);
+		assert.ok(stream.fd > 0);
+
+		stream.destroy();
+	});
+
+	test('buffers until minLength, then flushes', config('sync'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-buffered.log', sync: true, minLength: 4096 });
+
+		stream.write('buffered');
+		assert.equal(fs.readFileSync('u8-buffered.log', 'utf8'), '');
+
+		stream.flushSync();
+		assert.equal(fs.readFileSync('u8-buffered.log', 'utf8'), 'buffered');
+
+		stream.destroy();
+	});
+
+	test('truncates when append is false', config('sync'), () => {
+		fs.writeFileSync('u8-append.log', 'existing\n');
+
+		const stream = new fs.Utf8Stream({ dest: 'u8-append.log', sync: true, append: false });
+		stream.write('replaced');
+		assert.equal(fs.readFileSync('u8-append.log', 'utf8'), 'replaced');
+
+		stream.destroy();
+	});
+
+	test('writes buffers when contentMode is buffer', config('sync'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-buffer.log', sync: true, contentMode: 'buffer' });
+
+		assert.equal(stream.contentMode, 'buffer');
+		assert.throws(() => stream.write('not a buffer'), { code: 'ERR_INVALID_ARG_TYPE' });
+		stream.write(Buffer.from('hi '));
+		stream.write(Buffer.from('there'));
+		assert.equal(fs.readFileSync('u8-buffer.log', 'utf8'), 'hi there');
+
+		stream.destroy();
+	});
+
+	test('drops writes over maxLength', config('sync'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-drop.log', sync: true, maxLength: 4 });
+
+		const dropped: string[] = [];
+		stream.on('drop', data => dropped.push(data.toString()));
+
+		stream.write('12345');
+		stream.write('12');
+
+		assert.deepEqual(dropped, ['12345']);
+		assert.equal(fs.readFileSync('u8-drop.log', 'utf8'), '12');
+
+		stream.destroy();
+	});
+
+	test('reopen switches files', config('sync'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-rotate.log', sync: true, minLength: 4096 });
+
+		stream.write('before');
+		stream.flushSync();
+		stream.reopen('u8-rotated.log');
+		assert.equal(stream.file, 'u8-rotated.log');
+
+		stream.write('after');
+		stream.flushSync();
+
+		assert.equal(fs.readFileSync('u8-rotate.log', 'utf8'), 'before');
+		assert.equal(fs.readFileSync('u8-rotated.log', 'utf8'), 'after');
+
+		stream.destroy();
+	});
+
+	test('creates missing directories when mkdir is set', config('sync', 'directories'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-deep/dir/out.log', sync: true, mkdir: true });
+
+		stream.write('made it');
+		assert.equal(fs.readFileSync('u8-deep/dir/out.log', 'utf8'), 'made it');
+
+		stream.destroy();
+	});
+
+	test('writes to an existing descriptor', config('sync'), () => {
+		const fd = fs.openSync('u8-fd.log', 'w');
+		const stream = new fs.Utf8Stream({ fd, sync: true });
+
+		assert.equal(stream.fd, fd);
+		stream.write('via fd');
+		assert.equal(fs.readFileSync('u8-fd.log', 'utf8'), 'via fd');
+
+		stream.destroy();
+	});
+
+	test('throws after being destroyed', config('sync'), () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-destroyed.log', sync: true });
+		stream.destroy();
+
+		assert.throws(() => stream.write('x'), { code: 'ERR_INVALID_STATE' });
+		assert.throws(() => stream.flushSync(), { code: 'ERR_INVALID_STATE' });
+		assert.throws(() => stream.end(), { code: 'ERR_INVALID_STATE' });
+		stream.destroy(); // A second destroy is a no-op
+	});
+
+	test('validates its options', () => {
+		assert.throws(() => new fs.Utf8Stream(), { code: 'ERR_INVALID_ARG_TYPE' });
+		assert.throws(() => new fs.Utf8Stream({ dest: 'u8-invalid.log', contentMode: 'ascii' as 'utf8' }), { code: 'ERR_INVALID_ARG_VALUE' });
+		assert.throws(() => new fs.Utf8Stream({ dest: 'u8-invalid.log', minLength: 100, maxWrite: 50 }), { code: 'ERR_INVALID_ARG_VALUE' });
+		assert.throws(() => new fs.Utf8Stream({ dest: 'u8-invalid.log', sync: 'yes' as unknown as boolean }), { code: 'ERR_INVALID_ARG_TYPE' });
+		assert.throws(() => new fs.Utf8Stream({ dest: 'u8-invalid.log', fs: { write: 5 } }), { code: 'ERR_INVALID_ARG_TYPE' });
+	});
+
+	test('writes asynchronously and emits events', config('async'), async () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-async.log' });
+
+		const events: string[] = [];
+		for (const event of ['ready', 'write', 'finish', 'close'] as const) stream.on(event, () => events.push(event));
+
+		assert.equal(stream.write('async hello\n'), true);
+		stream.end();
+		await new Promise<void>(resolve => stream.on('close', () => resolve()));
+
+		assert.deepEqual(events, ['ready', 'write', 'finish', 'close']);
+		assert.equal(fs.readFileSync('u8-async.log', 'utf8'), 'async hello\n');
+	});
+
+	test('flush invokes its callback once written', config('async'), async () => {
+		const stream = new fs.Utf8Stream({ dest: 'u8-flush.log', minLength: 4096 });
+		await new Promise<void>(resolve => stream.on('ready', () => resolve()));
+
+		stream.write('flushed');
+		assert.equal(fs.readFileSync('u8-flush.log', 'utf8'), '');
+
+		await new Promise<void>((resolve, reject) => stream.flush(err => (err ? reject(err) : resolve())));
+		assert.equal(fs.readFileSync('u8-flush.log', 'utf8'), 'flushed');
+
+		stream.destroy();
+	});
+});

package/tests/fs/concurrency.test.ts

@@ -87,4 +87,27 @@ suite('Concurrency', config('write', 'async'), () => {
 		await writer.close();
 		assert.equal(await fs.promises.readFile('/issue-303-close.txt', 'utf8'), 'DIRTYnal');
 	});
+
+	test('concurrent recursive mkdir of overlapping trees does not fail #308', async () => {
+		const paths = ['/308/a', '/308/a', '/308/a/b', '/308/a/b', '/308/c', '/308/c', '/308-2', '/308-2'];
+
+		const results = await Promise.allSettled(paths.map(path => fs.promises.mkdir(path, { recursive: true })));
+
+		const rejected = results.filter(r => r.status == 'rejected');
+		assert.deepEqual(
+			rejected.map(r => r.reason.code ?? r.reason.message),
+			[]
+		);
+
+		for (const path of paths) assert((await fs.promises.stat(path)).isDirectory());
+	});
+
+	test('parallel recursive mkdir of the same path creates it once #308', async () => {
+		const results = await Promise.all(Array.from({ length: 8 }, () => fs.promises.mkdir('/308-same/nested', { recursive: true })));
+
+		assert.deepEqual(
+			results.filter(result => result !== undefined),
+			['/308-same']
+		);
+	});
 });

package/tests/fs/directory.test.ts

@@ -45,6 +45,13 @@ suite('Directories', config('directories'), () => {
 		assert.equal((await fs.promises.stat('/recursiveP/A/B/C/D')).mode, fs.constants.S_IFDIR | 0o777);
 	});
 
+	test('mkdir, recursive with a file in the way', config('async'), async () => {
+		await fs.promises.writeFile('/recursiveF', 'Sample content');
+
+		await assert.rejects(fs.promises.mkdir('/recursiveF', { recursive: true }), { code: 'EEXIST', path: '/recursiveF' });
+		await assert.rejects(fs.promises.mkdir('/recursiveF/A/B', { recursive: true }), { code: 'ENOTDIR', path: '/recursiveF/A/B' });
+	});
+
 	test('mkdirSync, recursive', config('sync'), () => {
 		assert.equal(fs.mkdirSync('/recursiveS/A/B', { recursive: true, mode: 0o755 }), '/recursiveS');
 		assert.equal(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o777 }), '/recursiveS/A/B/C');
@@ -57,6 +64,13 @@ suite('Directories', config('directories'), () => {
 		assert.equal(fs.statSync('/recursiveS/A/B/C/D').mode, fs.constants.S_IFDIR | 0o777);
 	});
 
+	test('mkdirSync, recursive with a file in the way', config('sync'), () => {
+		fs.writeFileSync('/recursiveSF', 'Sample content');
+
+		assert.throws(() => fs.mkdirSync('/recursiveSF', { recursive: true }), { code: 'EEXIST', path: '/recursiveSF' });
+		assert.throws(() => fs.mkdirSync('/recursiveSF/A/B', { recursive: true }), { code: 'ENOTDIR', path: '/recursiveSF/A/B' });
+	});
+
 	test('rmdir (non-empty)', config('async'), async () => {
 		await fs.promises.mkdir('/rmdirTest');
 		await fs.promises.mkdir('/rmdirTest/rmdirTest2');
@@ -165,4 +179,11 @@ suite('Directories', config('directories'), () => {
 		fs.writeFileSync('/мой-файл.txt', 'HELLO!', 'utf-8');
 		assert(fs.readdirSync('/').includes('мой-файл.txt'));
 	});
+
+	test('re-creating a deleted path still shows up in readdir #305', config('sync'), () => {
+		fs.unlinkSync('/elipses.txt');
+		fs.writeFileSync('/elipses.txt', '...');
+
+		assert(fs.readdirSync('/').includes('elipses.txt'));
+	});
 });

package/tests/fs/links.test.ts

@@ -83,4 +83,150 @@ suite('Links', config('symlinks'), () => {
 		const linkContent = await fs.promises.readFile(link, 'utf8');
 		assert.equal(targetContent, linkContent);
 	});
+
+	test('mkdir does not follow a symlink at the final component', config('async'), async () => {
+		await fs.promises.mkdir('/mkdir-real');
+		await fs.promises.symlink('/mkdir-real', '/mkdir-link');
+		await fs.promises.writeFile('/mkdir-file', 'contents');
+		await fs.promises.symlink('/mkdir-file', '/mkdir-flink');
+		await fs.promises.symlink('/mkdir-missing', '/mkdir-dangling');
+
+		await assert.rejects(fs.promises.mkdir('/mkdir-link'), { code: 'EEXIST' });
+		await assert.rejects(fs.promises.mkdir('/mkdir-dangling'), { code: 'EEXIST' });
+		await assert.rejects(fs.promises.mkdir('/mkdir-flink', { recursive: true }), { code: 'EEXIST' });
+		await assert.rejects(fs.promises.mkdir('/mkdir-dangling', { recursive: true }), { code: 'ENOENT' });
+
+		// 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')));
+	});
+
+	test('mkdir follows symlinks for intermediate components', config('async'), async () => {
+		assert.equal(await fs.promises.mkdir('/mkdir-link/direct'), undefined);
+		assert.equal(await fs.promises.mkdir('/mkdir-link/nested/deep', { recursive: true }), '/mkdir-link/nested');
+
+		assert.deepEqual((await fs.promises.readdir('/mkdir-real')).sort(), ['direct', 'nested']);
+		assert((await fs.promises.stat('/mkdir-real/nested/deep')).isDirectory());
+
+		await assert.rejects(fs.promises.mkdir('/mkdir-flink/x', { recursive: true }), { code: 'ENOTDIR' });
+
+		// 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')));
+	});
+
+	test('mkdirSync does not follow a symlink at the final component', config('sync'), () => {
+		fs.mkdirSync('/mkdirS-real');
+		fs.symlinkSync('/mkdirS-real', '/mkdirS-link');
+		fs.writeFileSync('/mkdirS-file', 'contents');
+		fs.symlinkSync('/mkdirS-file', '/mkdirS-flink');
+		fs.symlinkSync('/mkdirS-missing', '/mkdirS-dangling');
+
+		assert.throws(() => fs.mkdirSync('/mkdirS-link'), { code: 'EEXIST' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-dangling'), { code: 'EEXIST' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-flink', { recursive: true }), { code: 'EEXIST' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-dangling', { recursive: true }), { code: 'ENOENT' });
+
+		assert.equal(fs.mkdirSync('/mkdirS-link', { recursive: true }), undefined);
+		assert(fs.lstatSync('/mkdirS-link').isSymbolicLink());
+		assert(!fs.existsSync('/mkdirS-missing'));
+	});
+
+	test('mkdirSync follows symlinks for intermediate components', config('sync'), () => {
+		assert.equal(fs.mkdirSync('/mkdirS-link/direct'), undefined);
+		assert.equal(fs.mkdirSync('/mkdirS-link/nested/deep', { recursive: true }), '/mkdirS-link/nested');
+
+		assert.deepEqual(fs.readdirSync('/mkdirS-real').sort(), ['direct', 'nested']);
+		assert(fs.statSync('/mkdirS-real/nested/deep').isDirectory());
+
+		assert.throws(() => fs.mkdirSync('/mkdirS-flink/x', { recursive: true }), { code: 'ENOTDIR' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-dangling/x', { recursive: true }), { code: 'ENOENT', path: '/mkdirS-dangling/x' });
+		assert(!fs.existsSync('/mkdirS-missing'));
+	});
+
+	test('writeFile and appendFile follow symlinks', config('async'), async () => {
+		await fs.promises.mkdir('/wf-real');
+		await fs.promises.symlink('/wf-real', '/wf-link');
+		await fs.promises.writeFile('/wf-real/f.txt', 'original');
+		await fs.promises.symlink('/wf-real/f.txt', '/wf-flink');
+		await fs.promises.symlink('/wf-missing.txt', '/wf-dangling');
+
+		await fs.promises.writeFile('/wf-link/new.txt', 'hi');
+		assert.equal(await fs.promises.readFile('/wf-real/new.txt', 'utf8'), 'hi');
+
+		// A link to a file is written through, not replaced
+		await fs.promises.writeFile('/wf-flink', 'replaced');
+		await fs.promises.appendFile('/wf-flink', '+');
+		assert.equal(await fs.promises.readFile('/wf-real/f.txt', 'utf8'), 'replaced+');
+		assert((await fs.promises.lstat('/wf-flink')).isSymbolicLink());
+
+		// Writing through a dangling link creates its target
+		await fs.promises.writeFile('/wf-dangling', 'made');
+		assert.equal(await fs.promises.readFile('/wf-missing.txt', 'utf8'), 'made');
+		assert((await fs.promises.lstat('/wf-dangling')).isSymbolicLink());
+	});
+
+	test('writeFileSync and appendFileSync follow symlinks', config('sync'), () => {
+		fs.mkdirSync('/wfS-real');
+		fs.symlinkSync('/wfS-real', '/wfS-link');
+		fs.writeFileSync('/wfS-real/f.txt', 'original');
+		fs.symlinkSync('/wfS-real/f.txt', '/wfS-flink');
+		fs.symlinkSync('/wfS-missing.txt', '/wfS-dangling');
+
+		fs.writeFileSync('/wfS-link/new.txt', 'hi');
+		assert.equal(fs.readFileSync('/wfS-real/new.txt', 'utf8'), 'hi');
+
+		fs.writeFileSync('/wfS-flink', 'replaced');
+		fs.appendFileSync('/wfS-flink', '+');
+		assert.equal(fs.readFileSync('/wfS-real/f.txt', 'utf8'), 'replaced+');
+		assert(fs.lstatSync('/wfS-flink').isSymbolicLink());
+
+		fs.writeFileSync('/wfS-dangling', 'made');
+		assert.equal(fs.readFileSync('/wfS-missing.txt', 'utf8'), 'made');
+		assert(fs.lstatSync('/wfS-dangling').isSymbolicLink());
+	});
+
+	test('cp preserves a symlink by default #304', async () => {
+		await fs.promises.mkdir('/cp-src');
+		await fs.promises.writeFile('/cp-src/real.txt', 'contents');
+		await fs.promises.symlink('real.txt', '/cp-src/link.txt');
+
+		await fs.promises.cp('/cp-src', '/cp-dst', { recursive: true });
+
+		const stats = await fs.promises.lstat('/cp-dst/link.txt');
+		assert(stats.isSymbolicLink());
+
+		// A relative target is resolved against the link's directory, so the copy points at the original file
+		assert.equal(await fs.promises.readlink('/cp-dst/link.txt'), '/cp-src/real.txt');
+	});
+
+	test('cp with verbatimSymlinks keeps the target unresolved', async () => {
+		await fs.promises.cp('/cp-src', '/cp-verbatim', { recursive: true, verbatimSymlinks: true });
+
+		assert((await fs.promises.lstat('/cp-verbatim/link.txt')).isSymbolicLink());
+		assert.equal(await fs.promises.readlink('/cp-verbatim/link.txt'), 'real.txt');
+	});
+
+	test('cp with dereference copies the symlink target contents #304', async () => {
+		await fs.promises.cp('/cp-src', '/cp-deref', { recursive: true, dereference: true });
+
+		const stats = await fs.promises.lstat('/cp-deref/link.txt');
+		assert(!stats.isSymbolicLink());
+		assert.equal(await fs.promises.readFile('/cp-deref/link.txt', 'utf8'), 'contents');
+	});
+
+	test('cpSync preserves a symlink #304', () => {
+		fs.writeFileSync('/cp-sync-target.txt', 'contents');
+		fs.symlinkSync('cp-sync-target.txt', '/cp-sync-link');
+
+		fs.cpSync('/cp-sync-link', '/cp-sync-link-copy');
+
+		const stats = fs.lstatSync('/cp-sync-link-copy');
+		assert(stats.isSymbolicLink());
+		assert.equal(fs.readlinkSync('/cp-sync-link-copy'), '/cp-sync-target.txt');
+
+		fs.cpSync('/cp-sync-link', '/cp-sync-link-verbatim', { verbatimSymlinks: true });
+		assert.equal(fs.readlinkSync('/cp-sync-link-verbatim'), 'cp-sync-target.txt');
+	});
 });

package/tests/fs/stat.test.ts

@@ -1,5 +1,5 @@
 // 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';
@@ -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/native/setup.ts

@@ -47,6 +47,7 @@ function toNative(path: PathLike): string {
 
 /** Translate a native path back into a test path */
 function fromNative(path: string): string {
+	if (!isAbsolute(path)) return path;
 	return resolve('/', relative(root, path));
 }