@getrouter/getrouter-cli 0.1.0

package/tests/cmd/keys.test.ts

@@ -0,0 +1,163 @@
+import prompts from "prompts";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createProgram } from "../../src/cli";
+import { createApiClients } from "../../src/core/api/client";
+import type {
+  AuthService,
+  ConsumerService,
+  SubscriptionService,
+} from "../../src/generated/router/dashboard/v1";
+
+vi.mock("../../src/core/api/client", () => ({
+  createApiClients: vi.fn(),
+}));
+
+const mockConsumer = {
+  id: "c1",
+  name: "dev",
+  enabled: true,
+  apiKey: "abcd1234WXYZ",
+  lastAccess: "2026-01-02T00:00:00Z",
+  createdAt: "2026-01-01T00:00:00Z",
+};
+
+const emptyAuthService = {} as AuthService;
+const emptySubscriptionService = {} as SubscriptionService;
+
+const originalIsTTY = process.stdin.isTTY;
+const setStdinTTY = (value: boolean) => {
+  Object.defineProperty(process.stdin, "isTTY", {
+    value,
+    configurable: true,
+  });
+};
+
+afterEach(() => {
+  setStdinTTY(originalIsTTY);
+  prompts.inject([]);
+});
+
+describe("keys command", () => {
+  it("lists keys and redacts apiKey", async () => {
+    setStdinTTY(false);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({ consumers: [mockConsumer] }),
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys", "list"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("API_KEY");
+    expect(output).toContain("NAME");
+    expect(output).not.toContain("ID");
+    expect(output).toContain("abcd...WXYZ");
+    log.mockRestore();
+  });
+
+  it("lists keys when no subcommand", async () => {
+    setStdinTTY(true);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({ consumers: [mockConsumer] }),
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("NAME");
+    expect(output).not.toContain("ID");
+    expect(output).toContain("abcd...WXYZ");
+    log.mockRestore();
+  });
+
+  it("rejects removed get subcommand", async () => {
+    setStdinTTY(false);
+    const program = createProgram();
+    program.exitOverride();
+    await expect(
+      program.parseAsync(["node", "getrouter", "keys", "get", "c1"]),
+    ).rejects.toBeTruthy();
+  });
+
+  it("creates a key and prints reminder", async () => {
+    setStdinTTY(true);
+    prompts.inject(["dev", true]);
+    const createConsumer = vi.fn().mockResolvedValue(mockConsumer);
+    const updateConsumer = vi.fn().mockResolvedValue(mockConsumer);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        CreateConsumer: createConsumer,
+        UpdateConsumer: updateConsumer,
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys", "create"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("NAME");
+    expect(output).toContain("API_KEY");
+    expect(output).toContain("Please store this API key securely.");
+    log.mockRestore();
+  });
+
+  it("updates a key from prompts", async () => {
+    setStdinTTY(true);
+    prompts.inject(["new-name", false]);
+    const updateConsumer = vi.fn().mockResolvedValue({
+      ...mockConsumer,
+      name: "new-name",
+      enabled: false,
+    });
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        UpdateConsumer: updateConsumer,
+        GetConsumer: vi.fn().mockResolvedValue(mockConsumer),
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys", "update", "c1"]);
+    expect(updateConsumer).toHaveBeenCalledWith(
+      expect.objectContaining({
+        consumer: expect.objectContaining({
+          id: "c1",
+          name: "new-name",
+          enabled: false,
+        }),
+      }),
+    );
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("NAME");
+    log.mockRestore();
+  });
+
+  it("does not delete when confirmation is declined", async () => {
+    setStdinTTY(true);
+    prompts.inject([false]);
+    const deleteConsumer = vi.fn().mockResolvedValue({});
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        DeleteConsumer: deleteConsumer,
+        GetConsumer: vi.fn().mockResolvedValue(mockConsumer),
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys", "delete", "c1"]);
+    expect(deleteConsumer).not.toHaveBeenCalled();
+    log.mockRestore();
+  });
+});

package/tests/cmd/models.test.ts

