superacli 1.0.1 → 1.1.2

package/__tests__/server-config-service.test.js

@@ -0,0 +1,79 @@
+const {
+  getCLIConfig,
+  bumpVersion,
+  getNamespaces,
+  getResources,
+  getActions,
+  getCommand
+} = require("../server/services/configService")
+const { getStorage } = require("../server/storage/adapter")
+
+jest.mock("../server/storage/adapter")
+
+describe("configService", () => {
+  let mockStorage
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockStorage = {
+      listKeys: jest.fn(),
+      get: jest.fn(),
+      set: jest.fn()
+    }
+    getStorage.mockReturnValue(mockStorage)
+  })
+
+  test("getCLIConfig returns full structured config", async () => {
+    mockStorage.listKeys.mockImplementation((prefix) => {
+      if (prefix === "command:") return ["command:n.r.a"]
+      if (prefix === "mcp:") return ["mcp:s1"]
+      if (prefix === "spec:") return ["spec:sp1"]
+      return []
+    })
+    mockStorage.get.mockImplementation((key) => {
+      if (key === "command:n.r.a") return { namespace: "n", resource: "r", action: "a", adapter: "builtin" }
+      if (key === "mcp:s1") return { name: "s1", url: "u1" }
+      if (key === "spec:sp1") return { name: "sp1", url: "u2", auth: "none" }
+      if (key === "settings:config_version") return "10"
+      return null
+    })
+
+    const config = await getCLIConfig()
+    expect(config.version).toBe("10")
+    expect(config.commands).toHaveLength(1)
+    expect(config.mcp_servers).toHaveLength(1)
+    expect(config.specs).toHaveLength(1)
+  })
+
+  test("bumpVersion increments and saves", async () => {
+    mockStorage.get.mockResolvedValue("5")
+    const next = await bumpVersion()
+    expect(next).toBe("6")
+    expect(mockStorage.set).toHaveBeenCalledWith("settings:config_version", "6")
+  })
+
+  test("getNamespaces extracts unique prefixes", async () => {
+    mockStorage.listKeys.mockResolvedValue(["command:n1.r.a", "command:n1.r.b", "command:n2.r.a"])
+    const ns = await getNamespaces()
+    expect(ns.sort()).toEqual(["n1", "n2"])
+  })
+
+  test("getResources extracts second part", async () => {
+    mockStorage.listKeys.mockResolvedValue(["command:n.r1.a", "command:n.r2.a"])
+    const res = await getResources("n")
+    expect(res.sort()).toEqual(["r1", "r2"])
+  })
+
+  test("getActions extracts third part", async () => {
+    mockStorage.listKeys.mockResolvedValue(["command:n.r.a1", "command:n.r.a2"])
+    const act = await getActions("n", "r")
+    expect(act.sort()).toEqual(["a1", "a2"])
+  })
+
+  test("getCommand fetches by key", async () => {
+    mockStorage.get.mockResolvedValue({ id: "cmd" })
+    const cmd = await getCommand("n", "r", "a")
+    expect(cmd).toEqual({ id: "cmd" })
+    expect(mockStorage.get).toHaveBeenCalledWith("command:n.r.a")
+  })
+})

package/__tests__/server-routes-ask.test.js

