pi-harness-runtime 0.10.43 → 1.1.1

package/packages/quota-manager/test/quota.test.ts

@@ -0,0 +1,432 @@
+/**
+ * Quota Manager Tests
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+	QuotaManager,
+	parseMiniMaxError,
+	parseOpenAIError,
+} from "../src/quota-manager.js";
+import { TUIUsageMonitor } from "../src/tui-usage-monitor.js";
+
+describe("QuotaManager", () => {
+	let manager: QuotaManager;
+
+	beforeEach(() => {
+		manager = new QuotaManager(30 * 60 * 1000);
+	});
+
+	describe("recordSignal", () => {
+		it("records a basic signal", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 50,
+			});
+
+			const signal = manager.getLatestSignal("minimax", "5h");
+			expect(signal).not.toBeNull();
+			expect(signal!.usedPct).toBe(50);
+			expect(signal!.remainingPct).toBe(50);
+			expect(signal!.exhausted).toBe(false);
+		});
+
+		it("records exhausted signal", () => {
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "daily",
+				usedPct: 100,
+				exhausted: true,
+			});
+
+			const signal = manager.getLatestSignal("openai", "daily");
+			expect(signal!.exhausted).toBe(true);
+		});
+
+		it("stores multiple signals per provider", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 30,
+			});
+			manager.recordSignal({
+				provider: "minimax",
+				source: "playwright",
+				windowType: "daily",
+				usedPct: 70,
+			});
+
+			const signals = manager.getSignals("minimax");
+			expect(signals.length).toBeGreaterThanOrEqual(2);
+		});
+	});
+
+	describe("getLatestSignal", () => {
+		it("returns most recent by capturedAt", async () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 10,
+			});
+			await new Promise((r) => setTimeout(r, 2));
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 80,
+			});
+
+			const latest = manager.getLatestSignal("minimax", "5h");
+			expect(latest!.usedPct).toBe(80);
+		});
+
+		it("returns null for unknown provider", () => {
+			expect(manager.getLatestSignal("unknown")).toBeNull();
+		});
+	});
+
+	describe("getProviderState", () => {
+		it("available when under 90%", () => {
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "daily",
+				usedPct: 50,
+			});
+
+			const state = manager.getProviderState("openai");
+			expect(state.available).toBe(true);
+			expect(state.limited).toBe(false);
+			expect(state.exhausted).toBe(false);
+		});
+
+		it("limited when at 90%+", () => {
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "daily",
+				usedPct: 95,
+			});
+
+			const state = manager.getProviderState("openai");
+			expect(state.limited).toBe(true);
+			expect(state.available).toBe(false);
+		});
+
+		it("exhausted when at 100%", () => {
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "daily",
+				usedPct: 100,
+			});
+
+			const state = manager.getProviderState("openai");
+			expect(state.exhausted).toBe(true);
+		});
+
+		it("exhausted when explicit flag set", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				exhausted: true,
+			});
+
+			const state = manager.getProviderState("minimax");
+			expect(state.exhausted).toBe(true);
+		});
+
+		it("includes next available time", () => {
+			const future = new Date(Date.now() + 3600000).toISOString();
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "daily",
+				exhausted: true,
+				resetsAt: future,
+			});
+
+			const state = manager.getProviderState("openai");
+			expect(state.nextAvailableAt).toBeDefined();
+		});
+	});
+
+	describe("isAvailable / isExhausted", () => {
+		it("isAvailable true when under 90%", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 50,
+			});
+			expect(manager.isAvailable("minimax")).toBe(true);
+		});
+
+		it("isExhausted true when exhausted", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				exhausted: true,
+			});
+			expect(manager.isExhausted("minimax")).toBe(true);
+		});
+	});
+
+	describe("selectBestProvider", () => {
+		it("returns provider with most remaining quota", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 80,
+			});
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 30,
+			});
+
+			const best = manager.selectBestProvider(["minimax", "openai"]);
+			expect(best).toBe("openai");
+		});
+
+		it("returns null when all exhausted", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				exhausted: true,
+			});
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "5h",
+				exhausted: true,
+			});
+
+			expect(manager.selectBestProvider(["minimax", "openai"])).toBeNull();
+		});
+
+		it("returns null for empty list", () => {
+			expect(manager.selectBestProvider([])).toBeNull();
+		});
+	});
+
+	describe("clearStale", () => {
+		it("clears old signals", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 50,
+			});
+
+			// Manually add a stale signal (simulated)
+			manager.clearStale();
+
+			const signals = manager.getSignals("minimax");
+			expect(signals.length).toBeGreaterThanOrEqual(0);
+		});
+	});
+
+	describe("generateReport", () => {
+		it("generates report for known providers", () => {
+			manager.recordSignal({
+				provider: "minimax",
+				source: "api_response",
+				windowType: "5h",
+				usedPct: 45,
+			});
+
+			const report = manager.generateReport(["minimax"]);
+			expect(report).toContain("minimax");
+			expect(report).toContain("AVAILABLE");
+		});
+
+		it("shows EXHAUSTED for exhausted providers", () => {
+			manager.recordSignal({
+				provider: "openai",
+				source: "api_response",
+				windowType: "daily",
+				exhausted: true,
+			});
+
+			const report = manager.generateReport(["openai"]);
+			expect(report).toContain("EXHAUSTED");
+		});
+	});
+});
+
+describe("parseMiniMaxError", () => {
+	it("parses quota error code 2056", () => {
+		const result = parseMiniMaxError({
+			message: "Error code: 2056 - Rate limit exceeded",
+		});
+		expect(result).not.toBeNull();
+		expect(result!.provider).toBe("minimax");
+		expect(result!.exhausted).toBe(true);
+	});
+
+	it("parses quota keyword", () => {
+		const result = parseMiniMaxError({ message: "quota exceeded" });
+		expect(result).not.toBeNull();
+		expect(result!.exhausted).toBe(true);
+	});
+
+	it("returns null for unrelated errors", () => {
+		const result = parseMiniMaxError({ message: "Invalid request" });
+		expect(result).toBeNull();
+	});
+
+	it("extracts retry time in seconds", () => {
+		const result = parseMiniMaxError({
+			message: "rate limit exceeded. Retry after 30 seconds",
+		});
+		expect(result).not.toBeNull();
+		expect(result!.retryAfterMs).toBe(30000);
+	});
+
+	it("extracts retry time in minutes", () => {
+		const result = parseMiniMaxError({
+			message: "rate limit exceeded. Retry after 2 minutes",
+		});
+		expect(result).not.toBeNull();
+		expect(result!.retryAfterMs).toBe(120000);
+	});
+});
+
+describe("parseOpenAIError", () => {
+	it("parses insufficient_quota", () => {
+		const result = parseOpenAIError({
+			code: "insufficient_quota",
+			message: "Quota exceeded",
+		});
+		expect(result).not.toBeNull();
+		expect(result!.provider).toBe("openai");
+		expect(result!.exhausted).toBe(true);
+	});
+
+	it("parses context_length_exceeded", () => {
+		const result = parseOpenAIError({
+			code: "context_length_exceeded",
+			message: "Too many tokens",
+		});
+		expect(result).not.toBeNull();
+		expect(result!.exhausted).toBe(true);
+	});
+
+	it("parses 429 rate limit", () => {
+		const result = parseOpenAIError({
+			message: "HTTP 429: Rate limit exceeded",
+		});
+		expect(result).not.toBeNull();
+		expect(result!.exhausted).toBe(true);
+		expect(result!.windowType).toBe("5h");
+	});
+
+	it("returns null for unrelated errors", () => {
+		const result = parseOpenAIError({
+			code: "invalid_request_error",
+			message: "Bad request",
+		});
+		expect(result).toBeNull();
+	});
+});
+
+describe("TUIUsageMonitor", () => {
+	let manager: QuotaManager;
+	let monitor: TUIUsageMonitor;
+
+	beforeEach(() => {
+		manager = new QuotaManager();
+		monitor = new TUIUsageMonitor({ quotaManager: manager });
+	});
+
+	describe("detectProvider", () => {
+		it("detects OpenAI", () => {
+			expect(monitor.detectProvider("OpenAI GPT-4 quota exceeded")).toBe(
+				"openai",
+			);
+		});
+
+		it("detects GLM", () => {
+			expect(monitor.detectProvider("GLM rate limit exceeded")).toBe("glm");
+		});
+
+		it("detects Anthropic Claude", () => {
+			expect(monitor.detectProvider("Claude overloaded_error")).toBe(
+				"anthropic",
+			);
+		});
+
+		it("detects OpenRouter", () => {
+			expect(monitor.detectProvider("OpenRouter quota exhausted")).toBe(
+				"openrouter",
+			);
+		});
+
+		it("returns null for unknown", () => {
+			expect(monitor.detectProvider("Random message")).toBeNull();
+		});
+	});
+
+	describe("processMessage", () => {
+		it("processes OpenAI quota message", () => {
+			const signal = monitor.processMessage(
+				"OpenAI insufficient_quota: daily limit reached",
+			);
+			expect(signal).not.toBeNull();
+			expect(signal!.provider).toBe("openai");
+		});
+
+		it("processes rate limit message", () => {
+			const signal = monitor.processMessage(
+				"Claude rate_limit_error: try again in 30 seconds",
+			);
+			expect(signal).not.toBeNull();
+			expect(signal!.provider).toBe("anthropic");
+			expect(signal!.limitType).toBe("rate_limit");
+		});
+
+		it("processes context window message", () => {
+			const signal = monitor.processMessage(
+				"OpenAI context_length_exceeded: too many tokens",
+			);
+			expect(signal).not.toBeNull();
+			expect(signal!.limitType).toBe("context_window");
+		});
+
+		it("returns null for non-quota messages", () => {
+			const signal = monitor.processMessage("Hello world, this is just a test");
+			expect(signal).toBeNull();
+		});
+
+		it("records to QuotaManager", () => {
+			monitor.processMessage("OpenAI quota exhausted at 100%");
+			expect(manager.getSignals("openai").length).toBeGreaterThan(0);
+		});
+
+		it("stores last signal per provider", () => {
+			monitor.processMessage("OpenAI quota exhausted at 100%");
+			monitor.processMessage("GLM quota exhausted");
+			const openaiSignal = monitor.getLastSignal("openai");
+			const glmSignal = monitor.getLastSignal("glm");
+			expect(openaiSignal?.provider).toBe("openai");
+			expect(glmSignal?.provider).toBe("glm");
+		});
+
+		it("clears stored signals", () => {
+			monitor.processMessage("OpenAI GPT-4 quota exhausted");
+			monitor.clear();
+			expect(monitor.getLastSignal("openai")).toBeNull();
+		});
+	});
+});