gemiterm 2.0.0

package/tests/cli/install-browser-command.test.ts

@@ -0,0 +1,48 @@
+import { describe, test, expect, beforeEach, mock, spyOn } from "bun:test";
+import { InstallBrowserCommand } from "../../src/cli/commands/install-browser-command.ts";
+import { InstallBrowserService, InstallBrowserError } from "../../src/services/install-browser-service.ts";
+
+describe("InstallBrowserCommand", () => {
+  let command: InstallBrowserCommand;
+
+  beforeEach(() => {
+    command = new InstallBrowserCommand();
+  });
+
+  test("has correct name and description", () => {
+    expect(command.name).toBe("install-browser");
+    expect(command.description).toContain("Chromium");
+  });
+
+  test("implements CliCommand interface", () => {
+    expect(typeof command.execute).toBe("function");
+  });
+
+  test("exits with code 1 on InstallBrowserError", async () => {
+    const exitSpy = spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+
+    const service = new InstallBrowserService();
+    spyOn(service, "install").mockImplementation(async () => {
+      throw new InstallBrowserError("install failed");
+    });
+
+    const spy = spyOn(InstallBrowserService.prototype, "install").mockImplementation(async () => {
+      throw new InstallBrowserError("install failed");
+    });
+
+    await expect(command.execute([], { verbose: false })).rejects.toThrow("process.exit");
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+    spy.mockRestore();
+    exitSpy.mockRestore();
+  });
+
+  test("succeeds when install completes", async () => {
+    const spy = spyOn(InstallBrowserService.prototype, "install").mockResolvedValue(undefined);
+
+    await expect(command.execute([], { verbose: false })).resolves.toBeUndefined();
+    spy.mockRestore();
+  });
+});

package/tests/cli/list-command.test.ts

@@ -0,0 +1,179 @@
+import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import { ListCommand } from "../../src/cli/commands/list-command.ts";
+import { Mediator } from "../../src/core/mediator.ts";
+import type { CliCommandContext } from "../../src/cli/command-registry.ts";
+import { QUERY_TYPES } from "../../src/core/query-handlers.ts";
+import type { ListChatsQueryResult } from "../../src/core/query-handlers.ts";
+
+const SAMPLE_CHATS = [
+  { id: "abc123", title: "Python tips", isPinned: true, timestamp: 1717000000000 },
+  { id: "def456", title: "Bun setup", isPinned: false, timestamp: 1717100000000 },
+  { id: "ghi789", title: "Alpha test", isPinned: false, timestamp: 1716900000000 },
+];
+
+describe("ListCommand", () => {
+  let command: ListCommand;
+  let mediator: Mediator;
+  let context: CliCommandContext;
+  let logSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new ListCommand();
+    mediator = new Mediator();
+    context = { verbose: false, mediator };
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    mock.restore();
+    logSpy.mockRestore();
+  });
+
+  test("has correct name and description", () => {
+    expect(command.name).toBe("list");
+    expect(command.description).toBe("List conversations");
+  });
+
+  test("shows help with --help flag", async () => {
+    await command.execute(["--help"], context);
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Usage: gemiterm list");
+    expect(output).toContain("--limit");
+    expect(output).toContain("--format");
+  });
+
+  test("sends list-chats query and displays results", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute([], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("abc123");
+    expect(output).toContain("Python tips");
+    expect(output).toContain("Total: 3 conversations");
+  });
+
+  test("applies limit", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute(["--limit", "1"], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Total: 1 conversation");
+  });
+
+  test("applies search filter", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => {
+        const filtered = SAMPLE_CHATS.filter((c) => c.title.toLowerCase().includes("bun"));
+        return { chats: filtered };
+      }),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute(["--search", "Bun"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({ search: "Bun" }),
+      }),
+    );
+  });
+
+  test("applies --all flag", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute(["--all"], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Total: 3 conversations");
+  });
+
+  test("applies sort by alpha", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute(["--sort", "alpha"], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    const alphaIdx = output.indexOf("Alpha test");
+    const bunIdx = output.indexOf("Bun setup");
+    const pythonIdx = output.indexOf("Python tips");
+    expect(alphaIdx).toBeLessThan(bunIdx);
+    expect(bunIdx).toBeLessThan(pythonIdx);
+  });
+
+  test("outputs JSON format", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute(["--format", "json"], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    const parsed = JSON.parse(output);
+    expect(parsed).toHaveProperty("chats");
+    expect(parsed.chats).toHaveLength(3);
+  });
+
+  test("shows no conversations message when empty", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: [] })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute([], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("No conversations found");
+  });
+
+  test("applies --all-profiles flag in query", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: [] })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute(["--all-profiles"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        payload: expect.objectContaining({ allProfiles: true }),
+      }),
+    );
+  });
+
+  test("applies --offset flag", async () => {
+    const mockHandler = {
+      queryType: QUERY_TYPES.LIST_CHATS,
+      handle: mock(async () => ({ chats: SAMPLE_CHATS })),
+    };
+    mediator.registerQueryHandler(mockHandler as any);
+
+    await command.execute(["--offset", "2", "--limit", "1"], context);
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("ghi789");
+    expect(output).toContain("Total: 1 conversation");
+  });
+});

