plainleaf/client/plugos/syscalls/space.test.ts

import { describe, expect, test, vi } from "vitest";
import { spaceReadSyscalls, spaceWriteSyscalls } from "./space.ts";

function callback(mapping: ReturnType<typeof spaceReadSyscalls>, name: string) {
  const entry = mapping[name];
  return typeof entry === "function" ? entry : entry.callback;
}

describe("Base64 file syscalls", () => {
  test("reads binary files as Base64 across the plug boundary", async () => {
    const client = {
      space: {
        spacePrimitives: {
          readFile: vi.fn(async () => ({
            data: new Uint8Array([0, 1, 2, 255]),
            meta: {},
          })),
        },
      },
    } as any;

    const read = callback(spaceReadSyscalls(client), "space.readFileBase64");
    await expect(read({}, "plug.js")).resolves.toBe("AAEC/w==");
  });

  test("decodes Base64 only after reaching the main thread", async () => {
    const writeFile = vi.fn(async (_name: string, _data: Uint8Array) => ({}));
    const client = {
      space: { spacePrimitives: { writeFile } },
    } as any;

    const write = callback(spaceWriteSyscalls(client), "space.writeFileBase64");
    await write({}, "plug.js", "AAEC/w==");

    expect(writeFile).toHaveBeenCalledOnce();
    expect(writeFile.mock.calls[0][0]).toBe("plug.js");
    expect(writeFile.mock.calls[0][1]).toEqual(new Uint8Array([0, 1, 2, 255]));
  });

  test("rejects non-string Base64 payloads before writing", async () => {
    const writeFile = vi.fn(async (_name: string, _data: Uint8Array) => ({}));
    const client = {
      space: { spacePrimitives: { writeFile } },
    } as any;
    const write = callback(spaceWriteSyscalls(client), "space.writeFileBase64");

    expect(() => write({}, "plug.js", undefined)).toThrow(
      "Base64 file data must be a string",
    );
    expect(writeFile).not.toHaveBeenCalled();
  });
});