@@ -0,0 +1,89 @@
+const askRouter = require("../server/routes/ask")
+const configService = require("../server/services/configService")
+
+jest.mock("../server/services/configService")
+
+function getHandler(router, method, path) {
+  const route = router.stack.find(s => s.route && s.route.path === path && s.route.methods[method])
+  return route ? route.route.stack[0].handle : null
+}
+
+describe("server routes - ask", () => {
+  let req, res
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    res = {
+      json: jest.fn().mockReturnThis(),
+      status: jest.fn().mockReturnThis()
+    }
+    global.fetch = jest.fn()
+    process.env.OPENAI_BASE_URL = "http://openai"
+  })
+
+  afterEach(() => {
+    delete process.env.OPENAI_BASE_URL
+  })
+
+  test("POST / returns 400 if query missing", async () => {
+    const handler = getHandler(askRouter, "post", "/")
+    await handler({ body: {} }, res)
+    expect(res.status).toHaveBeenCalledWith(400)
+  })
+
+  test("POST / returns 501 if OPENAI_BASE_URL missing", async () => {
+    delete process.env.OPENAI_BASE_URL
+    const handler = getHandler(askRouter, "post", "/")
+    await handler({ body: { query: "hi" } }, res)
+    expect(res.status).toHaveBeenCalledWith(501)
+  })
+
+  test("POST / successfully calls LLM and returns steps", async () => {
+    const handler = getHandler(askRouter, "post", "/")
+    configService.getNamespaces.mockResolvedValue(["n"])
+    configService.getResources.mockResolvedValue(["r"])
+    configService.getActions.mockResolvedValue(["a"])
+    configService.getCommand.mockResolvedValue({ description: "desc", args: [{ name: "f", required: true }] })
+    
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        choices: [{ message: { content: '[{"command": "n.r.a"}]' } }]
+      })
+    })
+
+    await handler({ body: { query: "help" } }, res)
+    
+    expect(res.json).toHaveBeenCalledWith({ steps: [{ command: "n.r.a" }] })
+  })
+
+  test("POST / handles markdown-wrapped JSON from LLM", async () => {
+    const handler = getHandler(askRouter, "post", "/")
+    configService.getNamespaces.mockResolvedValue([])
+    
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({
+        choices: [{ message: { content: '```json\n[{"ok":true}]\n```' } }]
+      })
+    })
+
+    await handler({ body: { query: "help" } }, res)
+    expect(res.json).toHaveBeenCalledWith({ steps: [{ ok: true }] })
+  })
+
+  test("POST / handles LLM error", async () => {
+    const handler = getHandler(askRouter, "post", "/")
+    configService.getNamespaces.mockResolvedValue([])
+    
+    global.fetch.mockResolvedValue({
+      ok: false,
+      status: 401,
+      text: () => Promise.resolve("unauthorized")
+    })
+
+    await handler({ body: { query: "help" } }, res)
+    expect(res.status).toHaveBeenCalledWith(500)
+    expect(res.json).toHaveBeenCalledWith({ error: expect.stringContaining("LLM Error 401") })
+  })
+})

package/__tests__/server-routes-commands.test.js

@@ -0,0 +1,55 @@
+const commandsRouter = require("../server/routes/commands")
+const { getStorage } = require("../server/storage/adapter")
+const { bumpVersion } = require("../server/services/configService")
+
+jest.mock("../server/storage/adapter")
+jest.mock("../server/services/configService")
+
+function getHandler(router, method, path) {
+  const route = router.stack.find(s => s.route && s.route.path === path && s.route.methods[method])
+  return route ? route.route.stack[0].handle : null
+}
+
+describe("server routes - commands", () => {
+  let res, mockStorage
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockStorage = {
+      listKeys: jest.fn().mockResolvedValue([]),
+      get: jest.fn(),
+      set: jest.fn(),
+      delete: jest.fn()
+    }
+    getStorage.mockReturnValue(mockStorage)
+    res = {
+      json: jest.fn().mockReturnThis(),
+      status: jest.fn().mockReturnThis(),
+      render: jest.fn().mockReturnThis(),
+      redirect: jest.fn().mockReturnThis(),
+      send: jest.fn().mockReturnThis()
+    }
+  })
+
+  test("GET / success", async () => {
+    mockStorage.listKeys.mockResolvedValue(["command:a"])
+    mockStorage.get.mockResolvedValue({ _id: "command:a" })
+    await getHandler(commandsRouter, "get", "/")({ query: { format: "json" }, headers: {} }, res)
+    expect(res.json).toHaveBeenCalled()
+  })
+
+  test("POST / success", async () => {
+    await getHandler(commandsRouter, "post", "/")({ body: { namespace: "n", resource: "r", action: "a" }, headers: {} }, res)
+    expect(res.status).toHaveBeenCalledWith(201)
+  })
+
+  test("PUT / success", async () => {
+    await getHandler(commandsRouter, "put", "/:id")({ params: { id: "old" }, body: { namespace: "n", resource: "r", action: "a" } }, res)
+    expect(res.json).toHaveBeenCalledWith({ ok: true })
+  })
+
+  test("DELETE / success", async () => {
+    await getHandler(commandsRouter, "delete", "/:id")({ params: { id: "1" } }, res)
+    expect(res.json).toHaveBeenCalledWith({ ok: true })
+  })
+})

package/__tests__/server-routes-config.test.js

