import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { TorrentClawClient, ApiError } from "../src/api-client.js";
describe("TorrentClawClient", () => {
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" },
}),
);
}
function mockFetchError(body: string, status: number) {
(globalThis.fetch as ReturnType<typeof vi.fn>).mockResolvedValueOnce(
new Response(body, { status }),
);
}
it("builds correct search URL with all parameters", async () => {
mockFetch({ total: 0, page: 1, pageSize: 10, results: [] });
const client = new TorrentClawClient();
await client.search({
query: "inception",
type: "movie",
sort: "seeders",
quality: "1080p",
min_rating: 7,
});
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("q=inception");
expect(calledUrl).toContain("type=movie");
expect(calledUrl).toContain("sort=seeders");
expect(calledUrl).toContain("quality=1080p");
expect(calledUrl).toContain("min_rating=7");
});
it("omits undefined parameters from URL", async () => {
mockFetch({ total: 0, page: 1, pageSize: 10, results: [] });
const client = new TorrentClawClient();
await client.search({ query: "test" });
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("q=test");
expect(calledUrl).not.toContain("type=");
expect(calledUrl).not.toContain("genre=");
});
it("includes correct headers", async () => {
mockFetch({ total: 0, page: 1, pageSize: 10, results: [] });
const client = new TorrentClawClient();
await client.search({ query: "test" });
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const options = fetchMock.mock.calls[0][1] as RequestInit;
const headers = options.headers as Record<string, string>;
expect(headers["Accept"]).toBe("application/json");
expect(headers["X-Search-Source"]).toBe("mcp");
expect(headers["User-Agent"]).toMatch(/^torrentclaw-mcp\//);
});
it("throws ApiError on 400 response", async () => {
mockFetchError("Bad request", 400);
const client = new TorrentClawClient();
await expect(client.search({ query: "test" })).rejects.toThrow(ApiError);
});
it("throws ApiError with rate limit message on 429 after retries", async () => {
// With retry logic (MAX_RETRIES=2), need 3 consecutive 429 responses
mockFetchError("Too many requests", 429);
mockFetchError("Too many requests", 429);
mockFetchError("Too many requests", 429);
const client = new TorrentClawClient();
try {
await client.search({ query: "test" });
expect.fail("Should have thrown");
} catch (e) {
expect(e).toBeInstanceOf(ApiError);
expect((e as ApiError).message).toContain("Rate limit exceeded");
expect((e as ApiError).status).toBe(429);
}
});
it("constructs torrent download URL", () => {
const client = new TorrentClawClient();
const url = client.getTorrentDownloadUrl(
"aaf1e71c0a0e3b1c0f1a2b3c4d5e6f7a8b9c0d1e",
);
expect(url).toBe(
"https://torrentclaw.com/api/v1/torrent/aaf1e71c0a0e3b1c0f1a2b3c4d5e6f7a8b9c0d1e",
);
});
it("calls correct endpoint for popular", async () => {
mockFetch({ items: [], total: 0, page: 1, pageSize: 10 });
const client = new TorrentClawClient();
await client.getPopular(5, 2);
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("/api/v1/popular");
expect(calledUrl).toContain("limit=5");
expect(calledUrl).toContain("page=2");
});
it("includes locale param for popular", async () => {
mockFetch({ items: [], total: 0, page: 1, pageSize: 10 });
const client = new TorrentClawClient();
await client.getPopular(10, 1, "es");
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("locale=es");
});
it("includes locale param for recent", async () => {
mockFetch({ items: [], total: 0, page: 1, pageSize: 10 });
const client = new TorrentClawClient();
await client.getRecent(10, 1, "fr");
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("locale=fr");
});
it("calls correct endpoint for watch providers", async () => {
mockFetch({
contentId: 42,
country: "ES",
providers: { flatrate: [], rent: [], buy: [], free: [] },
attribution: "JustWatch",
});
const client = new TorrentClawClient();
await client.getWatchProviders(42, "ES");
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("/api/v1/content/42/watch-providers");
expect(calledUrl).toContain("country=ES");
});
it("calls correct endpoint for recent", async () => {
mockFetch({ items: [], total: 0, page: 1, pageSize: 10 });
const client = new TorrentClawClient();
await client.getRecent(10, 3);
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("/api/v1/recent");
expect(calledUrl).toContain("limit=10");
expect(calledUrl).toContain("page=3");
});
it("calls correct endpoint for credits", async () => {
mockFetch({ contentId: 7, director: "Nolan", cast: [] });
const client = new TorrentClawClient();
await client.getCredits(7);
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("/api/v1/content/7/credits");
});
it("calls correct endpoint for stats", async () => {
mockFetch({
content: { movies: 100, shows: 50, tmdbEnriched: 80 },
torrents: { total: 1000, withSeeders: 500, bySource: {} },
recentIngestions: [],
});
const client = new TorrentClawClient();
const result = await client.getStats();
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("/api/v1/stats");
expect(result.content.movies).toBe(100);
});
it("includes 4xx body truncated to 200 chars", async () => {
const longBody = "x".repeat(300);
mockFetchError(longBody, 422);
const client = new TorrentClawClient();
try {
await client.search({ query: "test" });
expect.fail("Should have thrown");
} catch (e) {
expect(e).toBeInstanceOf(ApiError);
expect((e as ApiError).body.length).toBeLessThanOrEqual(200);
}
});
it("omits body for 5xx responses", async () => {
mockFetchError("Internal server error with stack trace", 500);
const client = new TorrentClawClient();
try {
await client.search({ query: "test" });
expect.fail("Should have thrown");
} catch (e) {
expect(e).toBeInstanceOf(ApiError);
expect((e as ApiError).body).toBe("");
expect((e as ApiError).status).toBe(500);
}
});
it("omits body for 502 responses", async () => {
mockFetchError("Bad gateway details", 502);
const client = new TorrentClawClient();
try {
await client.search({ query: "test" });
expect.fail("Should have thrown");
} catch (e) {
expect(e).toBeInstanceOf(ApiError);
expect((e as ApiError).body).toBe("");
}
});
it("calls correct endpoint for autocomplete", async () => {
mockFetch({ suggestions: [{ id: 1, title: "Test", year: 2024, contentType: "movie", posterUrl: null }] });
const client = new TorrentClawClient();
const result = await client.autocomplete("test");
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("/api/v1/autocomplete");
expect(calledUrl).toContain("q=test");
expect(result.suggestions).toHaveLength(1);
});
it("calls correct endpoint for track (POST)", async () => {
mockFetch({ ok: true });
const client = new TorrentClawClient();
const result = await client.track("abc123def456abc123def456abc123def456abc1", "magnet");
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
const options = fetchMock.mock.calls[0][1] as RequestInit;
expect(calledUrl).toContain("/api/v1/track");
expect(options.method).toBe("POST");
expect(JSON.parse(options.body as string)).toEqual({
infoHash: "abc123def456abc123def456abc123def456abc1",
action: "magnet",
});
expect(result.ok).toBe(true);
});
it("calls correct endpoint for submitScanRequest (POST)", async () => {
mockFetch({ status: "pending" });
const client = new TorrentClawClient();
const result = await client.submitScanRequest("abc123def456abc123def456abc123def456abc1", "test@example.com");
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
const options = fetchMock.mock.calls[0][1] as RequestInit;
expect(calledUrl).toContain("/api/v1/scan-request");
expect(options.method).toBe("POST");
expect(JSON.parse(options.body as string)).toEqual({
infoHash: "abc123def456abc123def456abc123def456abc1",
email: "test@example.com",
website: "",
});
expect(result.status).toBe("pending");
});
it("calls correct endpoint for getScanStatus", async () => {
mockFetch({ status: "completed", source: "scan_request" });
const client = new TorrentClawClient();
const result = await client.getScanStatus("abc123def456abc123def456abc123def456abc1");
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const calledUrl = fetchMock.mock.calls[0][0] as string;
expect(calledUrl).toContain("/api/v1/scan-request/abc123def456abc123def456abc123def456abc1");
expect(result.status).toBe("completed");
});
it("retries on 429 and succeeds", async () => {
mockFetchError("Too many requests", 429);
mockFetch({ total: 1, page: 1, pageSize: 10, results: [] });
const client = new TorrentClawClient();
const result = await client.search({ query: "test" });
expect(result.total).toBe(1);
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
expect(fetchMock).toHaveBeenCalledTimes(2);
});
it("includes Authorization header when apiKey is set", async () => {
mockFetch({ total: 0, page: 1, pageSize: 10, results: [] });
const client = new TorrentClawClient();
// eslint-disable-next-line @typescript-eslint/no-explicit-any
(client as any).apiKey = "test-api-key-123";
await client.search({ query: "test" });
const fetchMock = globalThis.fetch as ReturnType<typeof vi.fn>;
const options = fetchMock.mock.calls[0][1] as RequestInit;
const headers = options.headers as Record<string, string>;
expect(headers["Authorization"]).toBe("Bearer test-api-key-123");
});
it("throws ApiError on POST 400 response", async () => {
mockFetchError("Invalid body", 400);
const client = new TorrentClawClient();
await expect(
client.track("abc123def456abc123def456abc123def456abc1", "magnet"),
).rejects.toThrow(ApiError);
});
});