package/tests/cli/new-command.test.ts

@@ -0,0 +1,139 @@
+import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import { NewCommand } from "../../src/cli/commands/new-command.ts";
+import { Mediator } from "../../src/core/mediator.ts";
+import type { CliCommandContext } from "../../src/cli/command-registry.ts";
+import { COMMAND_TYPES } from "../../src/core/command-handlers.ts";
+
+describe("NewCommand", () => {
+  let command: NewCommand;
+  let mediator: Mediator;
+  let context: CliCommandContext;
+  let logSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new NewCommand();
+    mediator = new Mediator();
+    context = {
+      verbose: false,
+      mediator,
+      profileAuthManager: {
+        getActiveProfiles: mock(() => ["default"]),
+        findProfileForConversation: mock(() => null),
+        ensureAuthenticated: mock(() => ({ secure_1psid: "", secure_1psidts: null })),
+      } as unknown as CliCommandContext["profileAuthManager"],
+    };
+    logSpy = spyOn(console, "log").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    mock.restore();
+    logSpy.mockRestore();
+  });
+
+  test("has correct name and description", () => {
+    expect(command.name).toBe("new");
+    expect(command.description).toBe("Start a new conversation");
+  });
+
+  test("shows help with --help flag", async () => {
+    await command.execute(["--help"], context);
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Usage: gemiterm new");
+    expect(output).toContain("--profile");
+    expect(output).toContain("message");
+  });
+
+  test("shows help with -h flag", async () => {
+    await command.execute(["-h"], context);
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("Usage: gemiterm new");
+  });
+
+  test("sends start-new-chat command with message", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.START_NEW_CHAT,
+      handle: mock(async () => ({
+        response: "Hello from Gemini!",
+        conversationId: "conv-123",
+      })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["Hello there"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: COMMAND_TYPES.START_NEW_CHAT,
+        payload: expect.objectContaining({
+          message: "Hello there",
+        }),
+      }),
+    );
+
+    const output = logSpy.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("conv-123");
+    expect(output).toContain("Hello from Gemini!");
+  });
+
+  test("sends start-new-chat command with profile specified via -p", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.START_NEW_CHAT,
+      handle: mock(async () => ({
+        response: "Hello from Gemini!",
+        conversationId: "conv-456",
+      })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["-p", "dhb-worker", "a new test message"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: COMMAND_TYPES.START_NEW_CHAT,
+        payload: expect.objectContaining({
+          message: "a new test message",
+          profileName: "dhb-worker",
+        }),
+      }),
+    );
+  });
+
+  test("sends start-new-chat command with profile specified via --profile", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.START_NEW_CHAT,
+      handle: mock(async () => ({
+        response: "Hello from Gemini!",
+        conversationId: "conv-789",
+      })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["--profile", "my-profile", "test message"], context);
+
+    expect(mockHandler.handle).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: COMMAND_TYPES.START_NEW_CHAT,
+        payload: expect.objectContaining({
+          message: "test message",
+          profileName: "my-profile",
+        }),
+      }),
+    );
+  });
+
+  test("does not include profileName in payload when no profile specified", async () => {
+    const mockHandler = {
+      commandType: COMMAND_TYPES.START_NEW_CHAT,
+      handle: mock(async () => ({
+        response: "Hello",
+        conversationId: "conv-abc",
+      })),
+    };
+    mediator.registerCommandHandler(mockHandler as any);
+
+    await command.execute(["hello"], context);
+
+    const call = mockHandler.handle.mock.calls[0][0];
+    expect(call.payload.profileName).toBeUndefined();
+  });
+});

