@zenfs/core 1.7.2 → 1.8.0

package/scripts/test.js

@@ -16,7 +16,10 @@ const { values: options, positionals } = parseArgs({
 		build: { short: 'b', type: 'boolean', default: false },
 		common: { short: 'c', type: 'boolean', default: false },
 		coverage: { type: 'string', default: 'tests/.coverage' },
+		preserve: { short: 'p', type: 'boolean' },
 		'exit-on-fail': { short: 'e', type: 'boolean' },
+		report: { type: 'boolean' },
+		clean: { type: 'boolean' },
 	},
 	allowPositionals: true,
 });
@@ -36,7 +39,12 @@ Options:
     -q, --quiet         Don't output normal messages
     -t, --test <glob>   Which FS test suite(s) to run
     -f, --force         Whether to use --test-force-exit
-    --coverage <dir>    Override the default coverage data directory`);
+
+Coverage:
+    --coverage <dir>    Override the default coverage data directory
+    -p,--preserve       Do not delete or report coverage data
+	--report            ONLY report coverage
+    --clean             ONLY clean up coverage directory`);
 	process.exit();
 }
 
@@ -45,6 +53,19 @@ if (options.quiet && options.verbose) {
 	process.exit(1);
 }
 
+process.env.NODE_V8_COVERAGE = options.coverage;
+
+if (options.clean) {
+	rmSync(options.coverage, { recursive: true, force: true });
+	process.exit();
+}
+
+if (options.report) {
+	execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
+	rmSync(options.coverage, { recursive: true, force: true });
+	process.exit();
+}
+
 options.verbose && options.force && console.debug('Forcing tests to exit (--test-force-exit)');
 
 if (options.build) {
@@ -73,19 +94,56 @@ if (options.auto) {
 	!options.quiet && console.log(`Auto-detected ${sum} test setup files`);
 }
 
-if (existsSync(options.coverage)) rmSync(options.coverage, { recursive: true });
-mkdirSync(options.coverage);
-process.env.NODE_V8_COVERAGE = options.coverage;
+/**
+ * Colorizes some text
+ * @param {string} text Text to color
+ * @param {string | number} code ANSI escape code
+ * @returns
+ */
+function color(text, code) {
+	return `\x1b[${code}m${text}\x1b[0m`;
+}
+
+function status(name) {
+	const start = performance.now();
+
+	const time = () => {
+		let delta = Math.round(performance.now() - start),
+			unit = 'ms';
+
+		if (delta > 5000) {
+			delta /= 1000;
+			unit = 's';
+		}
+
+		return color(`(${delta} ${unit})`, '2;37');
+	};
+
+	return {
+		pass() {
+			if (!options.quiet) console.log(`${color('passed', 32)}: ${name} ${time()}`);
+		},
+		fail() {
+			console.error(`${color('failed', '1;31')}: ${name} ${time()}`);
+			process.exitCode = 1;
+			if (options['exit-on-fail']) process.exit();
+		},
+	};
+}
+
+if (!options.preserve) rmSync(options.coverage, { force: true, recursive: true });
+mkdirSync(options.coverage, { recursive: true });
 
 if (options.common) {
 	!options.quiet && console.log('Running common tests...');
+	const { pass, fail } = status('Common tests');
 	try {
 		execSync("tsx --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'", {
 			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 		});
+		pass();
 	} catch {
-		console.error('Common tests failed');
-		if (options['exit-on-fail']) process.exit(1);
+		fail();
 	}
 }
 
@@ -97,18 +155,22 @@ for (const setupFile of positionals) {
 		continue;
 	}
 
-	!options.quiet && console.debug('Running tests using setup:', setupFile);
+	!options.quiet && console.log('Running tests:', setupFile);
 	process.env.SETUP = setupFile;
 
+	const { pass, fail } = status(setupFile);
+
 	try {
 		execSync(['tsx --test --experimental-test-coverage', options.force ? '--test-force-exit' : '', testsGlob, process.env.CMD].join(' '), {
 			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 		});
+		pass();
 	} catch {
-		!options.quiet && console.error('Tests failed:', setupFile);
-		if (options['exit-on-fail']) process.exit(1);
+		fail();
 	}
 }
 
-execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
-rmSync(options.coverage, { recursive: true });
+if (!options.preserve) {
+	execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
+	rmSync(options.coverage, { recursive: true });
+}

package/tests/common/mutex.test.ts

@@ -51,7 +51,7 @@ suite('LockFS mutex', () => {
 
 		async function foo() {
 			const lock = await fs.lock('raceConditions', 'test');
-			await wait(100);
+			await wait(25);
 			x++;
 			lock.unlock();
 		}

package/tests/fetch/run.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/bash
+
+# Credit: Dave Dopson, https://stackoverflow.com/a/246128/17637456
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+npx tsx $SCRIPT_DIR/server.ts &
+PID=$!
+
+echo "Waiting for server to start..."
+until nc -z localhost 26514; do
+  sleep 0.5
+done
+
+npx zenfs-test $SCRIPT_DIR/setup.ts --preserve --force $@
+
+kill $PID

package/tests/fetch/server.ts

@@ -0,0 +1,49 @@
+import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { data, tmp } from '../setup.js';
+
+// If you change the port please update the setup file as well
+const port = 26514;
+
+const statusCodes = {
+	ENOENT: 404,
+};
+
+try {
+	execSync(`npm exec make-index -- ${data} --output ${tmp}/index.json --quiet`, { stdio: 'inherit' });
+} catch (e: any) {
+	if (e.signal == 'SIGINT') {
+		console.log('Aborted whilst creating index.');
+		process.exit(0);
+	} else {
+		console.error('Index creation failed: ' + e.message);
+		process.exit(1);
+	}
+}
+
+const server = createServer((request, response) => {
+	const { url = '' } = request;
+
+	if (url == '/.ping') {
+		response.statusCode = 200;
+		response.end('pong');
+		return;
+	}
+
+	const path = url == '/.index.json' ? join(tmp, 'index.json') : join(data, url.slice(1) || '');
+	try {
+		response.statusCode = 200;
+		response.end(readFileSync(path));
+	} catch (e: any) {
+		response.statusCode = statusCodes[e.code as keyof typeof statusCodes] || 400;
+		response.end();
+	}
+});
+
+server.listen(port);
+
+process.on('beforeExit', () => {
+	server.close().unref();
+});

package/tests/fetch/setup.ts

@@ -0,0 +1,13 @@
+import { configureSingle, Fetch, InMemory, Overlay, resolveMountConfig } from '../../dist/index.js';
+
+const baseUrl = 'http://localhost:26514';
+
+await configureSingle({
+	backend: Overlay,
+	readable: await resolveMountConfig({
+		backend: Fetch,
+		baseUrl,
+		index: baseUrl + '/.index.json',
+	}),
+	writable: InMemory.create({ name: 'cow' }),
+});

package/tests/fs/read.test.ts

@@ -1,17 +1,17 @@
 import assert from 'node:assert';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
+import { Buffer } from 'buffer';
 
-const filepath: string = 'x.txt';
-const expected: string = 'xyz\n';
+const filepath = 'x.txt';
+const expected = '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.equal(bytesRead, expected.length);
-		assert(buffer.toString() == expected);
+		assert.equal(buffer.toString(), expected);
 	});
 
 	test('read file synchronously', () => {
@@ -20,19 +20,19 @@ suite('read', () => {
 		const bytesRead = fs.readSync(fd, buffer, 0, expected.length, 0);
 
 		assert.equal(bytesRead, expected.length);
-		assert(buffer.toString() == expected);
+		assert.equal(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);
+		assert.strictEqual((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);
+		assert.strictEqual((buff[1] << 8) | buff[0], 32994);
 	});
 });
 
@@ -45,14 +45,14 @@ suite('read buffer', () => {
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
 		assert.strictEqual(bytesRead, expected.length);
-		assert(bufferAsync.toString() === expected);
+		assert.strictEqual(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.strictEqual(bufferSync.toString(), expected);
 		assert.strictEqual(bytesRead, expected.length);
 	});
 
@@ -61,7 +61,7 @@ suite('read buffer', () => {
 		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.strictEqual(buffer.subarray(10, buffer.length).toString(), expected);
 		assert.strictEqual(bytesRead, expected.length);
 	});
 });