@@ -0,0 +1,87 @@
+const configRouter = require("../server/routes/config")
+const configService = require("../server/services/configService")
+
+jest.mock("../server/services/configService")
+
+function getHandler(router, method, path) {
+  const route = router.stack.find(s => s.route && s.route.path === path && s.route.methods[method])
+  return route ? route.route.stack[0].handle : null
+}
+
+describe("server routes - config", () => {
+  let req, res
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    res = {
+      json: jest.fn().mockReturnThis(),
+      status: jest.fn().mockReturnThis()
+    }
+  })
+
+  test("GET / aggregates full config", async () => {
+    const handler = getHandler(configRouter, "get", "/")
+    configService.getCLIConfig.mockResolvedValue({ version: "1" })
+    
+    await handler({}, res)
+    
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ version: "1" }))
+  })
+
+  test("GET / handles error", async () => {
+    const handler = getHandler(configRouter, "get", "/")
+    configService.getCLIConfig.mockRejectedValue(new Error("fail"))
+    
+    await handler({}, res)
+    
+    expect(res.status).toHaveBeenCalledWith(500)
+    expect(res.json).toHaveBeenCalledWith({ error: "fail" })
+  })
+
+  test("GET /tree returns namespaces", async () => {
+    const handler = getHandler(configRouter, "get", "/tree")
+    configService.getNamespaces.mockResolvedValue(["ns1"])
+    
+    await handler({}, res)
+    
+    expect(res.json).toHaveBeenCalledWith({ namespaces: ["ns1"] })
+  })
+
+  test("GET /tree/:ns returns resources", async () => {
+    const handler = getHandler(configRouter, "get", "/tree/:ns")
+    configService.getResources.mockResolvedValue(["r1"])
+    
+    await handler({ params: { ns: "n" } }, res)
+    
+    expect(configService.getResources).toHaveBeenCalledWith("n")
+    expect(res.json).toHaveBeenCalledWith({ resources: ["r1"] })
+  })
+
+  test("GET /tree/:ns/:res returns actions", async () => {
+    const handler = getHandler(configRouter, "get", "/tree/:ns/:res")
+    configService.getActions.mockResolvedValue(["a1"])
+    
+    await handler({ params: { ns: "n", res: "r" } }, res)
+    
+    expect(configService.getActions).toHaveBeenCalledWith("n", "r")
+    expect(res.json).toHaveBeenCalledWith({ actions: ["a1"] })
+  })
+
+  test("GET /command/:ns/:res/:act returns command", async () => {
+    const handler = getHandler(configRouter, "get", "/command/:ns/:res/:act")
+    configService.getCommand.mockResolvedValue({ id: "c1" })
+    
+    await handler({ params: { ns: "n", res: "r", act: "a" } }, res)
+    
+    expect(res.json).toHaveBeenCalledWith({ id: "c1" })
+  })
+
+  test("GET /command/:ns/:res/:act returns 404 if missing", async () => {
+    const handler = getHandler(configRouter, "get", "/command/:ns/:res/:act")
+    configService.getCommand.mockResolvedValue(null)
+    
+    await handler({ params: { ns: "n", res: "r", act: "a" } }, res)
+    
+    expect(res.status).toHaveBeenCalledWith(404)
+  })
+})

package/__tests__/server-routes-jobs.test.js

@@ -0,0 +1,53 @@
+const jobsRouter = require("../server/routes/jobs")
+const { getStorage } = require("../server/storage/adapter")
+
+jest.mock("../server/storage/adapter")
+
+function getHandler(router, method, path) {
+  const route = router.stack.find(s => s.route && s.route.path === path && s.route.methods[method])
+  return route ? route.route.stack[0].handle : null
+}
+
+describe("server routes - jobs", () => {
+  let res, mockStorage
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockStorage = {
+      listKeys: jest.fn().mockResolvedValue([]),
+      get: jest.fn(),
+      set: jest.fn()
+    }
+    getStorage.mockReturnValue(mockStorage)
+    res = {
+      json: jest.fn().mockReturnThis(),
+      status: jest.fn().mockReturnThis(),
+      render: jest.fn().mockReturnThis()
+    }
+  })
+
+  test("POST / success", async () => {
+    await getHandler(jobsRouter, "post", "/")({ body: { command: "test" } }, res)
+    expect(res.status).toHaveBeenCalledWith(201)
+  })
+
+  test("GET / success", async () => {
+    mockStorage.listKeys.mockResolvedValue(["job:1"])
+    mockStorage.get.mockResolvedValue({ command: "c1", timestamp: "2024-01-01" })
+    await getHandler(jobsRouter, "get", "/")({ query: { format: "json" }, headers: {} }, res)
+    expect(res.json).toHaveBeenCalled()
+  })
+
+  test("GET /stats success", async () => {
+    mockStorage.listKeys.mockResolvedValue(["job:1"])
+    mockStorage.get.mockResolvedValue({ command: "c1", status: "success", duration_ms: 10 })
+    await getHandler(jobsRouter, "get", "/stats")({}, res)
+    expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ total: 1 }))
+  })
+
+  test("GET /:id success", async () => {
+    mockStorage.get.mockResolvedValue({ id: "job:1" })
+    await getHandler(jobsRouter, "get", "/:id")({ params: { id: "1" } }, res)
+    expect(res.json).toHaveBeenCalled()
+  })
+})