package/tests/cli/status-command.test.ts

@@ -0,0 +1,106 @@
+import { describe, test, expect, mock, beforeEach, afterEach, spyOn } from "bun:test";
+import { StatusCommand } from "../../src/cli/commands/status-command.ts";
+import { Mediator } from "../../src/core/mediator.ts";
+import type { CliCommandContext } from "../../src/cli/command-registry.ts";
+import * as configModule from "../../src/infrastructure/config.ts";
+
+describe("StatusCommand", () => {
+  let command: StatusCommand;
+  let context: CliCommandContext;
+  let exitSpy: ReturnType<typeof spyOn>;
+
+  beforeEach(() => {
+    command = new StatusCommand();
+    context = { verbose: false, mediator: new Mediator() };
+    exitSpy = spyOn(process, "exit").mockImplementation((code?: number) => {
+      throw new Error(`process.exit(${code})`);
+    });
+  });
+
+  afterEach(() => {
+    mock.restore();
+    exitSpy.mockRestore();
+  });
+
+  test("has correct name and description", () => {
+    expect(command.name).toBe("status");
+    expect(command.description).toBe("Show configuration and profile status");
+  });
+
+  describe("execute", () => {
+    test("exits with code 2 when no profiles exist", async () => {
+      spyOn(configModule, "listProfiles").mockReturnValue([]);
+      spyOn(configModule, "getConfigDir").mockReturnValue("/tmp/gemiterm");
+      spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
+      spyOn(configModule, "getDefaultProfileName").mockReturnValue("default");
+      spyOn(console, "log").mockImplementation(() => {});
+
+      await expect(command.execute([], context)).rejects.toThrow("process.exit(2)");
+    });
+
+    test("displays config directory and profile table", async () => {
+      spyOn(configModule, "listProfiles").mockReturnValue(["default"]);
+      spyOn(configModule, "getConfigDir").mockReturnValue("/home/user/.config/gemiterm");
+      spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
+      spyOn(configModule, "getDefaultProfileName").mockReturnValue("default");
+
+      const logOutput: string[] = [];
+      spyOn(console, "log").mockImplementation((...args) => {
+        logOutput.push(args.join(" "));
+      });
+
+      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
+      const mockGetStatus = mock(() => ({
+        name: "default",
+        exists: true,
+        isActive: true,
+        expiresAt: "2026-07-01T00:00:00.000Z",
+        isDefault: true,
+      }));
+      const origProto = ProfileManager.prototype.getStatus;
+      ProfileManager.prototype.getStatus = mockGetStatus;
+
+      try {
+        await command.execute([], context);
+
+        const combined = logOutput.join("\n");
+        expect(combined).toContain("Configuration");
+        expect(combined).toContain("/home/user/.config/gemiterm");
+        expect(combined).toContain("Profiles");
+        expect(combined).toContain("default");
+      } finally {
+        ProfileManager.prototype.getStatus = origProto;
+      }
+    });
+
+    test("displays multiple profiles with correct default marker", async () => {
+      spyOn(configModule, "listProfiles").mockReturnValue(["work", "personal"]);
+      spyOn(configModule, "getConfigDir").mockReturnValue("/home/user/.config/gemiterm");
+      spyOn(configModule, "ensureConfigDir").mockImplementation(() => {});
+      spyOn(configModule, "getDefaultProfileName").mockReturnValue("work");
+
+      const logOutput: string[] = [];
+      spyOn(console, "log").mockImplementation((...args) => {
+        logOutput.push(args.join(" "));
+      });
+
+      const { ProfileManager } = await import("../../src/infrastructure/storage.ts");
+      const statuses = {
+        work: { name: "work", exists: true, isActive: true, expiresAt: "2026-08-01T00:00:00.000Z", isDefault: true },
+        personal: { name: "personal", exists: true, isActive: false, expiresAt: null, isDefault: false },
+      };
+      const origProto = ProfileManager.prototype.getStatus;
+      ProfileManager.prototype.getStatus = mock((name: string) => statuses[name as keyof typeof statuses]);
+
+      try {
+        await command.execute([], context);
+
+        const combined = logOutput.join("\n");
+        expect(combined).toContain("work");
+        expect(combined).toContain("personal");
+      } finally {
+        ProfileManager.prototype.getStatus = origProto;
+      }
+    });
+  });
+});