@@ -0,0 +1,63 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createProgram } from "../../src/cli";
+import { createApiClients } from "../../src/core/api/client";
+import type { ModelService } from "../../src/generated/router/dashboard/v1";
+
+vi.mock("../../src/core/api/client", () => ({
+  createApiClients: vi.fn(),
+}));
+
+const originalIsTTY = process.stdin.isTTY;
+const setStdinTTY = (value: boolean) => {
+  Object.defineProperty(process.stdin, "isTTY", {
+    value,
+    configurable: true,
+  });
+};
+
+const mockModel = {
+  id: "gpt-5",
+  name: "GPT-5",
+  author: "OpenAI",
+  enabled: true,
+  updatedAt: "2026-01-01T00:00:00Z",
+};
+
+afterEach(() => {
+  setStdinTTY(originalIsTTY);
+});
+
+describe("models command", () => {
+  it("lists models with list subcommand", async () => {
+    setStdinTTY(false);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      modelService: {
+        ListModels: vi.fn().mockResolvedValue({ models: [mockModel] }),
+      } as unknown as ModelService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "models", "list"]);
+    const output = log.mock.calls.map((call) => call[0]).join("\n");
+    expect(output).toContain("NAME");
+    expect(output).not.toContain("ID");
+    log.mockRestore();
+  });
+
+  it("lists models when no subcommand", async () => {
+    setStdinTTY(true);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      modelService: {
+        ListModels: vi.fn().mockResolvedValue({ models: [mockModel] }),
+      } as unknown as ModelService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "models"]);
+    const output = log.mock.calls.map((call) => call[0]).join("\n");
+    expect(output).toContain("NAME");
+    expect(output).not.toContain("ID");
+    expect(output).toContain("GPT-5");
+    log.mockRestore();
+  });
+});

package/tests/cmd/status.test.ts

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { createProgram } from "../../src/cli";
+import { createApiClients } from "../../src/core/api/client";
+import { writeAuth } from "../../src/core/config";
+import type {
+  AuthService,
+  ConsumerService,
+  SubscriptionService,
+} from "../../src/generated/router/dashboard/v1";
+
+vi.mock("../../src/core/api/client", () => ({
+  createApiClients: vi.fn(),
+}));
+
+const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+
+describe("status command", () => {
+  it("prints logged out status with no subscription", async () => {
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      subscriptionService: {
+        CurrentSubscription: vi.fn().mockResolvedValue(null),
+      } as SubscriptionService,
+      authService: {} as AuthService,
+      consumerService: {} as unknown as ConsumerService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "status"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("🔐 Auth");
+    expect(output).toContain("  Status    : ❌ Logged out");
+    expect(output).toContain("\n\n📦 Subscription");
+    expect(output).toContain("  Status    : No active subscription");
+    log.mockRestore();
+  });
+
+  it("prints logged in status with subscription info", async () => {
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "token",
+      refreshToken: "refresh",
+      expiresAt: "2026-02-02T14:39:49Z",
+      tokenType: "Bearer",
+    });
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      subscriptionService: {
+        CurrentSubscription: vi.fn().mockResolvedValue({
+          status: "ACTIVE",
+          plan: { name: "Pro", requestPerMinute: 20, tokenPerMinute: "150K" },
+          startAt: "2026-01-01T00:00:00Z",
+          endAt: "2026-02-01T00:00:00Z",
+        }),
+      } as SubscriptionService,
+      authService: {} as AuthService,
+      consumerService: {} as unknown as ConsumerService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "status"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("🔐 Auth");
+    expect(output).toContain("  Status    : ✅ Logged in");
+    expect(output).toContain("  Expires   : 2026-02-02T14:39:49Z");
+    expect(output).toContain("  TokenType : Bearer");
+    expect(output).toContain("  Access    : token");
+    expect(output).toContain("  Refresh   : refresh");
+    expect(output).toContain("\n\n📦 Subscription");
+    expect(output).toContain("  Plan      : Pro");
+    expect(output).toContain("  Status    : ACTIVE");
+    expect(output).toContain(
+      "  Window    : 2026-01-01T00:00:00Z → 2026-02-01T00:00:00Z",
+    );
+    expect(output).toContain("  Limits    : 20 req/min · 150K tok/min");
+    log.mockRestore();
+  });
+});

package/tests/cmd/usages.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from "vitest";
+import { createProgram } from "../../src/cli";
+import { createApiClients } from "../../src/core/api/client";
+
+vi.mock("../../src/core/api/client", () => ({
+  createApiClients: vi.fn(),
+}));
+
+describe("usages command", () => {
+  it("prints chart and table", async () => {
+    const listUsage = vi.fn().mockResolvedValue({
+      usages: [
+        {
+          createdAt: "2026-01-03T00:00:00Z",
+          inputTokens: 1000,
+          outputTokens: 1000,
+          totalTokens: 2000,
+        },
+      ],
+    });
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      usageService: { ListUsage: listUsage },
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "usages"]);
+    expect(listUsage).toHaveBeenCalledTimes(1);
+    expect(listUsage).toHaveBeenCalledWith({
+      pageSize: 7,
+      pageToken: undefined,
+    });
+    expect(log).toHaveBeenCalledTimes(1);
+    const output = String(log.mock.calls[0][0] ?? "");
+    expect(output).toContain("📊 Usage (last 7 days)");
+    expect(output).toContain("I:1K");
+    expect(output).toContain("O:1K");
+    expect(output).toContain("Legend:");
+    expect(output).not.toContain("DAY");
+    expect(output).not.toContain("O:0179");
+    log.mockRestore();
+  });
+});