package/__tests__/server-routes-misc.test.js

@@ -0,0 +1,112 @@
+const mcpRouter = require("../server/routes/mcp")
+const specsRouter = require("../server/routes/specs")
+const plansRouter = require("../server/routes/plans")
+const { getStorage } = require("../server/storage/adapter")
+const planner = require("../cli/planner")
+const executor = require("../cli/executor")
+
+jest.mock("../server/storage/adapter")
+jest.mock("../cli/planner")
+jest.mock("../cli/executor")
+
+function getHandler(router, method, path) {
+  const route = router.stack.find(s => s.route && s.route.path === path && s.route.methods[method])
+  return route ? route.route.stack[0].handle : null
+}
+
+describe("server routes - misc", () => {
+  let res, mockStorage
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockStorage = {
+      listKeys: jest.fn().mockResolvedValue([]),
+      get: jest.fn(),
+      set: jest.fn(),
+      delete: jest.fn()
+    }
+    getStorage.mockReturnValue(mockStorage)
+    res = {
+      json: jest.fn().mockReturnThis(),
+      status: jest.fn().mockReturnThis(),
+      render: jest.fn().mockReturnThis(),
+      redirect: jest.fn().mockReturnThis()
+    }
+  })
+
+  describe("mcp routes", () => {
+    test("GET / success", async () => {
+      mockStorage.listKeys.mockResolvedValue(["mcp:a"])
+      mockStorage.get.mockResolvedValue({ name: "a" })
+      await getHandler(mcpRouter, "get", "/")({ query: { format: "json" }, headers: {} }, res)
+      expect(res.json).toHaveBeenCalled()
+    })
+    test("POST / success", async () => {
+      await getHandler(mcpRouter, "post", "/")({ body: { name: "a", url: "u" }, headers: {} }, res)
+      expect(res.status).toHaveBeenCalledWith(201)
+    })
+    test("PUT / success", async () => {
+      await getHandler(mcpRouter, "put", "/:id")({ params: { id: "mcp:a" }, body: { name: "a", url: "u" } }, res)
+      expect(res.json).toHaveBeenCalledWith({ ok: true })
+    })
+    test("DELETE / success", async () => {
+      await getHandler(mcpRouter, "delete", "/:id")({ params: { id: "mcp:a" } }, res)
+      expect(res.json).toHaveBeenCalledWith({ ok: true })
+    })
+  })
+
+  describe("specs routes", () => {
+    test("GET / success", async () => {
+      mockStorage.listKeys.mockResolvedValue(["spec:a"])
+      mockStorage.get.mockResolvedValue({ name: "a" })
+      await getHandler(specsRouter, "get", "/")({ query: { format: "json" }, headers: {} }, res)
+      expect(res.json).toHaveBeenCalled()
+    })
+    test("POST / success", async () => {
+      await getHandler(specsRouter, "post", "/")({ body: { name: "a", url: "u" }, headers: {} }, res)
+      expect(res.status).toHaveBeenCalledWith(201)
+    })
+    test("PUT / success", async () => {
+      await getHandler(specsRouter, "put", "/:id")({ params: { id: "spec:a" }, body: { name: "a", url: "u" } }, res)
+      expect(res.json).toHaveBeenCalledWith({ ok: true })
+    })
+    test("DELETE / success", async () => {
+      await getHandler(specsRouter, "delete", "/:id")({ params: { id: "spec:a" } }, res)
+      expect(res.json).toHaveBeenCalledWith({ ok: true })
+    })
+  })
+
+  describe("plans routes", () => {
+    test("POST / success", async () => {
+      mockStorage.get.mockResolvedValue({ id: "cmd" })
+      planner.createPlan.mockReturnValue({ plan_id: "p1" })
+      await getHandler(plansRouter, "post", "/")({ body: { command: "n.r.a" } }, res)
+      expect(res.status).toHaveBeenCalledWith(201)
+    })
+    test("GET / success", async () => {
+      mockStorage.listKeys.mockResolvedValue(["plan:p1"])
+      mockStorage.get.mockResolvedValue({ created_at: "2024-01-01" })
+      await getHandler(plansRouter, "get", "/")({}, res)
+      expect(res.json).toHaveBeenCalled()
+    })
+    test("GET /:id success", async () => {
+      mockStorage.get.mockResolvedValue({ id: "p1" })
+      await getHandler(plansRouter, "get", "/:id")({ params: { id: "p1" } }, res)
+      expect(res.json).toHaveBeenCalledWith({ id: "p1" })
+    })
+    test("POST /:id/execute success", async () => {
+      mockStorage.get.mockImplementation((k) => {
+        if (k === "plan:p1") return { status: "planned", command: "n.r.a", plan_id: "p1" }
+        if (k === "command:n.r.a") return { adapter: "builtin" }
+        return null
+      })
+      executor.execute.mockResolvedValue({ ok: true })
+      await getHandler(plansRouter, "post", "/:id/execute")({ params: { id: "p1" } }, res)
+      expect(res.json).toHaveBeenCalledWith(expect.objectContaining({ status: "success" }))
+    })
+    test("DELETE /:id success", async () => {
+      await getHandler(plansRouter, "delete", "/:id")({ params: { id: "p1" } }, res)
+      expect(res.json).toHaveBeenCalledWith({ ok: true })
+    })
+  })
+})

