@zenfs/core 1.2.1 → 1.2.2

package/dist/emulation/cache.d.ts

@@ -10,11 +10,23 @@ export declare function setEnabled(value: boolean): void;
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.
  */
-export declare function getStats(path: string): Stats | undefined;
+export declare function getStatsSync(path: string): Stats | undefined;
 /**
  * Adds stats if the cache is enabled
  */
-export declare function setStats(path: string, value: Stats): void;
+export declare function setStatsSync(path: string, value: Stats): void;
+/**
+ * Clears the cache if it is enabled
+ */
+export declare function clearStatsSync(): void;
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export declare function getStats(path: string): Promise<Stats | undefined> | undefined;
+/**
+ * Adds stats if the cache is enabled
+ */
+export declare function setStats(path: string, value: Promise<Stats | undefined>): void;
 /**
  * Clears the cache if it is enabled
  */

package/dist/emulation/cache.js

@@ -9,6 +9,31 @@ export let isEnabled = false;
 export function setEnabled(value) {
     isEnabled = value;
 }
+const statsSync = new Map();
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export function getStatsSync(path) {
+    if (!isEnabled)
+        return;
+    return statsSync.get(path);
+}
+/**
+ * Adds stats if the cache is enabled
+ */
+export function setStatsSync(path, value) {
+    if (!isEnabled)
+        return;
+    statsSync.set(path, value);
+}
+/**
+ * Clears the cache if it is enabled
+ */
+export function clearStatsSync() {
+    if (!isEnabled)
+        return;
+    statsSync.clear();
+}
 const stats = new Map();
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.

package/dist/emulation/promises.js

