@zenfs/core 1.10.0 → 1.10.2

package/tests/fs/streams.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
+import { promisify } from 'node:util';
 
 // Top-level initialization
 const testFilePath = 'test-file.txt';
@@ -10,9 +11,10 @@ await fs.promises.writeFile(testFilePath, testData);
 const testFilePathWrite = 'test-file-write.txt';
 await fs.promises.writeFile(testFilePathWrite, ''); // Ensure the file exists
 
-suite('ReadStream', () => {
+suite('Streams', () => {
 	test('ReadStream reads data correctly', (_, done) => {
 		const readStream = fs.createReadStream(testFilePath);
+
 		let data = '';
 		readStream.on('data', chunk => {
 			data += chunk;
@@ -28,12 +30,14 @@ suite('ReadStream', () => {
 
 	test('ReadStream close method works', (_, done) => {
 		const readStream = fs.createReadStream(testFilePath);
+
 		let closed = false;
 		readStream.on('close', () => {
 			closed = true;
 		});
+
 		readStream.close(err => {
-			assert.equal(err, null);
+			assert.ifError(err);
 			assert(closed);
 			done();
 		});
@@ -55,36 +59,24 @@ suite('ReadStream', () => {
 		assert(!readStream.pending);
 	});
 
-	test('ReadStream close method can be called multiple times', (_, done) => {
+	test('ReadStream close method can be called multiple times', async () => {
 		const readStream = new fs.ReadStream();
-		readStream.close(err => {
-			assert.equal(err, null);
-			// Call close again
-			readStream.close(err2 => {
-				assert.equal(err2, null);
-				done();
-			});
-		});
+
+		const close = promisify(readStream.close);
+		await close();
+		await close();
 	});
-});
 
-suite('WriteStream', () => {
-	test.skip('WriteStream writes data correctly', (_, done) => {
+	test('WriteStream writes data correctly', async () => {
 		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);
-		});
+
+		const { promise, resolve, reject } = Promise.withResolvers();
+		writeStream.on('finish', resolve);
+		writeStream.on('error', reject);
+		writeStream.end(testData, 'utf8');
+		await promise;
+
+		assert.equal(fs.readFileSync(testFilePathWrite, 'utf8'), testData);
 	});
 
 	test('WriteStream close method works', (_, done) => {
@@ -94,7 +86,7 @@ suite('WriteStream', () => {
 			closed = true;
 		});
 		writeStream.close(err => {
-			assert.equal(err, null);
+			assert.ifError(err);
 			assert(closed);
 			done();
 		});
@@ -116,62 +108,75 @@ suite('WriteStream', () => {
 		assert(writeStream.pending);
 	});
 
-	test('WriteStream close method can be called multiple times', (_, done) => {
+	test('WriteStream close method can be called multiple times', async () => {
 		const writeStream = new fs.WriteStream();
-		writeStream.close(err => {
-			assert.equal(err, null);
-			// Call close again
-			writeStream.close(err2 => {
-				assert.equal(err2, null);
-				done();
-			});
-		});
+
+		const close = promisify(writeStream.close);
+		await close();
+		await close();
 	});
-});
 
-suite('FileHandle', () => {
-	test.skip('FileHandle.createReadStream reads data correctly', async () => {
+	test('createReadStream with start', async () => {
+		await fs.promises.writeFile('hello.txt', 'Hello world');
+
+		const stream = fs.createReadStream('hello.txt', { start: 6, encoding: 'utf-8' });
+
+		const data = (await stream.toArray()).join('');
+
+		assert.equal(data, 'world');
+	});
+
+	test('createReadStream with end', async () => {
+		await fs.promises.writeFile('hello.txt', 'Hello world');
+
+		const stream = fs.createReadStream('hello.txt', { end: 5, encoding: 'utf-8' });
+
+		const data = (await stream.toArray()).join('');
+
+		assert.equal(data, 'Hello');
+	});
+
+	test('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.equal(data, testData);
-				resolve();
-			});
-			readStream.on('error', reject);
-		});
+		const readStream = fileHandle.createReadStream({ encoding: 'utf-8' });
+		const [data] = await readStream.toArray();
+		assert.equal(data, testData);
 		await fileHandle.close();
 	});
 
-	test.skip('FileHandle.createWriteStream writes data correctly', async () => {
+	test('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 { promise, resolve, reject } = Promise.withResolvers();
+		writeStream.on('finish', resolve);
+		writeStream.on('error', reject);
+		writeStream.end(testData, 'utf8');
+		await promise;
+
 		const data = await fs.promises.readFile(testFilePathWrite, 'utf8');
 		assert.equal(data, testData);
 		await fileHandle.close();
 	});
 
-	test('FileHandle.createReadStream after close should throw', async () => {
+	test('FileHandle.createReadStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePath, 'r');
 		await fileHandle.close();
-		assert.throws(() => fileHandle.createReadStream());
+		const stream = fileHandle.createReadStream();
+		const { promise, resolve, reject } = Promise.withResolvers();
+		setTimeout(resolve, 100);
+		stream.on('error', reject);
+		assert.rejects(promise);
 	});
 
-	test.skip('FileHandle.createWriteStream after close should throw', async () => {
+	test('FileHandle.createWriteStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePathWrite, 'w');
 		await fileHandle.close();
-		assert.throws(() => fileHandle.createWriteStream());
+		const stream = fileHandle.createWriteStream();
+		const { promise, resolve, reject } = Promise.withResolvers();
+		setTimeout(resolve, 100);
+		stream.on('error', reject);
+		assert.rejects(promise);
+		stream.write('Nuh-uh');
 	});
 });

package/tests/setup/cow.ts

@@ -0,0 +1,13 @@
+import { configureSingle, InMemory, CopyOnWrite, resolveMountConfig, fs } from '../../dist/index.js';
+import { copySync, data } from '../setup.js';
+
+fs.umount('/');
+const readable = await resolveMountConfig({ backend: InMemory, label: 'ro' });
+fs.mount('/', readable);
+copySync(data);
+
+await configureSingle({
+	backend: CopyOnWrite,
+	readable,
+	writable: InMemory.create({ label: 'cow' }),
+});

package/tests/tsconfig.json

@@ -1,14 +1,11 @@
 {
+	"extends": "../tsconfig.json",
 	"type": "module",
 	"compilerOptions": {
-		"module": "NodeNext",
 		"target": "ES2022",
 		"noEmit": true,
-		"lib": ["ESNext", "ESNext.Disposable"],
-		"moduleResolution": "NodeNext",
 		"esModuleInterop": true,
 		"allowSyntheticDefaultImports": true,
-		"strict": true,
 		"allowJs": true
 	},
 	"include": ["**/*.ts", "*.ts", "**/*.js"]

package/types/README.md

@@ -0,0 +1 @@
+This directory contains declaration files. Due to numerous TypeScript shenanigans, placing them into `src` is a really bad idea. Instead, we put them here.

package/types/readable-stream.d.ts

@@ -0,0 +1,17 @@
+/*
+@types/readable-stream has *many* problems:
+https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71923
+https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71307
+https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71083
+https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/66049
+... and many more
+
+This allows us to bypass those problems.
+
+Warning: Do not install @types/readable-stream alongside this package!
+*/
+
+declare module 'readable-stream' {
+	import { Readable, Writable } from 'node:stream';
+	export { Readable, Writable };
+}

package/tests/setup/_overlay.ts

@@ -1,7 +0,0 @@
-import { configureSingle, InMemory, Overlay } from '../../dist/index.js';
-
-await configureSingle({
-	backend: Overlay,
-	readable: InMemory.create({ name: 'ro' }),
-	writable: InMemory.create({ name: 'cow' }),
-});