package/__tests__/server-storage-adapter.test.js

@@ -0,0 +1,40 @@
+const { getStorage } = require("../server/storage/adapter")
+const MongoAdapter = require("../server/storage/mongo")
+const FileAdapter = require("../server/storage/file")
+
+jest.mock("../server/storage/mongo")
+jest.mock("../server/storage/file")
+
+describe("storage adapter factory", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    delete process.env.SUPERCLI_USE_MONGO
+    // We can't easily reset the singleton without resetModules, 
+    // so we'll just test the logic via fresh requires if needed.
+    jest.resetModules()
+  })
+
+  test("returns FileAdapter by default", () => {
+    const FileAdapterMock = require("../server/storage/file")
+    const { getStorage } = require("../server/storage/adapter")
+    const storage = getStorage()
+    expect(FileAdapterMock).toHaveBeenCalled()
+    expect(storage).toBeInstanceOf(FileAdapterMock)
+  })
+
+  test("returns MongoAdapter if SUPERCLI_USE_MONGO=true", () => {
+    process.env.SUPERCLI_USE_MONGO = "true"
+    const MongoAdapterMock = require("../server/storage/mongo")
+    const { getStorage } = require("../server/storage/adapter")
+    const storage = getStorage()
+    expect(MongoAdapterMock).toHaveBeenCalled()
+    expect(storage).toBeInstanceOf(MongoAdapterMock)
+  })
+
+  test("singleton behavior", () => {
+    const { getStorage } = require("../server/storage/adapter")
+    const s1 = getStorage()
+    const s2 = getStorage()
+    expect(s1).toBe(s2)
+  })
+})

package/__tests__/server-storage-file.test.js

