@ricsam/isolate-fs 0.0.1 → 0.1.1

package/src/integration.test.ts

@@ -0,0 +1,288 @@
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert";
+import { createRuntime, type RuntimeHandle } from "@ricsam/isolate-runtime";
+import { createNodeFileSystemHandler } from "./node-adapter.ts";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import * as fs from "node:fs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const fixturesDir = join(__dirname, "fixtures");
+
+describe("FS + HTTP Integration Tests", () => {
+  let runtime: RuntimeHandle | undefined;
+
+  afterEach(async () => {
+    if (runtime) {
+      runtime.dispose();
+      runtime = undefined;
+    }
+  });
+
+  test("binary file (image) can be read from disk and returned in response", async () => {
+    // 1. Read original image bytes for comparison
+    const originalBytes = fs.readFileSync(join(fixturesDir, "test-image.png"));
+
+    // 2. Create runtime with fs enabled, pointing to fixtures dir
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {}, // Suppress logs
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    // 3. Run code that reads file and returns as Response
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+        const arrayBuffer = await file.arrayBuffer();
+
+        const response = new Response(arrayBuffer, {
+          headers: { "Content-Type": "image/png" }
+        });
+
+        // Return the response body as array for comparison
+        const responseBuffer = await response.arrayBuffer();
+        return JSON.stringify(Array.from(new Uint8Array(responseBuffer)));
+      })()
+      `,
+      { promise: true }
+    );
+
+    // 4. Verify response matches original file
+    const responseBytes = new Uint8Array(JSON.parse(result as string));
+    assert.deepStrictEqual(responseBytes, new Uint8Array(originalBytes));
+  });
+
+  test("new Response(file) streams file directly (WHATWG compliant)", async () => {
+    // 1. Read original image bytes for comparison
+    const originalBytes = fs.readFileSync(join(fixturesDir, "test-image.png"));
+
+    // 2. Create runtime with fs enabled
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {},
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    // 3. Run code that passes File directly to Response
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+
+        // Pass File directly to Response - should stream automatically
+        const response = new Response(file);
+
+        // Return the response body as array for comparison
+        const responseBuffer = await response.arrayBuffer();
+        return JSON.stringify(Array.from(new Uint8Array(responseBuffer)));
+      })()
+      `,
+      { promise: true }
+    );
+
+    // 4. Verify response matches original file
+    const responseBytes = new Uint8Array(JSON.parse(result as string));
+    assert.deepStrictEqual(responseBytes, new Uint8Array(originalBytes));
+  });
+
+  test("new Response(blob) streams blob directly (WHATWG compliant)", async () => {
+    // 1. Read original image bytes for comparison
+    const originalBytes = fs.readFileSync(join(fixturesDir, "test-image.png"));
+
+    // 2. Create runtime with fs enabled
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {},
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    // 3. Run code that creates Blob from file and passes to Response
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+
+        // Create a Blob from file contents and pass directly to Response
+        const arrayBuffer = await file.arrayBuffer();
+        const blob = new Blob([arrayBuffer], { type: "image/png" });
+        const response = new Response(blob);
+
+        // Return the response body as array for comparison
+        const responseBuffer = await response.arrayBuffer();
+        return JSON.stringify(Array.from(new Uint8Array(responseBuffer)));
+      })()
+      `,
+      { promise: true }
+    );
+
+    // 4. Verify response matches original file
+    const responseBytes = new Uint8Array(JSON.parse(result as string));
+    assert.deepStrictEqual(responseBytes, new Uint8Array(originalBytes));
+  });
+
+  test("new Response(file.slice()) returns sliced blob (WHATWG compliant)", async () => {
+    // 1. Read original image bytes for comparison
+    const originalBytes = fs.readFileSync(join(fixturesDir, "test-image.png"));
+
+    // 2. Create runtime with fs enabled
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {},
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    // 3. Run code that uses file.slice() - File extends Blob
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+
+        // Use file.slice() to get first 100 bytes - File extends Blob
+        const slicedBlob = file.slice(0, 100);
+        const response = new Response(slicedBlob);
+
+        // Return the response body as array for comparison
+        const responseBuffer = await response.arrayBuffer();
+        return JSON.stringify(Array.from(new Uint8Array(responseBuffer)));
+      })()
+      `,
+      { promise: true }
+    );
+
+    // 4. Verify response is first 100 bytes
+    const responseBytes = new Uint8Array(JSON.parse(result as string));
+    const expectedSlice = new Uint8Array(originalBytes).slice(0, 100);
+    assert.deepStrictEqual(responseBytes, expectedSlice);
+  });
+
+  test("file.type returns correct MIME type", async () => {
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {},
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+        return file.type;
+      })()
+      `,
+      { promise: true }
+    );
+
+    assert.strictEqual(result, "image/png");
+  });
+
+  test("file.name returns correct filename", async () => {
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {},
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+        return file.name;
+      })()
+      `,
+      { promise: true }
+    );
+
+    assert.strictEqual(result, "test-image.png");
+  });
+
+  test("file.size returns correct size", async () => {
+    const originalBytes = fs.readFileSync(join(fixturesDir, "test-image.png"));
+
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {},
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+        return file.size;
+      })()
+      `,
+      { promise: true }
+    );
+
+    assert.strictEqual(result, originalBytes.length);
+  });
+
+  test("file instanceof checks work correctly", async () => {
+    runtime = await createRuntime({
+      console: {
+        onLog: () => {},
+      },
+      fs: {
+        getDirectory: async () => createNodeFileSystemHandler(fixturesDir),
+      },
+    });
+
+    const result = await runtime.context.eval(
+      `
+      (async () => {
+        const root = await getDirectory("/");
+        const fileHandle = await root.getFileHandle("test-image.png");
+        const file = await fileHandle.getFile();
+        return JSON.stringify({
+          isFile: file instanceof File,
+          isBlob: file instanceof Blob,
+        });
+      })()
+      `,
+      { promise: true }
+    );
+
+    assert.deepStrictEqual(JSON.parse(result as string), {
+      isFile: true,
+      isBlob: true,
+    });
+  });
+});

package/src/node-adapter.test.ts

@@ -0,0 +1,337 @@
+import { test, describe, beforeEach } from "node:test";
+import assert from "node:assert";
+import { createFsFromVolume, Volume } from "memfs";
+import { createNodeFileSystemHandler } from "./node-adapter.ts";
+import type { FileSystemHandler } from "./index.ts";
+
+describe("createNodeFileSystemHandler", () => {
+  let vol: InstanceType<typeof Volume>;
+  let handler: FileSystemHandler;
+
+  beforeEach(() => {
+    vol = new Volume();
+    const memfs = createFsFromVolume(vol);
+    handler = createNodeFileSystemHandler("/", { fs: memfs as any });
+  });
+
+  describe("getFileHandle", () => {
+    test("creates new file when create: true", async () => {
+      await handler.getFileHandle("/newfile.txt", { create: true });
+      assert.ok(vol.existsSync("/newfile.txt"));
+    });
+
+    test("opens existing file without create option", async () => {
+      vol.writeFileSync("/existing.txt", "content");
+      await handler.getFileHandle("/existing.txt");
+      // Should not throw
+    });
+
+    test("throws NotFoundError for missing file without create", async () => {
+      await assert.rejects(
+        () => handler.getFileHandle("/nonexistent.txt"),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+
+    test("throws TypeMismatchError when path is a directory", async () => {
+      vol.mkdirSync("/somedir");
+      await assert.rejects(
+        () => handler.getFileHandle("/somedir"),
+        (err: Error) => err.message.includes("[TypeMismatchError]")
+      );
+    });
+  });
+
+  describe("getDirectoryHandle", () => {
+    test("creates new directory when create: true", async () => {
+      await handler.getDirectoryHandle("/newdir", { create: true });
+      assert.ok(vol.existsSync("/newdir"));
+      const stats = vol.statSync("/newdir");
+      assert.ok(stats.isDirectory());
+    });
+
+    test("creates nested directories with create: true", async () => {
+      await handler.getDirectoryHandle("/parent/child/grandchild", { create: true });
+      assert.ok(vol.existsSync("/parent/child/grandchild"));
+    });
+
+    test("opens existing directory without create option", async () => {
+      vol.mkdirSync("/existingdir");
+      await handler.getDirectoryHandle("/existingdir");
+      // Should not throw
+    });
+
+    test("throws NotFoundError for missing directory without create", async () => {
+      await assert.rejects(
+        () => handler.getDirectoryHandle("/nonexistent"),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+
+    test("throws TypeMismatchError when path is a file", async () => {
+      vol.writeFileSync("/somefile", "content");
+      await assert.rejects(
+        () => handler.getDirectoryHandle("/somefile"),
+        (err: Error) => err.message.includes("[TypeMismatchError]")
+      );
+    });
+  });
+
+  describe("removeEntry", () => {
+    test("removes a file", async () => {
+      vol.writeFileSync("/todelete.txt", "content");
+      await handler.removeEntry("/todelete.txt");
+      assert.ok(!vol.existsSync("/todelete.txt"));
+    });
+
+    test("removes an empty directory", async () => {
+      vol.mkdirSync("/emptydir");
+      await handler.removeEntry("/emptydir");
+      assert.ok(!vol.existsSync("/emptydir"));
+    });
+
+    test("removes non-empty directory with recursive: true", async () => {
+      vol.mkdirSync("/parent");
+      vol.mkdirSync("/parent/child");
+      vol.writeFileSync("/parent/file.txt", "content");
+      vol.writeFileSync("/parent/child/nested.txt", "nested");
+
+      await handler.removeEntry("/parent", { recursive: true });
+
+      assert.ok(!vol.existsSync("/parent"));
+      assert.ok(!vol.existsSync("/parent/child"));
+      assert.ok(!vol.existsSync("/parent/file.txt"));
+    });
+
+    test("throws error for non-empty directory without recursive", async () => {
+      vol.mkdirSync("/nonempty");
+      vol.writeFileSync("/nonempty/file.txt", "content");
+
+      await assert.rejects(
+        () => handler.removeEntry("/nonempty"),
+        (err: Error) => err.message.includes("[InvalidModificationError]")
+      );
+    });
+
+    test("throws NotFoundError for non-existent path", async () => {
+      await assert.rejects(
+        () => handler.removeEntry("/nonexistent"),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+  });
+
+  describe("readDirectory", () => {
+    test("lists files and directories", async () => {
+      vol.mkdirSync("/testdir");
+      vol.writeFileSync("/testdir/file1.txt", "content1");
+      vol.writeFileSync("/testdir/file2.txt", "content2");
+      vol.mkdirSync("/testdir/subdir");
+
+      const entries = await handler.readDirectory("/testdir");
+
+      assert.strictEqual(entries.length, 3);
+
+      const sorted = entries.sort((a, b) => a.name.localeCompare(b.name));
+      assert.deepStrictEqual(sorted[0], { name: "file1.txt", kind: "file" });
+      assert.deepStrictEqual(sorted[1], { name: "file2.txt", kind: "file" });
+      assert.deepStrictEqual(sorted[2], { name: "subdir", kind: "directory" });
+    });
+
+    test("returns empty array for empty directory", async () => {
+      vol.mkdirSync("/emptydir");
+      const entries = await handler.readDirectory("/emptydir");
+      assert.strictEqual(entries.length, 0);
+    });
+
+    test("throws NotFoundError for non-existent directory", async () => {
+      await assert.rejects(
+        () => handler.readDirectory("/nonexistent"),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+  });
+
+  describe("readFile", () => {
+    test("reads file content as Uint8Array", async () => {
+      const content = "hello world";
+      vol.writeFileSync("/test.txt", content);
+
+      const result = await handler.readFile("/test.txt");
+
+      assert.ok(result.data instanceof Uint8Array);
+      assert.strictEqual(new TextDecoder().decode(result.data), content);
+    });
+
+    test("returns correct size", async () => {
+      const content = "hello world";
+      vol.writeFileSync("/test.txt", content);
+
+      const result = await handler.readFile("/test.txt");
+
+      assert.strictEqual(result.size, content.length);
+    });
+
+    test("returns lastModified timestamp", async () => {
+      vol.writeFileSync("/test.txt", "content");
+
+      const result = await handler.readFile("/test.txt");
+
+      assert.ok(typeof result.lastModified === "number");
+      assert.ok(result.lastModified > 0);
+    });
+
+    test("returns MIME type based on extension", async () => {
+      vol.writeFileSync("/test.txt", "content");
+      vol.writeFileSync("/test.json", "{}");
+      vol.writeFileSync("/test.png", "binary");
+
+      const txtResult = await handler.readFile("/test.txt");
+      const jsonResult = await handler.readFile("/test.json");
+      const pngResult = await handler.readFile("/test.png");
+
+      assert.strictEqual(txtResult.type, "text/plain");
+      assert.strictEqual(jsonResult.type, "application/json");
+      assert.strictEqual(pngResult.type, "image/png");
+    });
+
+    test("throws NotFoundError for non-existent file", async () => {
+      await assert.rejects(
+        () => handler.readFile("/nonexistent.txt"),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+
+    test("throws TypeMismatchError for directory", async () => {
+      vol.mkdirSync("/somedir");
+      await assert.rejects(
+        () => handler.readFile("/somedir"),
+        (err: Error) => err.message.includes("[TypeMismatchError]")
+      );
+    });
+  });
+
+  describe("writeFile", () => {
+    test("writes data to file (overwrite mode)", async () => {
+      vol.writeFileSync("/test.txt", "old content");
+
+      const newContent = new TextEncoder().encode("new content");
+      await handler.writeFile("/test.txt", newContent);
+
+      const result = vol.readFileSync("/test.txt", "utf-8");
+      assert.strictEqual(result, "new content");
+    });
+
+    test("writes data at specific position", async () => {
+      vol.writeFileSync("/test.txt", "hello world");
+
+      const data = new TextEncoder().encode("XXXXX");
+      await handler.writeFile("/test.txt", data, 6);
+
+      const result = vol.readFileSync("/test.txt", "utf-8");
+      assert.strictEqual(result, "hello XXXXX");
+    });
+
+    test("throws NotFoundError for non-existent file", async () => {
+      const data = new TextEncoder().encode("content");
+      await assert.rejects(
+        () => handler.writeFile("/nonexistent.txt", data),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+  });
+
+  describe("truncateFile", () => {
+    test("truncates file to smaller size", async () => {
+      vol.writeFileSync("/test.txt", "hello world");
+
+      await handler.truncateFile("/test.txt", 5);
+
+      const result = vol.readFileSync("/test.txt", "utf-8");
+      assert.strictEqual(result, "hello");
+    });
+
+    test("extends file to larger size", async () => {
+      vol.writeFileSync("/test.txt", "hi");
+
+      await handler.truncateFile("/test.txt", 10);
+
+      const stats = vol.statSync("/test.txt");
+      assert.strictEqual(stats.size, 10);
+    });
+
+    test("throws NotFoundError for non-existent file", async () => {
+      await assert.rejects(
+        () => handler.truncateFile("/nonexistent.txt", 10),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+  });
+
+  describe("getFileMetadata", () => {
+    test("returns size", async () => {
+      const content = "hello world";
+      vol.writeFileSync("/test.txt", content);
+
+      const result = await handler.getFileMetadata("/test.txt");
+
+      assert.strictEqual(result.size, content.length);
+    });
+
+    test("returns lastModified timestamp", async () => {
+      vol.writeFileSync("/test.txt", "content");
+
+      const result = await handler.getFileMetadata("/test.txt");
+
+      assert.ok(typeof result.lastModified === "number");
+      assert.ok(result.lastModified > 0);
+    });
+
+    test("returns MIME type based on extension", async () => {
+      vol.writeFileSync("/test.html", "<html></html>");
+
+      const result = await handler.getFileMetadata("/test.html");
+
+      assert.strictEqual(result.type, "text/html");
+    });
+
+    test("throws NotFoundError for non-existent file", async () => {
+      await assert.rejects(
+        () => handler.getFileMetadata("/nonexistent.txt"),
+        (err: Error) => err.message.includes("[NotFoundError]")
+      );
+    });
+
+    test("throws TypeMismatchError for directory", async () => {
+      vol.mkdirSync("/somedir");
+      await assert.rejects(
+        () => handler.getFileMetadata("/somedir"),
+        (err: Error) => err.message.includes("[TypeMismatchError]")
+      );
+    });
+  });
+
+  describe("path mapping", () => {
+    test("maps root path correctly", async () => {
+      const memfs = createFsFromVolume(vol);
+      const rootHandler = createNodeFileSystemHandler("/sandbox", { fs: memfs as any });
+
+      vol.mkdirSync("/sandbox", { recursive: true });
+      vol.writeFileSync("/sandbox/test.txt", "content");
+
+      const result = await rootHandler.readFile("/test.txt");
+      assert.strictEqual(new TextDecoder().decode(result.data), "content");
+    });
+
+    test("handles nested paths correctly", async () => {
+      const memfs = createFsFromVolume(vol);
+      const rootHandler = createNodeFileSystemHandler("/sandbox", { fs: memfs as any });
+
+      vol.mkdirSync("/sandbox/subdir", { recursive: true });
+      vol.writeFileSync("/sandbox/subdir/file.txt", "nested content");
+
+      const result = await rootHandler.readFile("/subdir/file.txt");
+      assert.strictEqual(new TextDecoder().decode(result.data), "nested content");
+    });
+  });
+});