torrentclaw-mcp/tests/cache.test.ts

import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { ResponseCache, TorrentClawClient } from "../src/api-client.js";

describe("ResponseCache", () => {
  it("returns undefined for missing keys", () => {
    const cache = new ResponseCache();
    expect(cache.get("missing")).toBeUndefined();
  });

  it("stores and retrieves values", () => {
    const cache = new ResponseCache();
    cache.set("key1", { data: "hello" });
    expect(cache.get("key1")).toEqual({ data: "hello" });
  });

  it("expires entries after TTL", () => {
    const cache = new ResponseCache(100); // 100ms TTL
    cache.set("key1", "value");

    // Advance time past TTL
    vi.useFakeTimers();
    vi.advanceTimersByTime(150);

    expect(cache.get("key1")).toBeUndefined();
    // Expired entry should be removed from store
    expect(cache.size).toBe(0);

    vi.useRealTimers();
  });

  it("returns value before TTL expires", () => {
    vi.useFakeTimers();
    const cache = new ResponseCache(1000); // 1s TTL
    cache.set("key1", "value");

    vi.advanceTimersByTime(500);
    expect(cache.get("key1")).toBe("value");

    vi.useRealTimers();
  });

  it("clears all entries", () => {
    const cache = new ResponseCache();
    cache.set("a", 1);
    cache.set("b", 2);
    expect(cache.size).toBe(2);

    cache.clear();
    expect(cache.size).toBe(0);
    expect(cache.get("a")).toBeUndefined();
  });

  it("overwrites existing keys", () => {
    const cache = new ResponseCache();
    cache.set("key1", "old");
    cache.set("key1", "new");
    expect(cache.get("key1")).toBe("new");
    expect(cache.size).toBe(1);
  });
});

describe("TorrentClawClient cache integration", () => {
  const originalFetch = globalThis.fetch;

  beforeEach(() => {
    globalThis.fetch = vi.fn();
  });

  afterEach(() => {
    globalThis.fetch = originalFetch;
  });

  function mockFetch(body: unknown, status = 200) {
    (globalThis.fetch as ReturnType<typeof vi.fn>).mockResolvedValueOnce(
      new Response(JSON.stringify(body), {
        status,
        headers: { "Content-Type": "application/json" },
      }),
    );
  }

  it("caches search results on second call", async () => {
    const responseData = { total: 1, page: 1, pageSize: 10, results: [] };
    mockFetch(responseData);

    const client = new TorrentClawClient();
    const result1 = await client.search({ query: "inception" });
    const result2 = await client.search({ query: "inception" });

    // Only one fetch call — second was served from cache
    expect(globalThis.fetch).toHaveBeenCalledTimes(1);
    expect(result1).toEqual(responseData);
    expect(result2).toEqual(responseData);
  });

  it("does not cache different queries", async () => {
    const data1 = { total: 1, page: 1, pageSize: 10, results: [] };
    const data2 = { total: 2, page: 1, pageSize: 10, results: [] };
    mockFetch(data1);
    mockFetch(data2);

    const client = new TorrentClawClient();
    await client.search({ query: "inception" });
    await client.search({ query: "matrix" });

    expect(globalThis.fetch).toHaveBeenCalledTimes(2);
  });

  it("does not cache error responses", async () => {
    (globalThis.fetch as ReturnType<typeof vi.fn>)
      .mockResolvedValueOnce(new Response("Server error", { status: 500 }))
      .mockResolvedValueOnce(
        new Response(
          JSON.stringify({ total: 0, page: 1, pageSize: 10, results: [] }),
          {
            status: 200,
            headers: { "Content-Type": "application/json" },
          },
        ),
      );

    const client = new TorrentClawClient();

    // First call fails
    await expect(client.search({ query: "test" })).rejects.toThrow();

    // Second call should hit the API again (not cached)
    const result = await client.search({ query: "test" });
    expect(result.total).toBe(0);
    expect(globalThis.fetch).toHaveBeenCalledTimes(2);
  });

  it("cache can be cleared manually", async () => {
    const data = { total: 1, page: 1, pageSize: 10, results: [] };
    mockFetch(data);
    mockFetch(data);

    const client = new TorrentClawClient();
    await client.search({ query: "test" });
    expect(globalThis.fetch).toHaveBeenCalledTimes(1);

    client.cache.clear();
    await client.search({ query: "test" });
    expect(globalThis.fetch).toHaveBeenCalledTimes(2);
  });
});