package/tests/core/query-handlers.test.ts

@@ -0,0 +1,187 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+import {
+  ListChatsQueryHandler,
+  FetchChatQueryHandler,
+  GetProfileStatusesQueryHandler,
+  GetAuthStatusQueryHandler,
+  ListModelsQueryHandler,
+  QUERY_TYPES,
+} from "../../src/core/query-handlers.ts";
+import type { IGeminiClientQueryService, IProfileQueryService } from "../../src/core/query-handlers.ts";
+import type { Query } from "../../src/core/mediator.ts";
+
+function makeQuery<T>(type: string, payload: T): Query<T> {
+  return { type, payload: payload as unknown as Record<string, unknown> };
+}
+
+describe("ListChatsQueryHandler", () => {
+  let mockClient: IGeminiClientQueryService & { forProfile: (name: string) => IGeminiClientQueryService };
+
+  beforeEach(() => {
+    mockClient = {
+      listChats: mock(() => Promise.resolve([])),
+      fetchChat: mock(() => Promise.resolve([])),
+      listModels: mock(() => Promise.resolve([])),
+      forProfile: (name: string) => mockClient,
+    };
+  });
+
+  test("has correct queryType", () => {
+    const handler = new ListChatsQueryHandler(() => mockClient as any, () => []);
+    expect(handler.queryType).toBe(QUERY_TYPES.LIST_CHATS);
+  });
+
+  test("returns chats from gemini client", async () => {
+    const chats = [
+      { id: "1", title: "Chat 1", isPinned: false, timestamp: 1000 },
+      { id: "2", title: "Chat 2", isPinned: true, timestamp: 2000 },
+    ];
+    mockClient.listChats = mock(() => Promise.resolve(chats));
+
+    const handler = new ListChatsQueryHandler(() => mockClient as any, () => []);
+    const result = await handler.handle(makeQuery(QUERY_TYPES.LIST_CHATS, {}));
+    expect(result.chats).toEqual(chats);
+  });
+
+  test("passes limit, offset, search options", async () => {
+    mockClient.listChats = mock((opts) => {
+      expect(opts).toEqual({ limit: 10, offset: 5, search: "hello" });
+      return Promise.resolve([]);
+    });
+
+    const handler = new ListChatsQueryHandler(() => mockClient as any, () => []);
+    await handler.handle(
+      makeQuery(QUERY_TYPES.LIST_CHATS, { limit: 10, offset: 5, search: "hello" }),
+    );
+    expect(mockClient.listChats).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("FetchChatQueryHandler", () => {
+  let mockClient: IGeminiClientQueryService;
+
+  beforeEach(() => {
+    mockClient = {
+      listChats: mock(() => Promise.resolve([])),
+      fetchChat: mock(() => Promise.resolve([])),
+      listModels: mock(() => Promise.resolve([])),
+    };
+  });
+
+  test("has correct queryType", () => {
+    const handler = new FetchChatQueryHandler(mockClient);
+    expect(handler.queryType).toBe(QUERY_TYPES.FETCH_CHAT);
+  });
+
+  test("returns messages for conversation", async () => {
+    const messages = [
+      { role: "user" as const, content: "Hello" },
+      { role: "model" as const, content: "Hi there!" },
+    ];
+    mockClient.fetchChat = mock(() => Promise.resolve(messages));
+
+    const handler = new FetchChatQueryHandler(mockClient);
+    const result = await handler.handle(
+      makeQuery(QUERY_TYPES.FETCH_CHAT, { conversationId: "conv-123" }),
+    );
+    expect(result.messages).toEqual(messages);
+    expect(mockClient.fetchChat).toHaveBeenCalledWith("conv-123");
+  });
+});
+
+describe("GetProfileStatusesQueryHandler", () => {
+  let mockProfileService: IProfileQueryService;
+
+  beforeEach(() => {
+    mockProfileService = {
+      getProfileStatuses: mock(() => Promise.resolve([])),
+      getAuthStatus: mock(() => Promise.resolve({ authenticated: false, profileName: null })),
+    };
+  });
+
+  test("has correct queryType", () => {
+    const handler = new GetProfileStatusesQueryHandler(mockProfileService);
+    expect(handler.queryType).toBe(QUERY_TYPES.GET_PROFILE_STATUSES);
+  });
+
+  test("returns profile statuses", async () => {
+    const statuses = [
+      {
+        name: "default",
+        exists: true,
+        isActive: true,
+        expiresAt: "2099-01-01T00:00:00Z",
+        isDefault: true,
+      },
+    ];
+    mockProfileService.getProfileStatuses = mock(() => Promise.resolve(statuses));
+
+    const handler = new GetProfileStatusesQueryHandler(mockProfileService);
+    const result = await handler.handle(makeQuery(QUERY_TYPES.GET_PROFILE_STATUSES, {}));
+    expect(result.statuses).toEqual(statuses);
+  });
+});
+
+describe("GetAuthStatusQueryHandler", () => {
+  let mockProfileService: IProfileQueryService;
+
+  beforeEach(() => {
+    mockProfileService = {
+      getProfileStatuses: mock(() => Promise.resolve([])),
+      getAuthStatus: mock(() => Promise.resolve({ authenticated: false, profileName: null })),
+    };
+  });
+
+  test("has correct queryType", () => {
+    const handler = new GetAuthStatusQueryHandler(mockProfileService);
+    expect(handler.queryType).toBe(QUERY_TYPES.GET_AUTH_STATUS);
+  });
+
+  test("returns authenticated true with profile name", async () => {
+    mockProfileService.getAuthStatus = mock(() =>
+      Promise.resolve({ authenticated: true, profileName: "default" }),
+    );
+
+    const handler = new GetAuthStatusQueryHandler(mockProfileService);
+    const result = await handler.handle(makeQuery(QUERY_TYPES.GET_AUTH_STATUS, {}));
+    expect(result.authenticated).toBe(true);
+    expect(result.profileName).toBe("default");
+  });
+
+  test("returns authenticated false with null profile name", async () => {
+    mockProfileService.getAuthStatus = mock(() =>
+      Promise.resolve({ authenticated: false, profileName: null }),
+    );
+
+    const handler = new GetAuthStatusQueryHandler(mockProfileService);
+    const result = await handler.handle(makeQuery(QUERY_TYPES.GET_AUTH_STATUS, {}));
+    expect(result.authenticated).toBe(false);
+    expect(result.profileName).toBeNull();
+  });
+});
+
+describe("ListModelsQueryHandler", () => {
+  let mockClient: IGeminiClientQueryService;
+
+  beforeEach(() => {
+    mockClient = {
+      listChats: mock(() => Promise.resolve([])),
+      fetchChat: mock(() => Promise.resolve([])),
+      listModels: mock(() => Promise.resolve([])),
+    };
+  });
+
+  test("has correct queryType", () => {
+    const handler = new ListModelsQueryHandler(mockClient);
+    expect(handler.queryType).toBe(QUERY_TYPES.LIST_MODELS);
+  });
+
+  test("returns models from gemini client", async () => {
+    const models = ["gemini-pro", "gemini-1.5-pro", "gemini-1.5-flash"];
+    mockClient.listModels = mock(() => Promise.resolve(models));
+
+    const handler = new ListModelsQueryHandler(mockClient);
+    const result = await handler.handle(makeQuery(QUERY_TYPES.LIST_MODELS, {}));
+    expect(result.models).toEqual(models);
+  });
+});