package/tests/fs/times.test.ts

@@ -69,7 +69,7 @@ suite('times', () => {
 	test('read changes atime', async () => {
 		const before = fs.statSync(path).atimeMs;
 		fs.readFileSync(path);
-		await wait(100);
+		await wait(25);
 		const after = fs.statSync(path).atimeMs;
 		assert(before < after);
 	});
@@ -77,7 +77,7 @@ suite('times', () => {
 	test('write changes mtime', async () => {
 		const before = fs.statSync(path).mtimeMs;
 		fs.writeFileSync(path, 'cool');
-		await wait(100);
+		await wait(25);
 		const after = fs.statSync(path).mtimeMs;
 		assert(before < after);
 	});

package/tests/setup/index.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path/posix';
+import { configureSingle, InMemory, InMemoryStore, mounts, Overlay, Readonly, resolveMountConfig, StoreFS } from '../../dist/index.js';
+import { S_IFDIR } from '../../dist/vfs/constants.js';
+import { copy, data } from '../setup.js';
+
+copy(data);
+
+const index = (mounts.get('/') as StoreFS).createIndexSync();
+
+class MockFS extends Readonly(StoreFS) {
+	constructor() {
+		super(new InMemoryStore());
+		this.loadIndexSync(index);
+
+		using tx = this.store.transaction();
+
+		for (const [path, node] of index) {
+			if (node.mode & S_IFDIR) continue;
+
+			const content = readFileSync(join(data, path));
+
+			tx.setSync(node.data, content);
+		}
+
+		tx.commitSync();
+	}
+}
+
+const readable = new MockFS();
+
+await readable.ready();
+
+await configureSingle({
+	backend: Overlay,
+	readable,
+	writable: await resolveMountConfig({ backend: InMemory, name: 'cow' }),
+});

package/tests/setup/port.ts

@@ -0,0 +1,15 @@
+import { MessageChannel } from 'node:worker_threads';
+import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount } from '../../dist/index.js';
+import { copy, data } from '../setup.js';
+
+const { port1: localPort, port2: remotePort } = new MessageChannel();
+
+fs.umount('/');
+const tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
+
+fs.mount('/', tmpfs);
+copy(data, fs);
+
+await resolveRemoteMount(remotePort, tmpfs);
+
+await configureSingle({ backend: Port, port: localPort });

package/dist/backends/file_index.d.ts

@@ -1,63 +0,0 @@
-import { NoSyncFile } from '../file.js';
-import { FileSystem } from '../filesystem.js';
-import type { StatsLike } from '../stats.js';
-import { Stats } from '../stats.js';
-/**
- * An Index in JSON form
- * @internal
- */
-export interface IndexData {
-    version: number;
-    entries: Record<string, StatsLike<number>>;
-}
-export declare const version = 1;
-/**
- * An index of files
- * @internal
- */
-export declare class Index extends Map<string, Stats> {
-    /**
-     * Convenience method
-     */
-    files(): Map<string, Stats>;
-    /**
-     * Converts the index to JSON
-     */
-    toJSON(): IndexData;
-    /**
-     * Converts the index to a string
-     */
-    toString(): string;
-    /**
-     * Returns the files in the directory `dir`.
-     * This is expensive so it is only called once per directory.
-     */
-    protected dirEntries(dir: string): string[];
-    /**
-     * Loads the index from JSON data
-     */
-    fromJSON(json: IndexData): void;
-    /**
-     * Parses an index from a string
-     */
-    static parse(data: string): Index;
-}
-declare const IndexFS_base: import("../index.js").Mixin<typeof FileSystem, import("../mixins/readonly.js").ReadonlyMixin>;
-export declare abstract class IndexFS extends IndexFS_base {
-    private indexData;
-    protected index: Index;
-    protected _isInitialized: boolean;
-    ready(): Promise<void>;
-    constructor(indexData: IndexData | Promise<IndexData>);
-    reloadFiles(): Promise<void>;
-    reloadFilesSync(): void;
-    stat(path: string): Promise<Stats>;
-    statSync(path: string): Stats;
-    openFile(path: string, flag: string): Promise<NoSyncFile<this>>;
-    openFileSync(path: string, flag: string): NoSyncFile<this>;
-    readdir(path: string): Promise<string[]>;
-    readdirSync(path: string): string[];
-    protected abstract getData(path: string, stats: Stats): Promise<Uint8Array>;
-    protected abstract getDataSync(path: string, stats: Stats): Uint8Array;
-}
-export {};

package/dist/backends/file_index.js

@@ -1,163 +0,0 @@
-/* Note: this file is named file_index.ts because Typescript has special behavior regarding index.ts which can't be disabled. */
-import { isJSON } from 'utilium';
-import { Errno, ErrnoError } from '../error.js';
-import { NoSyncFile, isWriteable } from '../file.js';
-import { FileSystem } from '../filesystem.js';
-import { Readonly } from '../mixins/readonly.js';
-import { Stats } from '../stats.js';
-import { decodeUTF8, encodeUTF8 } from '../utils.js';
-import { basename, dirname } from '../vfs/path.js';
-export const version = 1;
-/**
- * An index of files
- * @internal
- */
-export class Index extends Map {
-    /**
-     * Convenience method
-     */
-    files() {
-        const files = new Map();
-        for (const [path, stats] of this) {
-            if (stats.isFile()) {
-                files.set(path, stats);
-            }
-        }
-        return files;
-    }
-    /**
-     * Converts the index to JSON
-     */
-    toJSON() {
-        return {
-            version,
-            entries: Object.fromEntries(this),
-        };
-    }
-    /**
-     * Converts the index to a string
-     */
-    toString() {
-        return JSON.stringify(this.toJSON());
-    }
-    /**
-     * Returns the files in the directory `dir`.
-     * This is expensive so it is only called once per directory.
-     */
-    dirEntries(dir) {
-        const entries = [];
-        for (const entry of this.keys()) {
-            if (dirname(entry) == dir) {
-                entries.push(basename(entry));
-            }
-        }
-        return entries;
-    }
-    /**
-     * Loads the index from JSON data
-     */
-    fromJSON(json) {
-        if (json.version != version) {
-            throw new ErrnoError(Errno.EINVAL, 'Index version mismatch');
-        }
-        this.clear();
-        for (const [path, data] of Object.entries(json.entries)) {
-            const stats = new Stats(data);
-            if (stats.isDirectory()) {
-                stats.fileData = encodeUTF8(JSON.stringify(this.dirEntries(path)));
-            }
-            this.set(path, stats);
-        }
-    }
-    /**
-     * Parses an index from a string
-     */
-    static parse(data) {
-        if (!isJSON(data)) {
-            throw new ErrnoError(Errno.EINVAL, 'Invalid JSON');
-        }
-        const json = JSON.parse(data);
-        const index = new Index();
-        index.fromJSON(json);
-        return index;
-    }
-}
-export class IndexFS extends Readonly(FileSystem) {
-    async ready() {
-        await super.ready();
-        if (this._isInitialized) {
-            return;
-        }
-        this.index.fromJSON(await this.indexData);
-        this._isInitialized = true;
-    }
-    constructor(indexData) {
-        super();
-        this.indexData = indexData;
-        this.index = new Index();
-        this._isInitialized = false;
-    }
-    async reloadFiles() {
-        for (const [path, stats] of this.index.files()) {
-            delete stats.fileData;
-            stats.fileData = await this.getData(path, stats);
-        }
-    }
-    reloadFilesSync() {
-        for (const [path, stats] of this.index.files()) {
-            delete stats.fileData;
-            stats.fileData = this.getDataSync(path, stats);
-        }
-    }
-    stat(path) {
-        return Promise.resolve(this.statSync(path));
-    }
-    statSync(path) {
-        if (!this.index.has(path)) {
-            throw ErrnoError.With('ENOENT', path, 'stat');
-        }
-        return this.index.get(path);
-    }
-    async openFile(path, flag) {
-        if (isWriteable(flag)) {
-            // You can't write to files on this file system.
-            throw new ErrnoError(Errno.EPERM, path);
-        }
-        // Check if the path exists, and is a file.
-        const stats = this.index.get(path);
-        if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'openFile');
-        }
-        return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : await this.getData(path, stats));
-    }
-    openFileSync(path, flag) {
-        if (isWriteable(flag)) {
-            // You can't write to files on this file system.
-            throw new ErrnoError(Errno.EPERM, path);
-        }
-        // Check if the path exists, and is a file.
-        const stats = this.index.get(path);
-        if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'openFile');
-        }
-        return new NoSyncFile(this, path, flag, stats, stats.isDirectory() ? stats.fileData : this.getDataSync(path, stats));
-    }
-    readdir(path) {
-        return Promise.resolve(this.readdirSync(path));
-    }
-    readdirSync(path) {
-        // Check if it exists.
-        const stats = this.index.get(path);
-        if (!stats) {
-            throw ErrnoError.With('ENOENT', path, 'readdir');
-        }
-        const content = JSON.parse(decodeUTF8(stats.fileData));
-        if (!Array.isArray(content)) {
-            throw ErrnoError.With('ENODATA', path, 'readdir');
-        }
-        if (!content.every(item => typeof item == 'string')) {
-            throw ErrnoError.With('ENODATA', path, 'readdir');
-        }
-        return content;
-    }
-}