@@ -435,7 +435,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStats(path) || (await fs.stat(resolved))).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await (cache.getStats(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -584,7 +584,10 @@ export async function rmdir(path) {
     path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        const stats = cache.getStats(path) || (await fs.stat(resolved));
+        const stats = await (cache.getStats(path) || fs.stat(resolved));
+        if (!stats) {
+            throw ErrnoError.With('ENOENT', path, 'readdir');
+        }
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -640,8 +643,12 @@ export async function readdir(path, options) {
         throw fixError(e, { [resolved]: path });
     };
     const { fs, path: resolved } = resolveMount(path);
-    const stats = cache.getStats(path) || (await fs.stat(resolved).catch(handleError));
-    cache.setStats(path, stats);
+    const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
+    cache.setStats(path, _stats);
+    const stats = await _stats;
+    if (!stats) {
+        throw ErrnoError.With('ENOENT', path, 'readdir');
+    }
     if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
@@ -663,8 +670,9 @@ export async function readdir(path, options) {
     const addEntry = async (entry) => {
         let entryStats;
         if (options?.recursive || options?.withFileTypes) {
-            entryStats = cache.getStats(join(path, entry)) || (await fs.stat(join(resolved, entry)).catch(handleError));
-            cache.setStats(join(path, entry), entryStats);
+            const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+            cache.setStats(join(path, entry), _entryStats);
+            entryStats = await _entryStats;
         }
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStats));
@@ -934,15 +942,17 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const stats = cache.getStats(path) ||
-        (await stat(path).catch((error) => {
-            if (error.code != 'ENOENT' || !options?.force)
-                throw error;
-        }));
+    const _stats = cache.getStats(path) ||
+        stat(path).catch((error) => {
+            if (error.code == 'ENOENT' && options?.force)
+                return undefined;
+            throw error;
+        });
+    cache.setStats(path, _stats);
+    const stats = await _stats;
     if (!stats) {
         return;
     }
-    cache.setStats(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {

package/dist/emulation/sync.js

@@ -147,7 +147,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStats(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -394,7 +394,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
-        const stats = cache.getStats(path) || fs.statSync(resolved);
+        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -447,8 +447,8 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
     try {
-        const stats = cache.getStats(path) || fs.statSync(resolved);
-        cache.setStats(path, stats);
+        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+        cache.setStatsSync(path, stats);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -474,8 +474,8 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = cache.getStats(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.setStats(join(path, entry), entryStat);
+        const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+        cache.setStatsSync(join(path, entry), entryStat);
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -501,7 +501,7 @@ export function readdirSync(path, options) {
         }
     }
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.clearStatsSync();
     }
     return values;
 }
@@ -638,7 +638,7 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.getStats(path) || statSync(path);
+        stats = cache.getStatsSync(path) || statSync(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -647,7 +647,7 @@ export function rmSync(path, options) {
     if (!stats) {
         return;
     }
-    cache.setStats(path, stats);
+    cache.setStatsSync(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -666,11 +666,11 @@ export function rmSync(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.clearStats();
+            cache.clearStatsSync();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.clearStatsSync();
     }
 }
 rmSync;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.2.1",
+	"version": "1.2.2",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/src/emulation/cache.ts

@@ -14,12 +14,41 @@ export function setEnabled(value: boolean): void {
 	isEnabled = value;
 }
 
-const stats = new Map<string, Stats>();
+const statsSync = new Map<string, Stats>();
 
 /**
  * Gets stats from the cache, if they exist and the cache is enabled.
  */
-export function getStats(path: string): Stats | undefined {
+export function getStatsSync(path: string): Stats | undefined {
+	if (!isEnabled) return;
+
+	return statsSync.get(path);
+}
+
+/**
+ * Adds stats if the cache is enabled
+ */
+export function setStatsSync(path: string, value: Stats): void {
+	if (!isEnabled) return;
+
+	statsSync.set(path, value);
+}
+
+/**
+ * Clears the cache if it is enabled
+ */
+export function clearStatsSync(): void {
+	if (!isEnabled) return;
+
+	statsSync.clear();
+}
+
+const stats = new Map<string, Promise<Stats | undefined>>();
+
+/**
+ * Gets stats from the cache, if they exist and the cache is enabled.
+ */
+export function getStats(path: string): Promise<Stats | undefined> | undefined {
 	if (!isEnabled) return;
 
 	return stats.get(path);
@@ -28,7 +57,7 @@ export function getStats(path: string): Stats | undefined {
 /**
  * Adds stats if the cache is enabled
  */
-export function setStats(path: string, value: Stats): void {
+export function setStats(path: string, value: Promise<Stats | undefined>): void {
 	if (!isEnabled) return;
 
 	stats.set(path, value);

package/src/emulation/promises.ts

@@ -471,7 +471,7 @@ export async function unlink(path: fs.PathLike): Promise<void> {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.getStats(path) || (await fs.stat(resolved))).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(await (cache.getStats(path) || fs.stat(resolved)))!.hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		await fs.unlink(resolved);
@@ -624,7 +624,10 @@ export async function rmdir(path: fs.PathLike): Promise<void> {
 	path = await realpath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		const stats = cache.getStats(path) || (await fs.stat(resolved));
+		const stats = await (cache.getStats(path) || fs.stat(resolved));
+		if (!stats) {
+			throw ErrnoError.With('ENOENT', path, 'readdir');
+		}
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -716,8 +719,13 @@ export async function readdir(
 
 	const { fs, path: resolved } = resolveMount(path);
 
-	const stats = cache.getStats(path) || (await fs.stat(resolved).catch(handleError));
-	cache.setStats(path, stats);
+	const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
+	cache.setStats(path, _stats);
+	const stats = await _stats;
+
+	if (!stats) {
+		throw ErrnoError.With('ENOENT', path, 'readdir');
+	}
 
 	if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 		throw ErrnoError.With('EACCES', path, 'readdir');
@@ -744,8 +752,9 @@ export async function readdir(
 	const addEntry = async (entry: string) => {
 		let entryStats: Stats | undefined;
 		if (options?.recursive || options?.withFileTypes) {
-			entryStats = cache.getStats(join(path, entry)) || (await fs.stat(join(resolved, entry)).catch(handleError));
-			cache.setStats(join(path, entry), entryStats);
+			const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+			cache.setStats(join(path, entry), _entryStats);
+			entryStats = await _entryStats;
 		}
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStats!));
@@ -968,18 +977,20 @@ access satisfies typeof promises.access;
 export async function rm(path: fs.PathLike, options?: fs.RmOptions & InternalOptions) {
 	path = normalizePath(path);
 
-	const stats =
+	const _stats =
 		cache.getStats(path) ||
-		(await stat(path).catch((error: ErrnoError) => {
-			if (error.code != 'ENOENT' || !options?.force) throw error;
-		}));
+		stat(path).catch((error: ErrnoError) => {
+			if (error.code == 'ENOENT' && options?.force) return undefined;
+			throw error;
+		});
+
+	cache.setStats(path, _stats);
+	const stats = await _stats;
 
 	if (!stats) {
 		return;
 	}
 
-	cache.setStats(path, stats);
-
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
 			if (options?.recursive) {

package/src/emulation/sync.ts

@@ -106,7 +106,7 @@ export function unlinkSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(path);
 	try {
-		if (config.checkAccess && !(cache.getStats(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+		if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'unlink');
 		}
 		fs.unlinkSync(resolved);
@@ -387,7 +387,7 @@ export function rmdirSync(path: fs.PathLike): void {
 	path = normalizePath(path);
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	try {
-		const stats = cache.getStats(path) || fs.statSync(resolved);
+		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
 		if (!stats.isDirectory()) {
 			throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
 		}
@@ -460,8 +460,8 @@ export function readdirSync(
 	const { fs, path: resolved } = resolveMount(realpathSync(path));
 	let entries: string[];
 	try {
-		const stats = cache.getStats(path) || fs.statSync(resolved);
-		cache.setStats(path, stats);
+		const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+		cache.setStatsSync(path, stats);
 		if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
 			throw ErrnoError.With('EACCES', resolved, 'readdir');
 		}
@@ -488,8 +488,8 @@ export function readdirSync(
 	// Iterate over entries and handle recursive case if needed
 	const values: (string | Dirent | Buffer)[] = [];
 	for (const entry of entries) {
-		const entryStat = cache.getStats(join(path, entry)) || fs.statSync(join(resolved, entry));
-		cache.setStats(join(path, entry), entryStat);
+		const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+		cache.setStatsSync(join(path, entry), entryStat);
 
 		if (options?.withFileTypes) {
 			values.push(new Dirent(entry, entryStat));
@@ -513,7 +513,7 @@ export function readdirSync(
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.clearStatsSync();
 	}
 	return values as string[] | Dirent[] | Buffer[];
 }
@@ -671,7 +671,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 
 	let stats: Stats | undefined;
 	try {
-		stats = cache.getStats(path) || statSync(path);
+		stats = cache.getStatsSync(path) || statSync(path);
 	} catch (error) {
 		if ((error as ErrnoError).code != 'ENOENT' || !options?.force) throw error;
 	}
@@ -680,7 +680,7 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		return;
 	}
 
-	cache.setStats(path, stats);
+	cache.setStatsSync(path, stats);
 
 	switch (stats.mode & constants.S_IFMT) {
 		case constants.S_IFDIR:
@@ -701,12 +701,12 @@ export function rmSync(path: fs.PathLike, options?: fs.RmOptions & InternalOptio
 		case constants.S_IFIFO:
 		case constants.S_IFSOCK:
 		default:
-			cache.clearStats();
+			cache.clearStatsSync();
 			throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
 	}
 
 	if (!options?._isIndirect) {
-		cache.clearStats();
+		cache.clearStatsSync();
 	}
 }
 rmSync satisfies typeof fs.rmSync;

package/tests/fs/appendFile.test.ts

@@ -10,7 +10,7 @@ suite('appendFile', () => {
 		const filename = 'append.txt';
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == content);
+		assert.equal(data, content);
 	});
 
 	test('append data to a non-empty file', async () => {
@@ -19,7 +19,7 @@ suite('appendFile', () => {
 		await fs.promises.writeFile(filename, original);
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == original + content);
+		assert.equal(data, original + content);
 	});
 
 	test('append a buffer to the file', async () => {
@@ -28,6 +28,6 @@ suite('appendFile', () => {
 		await fs.promises.writeFile(filename, original);
 		await fs.promises.appendFile(filename, content);
 		const data = await fs.promises.readFile(filename, 'utf8');
-		assert(data == original + content);
+		assert.equal(data, original + content);
 	});
 });

package/tests/fs/dir.test.ts

@@ -18,8 +18,8 @@ suite('Dirent', () => {
 		const stats = await fs.promises.lstat(testFile);
 		const dirent = new fs.Dirent(testFile, stats);
 
-		assert(dirent.name === testFile);
-		assert(dirent.parentPath === testFile);
+		assert.equal(dirent.name, testFile);
+		assert.equal(dirent.parentPath, testFile);
 	});
 
 	test('Dirent.isFile', async () => {
@@ -68,7 +68,7 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirent2?.name));
 
 		const dirent3 = await dir.read();
-		assert(dirent3 === null);
+		assert.strictEqual(dirent3, null);
 
 		await dir.close();
 	});
@@ -76,8 +76,8 @@ suite('Dir', () => {
 	test('Dir read() method (Callback varient)', (_, done) => {
 		const dir = new fs.Dir(testDirPath);
 		dir.read((err, dirent) => {
-			assert(err === undefined);
-			assert(dirent != undefined);
+			assert.strictEqual(err, undefined);
+			assert.notEqual(dirent, undefined);
 			assert(dirent instanceof fs.Dirent);
 			assert(testFiles.includes(dirent?.name));
 			dir.closeSync();
@@ -97,7 +97,7 @@ suite('Dir', () => {
 		assert(testFiles.includes(dirent2?.name));
 
 		const dirent3 = dir.readSync();
-		assert(dirent3 === null);
+		assert.strictEqual(dirent3, null);
 
 		dir.closeSync();
 	});
@@ -122,7 +122,7 @@ suite('Dir', () => {
 			dirents.push(dirent);
 		}
 
-		assert(dirents.length === 2);
+		assert.strictEqual(dirents.length, 2);
 		assert(dirents[0] instanceof fs.Dirent);
 		assert(testFiles.includes(dirents[0].name));
 		assert(testFiles.includes(dirents[1].name));

package/tests/fs/directory.test.ts

@@ -17,7 +17,7 @@ suite('Directory', () => {
 			await fs.promises.mkdir('/nested/dir');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
@@ -51,7 +51,7 @@ suite('Directory', () => {
 			fs.readdirSync('/two');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EACCES');
+			assert.strictEqual(error.code, 'EACCES');
 		}
 	});
 
@@ -63,7 +63,7 @@ suite('Directory', () => {
 			await fs.promises.rmdir('/rmdirTest');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOTEMPTY');
+			assert.strictEqual(error.code, 'ENOTEMPTY');
 		}
 	});
 
@@ -75,7 +75,7 @@ suite('Directory', () => {
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
 			wasThrown = true;
-			assert(error.code === 'ENOTDIR');
+			assert.strictEqual(error.code, 'ENOTDIR');
 		}
 		assert(wasThrown);
 	});
@@ -85,7 +85,7 @@ suite('Directory', () => {
 			await fs.promises.readdir('a.js');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOTDIR');
+			assert.strictEqual(error.code, 'ENOTDIR');
 		}
 	});
 
@@ -97,7 +97,7 @@ suite('Directory', () => {
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
 			wasThrown = true;
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 		assert(wasThrown);
 	});
@@ -107,7 +107,7 @@ suite('Directory', () => {
 			await fs.promises.readdir('/does/not/exist');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 	});
 

package/tests/fs/links.test.ts

@@ -19,7 +19,7 @@ suite('Links', () => {
 
 	test('readlink', async () => {
 		const destination = await fs.promises.readlink(symlink);
-		assert(destination === target);
+		assert.strictEqual(destination, target);
 	});
 
 	test('unlink', async () => {
@@ -32,7 +32,7 @@ suite('Links', () => {
 		await fs.promises.link(target, hardlink);
 		const targetContent = await fs.promises.readFile(target, 'utf8');
 		const linkContent = await fs.promises.readFile(hardlink, 'utf8');
-		assert(targetContent === linkContent);
+		assert.strictEqual(targetContent, linkContent);
 	});
 
 	test('file inside symlinked directory', async () => {
@@ -41,6 +41,6 @@ suite('Links', () => {
 		const link = join('link', target);
 		assert((await fs.promises.realpath(link)) === target);
 		const linkContent = await fs.promises.readFile(link, 'utf8');
-		assert(targetContent === linkContent);
+		assert.strictEqual(targetContent, linkContent);
 	});
 });

package/tests/fs/open.test.ts

@@ -12,7 +12,7 @@ suite('fs file opening', () => {
 			fs.openSync('/path/to/file/that/does/not/exist', 'r');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error?.code === 'ENOENT');
+			assert.strictEqual(error?.code, 'ENOENT');
 			caughtException = true;
 		}
 		assert(caughtException);
@@ -23,7 +23,7 @@ suite('fs file opening', () => {
 			await fs.promises.open('/path/to/file/that/does/not/exist', 'r');
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error?.code === 'ENOENT');
+			assert.strictEqual(error?.code, 'ENOENT');
 		}
 	});
 

package/tests/fs/permissions.test.ts

@@ -10,7 +10,7 @@ suite('Permissions', () => {
 	async function test_item(path: string): Promise<void> {
 		const stats = await fs.promises.stat(path).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EACCES');
+			assert.strictEqual(error.code, 'EACCES');
 		});
 		if (!stats) {
 			return;

package/tests/fs/read.test.ts

@@ -10,7 +10,7 @@ suite('read', () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead, buffer } = await handle.read(Buffer.alloc(expected.length), 0, expected.length, 0);
 
-		assert(bytesRead == expected.length);
+		assert.equal(bytesRead, expected.length);
 		assert(buffer.toString() == expected);
 	});
 
@@ -19,7 +19,7 @@ suite('read', () => {
 		const buffer = Buffer.alloc(expected.length);
 		const bytesRead = fs.readSync(fd, buffer, 0, expected.length, 0);
 
-		assert(bytesRead == expected.length);
+		assert.equal(bytesRead, expected.length);
 		assert(buffer.toString() == expected);
 	});
 });
@@ -44,7 +44,7 @@ suite('read buffer', () => {
 		const handle = await fs.promises.open(filepath, 'r');
 		const { bytesRead } = await handle.read(bufferAsync, 0, expected.length, 0);
 
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 		assert(bufferAsync.toString() === expected);
 	});
 
@@ -53,7 +53,7 @@ suite('read buffer', () => {
 		const bytesRead = fs.readSync(fd, bufferSync, 0, expected.length, 0);
 
 		assert(bufferSync.toString() === expected);
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 	});
 
 	test('read file synchronously to non-zero offset', () => {
@@ -62,6 +62,6 @@ suite('read buffer', () => {
 		const bytesRead = fs.readSync(fd, buffer, 10, expected.length, 0);
 
 		assert(buffer.subarray(10, buffer.length).toString() === expected);
-		assert(bytesRead === expected.length);
+		assert.strictEqual(bytesRead, expected.length);
 	});
 });

package/tests/fs/readFile.test.ts

@@ -65,9 +65,9 @@ suite('fs file reading', () => {
 		const content = fs.readFileSync('elipses.txt', 'utf8');
 
 		for (let i = 0; i < content.length; i++) {
-			assert(content[i] === '…');
+			assert.strictEqual(content[i], '…');
 		}
 
-		assert(content.length === 10000);
+		assert.strictEqual(content.length, 10000);
 	});
 });

package/tests/fs/rename.test.ts

@@ -21,10 +21,10 @@ suite('Rename', () => {
 	 */
 	async function check_directory(dir: string) {
 		const contents = await fs.promises.readdir(dir);
-		assert(contents.length === 2);
+		assert.strictEqual(contents.length, 2);
 
 		const subContents = await fs.promises.readdir(dir + '/_rename_me');
-		assert(subContents.length === 1);
+		assert.strictEqual(subContents.length, 1);
 
 		assert(await fs.promises.exists(dir + '/file.dat'));
 		assert(await fs.promises.exists(dir + '/_rename_me/lol.txt'));
@@ -88,7 +88,7 @@ suite('Rename', () => {
 		  if (e == null) {
 			throw new Error("Failed invariant: Cannot rename a directory over a file.");
 		  } else {
-			assert(e.code === 'ENOTDIR');
+			assert.strictEqual(e.code, 'ENOTDIR');
 		  }
 		});*/
 	});
@@ -101,7 +101,7 @@ suite('Rename', () => {
 
 		await fs.promises.rename(renDir1, renDir2).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'EBUSY');
+			assert.strictEqual(error.code, 'EBUSY');
 		});
 	});
 });

package/tests/fs/streams.test.ts

@@ -18,7 +18,7 @@ suite('ReadStream', () => {
 			data += chunk;
 		});
 		readStream.on('end', () => {
-			assert(data == testData);
+			assert.equal(data, testData);
 			done();
 		});
 		readStream.on('error', err => {
@@ -33,7 +33,7 @@ suite('ReadStream', () => {
 			closed = true;
 		});
 		readStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			assert(closed);
 			done();
 		});
@@ -41,27 +41,27 @@ suite('ReadStream', () => {
 
 	test('ReadStream declared properties', () => {
 		const readStream = new fs.ReadStream();
-		assert(readStream.bytesRead === undefined);
-		assert(readStream.path === undefined);
-		assert(readStream.pending === undefined);
+		assert.strictEqual(readStream.bytesRead, undefined);
+		assert.strictEqual(readStream.path, undefined);
+		assert.strictEqual(readStream.pending, undefined);
 
 		// Assign values
 		readStream.bytesRead = 10;
 		readStream.path = testFilePath;
 		readStream.pending = false;
 
-		assert(readStream.bytesRead === 10);
-		assert(readStream.path === testFilePath);
+		assert.strictEqual(readStream.bytesRead, 10);
+		assert.strictEqual(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);
+			assert.strictEqual(err, undefined);
 			// Call close again
 			readStream.close(err2 => {
-				assert(err2 === undefined);
+				assert.strictEqual(err2, undefined);
 				done();
 			});
 		});
@@ -94,7 +94,7 @@ suite('WriteStream', () => {
 			closed = true;
 		});
 		writeStream.close(err => {
-			assert(err === undefined);
+			assert.strictEqual(err, undefined);
 			assert(closed);
 			done();
 		});
@@ -102,27 +102,27 @@ suite('WriteStream', () => {
 
 	test('WriteStream declared properties', () => {
 		const writeStream = new fs.WriteStream();
-		assert(writeStream.bytesWritten === undefined);
-		assert(writeStream.path === undefined);
-		assert(writeStream.pending === undefined);
+		assert.strictEqual(writeStream.bytesWritten, undefined);
+		assert.strictEqual(writeStream.path, undefined);
+		assert.strictEqual(writeStream.pending, undefined);
 
 		// Assign values
 		writeStream.bytesWritten = 20;
 		writeStream.path = testFilePathWrite;
 		writeStream.pending = true;
 
-		assert(writeStream.bytesWritten === 20);
-		assert(writeStream.path === testFilePathWrite);
+		assert.strictEqual(writeStream.bytesWritten, 20);
+		assert.strictEqual(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);
+			assert.strictEqual(err, undefined);
 			// Call close again
 			writeStream.close(err2 => {
-				assert(err2 === undefined);
+				assert.strictEqual(err2, undefined);
 				done();
 			});
 		});
@@ -139,7 +139,7 @@ suite('FileHandle', () => {
 				data += chunk;
 			});
 			readStream.on('end', () => {
-				assert(data == testData);
+				assert.equal(data, testData);
 				resolve();
 			});
 			readStream.on('error', reject);
@@ -159,7 +159,7 @@ suite('FileHandle', () => {
 			writeStream.on('error', reject);
 		});
 		const data = await fs.promises.readFile(testFilePathWrite, 'utf8');
-		assert(data == testData);
+		assert.equal(data, testData);
 		await fileHandle.close();
 	});
 

package/tests/fs/times.test.ts

@@ -21,7 +21,7 @@ suite('times', () => {
 
 		await fs.promises.utimes('foobarbaz', atime, mtime).catch((error: ErrnoError) => {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		});
 
 		// don't close this fd
@@ -40,21 +40,21 @@ suite('times', () => {
 			expect_assert(handle.fd, atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOSYS');
+			assert.strictEqual(error.code, 'ENOSYS');
 		}
 
 		try {
 			fs.utimesSync('foobarbaz', atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code === 'ENOENT');
+			assert.strictEqual(error.code, 'ENOENT');
 		}
 
 		try {
 			fs.futimesSync(-1, atime, mtime);
 		} catch (error: any) {
 			assert(error instanceof ErrnoError);
-			assert(error.code == 'EBADF');
+			assert.equal(error.code, 'EBADF');
 		}
 	}
 

package/tests/fs/watch.test.ts

@@ -14,8 +14,8 @@ await fs.promises.writeFile(testFile, 'Initial content');
 suite('Watch Features', () => {
 	test('fs.watch should emit events on file change', async () => {
 		using watcher = fs.watch(testFile, (eventType, filename) => {
-			assert(eventType === 'change');
-			assert(filename === 'test.txt');
+			assert.strictEqual(eventType, 'change');
+			assert.strictEqual(filename, 'test.txt');
 		});
 
 		// Modify the file to trigger the event
@@ -24,8 +24,8 @@ suite('Watch Features', () => {
 
 	test('fs.watch should emit events on file rename (delete)', async () => {
 		using watcher = fs.watch(testFile, (eventType, filename) => {
-			assert(eventType === 'rename');
-			assert(filename === 'test.txt');
+			assert.strictEqual(eventType, 'rename');
+			assert.strictEqual(filename, 'test.txt');
 		});
 
 		// Delete the file to trigger the event
@@ -63,8 +63,8 @@ suite('Watch Features', () => {
 
 	test('fs.watch should work with directories', async () => {
 		using watcher = fs.watch(testDir, (eventType, filename) => {
-			assert(eventType === 'change');
-			assert(filename === 'newFile.txt');
+			assert.strictEqual(eventType, 'change');
+			assert.strictEqual(filename, 'newFile.txt');
 		});
 
 		await fs.promises.writeFile(`${testDir}/newFile.txt`, 'Content');
@@ -77,8 +77,8 @@ suite('Watch Features', () => {
 		await fs.promises.writeFile(oldFile, 'Some content');
 
 		using watcher = fs.watch(testDir, (eventType, filename) => {
-			assert(eventType === 'rename');
-			assert(filename === 'oldFile.txt');
+			assert.strictEqual(eventType, 'rename');
+			assert.strictEqual(filename, 'oldFile.txt');
 		});
 
 		// Rename the file to trigger the event
@@ -91,8 +91,8 @@ suite('Watch Features', () => {
 		await fs.promises.writeFile(tempFile, 'Temporary content');
 
 		using watcher = fs.watch(tempFile, (eventType, filename) => {
-			assert(eventType === 'rename');
-			assert(filename === 'tempFile.txt');
+			assert.strictEqual(eventType, 'rename');
+			assert.strictEqual(filename, 'tempFile.txt');
 		});
 
 		await fs.promises.unlink(tempFile);

package/tests/fs/write.test.ts

@@ -10,11 +10,11 @@ suite('write', () => {
 		const handle = await fs.promises.open(fn, 'w', 0o644);
 		await handle.write('', 0, 'utf8');
 		const { bytesWritten } = await handle.write(expected, 0, 'utf8');
-		assert(bytesWritten === Buffer.from(expected).length);
+		assert.strictEqual(bytesWritten, Buffer.from(expected).length);
 		await handle.close();
 
 		const data = await fs.promises.readFile(fn, 'utf8');
-		assert(data === expected);
+		assert.strictEqual(data, expected);
 
 		await fs.promises.unlink(fn);
 	});
@@ -27,7 +27,7 @@ suite('write', () => {
 
 		const written = await handle.write(expected, 0, expected.length, null);
 
-		assert(expected.length === written.bytesWritten);
+		assert.strictEqual(expected.length, written.bytesWritten);
 
 		await handle.close();
 
@@ -43,13 +43,13 @@ suite('writeSync', () => {
 		const fd = fs.openSync(fn, 'w');
 
 		let written = fs.writeSync(fd, '');
-		assert(written === 0);
+		assert.strictEqual(written, 0);
 
 		fs.writeSync(fd, 'foo');
 
 		const data = Buffer.from('bár');
 		written = fs.writeSync(fd, data, 0, data.length);
-		assert(written === 4);
+		assert.strictEqual(written, 4);
 
 		fs.closeSync(fd);
 

package/tests/fs/writeFile.test.ts

@@ -10,7 +10,7 @@ suite('writeFile', () => {
 		const filename = 'test.txt';
 		await fs.promises.writeFile(filename, s);
 		const data = await fs.promises.readFile(filename);
-		assert(data.length === Buffer.from(s).length);
+		assert.strictEqual(data.length, Buffer.from(s).length);
 		await fs.promises.unlink(filename);
 	});
 
@@ -20,7 +20,7 @@ suite('writeFile', () => {
 
 		await fs.promises.writeFile(filename, expected);
 		const actual = await fs.promises.readFile(filename);
-		assert(actual.length === expected.length);
+		assert.strictEqual(actual.length, expected.length);
 
 		await fs.promises.unlink(filename);
 	});
@@ -35,7 +35,7 @@ suite('writeFile', () => {
 		await fs.promises.writeFile(filePath, buffer);
 
 		const read = await fs.promises.readFile(filePath, 'base64');
-		assert(read === data);
+		assert.strictEqual(read, data);
 	});
 });
 
@@ -47,7 +47,7 @@ suite('File Writing with Custom Mode', () => {
 		fs.writeFileSync(file, '123', { mode });
 
 		const content = fs.readFileSync(file, 'utf8');
-		assert(content === '123');
+		assert.strictEqual(content, '123');
 		assert((fs.statSync(file).mode & 0o777) === mode);
 
 		fs.unlinkSync(file);
@@ -60,7 +60,7 @@ suite('File Writing with Custom Mode', () => {
 		fs.appendFileSync(file, 'abc', { mode });
 
 		const content = fs.readFileSync(file, { encoding: 'utf8' });
-		assert(content === 'abc');
+		assert.strictEqual(content, 'abc');
 
 		assert((fs.statSync(file).mode & 0o777) === mode);
 

package/tests/handle.test.ts

@@ -50,8 +50,8 @@ await suite('FileHandle', () => {
 	test('chown', async () => {
 		await handle.chown(1234, 5678);
 		const stats = await handle.stat();
-		assert(stats.uid === 1234);
-		assert(stats.gid === 5678);
+		assert.equal(stats.uid, 1234);
+		assert.equal(stats.gid, 5678);
 	});
 
 	test('close', async () => {

package/tests/mutex.test.ts

@@ -57,6 +57,6 @@ suite('LockFS mutex', () => {
 		}
 
 		await Promise.all([foo(), foo(), foo()]);
-		assert(x === 4);
+		assert.strictEqual(x, 4);
 	});
 });

package/tests/port/timeout.test.ts

@@ -26,7 +26,7 @@ await suite('Timeout', { timeout: 1000 }, () => {
 			error = e;
 		}
 		assert(error! instanceof ErrnoError);
-		assert(error.code === 'EIO');
+		assert.strictEqual(error.code, 'EIO');
 		assert(error.message.includes('RPC Failed'));
 	});
 
@@ -40,7 +40,7 @@ await suite('Timeout', { timeout: 1000 }, () => {
 			error = e;
 		}
 		assert(error! instanceof ErrnoError);
-		assert(error.code === 'EIO');
+		assert.strictEqual(error.code, 'EIO');
 		assert(error.message.includes('RPC Failed'));
 	});
 });