@gjsify/fs 0.0.4 → 0.1.1

package/src/sync.spec.ts

@@ -1,17 +1,18 @@
 import { describe, it, expect } from '@gjsify/unit';
-import { join, dirname } from 'path';
-import { fileURLToPath } from "url";
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
 
-import { existsSync, readdirSync, readFileSync, mkdirSync, rmdirSync, writeFileSync, unlinkSync, watch, mkdtempSync, rmSync, realpathSync, symlinkSync } from 'fs';
-import { Buffer } from 'buffer';
+import { existsSync, readdirSync, readFileSync, mkdirSync, rmdirSync, writeFileSync, unlinkSync, watch, mkdtempSync, rmSync, realpathSync, symlinkSync, statSync } from 'node:fs';
+import { Buffer } from 'node:buffer';
+import { tmpdir } from 'node:os';
 
 export default async () => {
 	await describe('fs.existsSync', async () => {
 
-		const existingFiles = ['tsconfig.json', 'package.json', 'README.md'];
+		const existingFiles = ['/tmp', '/etc/hosts'];
 		const nonExistingFiles = ['asdasd', '/asdasd', ''];
 
 		await it('should return true for existing files', () => {
@@ -89,11 +90,11 @@ export default async () => {
 			const fileWithTypes = files.find((f) => f.name === expectedFile);
 			const dirWithTypes = files.find((f) => f.name === expectedDir);
 
-			expect(fileWithTypes.isFile()).toBeTruthy();
-			expect(fileWithTypes.isDirectory()).toBeFalsy();
+			expect(fileWithTypes!.isFile()).toBeTruthy();
+			expect(fileWithTypes!.isDirectory()).toBeFalsy();
 
-			expect(dirWithTypes.isFile()).toBeFalsy();
-			expect(dirWithTypes.isDirectory()).toBeTruthy();
+			expect(dirWithTypes!.isFile()).toBeFalsy();
+			expect(dirWithTypes!.isDirectory()).toBeTruthy();
 
 			// Clear
 			rmSync(file);
@@ -104,18 +105,28 @@ export default async () => {
 
 	await describe('fs.readFileSync', async () => {
 		await it('should return a Buffer if no encoding was specified', () => {
-			const bufferData = readFileSync('package.json');
+			const bufferData = readFileSync('/etc/hosts');
 			expect(bufferData instanceof Buffer).toBeTruthy();
 		});
 
 		await it('should return a string when encoding is utf-8', () => {
-			const utf8Data = readFileSync('./test/file.txt', 'utf-8');
+			const dir = mkdtempSync('fs-rfs-');
+			const filePath = join(dir, 'test.txt');
+			writeFileSync(filePath, 'Hello World');
+			const utf8Data = readFileSync(filePath, 'utf-8');
 			expect(typeof utf8Data === 'string').toBeTruthy();
+			rmSync(filePath);
+			rmdirSync(dir);
 		});
 
-		await it('should return a string with "Hello World"', () => {
-			const utf8Data = readFileSync('./test/file.txt', 'utf-8');
+		await it('should return the correct file content', () => {
+			const dir = mkdtempSync('fs-rfs-content-');
+			const filePath = join(dir, 'test.txt');
+			writeFileSync(filePath, 'Hello World');
+			const utf8Data = readFileSync(filePath, 'utf-8');
 			expect(utf8Data).toBe('Hello World');
+			rmSync(filePath);
+			rmdirSync(dir);
 		});
 	});
 
@@ -150,19 +161,31 @@ export default async () => {
 			writeFileSync(watchMe, '// test');
 		});
 
-		await it(`fs.watch should watch ${watchMe} for changes`, () => {
-			const watcher = watch(watchMe, {persistent: true}, console.log);
-
-			watcher.on('change', console.log).on('rename', console.log);
+		await it(`fs.watch should watch ${watchMe} for changes`, async () => {
+			await new Promise<void>((resolve) => {
+				let watcher: ReturnType<typeof watch>;
+				try {
+					watcher = watch(watchMe, {persistent: true}, console.log);
+				} catch (err: any) {
+					// EMFILE (too many open files) is a system-level issue, not a code bug
+					if (err?.code === 'EMFILE') { resolve(); return; }
+					throw err;
+				}
+				// FSWatcher inherits from EventEmitter at runtime
+			const w = watcher as unknown as import('node:events').EventEmitter;
+			w.on('change', console.log).on('rename', console.log);
 
-			setTimeout(() => { watcher.close(); }, 1000);
-
-			setTimeout(() => {
-				writeFileSync(watchMe, '// test');
 				setTimeout(() => {
-					unlinkSync(watchMe);
+					writeFileSync(watchMe, '// test');
+					setTimeout(() => {
+						try { unlinkSync(watchMe); } catch {}
+						watcher.close();
+						resolve();
+					}, 100);
 				}, 100);
-			}, 100);
+
+				setTimeout(() => { watcher.close(); resolve(); }, 2000);
+			});
 		});
 	});
 
@@ -186,20 +209,169 @@ export default async () => {
 		});
 
 		await it('should return the real and absolute path', () => {
-			const tsConfig = "./tsconfig.json";
-			const tsConfigSymlink = "./symlink_tsconfig.json";
+			const dir = mkdtempSync(join(tmpdir(), 'fs-rp-'));
+			const target = join(dir, 'target.txt');
+			const link = join(dir, 'link.txt');
+			writeFileSync(target, 'data');
+			symlinkSync(target, link);
+
+			const realPath = realpathSync(target);
+			const realSymLinkPath = realpathSync(link);
 
-			if(!existsSync(tsConfigSymlink)) {
-				symlinkSync(tsConfig, tsConfigSymlink);
+			// Should point to the real file, not the symlink
+			expect(realSymLinkPath).toBe(realPath);
 
-				const realPath = realpathSync(tsConfig);
-				const realSymLinkPath = realpathSync(tsConfigSymlink);
+			unlinkSync(link);
+			rmSync(target);
+			rmdirSync(dir);
+		});
+	});
+
+	await describe('fs.mkdirSync recursive', async () => {
+		await it('should return the first directory created when recursive is true', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-mkdir-rec-'));
+			const nested = join(dir, 'a', 'b', 'c');
+			const result = mkdirSync(nested, { recursive: true });
+			// The first created directory should be 'a' (the top-level new dir)
+			expect(typeof result).toBe('string');
+			expect(result).toBe(join(dir, 'a'));
+			expect(existsSync(nested)).toBe(true);
+			rmSync(dir, { recursive: true });
+		});
 
-				// Should point to the real file, not the symlink
-				expect(realSymLinkPath).toBe(realPath);
+		await it('should return undefined when all directories already exist', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-mkdir-rec-exist-'));
+			const result = mkdirSync(dir, { recursive: true });
+			expect(result).toBeUndefined();
+			rmdirSync(dir);
+		});
+
+		await it('should throw EEXIST when non-recursive and dir exists', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-mkdir-exist-'));
+			let threw = false;
+			try {
+				mkdirSync(dir);
+			} catch (e: unknown) {
+				threw = true;
+				expect((e as NodeJS.ErrnoException).code).toBe('EEXIST');
+			}
+			expect(threw).toBe(true);
+			rmdirSync(dir);
+		});
+
+		await it('should throw ENOENT when non-recursive and parent missing', () => {
+			const dir = join(tmpdir(), 'fs-mkdir-noparent-' + Date.now(), 'child');
+			let threw = false;
+			try {
+				mkdirSync(dir);
+			} catch (e: unknown) {
+				threw = true;
+				expect((e as NodeJS.ErrnoException).code).toBe('ENOENT');
 			}
+			expect(threw).toBe(true);
+		});
+	});
 
-			unlinkSync(tsConfigSymlink);
+	await describe('fs.rmSync error handling', async () => {
+		await it('should throw when removing non-empty dir without recursive', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-rmsync-notempty-'));
+			writeFileSync(join(dir, 'file.txt'), 'data');
+			let threw = false;
+			try {
+				rmSync(dir);
+			} catch (e: unknown) {
+				threw = true;
+				// Node.js throws ERR_FS_EISDIR, GJS throws ENOTEMPTY — both are correct
+				const code = (e as NodeJS.ErrnoException).code;
+				expect(code === 'ENOTEMPTY' || code === 'ERR_FS_EISDIR').toBe(true);
+			}
+			expect(threw).toBe(true);
+			rmSync(dir, { recursive: true });
+		});
+
+		await it('should not throw when force is true and path does not exist', () => {
+			const path = join(tmpdir(), 'fs-rmsync-force-nonexistent-' + Date.now());
+			let threw = false;
+			try {
+				rmSync(path, { force: true });
+			} catch {
+				threw = true;
+			}
+			expect(threw).toBe(false);
+		});
+
+		await it('should remove non-empty directory with recursive: true', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-rmsync-rec-'));
+			mkdirSync(join(dir, 'sub'));
+			writeFileSync(join(dir, 'sub', 'file.txt'), 'data');
+			writeFileSync(join(dir, 'root.txt'), 'data');
+			rmSync(dir, { recursive: true });
+			expect(existsSync(dir)).toBe(false);
+		});
+	});
+
+	await describe('fs.Dirent type methods', async () => {
+		await it('should return false for isCharacterDevice, isSocket, isFIFO on regular file', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-dirent-'));
+			const filePath = join(dir, 'test.txt');
+			writeFileSync(filePath, 'data');
+			const entries = readdirSync(dir, { withFileTypes: true });
+			const entry = entries[0];
+			expect(entry.isCharacterDevice()).toBe(false);
+			expect(entry.isSocket()).toBe(false);
+			expect(entry.isFIFO()).toBe(false);
+			expect(entry.isBlockDevice()).toBe(false);
+			expect(entry.isFile()).toBe(true);
+			rmSync(filePath);
+			rmdirSync(dir);
+		});
+
+		await it('should return false for isCharacterDevice, isSocket, isFIFO on directory', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-dirent-dir-'));
+			const subdir = join(dir, 'sub');
+			mkdirSync(subdir);
+			const entries = readdirSync(dir, { withFileTypes: true });
+			const entry = entries[0];
+			expect(entry.isCharacterDevice()).toBe(false);
+			expect(entry.isSocket()).toBe(false);
+			expect(entry.isFIFO()).toBe(false);
+			expect(entry.isBlockDevice()).toBe(false);
+			expect(entry.isDirectory()).toBe(true);
+			rmdirSync(subdir);
+			rmdirSync(dir);
+		});
+
+		await it('statSync should detect isCharacterDevice for /dev/null', () => {
+			const s = statSync('/dev/null');
+			expect(s.isCharacterDevice()).toBe(true);
+			expect(s.isFile()).toBe(false);
+			expect(s.isDirectory()).toBe(false);
+			expect(s.isSocket()).toBe(false);
+			expect(s.isFIFO()).toBe(false);
+			expect(s.isBlockDevice()).toBe(false);
+		});
+	});
+
+	await describe('fs.FSWatcher ref/unref', async () => {
+		await it('ref() and unref() should return the watcher itself', () => {
+			const dir = mkdtempSync(join(tmpdir(), 'fs-watcher-'));
+			const filePath = join(dir, 'watch.txt');
+			writeFileSync(filePath, 'data');
+			let watcher: ReturnType<typeof watch> | null = null;
+			try {
+				watcher = watch(filePath);
+				const refResult = watcher.ref();
+				expect(refResult).toBe(watcher);
+				const unrefResult = watcher.unref();
+				expect(unrefResult).toBe(watcher);
+			} catch (err: any) {
+				// EMFILE is a system-level issue, not a code bug
+				if (err?.code !== 'EMFILE') throw err;
+			} finally {
+				if (watcher) watcher.close();
+				rmSync(filePath);
+				rmdirSync(dir);
+			}
 		});
 	});
 }