package/tests/common/async.test.ts

@@ -1,31 +0,0 @@
-import assert from 'node:assert';
-import { suite, test } from 'node:test';
-import { configure } from '../../dist/config.js';
-import * as fs from '../../dist/vfs/index.js';
-import { InMemoryStore, StoreFS } from '../../dist/index.js';
-import { Async } from '../../dist/mixins/async.js';
-
-class ExampleAsyncFS extends Async(StoreFS) {
-	_sync = new StoreFS(new InMemoryStore('cache'));
-
-	public constructor() {
-		super(new InMemoryStore('test'));
-	}
-}
-
-const asyncFS = new ExampleAsyncFS();
-
-await configure({ mounts: { '/': asyncFS } });
-
-suite('Async Mixin', () => {
-	test('async -> cache syncing', async () => {
-		await fs.promises.writeFile('test', 'test');
-		assert.strictEqual(fs.readFileSync('test', 'utf8'), 'test');
-	});
-
-	test('cache -> async syncing', async () => {
-		fs.unlinkSync('test');
-		await asyncFS.queueDone();
-		assert(!(await fs.promises.exists('test')));
-	});
-});

package/tests/setup/cow+fetch.ts

@@ -1,45 +0,0 @@
-import { execSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { createServer } from 'node:http';
-import { join } from 'node:path';
-import { configureSingle, Fetch, InMemory, Overlay } from '../../dist/index.js';
-import { data, tmp } from '../setup.js';
-
-const port = 26514,
-	index = tmp + '/index.json';
-
-const statusCodes = {
-	ENOENT: 404,
-};
-
-execSync(`npm exec make-index -- ${data} --output ${index} --quiet`, { stdio: 'inherit' });
-
-const server = createServer((request, response) => {
-	const path = request.url == '/.index.json' ? index : join(data, request.url?.slice(1) || '');
-	try {
-		response.statusCode = 200;
-		response.end(readFileSync(path));
-	} catch (e: any) {
-		response.statusCode = statusCodes[e.code as keyof typeof statusCodes] || 400;
-		response.end();
-	}
-});
-
-server
-	.once('error', (error: NodeJS.ErrnoException) => {
-		if (error.code == 'EADDRINUSE') return;
-		throw error;
-	})
-	.listen(port)
-	.unref();
-
-const baseUrl = 'http://localhost:' + port;
-
-await configureSingle({
-	backend: Overlay,
-	readable: Fetch.create({
-		baseUrl,
-		index: baseUrl + '/.index.json',
-	}),
-	writable: InMemory.create({ name: 'cow' }),
-});