package/tests/config/fs.test.ts

@@ -0,0 +1,14 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { readJsonFile, writeJsonFile } from "../../src/core/config/fs";
+
+describe("config fs", () => {
+  it("writes and reads JSON", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    const file = path.join(dir, "config.json");
+    writeJsonFile(file, { hello: "world" });
+    expect(readJsonFile(file)).toEqual({ hello: "world" });
+  });
+});

package/tests/config/index.test.ts

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  readAuth,
+  readConfig,
+  writeAuth,
+  writeConfig,
+} from "../../src/core/config";
+
+describe("config read/write", () => {
+  it("writes and reads config with defaults", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeConfig({ apiBase: "https://getrouter.dev", json: true });
+    const cfg = readConfig();
+    expect(cfg.apiBase).toBe("https://getrouter.dev");
+    expect(cfg.json).toBe(true);
+  });
+
+  it("writes and reads auth state", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "a",
+      refreshToken: "b",
+      expiresAt: "c",
+      tokenType: "Bearer",
+    });
+    const auth = readAuth();
+    expect(auth.accessToken).toBe("a");
+    expect(auth.refreshToken).toBe("b");
+    expect(auth.expiresAt).toBe("c");
+  });
+
+  it("defaults tokenType to Bearer", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "a",
+      refreshToken: "b",
+      expiresAt: "c",
+      tokenType: "Bearer",
+    });
+    const auth = readAuth();
+    expect(auth.tokenType).toBe("Bearer");
+  });
+
+  it("writes auth file with 0600 on unix", () => {
+    if (process.platform === "win32") return;
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "a",
+      refreshToken: "b",
+      expiresAt: "c",
+      tokenType: "Bearer",
+    });
+    const mode = fs.statSync(path.join(dir, "auth.json")).mode & 0o777;
+    expect(mode).toBe(0o600);
+  });
+});

package/tests/config/paths.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { getAuthPath, getConfigPath } from "../../src/core/config/paths";
+
+describe("config paths", () => {
+  it("returns ~/.getrouter paths", () => {
+    expect(getConfigPath()).toContain(".getrouter");
+    expect(getConfigPath()).toContain("config.json");
+    expect(getAuthPath()).toContain("auth.json");
+  });
+});

package/tests/config/redact.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { redactSecrets } from "../../src/core/config/redact";
+
+describe("redact", () => {
+  it("redacts known secret fields", () => {
+    const out = redactSecrets({
+      accessToken: "secretcret",
+      refreshToken: "secretret2",
+      apiKey: "key",
+      other: "ok",
+    });
+    expect(out.accessToken).toBe("secr...cret");
+    expect(out.refreshToken).toBe("secr...ret2");
+    expect(out.apiKey).toBe("****");
+    expect(out.other).toBe("ok");
+  });
+});

package/tests/config/types.test.ts

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { defaultAuthState, defaultConfig } from "../../src/core/config/types";
+
+describe("config types defaults", () => {
+  it("provides sane defaults", () => {
+    expect(defaultConfig().apiBase).toBe("https://getrouter.dev");
+    expect(defaultConfig().json).toBe(false);
+    expect(defaultAuthState().accessToken).toBe("");
+  });
+});

