Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/web/__serial__/search.test.ts

Raw
import { afterEach, describe, expect, it, vi } from "vitest";
import * as codex from "../codex";
import * as ddg from "../ddg";
import * as fetchClient from "../fetch";
import * as google from "../google";
import * as minimax from "../minimax";
import * as parallel from "../parallel";
import { searchWeb } from "../search";
import * as zai from "../zai";

afterEach(() => vi.restoreAllMocks());

describe("search provider fallback order", () => {
	it.each(["google", "parallel", "codex", "minimax", "ddg", "zai", "none"])(
		"tries the configured order, with Z.AI last, until %s succeeds",
		async (winner) => {
			const calls: string[] = [];
			const attempt = (name: string) => {
				calls.push(name);
				if (name !== winner) throw new Error(`${name} unavailable`);
			};
			vi.spyOn(codex, "isCodexAvailable").mockResolvedValue(true);
			vi.spyOn(minimax, "isMinimaxAvailable").mockResolvedValue(true);
			vi.spyOn(zai, "isZaiAvailable").mockResolvedValue(true);
			vi.spyOn(ddg, "throttleWait").mockReturnValue(0);
			vi.spyOn(ddg, "markSearchTime").mockImplementation(() => {});
			vi.spyOn(codex, "codexSearch").mockImplementation(async () => {
				attempt("codex");
				return [];
			});
			vi.spyOn(minimax, "minimaxSearch").mockImplementation(async () => {
				attempt("minimax");
				return {
					organic: [],
					related_searches: [],
					base_resp: { status_code: 0, status_msg: "ok" },
				};
			});
			vi.spyOn(parallel, "parallelSearch").mockImplementation(async () => {
				attempt("parallel");
				return [];
			});
			vi.spyOn(google, "googleSearch").mockImplementation(async () => {
				attempt("google");
				return [];
			});
			vi.spyOn(fetchClient, "fetchSearchHtml").mockImplementation(async () => {
				attempt("ddg");
				return "";
			});
			vi.spyOn(ddg, "parseDdgResults").mockReturnValue({
				results: [],
				diagnostics: { resultsFound: 0, resultsSkipped: 0, rawBlockCount: 0 },
			});
			vi.spyOn(zai, "zaiSearch").mockImplementation(async () => {
				attempt("zai");
				return [];
			});

			const result = searchWeb({
				query: "docs",
				count: 5,
				timeout: 5000,
				ctx: {} as any,
			});
			const order = ["google", "parallel", "codex", "minimax", "ddg", "zai"];
			if (winner === "none") {
				await expect(result).rejects.toThrow(
					"Search unavailable: Google WML: google unavailable | Parallel: parallel unavailable | Codex: codex unavailable | MiniMax: minimax unavailable | DDG: ddg unavailable | Z.AI: zai unavailable",
				);
				expect(calls).toEqual(order);
			} else {
				await expect(result).resolves.toEqual({ results: [], source: winner });
				expect(calls).toEqual(order.slice(0, order.indexOf(winner) + 1));
			}
		},
	);

	it("uses explicit MiniMax only, preserves provenance, and reports activity", async () => {
		const result = [
			{ title: "M Plan", link: "https://example.com", snippet: "ok" },
		];
		vi.spyOn(minimax, "minimaxSearch").mockResolvedValue({
			organic: result,
			related_searches: [],
			base_resp: { status_code: 0, status_msg: "ok" },
		});
		const googleSearch = vi.spyOn(google, "googleSearch");
		const onMinimaxSearch = vi.fn();
		await expect(
			searchWeb({
				query: "docs",
				count: 5,
				timeout: 5000,
				provider: "minimax",
				onMinimaxSearch,
				ctx: {} as any,
			}),
		).resolves.toEqual({
			results: [{ title: "M Plan", url: "https://example.com", snippet: "ok" }],
			source: "minimax",
		});
		expect(googleSearch).not.toHaveBeenCalled();
		expect(onMinimaxSearch).toHaveBeenCalledOnce();
	});

	it("does not fall back when explicit MiniMax fails", async () => {
		vi.spyOn(minimax, "minimaxSearch").mockRejectedValue(
			new Error("MiniMax denied"),
		);
		const googleSearch = vi.spyOn(google, "googleSearch");
		const onMinimaxSearch = vi.fn();
		await expect(
			searchWeb({
				query: "docs",
				count: 5,
				timeout: 5000,
				provider: "minimax",
				onMinimaxSearch,
				ctx: {} as any,
			}),
		).rejects.toThrow("Search unavailable: MiniMax: MiniMax denied");
		expect(googleSearch).not.toHaveBeenCalled();
		expect(onMinimaxSearch).not.toHaveBeenCalled();
	});

	it.each([
		["M Plan", ["sk", "cp", "test"].join("-"), ["google", "minimax"]],
		["PAYG", ["sk", "api", "payg"].join("-"), ["google", "ddg"]],
	])(
		"automatic chain with a %s key includes MiniMax only when valid",
		async (_name, apiKey, expected) => {
			const calls: string[] = [];
			vi.spyOn(codex, "isCodexAvailable").mockResolvedValue(false);
			vi.spyOn(zai, "isZaiAvailable").mockResolvedValue(false);
			vi.spyOn(ddg, "throttleWait").mockReturnValue(0);
			vi.spyOn(ddg, "markSearchTime").mockImplementation(() => {});
			vi.spyOn(google, "googleSearch").mockImplementation(async () => {
				calls.push("google");
				throw new Error("google unavailable");
			});
			vi.spyOn(parallel, "parallelSearch").mockRejectedValue(
				new Error("parallel unavailable"),
			);
			vi.spyOn(minimax, "minimaxSearch").mockImplementation(async () => {
				calls.push("minimax");
				return {
					organic: [],
					related_searches: [],
					base_resp: { status_code: 0, status_msg: "ok" },
				};
			});
			vi.spyOn(fetchClient, "fetchSearchHtml").mockImplementation(async () => {
				calls.push("ddg");
				return "";
			});
			vi.spyOn(ddg, "parseDdgResults").mockReturnValue({
				results: [],
				diagnostics: { resultsFound: 0, resultsSkipped: 0, rawBlockCount: 0 },
			});
			const onMinimaxSearch = vi.fn();
			const ctx = {
				cwd: process.cwd(),
				isProjectTrusted: () => false,
				modelRegistry: {
					getProvider: () => ({
						id: "minimax",
						baseUrl: "https://api.minimax.io/anthropic",
					}),
					getProviderAuth: async () => ({ auth: { apiKey } }),
				},
			} as any;
			const outcome = await searchWeb({
				query: "docs",
				count: 5,
				timeout: 5000,
				ctx,
				onMinimaxSearch,
			});
			expect(outcome.source).toBe(expected.at(-1));
			expect(calls).toEqual(expected);
			expect(onMinimaxSearch).toHaveBeenCalledTimes(
				expected.includes("minimax") ? 1 : 0,
			);
		},
	);

	it("does not report MiniMax activity when automatic MiniMax fails", async () => {
		vi.spyOn(codex, "isCodexAvailable").mockResolvedValue(false);
		vi.spyOn(minimax, "isMinimaxAvailable").mockResolvedValue(true);
		vi.spyOn(zai, "isZaiAvailable").mockResolvedValue(false);
		vi.spyOn(google, "googleSearch").mockRejectedValue(new Error("down"));
		vi.spyOn(parallel, "parallelSearch").mockRejectedValue(new Error("down"));
		vi.spyOn(minimax, "minimaxSearch").mockRejectedValue(new Error("quota"));
		vi.spyOn(ddg, "throttleWait").mockReturnValue(0);
		vi.spyOn(ddg, "markSearchTime").mockImplementation(() => {});
		vi.spyOn(fetchClient, "fetchSearchHtml").mockResolvedValue("");
		vi.spyOn(ddg, "parseDdgResults").mockReturnValue({
			results: [],
			diagnostics: { resultsFound: 0, resultsSkipped: 0, rawBlockCount: 0 },
		});
		const onMinimaxSearch = vi.fn();
		await expect(
			searchWeb({
				query: "docs",
				count: 5,
				timeout: 5000,
				ctx: {} as any,
				onMinimaxSearch,
			}),
		).resolves.toMatchObject({ source: "ddg" });
		expect(onMinimaxSearch).not.toHaveBeenCalled();
	});

	it("does not continue to another provider after cancellation", async () => {
		vi.spyOn(codex, "isCodexAvailable").mockResolvedValue(true);
		vi.spyOn(minimax, "isMinimaxAvailable").mockResolvedValue(false);
		vi.spyOn(zai, "isZaiAvailable").mockResolvedValue(false);
		const abort = new AbortController();
		vi.spyOn(google, "googleSearch").mockImplementation(async () => {
			abort.abort(new Error("cancelled"));
			throw abort.signal.reason;
		});
		const next = vi.spyOn(parallel, "parallelSearch");
		await expect(
			searchWeb({
				query: "docs",
				count: 5,
				timeout: 5000,
				signal: abort.signal,
				ctx: {} as any,
			}),
		).rejects.toThrow("cancelled");
		expect(next).not.toHaveBeenCalled();
	});
});