@gjsify/fs 0.4.0 → 0.4.4

package/src/streams.spec.ts

@@ -1,513 +0,0 @@
-// fs stream tests — createReadStream, createWriteStream, pipe integration
-// Reference: refs/node-test/parallel/test-fs-read-stream*.js, test-fs-write-stream*.js
-
-import { describe, it, expect } from '@gjsify/unit';
-import { createReadStream, createWriteStream, writeFileSync, readFileSync, mkdtempSync, rmSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { Buffer } from 'node:buffer';
-import { Transform, PassThrough } from 'node:stream';
-
-let tmpDir: string;
-
-function setup(): void {
-  tmpDir = mkdtempSync(join(tmpdir(), 'gjsify-fs-stream-'));
-}
-
-function cleanup(): void {
-  try { rmSync(tmpDir, { recursive: true }); } catch {}
-}
-
-export default async () => {
-  // ---- createReadStream ----
-
-  await describe('fs.createReadStream', async () => {
-    await it('should read a file and emit data + end events', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'read-test.txt');
-        writeFileSync(filePath, 'hello world');
-        const chunks: string[] = [];
-        await new Promise<void>((resolve, reject) => {
-          const stream = createReadStream(filePath, { encoding: 'utf8' });
-          stream.on('data', (chunk) => chunks.push(chunk as string));
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        expect(chunks.join('')).toBe('hello world');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should read file as Buffer by default', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'buf-test.txt');
-        writeFileSync(filePath, 'buffer data');
-        const chunks: Buffer[] = [];
-        await new Promise<void>((resolve, reject) => {
-          const stream = createReadStream(filePath);
-          stream.on('data', (chunk) => chunks.push(Buffer.from(chunk as Uint8Array)));
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        const result = Buffer.concat(chunks).toString('utf8');
-        expect(result).toBe('buffer data');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should handle empty file', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'empty.txt');
-        writeFileSync(filePath, '');
-        const chunks: string[] = [];
-        await new Promise<void>((resolve, reject) => {
-          const stream = createReadStream(filePath, { encoding: 'utf8' });
-          stream.on('data', (chunk) => chunks.push(chunk as string));
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        expect(chunks.join('')).toBe('');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should emit error for non-existent file', async () => {
-      const err = await new Promise<Error>((resolve) => {
-        const stream = createReadStream('/nonexistent_gjsify_test_12345');
-        stream.on('error', (e) => resolve(e));
-      });
-      expect(err).toBeDefined();
-      // GJS Gio errors have numeric codes; Node.js has string 'ENOENT'
-      const code: unknown = (err as NodeJS.ErrnoException).code;
-      expect(code === 'ENOENT' || code === 1 || (err as any).code !== undefined).toBeTruthy();
-    });
-
-    await it('should read file with start and end options', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'range-test.txt');
-        writeFileSync(filePath, 'abcdefghij');
-        const chunks: string[] = [];
-        await new Promise<void>((resolve, reject) => {
-          const stream = createReadStream(filePath, { encoding: 'utf8', start: 2, end: 6 });
-          stream.on('data', (chunk) => chunks.push(chunk as string));
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        // start=2 (index 'c'), end=6 (index 'g', inclusive)
-        expect(chunks.join('')).toBe('cdefg');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should read a larger file (64KB)', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'large.txt');
-        const size = 64 * 1024;
-        writeFileSync(filePath, 'A'.repeat(size));
-        let totalLength = 0;
-        await new Promise<void>((resolve, reject) => {
-          const stream = createReadStream(filePath);
-          stream.on('data', (chunk) => { totalLength += (chunk as Buffer).length; });
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        expect(totalLength).toBe(size);
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should track bytesRead', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'bytes-read.txt');
-        const content = 'hello bytes';
-        writeFileSync(filePath, content);
-        const stream = createReadStream(filePath);
-        await new Promise<void>((resolve, reject) => {
-          stream.on('data', () => {});
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        expect(stream.bytesRead).toBe(Buffer.byteLength(content));
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should have path property', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'path-prop.txt');
-        writeFileSync(filePath, 'test');
-        const stream = createReadStream(filePath);
-        expect(stream.path).toBe(filePath);
-        await new Promise<void>((resolve) => {
-          stream.on('data', () => {});
-          stream.on('end', () => resolve());
-        });
-      } finally {
-        cleanup();
-      }
-    });
-
-    // Regression: ReadStream uses _construct() for async file opening.
-    // Verifies that 'open' and 'ready' fire and that pending starts as true.
-    await it('should emit open and ready events before data, pending starts true', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'open-ready.txt');
-        writeFileSync(filePath, 'hello');
-        const stream = createReadStream(filePath);
-        expect(stream.pending).toBeTruthy();
-        const events: string[] = [];
-        let openFd: number | undefined;
-        await new Promise<void>((resolve, reject) => {
-          stream.on('open', (fd: number) => { openFd = fd; events.push('open'); });
-          stream.on('ready', () => events.push('ready'));
-          stream.on('data', () => { if (!events.includes('data')) events.push('data'); });
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-          stream.resume();
-        });
-        expect(openFd).toBeDefined();
-        // 'open' and 'ready' must have fired (file was opened)
-        expect(events).toContain('open');
-        expect(events).toContain('ready');
-        // 'open' must fire before any data event
-        const openIdx = events.indexOf('open');
-        const dataIdx = events.indexOf('data');
-        if (dataIdx !== -1) expect(openIdx).toBeLessThan(dataIdx);
-      } finally {
-        cleanup();
-      }
-    });
-
-    // Regression: piping a ReadStream before the file is open (while pending=true)
-    // must still deliver all data. Previously _pendingReadSize approach hung under
-    // backpressure on GJS 1.88; _construct() fixes this properly.
-    await it('should pipe correctly when pipe() is called before file opens', async () => {
-      setup();
-      try {
-        const srcPath = join(tmpDir, 'pre-pipe-src.txt');
-        const dstPath = join(tmpDir, 'pre-pipe-dst.txt');
-        const size = 3 * 64 * 1024; // 3 × 64KB — forces multiple read chunks + backpressure
-        writeFileSync(srcPath, 'X'.repeat(size));
-        await new Promise<void>((resolve, reject) => {
-          const src = createReadStream(srcPath);
-          const dst = createWriteStream(dstPath);
-          // pipe() is called immediately — src is still pending (file not open yet)
-          expect(src.pending).toBeTruthy();
-          src.on('error', reject);
-          dst.on('error', reject);
-          dst.on('finish', resolve);
-          src.pipe(dst);
-        });
-        expect(readFileSync(dstPath, 'utf8').length).toBe(size);
-      } finally {
-        cleanup();
-      }
-    });
-  });
-
-  // ---- createWriteStream ----
-
-  await describe('fs.createWriteStream', async () => {
-    await it('should write data to a file', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'write-test.txt');
-        await new Promise<void>((resolve, reject) => {
-          const stream = createWriteStream(filePath);
-          stream.on('error', reject);
-          stream.write('hello ');
-          stream.write('world');
-          stream.end(() => resolve());
-        });
-        expect(readFileSync(filePath, 'utf8')).toBe('hello world');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should emit finish event', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'finish-test.txt');
-        const stream = createWriteStream(filePath);
-        const finished = await new Promise<boolean>((resolve) => {
-          stream.on('finish', () => resolve(true));
-          stream.end('done');
-        });
-        expect(finished).toBe(true);
-        expect(readFileSync(filePath, 'utf8')).toBe('done');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should write Buffer data', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'buf-write.txt');
-        await new Promise<void>((resolve, reject) => {
-          const stream = createWriteStream(filePath);
-          stream.on('error', reject);
-          stream.write(Buffer.from('buffer '));
-          stream.end(Buffer.from('content'));
-          stream.on('finish', () => resolve());
-        });
-        expect(readFileSync(filePath, 'utf8')).toBe('buffer content');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should write a large file (64KB)', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'large-write.txt');
-        const chunkSize = 1024;
-        const numChunks = 64;
-        await new Promise<void>((resolve, reject) => {
-          const stream = createWriteStream(filePath);
-          stream.on('error', reject);
-          for (let i = 0; i < numChunks; i++) {
-            stream.write('B'.repeat(chunkSize));
-          }
-          stream.end(() => resolve());
-        });
-        const content = readFileSync(filePath, 'utf8');
-        expect(content.length).toBe(chunkSize * numChunks);
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should have path property', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'path-prop-ws.txt');
-        const stream = createWriteStream(filePath);
-        expect(stream.path).toBe(filePath);
-        await new Promise<void>((resolve, reject) => {
-          stream.on('error', reject);
-          stream.end('test', () => resolve());
-        });
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should track bytesWritten', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'bytes-written.txt');
-        const stream = createWriteStream(filePath);
-        await new Promise<void>((resolve, reject) => {
-          stream.on('error', reject);
-          stream.write('hello');
-          stream.end(' world', () => resolve());
-        });
-        expect(stream.bytesWritten).toBe(11); // "hello world"
-      } finally {
-        cleanup();
-      }
-    });
-  });
-
-  // ---- pipe: ReadStream → WriteStream ----
-
-  await describe('fs pipe: createReadStream → createWriteStream', async () => {
-    await it('should copy a file via pipe', async () => {
-      setup();
-      try {
-        const srcPath = join(tmpDir, 'src.txt');
-        const dstPath = join(tmpDir, 'dst.txt');
-        writeFileSync(srcPath, 'pipe copy test');
-        await new Promise<void>((resolve, reject) => {
-          const src = createReadStream(srcPath);
-          const dst = createWriteStream(dstPath);
-          src.on('error', reject);
-          dst.on('error', reject);
-          dst.on('finish', () => resolve());
-          src.pipe(dst);
-        });
-        expect(readFileSync(dstPath, 'utf8')).toBe('pipe copy test');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should copy a large file via pipe', async () => {
-      setup();
-      try {
-        const srcPath = join(tmpDir, 'large-src.txt');
-        const dstPath = join(tmpDir, 'large-dst.txt');
-        const size = 128 * 1024; // 128KB
-        writeFileSync(srcPath, 'D'.repeat(size));
-        await new Promise<void>((resolve, reject) => {
-          const src = createReadStream(srcPath);
-          const dst = createWriteStream(dstPath);
-          src.on('error', reject);
-          dst.on('error', reject);
-          dst.on('finish', () => resolve());
-          src.pipe(dst);
-        });
-        const result = readFileSync(dstPath, 'utf8');
-        expect(result.length).toBe(size);
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should pipe through a Transform (uppercase)', async () => {
-      setup();
-      try {
-        const srcPath = join(tmpDir, 'transform-src.txt');
-        const dstPath = join(tmpDir, 'transform-dst.txt');
-        writeFileSync(srcPath, 'hello transform');
-        const upper = new Transform({
-          transform(chunk, _enc, cb) {
-            cb(null, chunk.toString().toUpperCase());
-          },
-        });
-        await new Promise<void>((resolve, reject) => {
-          const src = createReadStream(srcPath, { encoding: 'utf8' });
-          const dst = createWriteStream(dstPath);
-          dst.on('error', reject);
-          dst.on('finish', () => resolve());
-          src.pipe(upper).pipe(dst);
-        });
-        expect(readFileSync(dstPath, 'utf8')).toBe('HELLO TRANSFORM');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should pipe through a PassThrough', async () => {
-      setup();
-      try {
-        const srcPath = join(tmpDir, 'pt-src.txt');
-        const dstPath = join(tmpDir, 'pt-dst.txt');
-        writeFileSync(srcPath, 'passthrough test');
-        const pt = new PassThrough();
-        await new Promise<void>((resolve, reject) => {
-          const src = createReadStream(srcPath);
-          const dst = createWriteStream(dstPath);
-          dst.on('error', reject);
-          dst.on('finish', () => resolve());
-          src.pipe(pt).pipe(dst);
-        });
-        expect(readFileSync(dstPath, 'utf8')).toBe('passthrough test');
-      } finally {
-        cleanup();
-      }
-    });
-  });
-
-  // ---- Multiple sequential reads ----
-
-  await describe('fs streams: sequential operations', async () => {
-    await it('should read the same file twice sequentially', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'multi-read.txt');
-        writeFileSync(filePath, 'read me twice');
-        const readOnce = (): Promise<string> => new Promise((resolve, reject) => {
-          const chunks: string[] = [];
-          const stream = createReadStream(filePath, { encoding: 'utf8' });
-          stream.on('data', (chunk) => chunks.push(chunk as string));
-          stream.on('end', () => resolve(chunks.join('')));
-          stream.on('error', reject);
-        });
-        const r1 = await readOnce();
-        const r2 = await readOnce();
-        expect(r1).toBe('read me twice');
-        expect(r2).toBe('read me twice');
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should write then read the same file', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'write-then-read.txt');
-        // Write
-        await new Promise<void>((resolve, reject) => {
-          const ws = createWriteStream(filePath);
-          ws.on('error', reject);
-          ws.end('written content', () => resolve());
-        });
-        // Read
-        const chunks: string[] = [];
-        await new Promise<void>((resolve, reject) => {
-          const rs = createReadStream(filePath, { encoding: 'utf8' });
-          rs.on('data', (chunk) => chunks.push(chunk as string));
-          rs.on('end', () => resolve());
-          rs.on('error', reject);
-        });
-        expect(chunks.join('')).toBe('written content');
-      } finally {
-        cleanup();
-      }
-    });
-  });
-
-  // ---- Unicode and special content ----
-
-  await describe('fs streams: unicode and binary', async () => {
-    await it('should handle UTF-8 content with multibyte chars', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'unicode.txt');
-        const content = 'Hallo Welt! 你好世界 🌍🎉';
-        writeFileSync(filePath, content);
-        const chunks: string[] = [];
-        await new Promise<void>((resolve, reject) => {
-          const stream = createReadStream(filePath, { encoding: 'utf8' });
-          stream.on('data', (chunk) => chunks.push(chunk as string));
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        expect(chunks.join('')).toBe(content);
-      } finally {
-        cleanup();
-      }
-    });
-
-    await it('should handle binary data round-trip', async () => {
-      setup();
-      try {
-        const filePath = join(tmpDir, 'binary.dat');
-        const data = Buffer.from([0x00, 0x01, 0x80, 0xff, 0xfe, 0x7f, 0x00, 0x42]);
-        writeFileSync(filePath, data);
-        const chunks: Buffer[] = [];
-        await new Promise<void>((resolve, reject) => {
-          const stream = createReadStream(filePath);
-          stream.on('data', (chunk) => chunks.push(Buffer.from(chunk as Uint8Array)));
-          stream.on('end', () => resolve());
-          stream.on('error', reject);
-        });
-        const result = Buffer.concat(chunks);
-        expect(result.length).toBe(8);
-        expect(result[0]).toBe(0x00);
-        expect(result[2]).toBe(0x80);
-        expect(result[3]).toBe(0xff);
-        expect(result[7]).toBe(0x42);
-      } finally {
-        cleanup();
-      }
-    });
-  });
-};

package/src/symlink.spec.ts

@@ -1,188 +0,0 @@
-// Ported from refs/node-test/parallel/test-fs-symlink.js,
-//   test-fs-readlink.js, test-fs-realpath.js
-// Original: MIT license, Node.js contributors
-import { describe, it, expect } from '@gjsify/unit';
-import {
-  symlink as symlinkCb,
-  mkdtempSync,
-  rmdirSync,
-  unlinkSync,
-  lstatSync,
-  readlinkSync,
-  realpathSync,
-  writeFileSync,
-} from 'node:fs';
-import { symlink, readlink, realpath, unlink, rmdir, lstat, writeFile, mkdtemp } from 'node:fs/promises';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-
-export default async () => {
-  await describe('fs.symlink (callback)', async () => {
-
-    await it('should throw when no callback provided', async () => {
-      expect(() => {
-        // @ts-ignore
-        symlinkCb('some/path', 'some/other/path', 'dir');
-      }).toThrow(Error);
-    });
-
-    await it('should create a symlink pointing to a file', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-sym-cb-'));
-      const target = join(dir, 'target.txt');
-      const link = join(dir, 'link.txt');
-      writeFileSync(target, 'symlink target');
-
-      await new Promise<void>((resolve, reject) => {
-        symlinkCb(target, link, (err) => {
-          if (err) return reject(err);
-          try {
-            const s = lstatSync(link);
-            expect(s.isSymbolicLink()).toBe(true);
-            resolve();
-          } catch (e) {
-            reject(e);
-          }
-        });
-      });
-
-      unlinkSync(link);
-      unlinkSync(target);
-      rmdirSync(dir);
-    });
-  });
-
-  await describe('fs.symlink (promise)', async () => {
-    await it('should create a symlink pointing to a file', async () => {
-      const dir = await mkdtemp(join(tmpdir(), 'fs-sym-p-'));
-      const target = join(dir, 'target.txt');
-      const link = join(dir, 'link.txt');
-      await writeFile(target, 'symlink target content');
-
-      await symlink(target, link);
-
-      const s = lstatSync(link);
-      expect(s.isSymbolicLink()).toBe(true);
-
-      await unlink(link);
-      await unlink(target);
-      await rmdir(dir);
-    });
-
-    await it('should throw ENOENT when symlinking to non-existent target', async () => {
-      const dir = await mkdtemp(join(tmpdir(), 'fs-sym-err-'));
-      const link = join(dir, 'link.txt');
-      // Creating a dangling symlink — target doesn't exist
-      await symlink('/nonexistent/path/12345abc', link);
-      const s = await lstat(link);
-      expect(s.isSymbolicLink()).toBe(true);
-      await unlink(link);
-      await rmdir(dir);
-    });
-
-    await it('should throw EEXIST when symlink already exists', async () => {
-      const dir = await mkdtemp(join(tmpdir(), 'fs-sym-exist-'));
-      const target = join(dir, 'target.txt');
-      const link = join(dir, 'link.txt');
-      await writeFile(target, 'data');
-      await symlink(target, link);
-
-      let threw = false;
-      try {
-        await symlink(target, link);
-      } catch (e: unknown) {
-        threw = true;
-        expect((e as NodeJS.ErrnoException).code).toBe('EEXIST');
-      }
-      expect(threw).toBe(true);
-
-      await unlink(link);
-      await unlink(target);
-      await rmdir(dir);
-    });
-  });
-
-  await describe('fs.readlink', async () => {
-    await it('should read the symlink target synchronously', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-rl-'));
-      const target = join(dir, 'target.txt');
-      const link2 = join(dir, 'link2.txt');
-      writeFileSync(target, 'data');
-
-      await new Promise<void>(resolve => {
-        symlinkCb(target, link2, () => {
-          const dest = readlinkSync(link2);
-          expect(dest).toBe(target);
-          unlinkSync(link2);
-          unlinkSync(target);
-          rmdirSync(dir);
-          resolve();
-        });
-      });
-    });
-
-    await it('should read the symlink target via promise', async () => {
-      const dir = await mkdtemp(join(tmpdir(), 'fs-rl-p-'));
-      const target = join(dir, 'target.txt');
-      const link = join(dir, 'link.txt');
-      await writeFile(target, 'data');
-      await symlink(target, link);
-
-      const dest = await readlink(link);
-      expect(dest).toBe(target);
-
-      await unlink(link);
-      await unlink(target);
-      await rmdir(dir);
-    });
-
-    await it('should throw ENOENT when reading non-existent symlink', async () => {
-      let threw = false;
-      try {
-        await readlink('/nonexistent/path/no-link-xyz');
-      } catch (e: unknown) {
-        threw = true;
-        expect((e as NodeJS.ErrnoException).code).toBe('ENOENT');
-      }
-      expect(threw).toBe(true);
-    });
-  });
-
-  await describe('fs.realpath', async () => {
-    await it('should resolve a symlink to real path (sync)', async () => {
-      const dir = mkdtempSync(join(tmpdir(), 'fs-rp-'));
-      const target = join(dir, 'realfile.txt');
-      const link = join(dir, 'link.txt');
-      writeFileSync(target, 'realpath test');
-
-      await new Promise<void>(resolve => {
-        symlinkCb(target, link, () => {
-          const real = realpathSync(link);
-          // realpath resolves symlinks to actual path
-          expect(typeof real).toBe('string');
-          expect(real.length).toBeGreaterThan(0);
-          unlinkSync(link);
-          resolve();
-        });
-      });
-
-      unlinkSync(target);
-      rmdirSync(dir);
-    });
-
-    await it('should resolve a symlink to real path (promise)', async () => {
-      const dir = await mkdtemp(join(tmpdir(), 'fs-rp-p-'));
-      const target = join(dir, 'realfile.txt');
-      const link = join(dir, 'link.txt');
-      await writeFile(target, 'realpath test');
-      await symlink(target, link);
-
-      const real = await realpath(link);
-      expect(typeof real).toBe('string');
-      expect(real.length).toBeGreaterThan(0);
-
-      await unlink(link);
-      await unlink(target);
-      await rmdir(dir);
-    });
-  });
-};