package/tests/core/api/client.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  type ClientFactories,
+  createApiClients,
+  type RequestHandler,
+} from "../../../src/core/api/client";
+import type {
+  AuthService,
+  ConsumerService,
+  ModelService,
+  SubscriptionService,
+  UsageService,
+} from "../../../src/generated/router/dashboard/v1";
+
+const makeFetch = () =>
+  vi.fn(async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = typeof input === "string" ? input : input.toString();
+    return {
+      ok: true,
+      status: 200,
+      statusText: "OK",
+      json: async () => ({ url, init }),
+    } as Response;
+  }) as unknown as typeof fetch;
+
+describe("api client adapter", () => {
+  it("uses requestJson with generated paths", async () => {
+    const fetchImpl = makeFetch();
+    const fakeClients: ClientFactories = {
+      createConsumerServiceClient: (handler: RequestHandler) =>
+        ({
+          ListConsumers: () =>
+            handler(
+              { path: "v1/dashboard/consumers", method: "GET", body: null },
+              { service: "ConsumerService", method: "ListConsumers" },
+            ),
+        }) as unknown as ConsumerService,
+      createAuthServiceClient: (_handler: RequestHandler) =>
+        ({}) as AuthService,
+      createSubscriptionServiceClient: (_handler: RequestHandler) =>
+        ({}) as SubscriptionService,
+      createUsageServiceClient: (_handler: RequestHandler) =>
+        ({}) as UsageService,
+      createModelServiceClient: (handler: RequestHandler) =>
+        ({
+          ListModels: () =>
+            handler(
+              { path: "v1/dashboard/models", method: "GET", body: null },
+              { service: "ModelService", method: "ListModels" },
+            ),
+        }) as unknown as ModelService,
+    };
+    const { consumerService, modelService } = createApiClients({
+      fetchImpl,
+      clients: fakeClients,
+    });
+    const res = await consumerService.ListConsumers({
+      pageSize: 0,
+      pageToken: "",
+    });
+    const payload = res as unknown as { url: string; init: RequestInit };
+    expect(payload.url).toContain("/v1/dashboard/consumers");
+    expect(payload.init.method).toBe("GET");
+    const modelsRes = await modelService.ListModels({
+      pageSize: 0,
+      pageToken: "",
+      filter: "",
+    });
+    const modelsPayload = modelsRes as unknown as {
+      url: string;
+      init: RequestInit;
+    };
+    expect(modelsPayload.url).toContain("/v1/dashboard/models");
+  });
+
+  it("loads generated clients by default", async () => {
+    const fetchImpl = makeFetch();
+    const { consumerService } = createApiClients({ fetchImpl });
+    const res = await consumerService.ListConsumers({
+      pageSize: 0,
+      pageToken: "",
+    });
+    const payload = res as unknown as { url: string; init: RequestInit };
+    expect(payload.url).toContain("/v1/dashboard/consumers");
+    expect(payload.init.method).toBe("GET");
+  });
+
+  it("exposes usage service", () => {
+    const clients = createApiClients({});
+    expect("usageService" in clients).toBe(true);
+  });
+});

package/tests/core/interactive/clipboard.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  copyToClipboard,
+  getClipboardCommands,
+} from "../../../src/core/interactive/clipboard";
+
+const makeSpawn = () =>
+  vi.fn(() => {
+    const handlers: Record<string, Array<(code?: number) => void>> = {};
+    const child = {
+      stdin: { write: vi.fn(), end: vi.fn() },
+      on: (event: string, cb: (code?: number) => void) => {
+        handlers[event] = handlers[event] ?? [];
+        handlers[event].push(cb);
+        return child;
+      },
+    };
+    queueMicrotask(() => {
+      handlers.close?.forEach((cb) => {
+        cb(0);
+      });
+    });
+    return child;
+  });
+
+describe("getClipboardCommands", () => {
+  it("returns pbcopy on darwin", () => {
+    expect(getClipboardCommands("darwin")[0]?.command).toBe("pbcopy");
+  });
+});
+
+describe("copyToClipboard", () => {
+  it("writes to clipboard with provided spawn", async () => {
+    const spawnFn = makeSpawn();
+    const ok = await copyToClipboard("hello", {
+      platform: "darwin",
+      spawnFn,
+    });
+    expect(ok).toBe(true);
+    expect(spawnFn).toHaveBeenCalledWith("pbcopy", [], {
+      stdio: ["pipe", "ignore", "ignore"],
+    });
+  });
+});

package/tests/core/interactive/codex.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import {
+  MODEL_CHOICES,
+  mapReasoningValue,
+  REASONING_CHOICES,
+} from "../../../src/core/interactive/codex";
+
+describe("codex interactive helpers", () => {
+  it("maps extra high to xhigh", () => {
+    expect(mapReasoningValue("extra_high")).toBe("xhigh");
+  });
+
+  it("exports model and reasoning choices", () => {
+    expect(MODEL_CHOICES.length).toBeGreaterThan(0);
+    expect(REASONING_CHOICES.length).toBeGreaterThan(0);
+  });
+});

package/tests/core/interactive/fuzzy.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { rankFuzzyChoices } from "../../../src/core/interactive/fuzzy";
+
+const choices = [
+  { title: "gpt-5", value: "gpt-5", keywords: ["openai"] },
+  { title: "claude-3", value: "claude-3", keywords: ["anthropic"] },
+  { title: "gpt-4o", value: "gpt-4o", keywords: ["openai"] },
+];
+
+describe("rankFuzzyChoices", () => {
+  it("ranks by fuzzy match and uses keywords", () => {
+    const ranked = rankFuzzyChoices(choices, "open");
+    expect(ranked[0]?.value).toBe("gpt-5");
+    expect(ranked[1]?.value).toBe("gpt-4o");
+  });
+
+  it("returns all when query is empty", () => {
+    const ranked = rankFuzzyChoices(choices, "");
+    expect(ranked.map((choice) => choice.value)).toEqual([
+      "gpt-5",
+      "claude-3",
+      "gpt-4o",
+    ]);
+  });
+
+  it("limits results", () => {
+    const ranked = rankFuzzyChoices(choices, "g", 2);
+    expect(ranked.length).toBe(2);
+  });
+});