@zenfs/core 2.5.8 → 2.6.0

package/scripts/test.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // NOTE: Not compiled, use erasable TS only
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { existsSync, globSync, mkdirSync, rmSync } from 'node:fs';
 import { join, parse, basename } from 'node:path';
 import { parseArgs, styleText } from 'node:util';
@@ -25,7 +25,7 @@ const { values: options, positionals } = parseArgs({
 		inspect: { short: 'I', type: 'boolean', default: false },
 		skip: { short: 's', type: 'string', multiple: true, default: [] },
 		'exit-on-fail': { short: 'e', type: 'boolean' },
-		runs: { short: 'r', type: 'string' },
+		runs: { short: 'r', type: 'string', default: '1' },
 
 		// Coverage and performance
 		coverage: { type: 'string', default: 'tests/.coverage' },
@@ -34,9 +34,13 @@ const { values: options, positionals } = parseArgs({
 		clean: { type: 'boolean', default: false },
 		profile: { type: 'boolean', default: false },
 	},
+	strict: true,
 	allowPositionals: true,
 });
 
+/**
+ * @param  {...any} args
+ */
 function debug(...args) {
 	if (options.debug) console.debug(styleText('dim', '[debug]'), ...args.map(a => (typeof a === 'string' ? styleText('dim', a) : a)));
 }
@@ -92,7 +96,7 @@ if (options.clean) {
 
 function report() {
 	try {
-		execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
+		execFileSync('npx', ['--silent', 'c8', 'report', '--reporter=text'], { stdio: 'inherit' });
 	} catch (e) {
 		console.error('Failed to generate coverage report!');
 		console.error(e);
@@ -106,9 +110,12 @@ if (options.report) {
 	process.exit();
 }
 
+const nRuns = Number.isSafeInteger(parseInt(options.runs)) ? parseInt(options.runs) : 1;
+
+/** @type {typeof import('./ci.js')} */
 let ci;
 if (options.ci) {
-	if (options.runs) {
+	if (options.runs && nRuns !== 1) {
 		console.error('Cannot use --ci with --runs');
 		process.exit(1);
 	}
@@ -120,7 +127,7 @@ options.verbose && options.force && console.debug('Forcing tests to exit (--test
 if (options.build) {
 	!options.quiet && process.stdout.write('Building... ');
 	try {
-		execSync('npm run build');
+		execFileSync('npm', ['run', 'build', '--silent'], { stdio: 'inherit' });
 		console.log('done.');
 	} catch {
 		console.warn('failed, continuing without it.');
@@ -151,22 +158,24 @@ mkdirSync(options.coverage, { recursive: true });
  * Generate the command used to run the tests
  * @param {string} profileName
  * @param {...string} rest
- * @returns {string}
+ * @returns {string[]}
  */
 function makeCommand(profileName, ...rest) {
 	const command = [
-		'tsx --trace-deprecation',
-		options.inspect ? '--inspect' : '',
-		'--test --experimental-test-coverage',
-		options.force ? '--test-force-exit' : '',
-		options.skip.length ? `--test-skip-pattern='${options.skip.join('|').replaceAll("'", "\\'")}'` : '',
-		!options.profile ? '' : `--cpu-prof --cpu-prof-dir=.profiles --cpu-prof-name=${profileName}.cpuprofile --cpu-prof-interval=500`,
+		'--trace-deprecation',
+		options.inspect && '--inspect',
+		'--test',
+		'--experimental-test-coverage',
+		options.force && '--test-force-exit',
+		options.skip.length && `--test-skip-pattern=${options.skip.join('|')}`,
+		...(!options.profile
+			? []
+			: ['--cpu-prof', '--cpu-prof-dir=.profiles', `--cpu-prof-name=${profileName}.cpuprofile`, '--cpu-prof-interval=500']),
 		...rest,
 	]
 		.filter(v => v)
-		.join(' ');
-
-	if (!options.quiet) debug('command:', command);
+		.filter(v => typeof v == 'string');
+	if (!options.quiet) debug('command: tsx', command.join(' '));
 
 	return command;
 }
@@ -186,8 +195,6 @@ function duration(ms) {
 	return ms + ' ' + unit;
 }
 
-const nRuns = Number.isSafeInteger(parseInt(options.runs)) ? parseInt(options.runs) : 1;
-
 /**
  * @typedef {object} RunTestOptions
  * @property {string} name
@@ -228,7 +235,7 @@ async function runTests(config) {
 		}
 
 		try {
-			execSync(command, {
+			execFileSync('tsx', command, {
 				stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 			});
 			if (!options.quiet) console.log(`${styleText('green', 'passed')}${identText} ${time()}`);
@@ -250,7 +257,7 @@ async function runTests(config) {
 if (options.common) {
 	await runTests({
 		name: 'common',
-		args: [`'tests/*.test.ts'`, `'tests/**/!(fs)/*.test.ts'`],
+		args: ['tests/*.test.ts', `tests/**/!(fs)/*.test.ts`],
 		statusName: 'Common tests',
 	});
 }
@@ -269,9 +276,9 @@ for (const setupFile of positionals) {
 
 	await runTests({
 		name,
-		args: [`'${testsGlob.replaceAll("'", "\\'")}'`, process.env.CMD],
+		args: [`${testsGlob.replaceAll("'", "\\'")}`, process.env.CMD || ''],
 		shouldSkip() {
-			return basename(setupFile).startsWith('_');
+			return basename(setupFile).startsWith('_') && options.auto;
 		},
 	});
 }

package/tests/backend/port.test.ts

@@ -44,7 +44,7 @@ suite('Remote FS with resolveRemoteMount', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: configPort, timeout: 500 });
+		await configureSingle({ backend: Port, port: configPort, timeout: 1000 });
 	});
 
 	test('Write', async () => {
@@ -71,7 +71,7 @@ await suite('FS with MessageChannel', () => {
 	test('configuration', async () => {
 		tmpfs = await resolveMountConfig({ backend: InMemory, label: 'tmp' });
 		attachFS(channel.port2, tmpfs);
-		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 500 });
+		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 1000 });
 	});
 
 	test('write', async () => {
@@ -108,7 +108,7 @@ await suite('Remote FS', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: remotePort, timeout: 500 });
+		await configureSingle({ backend: Port, port: remotePort, timeout: 1000 });
 	});
 
 	test('Write', async () => {

package/tests/backend/store.test.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import { InMemoryStore, StoreFS } from '@zenfs/core';
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { setupLogs } from '../logs.js';
+setupLogs();
+
+const fs = new StoreFS(new InMemoryStore(0x100000, 'test'));
+await fs.ready();
+
+const encoder = new TextEncoder();
+
+suite('StoreFS', () => {
+	test('write updates inode metadata atomically #286', async () => {
+		await fs.createFile('/example.json', { mode: 0o644, uid: 0, gid: 0 });
+		const before = await fs.stat('/example.json');
+
+		// Write without a following touch(), like an interrupted VFS flush
+		const data = encoder.encode('{"json":true}');
+		await fs.write('/example.json', data, 0);
+
+		const after = await fs.stat('/example.json');
+		assert.equal(after.size, data.byteLength);
+		assert(after.mtimeMs >= before.mtimeMs);
+	});
+
+	test('writeSync updates inode metadata atomically #286', () => {
+		fs.createFileSync('/example-sync.json', { mode: 0o644, uid: 0, gid: 0 });
+
+		const data = encoder.encode('{"sync":true}');
+		fs.writeSync('/example-sync.json', data, 0);
+
+		const stats = fs.statSync('/example-sync.json');
+		assert.equal(stats.size, data.byteLength);
+	});
+
+	test('write does not resurrect truncated data', async () => {
+		await fs.createFile('/truncated.txt', { mode: 0o644, uid: 0, gid: 0 });
+
+		await fs.write('/truncated.txt', encoder.encode('a'.repeat(100)), 0);
+		await fs.touch('/truncated.txt', { size: 5 });
+
+		// A small write within the truncated size must not restore the old length from the data blob
+		await fs.write('/truncated.txt', encoder.encode('bbb'), 0);
+
+		const stats = await fs.stat('/truncated.txt');
+		assert.equal(stats.size, 5);
+	});
+});

package/tests/common.ts

@@ -20,3 +20,65 @@ const setup = await import(setupPath).catch(error => {
 
 // Satisfies is used to make sure that ZenFS is fully type compatible with Node.js
 export const fs = (setup.fs || defaultFS) as typeof defaultFS satisfies NodeFS;
+
+export const Stats = (setup.Stats || defaultFS.Stats) as typeof defaultFS.Stats;
+
+/**
+ * A feature or function a backend may not support.
+ * Tests that need one are skipped when the backend under test does not have it.
+ */
+export type TestFlag =
+	| 'sync'
+	| 'async'
+	| 'write'
+	| 'appends'
+	| 'directories'
+	| 'links'
+	| 'symlinks'
+	| 'rename'
+	| 'truncate'
+	| 'streams'
+	| 'watch'
+	| 'permissions'
+	| 'xattr'
+	| 'times'
+	| 'tempdir'
+	| 'lchmod';
+
+/**
+ * Whether a backend supports a flag.
+ *
+ * `false` is for things a backend can not support, while `'skip'` is for temporarily disabling something.
+ * `'todo'` is for things that should work but don't yet.
+ */
+export type TestFlagState = boolean | 'skip' | 'todo';
+
+/** Flags are supported unless the setup says otherwise */
+const flags = (setup.flags ?? {}) as Partial<Record<TestFlag, TestFlagState>>;
+
+/** Options for `suite` and `test`. Note this is a subset of both, since they do not share a type. */
+export interface TestConfig {
+	skip?: string;
+	todo?: string;
+}
+
+/**
+ * Configures a `suite` or `test` to run only if the backend supports all of the given flags.
+ *
+ * @example
+ * ```ts
+ * test('lchmod', config('lchmod', 'async'), async () => { ... });
+ * ```
+ */
+export function config(...required: TestFlag[]): TestConfig {
+	for (const flag of required) {
+		const state = flags[flag] ?? true;
+
+		if (state === true) continue;
+		if (state == 'todo') return { todo: `${flag} is not implemented yet` };
+
+		return { skip: state == 'skip' ? `${flag} is temporarily skipped` : `${flag} is not supported` };
+	}
+
+	return {};
+}

package/tests/fetch/fetch.ts

@@ -1,5 +1,6 @@
 import { configure, Fetch } from '@zenfs/core';
 import { log } from 'kerium';
+import type { TestFlag, TestFlagState } from '../common.js';
 import { baseUrl } from './config.js';
 
 await configure({
@@ -18,3 +19,8 @@ await configure({
 		dumpBacklog: true,
 	},
 });
+
+export const flags: Partial<Record<TestFlag, TestFlagState>> = {
+	// `IndexFS` does not implement hard links
+	links: false,
+};

package/tests/fetch/run.sh

@@ -6,12 +6,12 @@ SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
 node $SCRIPT_DIR/server.js &
 PID=$!
 
-echo -n "Waiting for server to start..."
+echo -en "Waiting for server to start...\r"
 if [ -n "$VERBOSE" ]; then echo; fi
 until nc -z localhost 26514; do
   sleep 0.25
 done
 
-npx zenfs-test $SCRIPT_DIR/fetch.ts --preserve --force "$@"
+npx --silent zenfs-test $SCRIPT_DIR/fetch.ts --preserve --force "$@"
 
 kill $PID

package/tests/fetch/server.js

@@ -1,15 +1,15 @@
-import { execSync } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { createServer } from 'node:http';
 import { join } from 'node:path';
-import { data, port, tmp, indexPath } from './config.js';
+import { data, indexPath, port, tmp } from './config.js';
 
 const statusCodes = {
 	ENOENT: 404,
 };
 
 try {
-	execSync(`npm exec make-index -- ${data} --output ${tmp}/index.json --quiet`, { stdio: 'inherit' });
+	execFileSync('npx', ['--silent', 'make-index', data, '--output', `${tmp}/index.json`, '--quiet'], { stdio: 'inherit' });
 } catch (e) {
 	if (e.signal == 'SIGINT') {
 		console.log('Aborted whilst creating index');

package/tests/fs/append.test.ts

@@ -1,20 +1,20 @@
 // 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 { fs, config } from '../common.js';
 
 const content = 'Sample content',
 	original = 'ABCD';
 
-suite('Appends', () => {
-	test('Create an empty file and add content', async () => {
+suite('Appends', config('appends'), () => {
+	test('Create an empty file and add content', config('async'), async () => {
 		const filename = 'append.txt';
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
 		assert.equal(data, content);
 	});
 
-	test('Append data to a non-empty file', async () => {
+	test('Append data to a non-empty file', config('async'), async () => {
 		const filename = 'append2.txt';
 
 		await fs.promises.writeFile(filename, original);
@@ -23,7 +23,7 @@ suite('Appends', () => {
 		assert.equal(data, original + content);
 	});
 
-	test('Append a buffer to the file', async () => {
+	test('Append a buffer to the file', config('async'), async () => {
 		const filename = 'append3.txt';
 
 		await fs.promises.writeFile(filename, original);

package/tests/fs/concurrency.test.ts

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { config, fs } from '../common.js';
+
+suite('Concurrency', config('write', 'async'), () => {
+	test('parallel writeFile in the same directory does not lose entries #256', async () => {
+		await fs.promises.mkdir('/issue-256');
+
+		await Promise.all([fs.promises.writeFile('/issue-256/a1.txt', 'a1'), fs.promises.writeFile('/issue-256/a2.txt', 'a2')]);
+
+		const files = await fs.promises.readdir('/issue-256');
+		assert.deepEqual(files.sort(), ['a1.txt', 'a2.txt']);
+	});
+
+	test('concurrent file creation does not lose directory entries #298', async () => {
+		await fs.promises.mkdir('/issue-298');
+
+		const names = Array.from({ length: 32 }, (_, i) => `file-${i}.txt`);
+		await Promise.all(names.map(name => fs.promises.writeFile(`/issue-298/${name}`, name)));
+
+		const files = await fs.promises.readdir('/issue-298');
+		assert.deepEqual(files.sort(), names.sort());
+	});
+
+	test('open handles for the same file share metadata #287', async () => {
+		await fs.promises.writeFile('/issue-287.txt', 'Hello World');
+
+		const a = await fs.promises.open('/issue-287.txt', 'r+');
+		const b = await fs.promises.open('/issue-287.txt', 'r+');
+
+		await a.truncate(5); // contents are now "Hello"
+		const { size } = await b.stat();
+		assert.equal(size, 5);
+
+		await a.close();
+		await b.close();
+	});
+
+	test('writes are visible to other open handles before syncing', async () => {
+		const a = await fs.promises.open('/shared-write.txt', 'w+');
+		const b = await fs.promises.open('/shared-write.txt', 'r');
+
+		await a.write('some shared data');
+
+		const { buffer } = await b.read(new Uint8Array(16), 0, 16, 0);
+		assert.equal(new TextDecoder().decode(buffer), 'some shared data');
+
+		await a.close();
+		await b.close();
+	});
+});

package/tests/fs/dir.test.ts

@@ -2,7 +2,7 @@
 import { sync, type Dirent } from '@zenfs/core';
 import assert, { rejects } from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { config, fs } from '../common.js';
 
 const testFile = 'test-file.txt';
 fs.writeFileSync(testFile, 'Sample content');
@@ -16,8 +16,8 @@ for (const file of testFiles) {
 }
 await sync();
 
-suite('Dir', () => {
-	test('read()', async () => {
+suite('Dir', config('directories'), () => {
+	test('read()', config('async'), async () => {
 		const dir = fs.opendirSync(testDirPath);
 
 		const dirent1 = await dir.read();
@@ -34,7 +34,7 @@ suite('Dir', () => {
 		await dir.close();
 	});
 
-	test('readSync()', () => {
+	test('readSync()', config('sync'), () => {
 		const dir = fs.opendirSync(testDirPath);
 
 		const dirent1 = dir.readSync();
@@ -51,19 +51,19 @@ suite('Dir', () => {
 		dir.closeSync();
 	});
 
-	test('close()', async () => {
+	test('close()', config('async'), async () => {
 		const dir = fs.opendirSync(testDirPath);
 		await dir.close();
 		rejects(dir.read());
 	});
 
-	test('closeSync()', () => {
+	test('closeSync()', config('sync'), () => {
 		const dir = fs.opendirSync(testDirPath);
 		dir.closeSync();
 		assert.throws(() => dir.readSync());
 	});
 
-	test('asynchronous iteration', async () => {
+	test('asynchronous iteration', config('async'), async () => {
 		const dir = fs.opendirSync(testDirPath);
 		const dirents: Dirent[] = [];
 
@@ -77,29 +77,27 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirents[1].name));
 	});
 
-	test('read after directory is closed', async () => {
+	test('read after directory is closed', config('async'), async () => {
 		const dir = fs.opendirSync(testDirPath);
 		await dir.close();
 		await assert.rejects(dir.read());
 	});
 
-	test('readSync after directory is closed', () => {
+	test('readSync after directory is closed', config('sync'), () => {
 		const dir = fs.opendirSync(testDirPath);
 		dir.closeSync();
 		assert.throws(() => dir.readSync());
 	});
 
-	test('close multiple times', async () => {
+	test('close multiple times', config('async'), async () => {
 		const dir = fs.opendirSync(testDirPath);
 		await dir.close();
-		await dir.close(); // Should not throw an error
-		assert(dir['closed']);
+		await assert.rejects(dir.close(), { code: 'ERR_DIR_CLOSED' });
 	});
 
-	test('closeSync multiple times', () => {
+	test('closeSync multiple times', config('sync'), () => {
 		const dir = fs.opendirSync(testDirPath);
 		dir.closeSync();
-		dir.closeSync(); // Should not throw an error
-		assert(dir['closed']);
+		assert.throws(() => dir.closeSync(), { code: 'ERR_DIR_CLOSED' });
 	});
 });