openlattice-modal 0.0.3

package/tests/modal-provider.test.ts

@@ -0,0 +1,461 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { ModalProvider } from "../src/modal-provider";
+
+// ── Mock modal SDK ──────────────────────────────────────────────────
+
+const mocks = vi.hoisted(() => {
+  const mockExec = vi.fn();
+  const mockTerminate = vi.fn();
+  const mockSnapshotFilesystem = vi.fn();
+
+  const mockSandbox = {
+    sandboxId: "sb-test-123",
+    exec: mockExec,
+    terminate: mockTerminate,
+    snapshotFilesystem: mockSnapshotFilesystem,
+  };
+
+  const mockCreate = vi.fn().mockResolvedValue(mockSandbox);
+  const mockFromId = vi.fn().mockResolvedValue(mockSandbox);
+  const mockFromName = vi.fn().mockResolvedValue({ appId: "app-123" });
+  const mockFromRegistry = vi.fn().mockReturnValue({ imageId: "img-123" });
+
+  return {
+    mockExec,
+    mockTerminate,
+    mockSnapshotFilesystem,
+    mockSandbox,
+    mockCreate,
+    mockFromId,
+    mockFromName,
+    mockFromRegistry,
+  };
+});
+
+vi.mock("modal", () => ({
+  ModalClient: vi.fn(function (this: any) {
+    this.apps = { fromName: mocks.mockFromName };
+    this.images = { fromRegistry: mocks.mockFromRegistry };
+    this.sandboxes = {
+      create: mocks.mockCreate,
+      fromId: mocks.mockFromId,
+    };
+    return this;
+  }),
+}));
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function setupExec(stdout: string, stderr: string, exitCode: number) {
+  mocks.mockExec.mockResolvedValue({
+    stdout: { readText: () => Promise.resolve(stdout) },
+    stderr: { readText: () => Promise.resolve(stderr) },
+    wait: () => Promise.resolve(exitCode),
+  });
+}
+
+// ── Tests ───────────────────────────────────────────────────────────
+
+describe("ModalProvider", () => {
+  let provider: ModalProvider;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.mockFromName.mockResolvedValue({ appId: "app-123" });
+    mocks.mockFromRegistry.mockReturnValue({ imageId: "img-123" });
+    mocks.mockCreate.mockResolvedValue(mocks.mockSandbox);
+    mocks.mockFromId.mockResolvedValue(mocks.mockSandbox);
+    mocks.mockTerminate.mockResolvedValue(undefined);
+    mocks.mockSnapshotFilesystem.mockResolvedValue({
+      imageId: "snap-img-456",
+    });
+    setupExec("", "", 0);
+    provider = new ModalProvider();
+  });
+
+  describe("constructor", () => {
+    it("sets name to 'modal'", () => {
+      expect(provider.name).toBe("modal");
+    });
+
+    it("declares expected capabilities", () => {
+      expect(provider.capabilities.restart).toBe(false);
+      expect(provider.capabilities.pause).toBe(false);
+      expect(provider.capabilities.snapshot).toBe(true);
+      expect(provider.capabilities.gpu).toBe(true);
+      expect(provider.capabilities.logs).toBe(false);
+      expect(provider.capabilities.tailscale).toBe(true);
+      expect(provider.capabilities.architectures).toContain("x86_64");
+      expect(provider.capabilities.persistentStorage).toBe(false);
+    });
+
+    it("has GPU types in constraints", () => {
+      expect(provider.capabilities.constraints?.gpuTypes).toContain("A100");
+      expect(provider.capabilities.constraints?.gpuTypes).toContain("H100");
+    });
+  });
+
+  describe("provision", () => {
+    it("creates a sandbox and returns node info", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      expect(node.externalId).toBe("sb-test-123");
+      expect(mocks.mockCreate).toHaveBeenCalledTimes(1);
+    });
+
+    it("resolves OCI images via fromRegistry", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12-slim" },
+      });
+
+      expect(mocks.mockFromRegistry).toHaveBeenCalledWith(
+        "python:3.12-slim"
+      );
+    });
+
+    it("passes GPU type to sandbox create", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+        gpu: { type: "A100", count: 1 },
+      });
+
+      expect(mocks.mockCreate).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.anything(),
+        expect.objectContaining({ gpu: "A100" })
+      );
+    });
+
+    it("defaults GPU to T4 when type not specified", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+        gpu: { count: 1 },
+      });
+
+      expect(mocks.mockCreate).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.anything(),
+        expect.objectContaining({ gpu: "T4" })
+      );
+    });
+
+    it("passes timeout from duration spec", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+        duration: { maxSeconds: 3600 },
+      });
+
+      expect(mocks.mockCreate).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.anything(),
+        expect.objectContaining({ timeout: 3600 })
+      );
+    });
+
+    it("passes workdir from runtime spec", async () => {
+      await provider.provision({
+        runtime: { image: "python:3.12", workdir: "/app" },
+      });
+
+      expect(mocks.mockCreate).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.anything(),
+        expect.objectContaining({ workdir: "/app" })
+      );
+    });
+
+    it("runs initial command if specified", async () => {
+      setupExec("setup done\n", "", 0);
+
+      await provider.provision({
+        runtime: {
+          image: "python:3.12",
+          command: ["pip", "install", "flask"],
+        },
+      });
+
+      expect(mocks.mockExec).toHaveBeenCalledWith(
+        ["pip", "install", "flask"],
+        expect.objectContaining({ stdout: "pipe", stderr: "pipe" })
+      );
+    });
+
+    it("calls tailscale up via sandbox exec when tailscaleAuthKey is set", async () => {
+      setupExec("", "", 0);
+
+      await provider.provision({
+        runtime: { image: "python:3.12" },
+        network: { tailscaleAuthKey: "tskey-auth-abc123" },
+      });
+
+      // Should have called exec with tailscale up command
+      const calls = mocks.mockExec.mock.calls;
+      const hasTailscaleUp = calls.some(
+        (c: any[]) => {
+          const cmd = Array.isArray(c[0]) ? c[0].join(" ") : "";
+          return cmd.includes("tailscale up") && cmd.includes("tskey-auth-abc123");
+        }
+      );
+      expect(hasTailscaleUp).toBe(true);
+    });
+  });
+
+  describe("exec", () => {
+    it("executes command in sandbox", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      setupExec("hello\n", "", 0);
+
+      const result = await provider.exec(node.externalId, [
+        "echo",
+        "hello",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe("hello\n");
+    });
+
+    it("captures stderr and exit codes", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      setupExec("", "error occurred\n", 1);
+
+      const result = await provider.exec(node.externalId, [
+        "sh",
+        "-c",
+        "exit 1",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr).toBe("error occurred\n");
+    });
+
+    it("wraps command with cwd and env", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      setupExec("", "", 0);
+
+      await provider.exec(node.externalId, ["ls"], {
+        cwd: "/app",
+        env: { FOO: "bar" },
+      });
+
+      expect(mocks.mockExec).toHaveBeenCalledWith(
+        ["sh", "-c", "cd /app && export FOO='bar' && ls"],
+        expect.anything()
+      );
+    });
+
+    it("passes timeout to exec options", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      setupExec("", "", 0);
+
+      await provider.exec(node.externalId, ["sleep", "1"], {
+        timeoutMs: 30000,
+      });
+
+      expect(mocks.mockExec).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ timeout: 30 })
+      );
+    });
+
+    it("calls onStdout and onStderr callbacks", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      setupExec("out\n", "err\n", 0);
+
+      const onStdout = vi.fn();
+      const onStderr = vi.fn();
+
+      await provider.exec(node.externalId, ["cmd"], {
+        onStdout,
+        onStderr,
+      });
+
+      expect(onStdout).toHaveBeenCalledWith("out\n");
+      expect(onStderr).toHaveBeenCalledWith("err\n");
+    });
+  });
+
+  describe("destroy", () => {
+    it("terminates the sandbox", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      await provider.destroy(node.externalId);
+
+      expect(mocks.mockTerminate).toHaveBeenCalledTimes(1);
+    });
+
+    it("is idempotent when sandbox not found", async () => {
+      mocks.mockFromId.mockRejectedValue(new Error("not found"));
+
+      await expect(
+        provider.destroy("nonexistent")
+      ).resolves.toBeUndefined();
+    });
+
+    it("is idempotent when terminate fails", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      mocks.mockTerminate.mockRejectedValue(new Error("already terminated"));
+
+      await expect(
+        provider.destroy(node.externalId)
+      ).resolves.toBeUndefined();
+    });
+  });
+
+  describe("inspect", () => {
+    it("returns running when sandbox is active", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const status = await provider.inspect(node.externalId);
+      expect(status.status).toBe("running");
+    });
+
+    it("returns terminated when sandbox not found", async () => {
+      mocks.mockFromId.mockRejectedValue(new Error("not found"));
+
+      const status = await provider.inspect("nonexistent");
+      expect(status.status).toBe("terminated");
+    });
+  });
+
+  describe("snapshot / restore", () => {
+    it("creates filesystem snapshot", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const snap = await provider.snapshot(node.externalId);
+
+      expect(snap.provider).toBe("modal");
+      expect(snap.externalId).toBe("snap-img-456");
+      expect(snap.type).toBe("filesystem");
+      expect(snap.createdAt).toBeInstanceOf(Date);
+    });
+
+    it("restores from snapshot", async () => {
+      const restoredSandbox = {
+        ...mocks.mockSandbox,
+        sandboxId: "sb-restored-789",
+      };
+      mocks.mockCreate.mockResolvedValueOnce(restoredSandbox);
+
+      const node = await provider.restore({
+        provider: "modal",
+        externalId: "snap-img-456",
+        createdAt: new Date(),
+        type: "filesystem",
+      });
+
+      expect(node.externalId).toBe("sb-restored-789");
+      expect(mocks.mockCreate).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ imageId: "snap-img-456" }),
+        expect.anything()
+      );
+    });
+
+    it("passes GPU spec to restored sandbox", async () => {
+      mocks.mockCreate.mockResolvedValueOnce({
+        ...mocks.mockSandbox,
+        sandboxId: "sb-gpu-restore",
+      });
+
+      await provider.restore(
+        {
+          provider: "modal",
+          externalId: "snap-img-456",
+          createdAt: new Date(),
+          type: "filesystem",
+        },
+        {
+          gpu: { type: "H100", count: 1 },
+        }
+      );
+
+      expect(mocks.mockCreate).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.anything(),
+        expect.objectContaining({ gpu: "H100" })
+      );
+    });
+  });
+
+  describe("healthCheck", () => {
+    it("returns healthy when Modal is reachable", async () => {
+      const health = await provider.healthCheck();
+      expect(health.healthy).toBe(true);
+      expect(health.latencyMs).toBeTypeOf("number");
+    });
+
+    it("returns unhealthy when Modal is unreachable", async () => {
+      mocks.mockFromName.mockRejectedValue(
+        new Error("connection refused")
+      );
+
+      // Need a fresh provider to trigger new client
+      const freshProvider = new ModalProvider();
+      const health = await freshProvider.healthCheck();
+      expect(health.healthy).toBe(false);
+      expect(health.message).toContain("unreachable");
+    });
+  });
+
+  describe("getExtension", () => {
+    it("returns files extension", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const files = provider.getExtension(node.externalId, "files");
+      expect(files).toBeDefined();
+      expect(files!.read).toBeTypeOf("function");
+      expect(files!.write).toBeTypeOf("function");
+      expect(files!.list).toBeTypeOf("function");
+      expect(files!.remove).toBeTypeOf("function");
+      expect(files!.mkdir).toBeTypeOf("function");
+    });
+
+    it("returns network extension", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      const network = provider.getExtension(node.externalId, "network");
+      expect(network).toBeDefined();
+      expect(network!.getUrl).toBeTypeOf("function");
+    });
+
+    it("returns undefined for unsupported extensions", async () => {
+      const node = await provider.provision({
+        runtime: { image: "python:3.12" },
+      });
+
+      expect(
+        provider.getExtension(node.externalId, "metrics")
+      ).toBeUndefined();
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src"]
+}