@@ -0,0 +1,73 @@
+const fs = require("fs").promises
+const path = require("path")
+const FileAdapter = require("../server/storage/file")
+
+jest.mock("fs", () => ({
+  promises: {
+    readFile: jest.fn(),
+    writeFile: jest.fn(),
+    unlink: jest.fn(),
+    readdir: jest.fn(),
+    mkdir: jest.fn()
+  },
+  existsSync: jest.fn()
+}))
+const fsMock = require("fs")
+
+describe("FileAdapter", () => {
+  const baseDir = "/tmp/storage"
+  let adapter
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    adapter = new FileAdapter(baseDir)
+  })
+
+  test("get returns parsed JSON", async () => {
+    fs.readFile.mockResolvedValue('{"a": 1}')
+    const result = await adapter.get("mykey")
+    expect(result).toEqual({ a: 1 })
+    expect(fs.readFile).toHaveBeenCalledWith(expect.stringContaining("mykey.json"), "utf-8")
+  })
+
+  test("get returns null on ENOENT", async () => {
+    fs.readFile.mockRejectedValue({ code: "ENOENT" })
+    expect(await adapter.get("missing")).toBeNull()
+  })
+
+  test("get throws other errors", async () => {
+    fs.readFile.mockRejectedValue(new Error("crash"))
+    await expect(adapter.get("err")).rejects.toThrow("crash")
+  })
+
+  test("set creates dir and writes file", async () => {
+    await adapter.set("key", { x: 1 })
+    expect(fs.mkdir).toHaveBeenCalledWith(baseDir, { recursive: true })
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining("key.json"),
+      expect.stringContaining('"x": 1'),
+      "utf-8"
+    )
+  })
+
+  test("delete unlinks file", async () => {
+    await adapter.delete("key")
+    expect(fs.unlink).toHaveBeenCalled()
+  })
+
+  test("delete ignores ENOENT", async () => {
+    fs.unlink.mockRejectedValue({ code: "ENOENT" })
+    await expect(adapter.delete("key")).resolves.not.toThrow()
+  })
+
+  test("listKeys filters and maps files", async () => {
+    fs.readdir.mockResolvedValue(["abc_1.json", "abc_2.json", "other.json", "abc_3.txt"])
+    const keys = await adapter.listKeys("abc")
+    expect(keys).toEqual(["abc_1", "abc_2"])
+  })
+
+  test("listKeys returns empty on ENOENT", async () => {
+    fs.readdir.mockRejectedValue({ code: "ENOENT" })
+    expect(await adapter.listKeys()).toEqual([])
+  })
+})

package/__tests__/server-storage-mongo.test.js

@@ -0,0 +1,74 @@
+const MongoAdapter = require("../server/storage/mongo")
+const { MongoClient } = require("mongodb")
+
+jest.mock("mongodb")
+
+describe("MongoAdapter", () => {
+  let adapter
+  let mockCollection
+  let mockDb
+  let mockClient
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockCollection = {
+      findOne: jest.fn(),
+      updateOne: jest.fn(),
+      deleteOne: jest.fn(),
+      find: jest.fn().mockReturnThis(),
+      toArray: jest.fn()
+    }
+    mockDb = {
+      collection: jest.fn().mockReturnValue(mockCollection)
+    }
+    mockClient = {
+      connect: jest.fn().mockResolvedValue({}),
+      db: jest.fn().mockReturnValue(mockDb)
+    }
+    MongoClient.mockImplementation(() => mockClient)
+
+    adapter = new MongoAdapter("mongodb://uri")
+  })
+
+  test("get returns value field", async () => {
+    mockCollection.findOne.mockResolvedValue({ _id: "k", value: { x: 1 } })
+    const result = await adapter.get("k")
+    expect(result).toEqual({ x: 1 })
+    expect(mockCollection.findOne).toHaveBeenCalledWith({ _id: "k" })
+  })
+
+  test("get returns null if doc missing", async () => {
+    mockCollection.findOne.mockResolvedValue(null)
+    expect(await adapter.get("k")).toBeNull()
+  })
+
+  test("set updates with upsert", async () => {
+    await adapter.set("k", { y: 2 })
+    expect(mockCollection.updateOne).toHaveBeenCalledWith(
+      { _id: "k" },
+      { $set: { value: { y: 2 } } },
+      { upsert: true }
+    )
+  })
+
+  test("delete removes by _id", async () => {
+    await adapter.delete("k")
+    expect(mockCollection.deleteOne).toHaveBeenCalledWith({ _id: "k" })
+  })
+
+  test("listKeys uses regex and maps ids", async () => {
+    mockCollection.toArray.mockResolvedValue([{ _id: "pre:1" }, { _id: "pre:2" }])
+    const keys = await adapter.listKeys("pre:")
+    expect(keys).toEqual(["pre:1", "pre:2"])
+    expect(mockCollection.find).toHaveBeenCalledWith(
+      { _id: { $regex: "^pre:" } },
+      { projection: { _id: 1 } }
+    )
+  })
+
+  test("listKeys without prefix", async () => {
+    mockCollection.toArray.mockResolvedValue([])
+    await adapter.listKeys()
+    expect(mockCollection.find).toHaveBeenCalledWith({}, expect.anything())
+  })
+})