claudeup 6.2.0 → 6.3.0

package/src/__tests__/github-budget.test.ts

@@ -1,15 +1,15 @@
-import { describe, it, expect, beforeEach } from "bun:test";
+import { beforeEach, describe, expect, it } from "bun:test";
 import {
-  activeCooldowns,
-  cooldownFor,
-  describeCooldown,
-  formatWait,
-  hostOf,
-  recordRateLimit,
-  recordSuccess,
-  remainingFromHeaders,
-  resetGitHubBudget,
-  waitMs,
+	activeCooldowns,
+	cooldownFor,
+	describeCooldown,
+	formatWait,
+	hostOf,
+	recordRateLimit,
+	recordSuccess,
+	remainingFromHeaders,
+	resetGitHubBudget,
+	waitMs,
 } from "../services/github-budget";
 
 /**
@@ -26,175 +26,181 @@ import {
 const NOW = 1_786_980_000_000;
 
 beforeEach(() => {
-  resetGitHubBudget();
+	resetGitHubBudget();
 });
 
 describe("hostOf", () => {
-  it("recognises the two budgeted hosts and nothing else", () => {
-    expect(hostOf("https://api.github.com/repos/x/y")).toBe("api.github.com");
-    expect(hostOf("https://raw.githubusercontent.com/x/y/main/f.json")).toBe(
-      "raw.githubusercontent.com",
-    );
-    expect(hostOf("https://github.com/x/y")).toBeNull();
-    expect(hostOf("not a url")).toBeNull();
-  });
+	it("recognises the two budgeted hosts and nothing else", () => {
+		expect(hostOf("https://api.github.com/repos/x/y")).toBe("api.github.com");
+		expect(hostOf("https://raw.githubusercontent.com/x/y/main/f.json")).toBe(
+			"raw.githubusercontent.com",
+		);
+		expect(hostOf("https://github.com/x/y")).toBeNull();
+		expect(hostOf("not a url")).toBeNull();
+	});
 });
 
 describe("recordRateLimit — exact timing when GitHub provides it", () => {
-  it("honours retry-after in seconds", () => {
-    const cooldown = recordRateLimit(
-      "api.github.com",
-      new Headers({ "retry-after": "120" }),
-      NOW,
-    );
-    expect(cooldown.exact).toBe(true);
-    expect(cooldown.until).toBe(NOW + 120_000);
-    expect(describeCooldown(cooldown, NOW)).toBe(
-      "GitHub rate limit resets in 2m",
-    );
-  });
-
-  it("honours retry-after as an HTTP date", () => {
-    const when = new Date(NOW + 300_000).toUTCString();
-    const cooldown = recordRateLimit(
-      "api.github.com",
-      new Headers({ "retry-after": when }),
-      NOW,
-    );
-    expect(cooldown.exact).toBe(true);
-    // UTCString drops sub-second precision, so allow a second of slack.
-    expect(Math.abs(cooldown.until - (NOW + 300_000))).toBeLessThanOrEqual(1000);
-  });
-
-  it("reads x-ratelimit-reset as epoch SECONDS, not milliseconds", () => {
-    // Treating it as ms lands in 1970, so the cooldown expires instantly and the
-    // UI reports "not rate limited" while GitHub is still refusing every call.
-    const resetEpochSeconds = Math.floor(NOW / 1000) + 600;
-    const cooldown = recordRateLimit(
-      "api.github.com",
-      new Headers({ "x-ratelimit-reset": String(resetEpochSeconds) }),
-      NOW,
-    );
-    expect(cooldown.exact).toBe(true);
-    expect(cooldown.until).toBe(resetEpochSeconds * 1000);
-    expect(waitMs("api.github.com", NOW)).toBeGreaterThan(0);
-  });
-
-  it("caps an implausible server window so a bad header cannot wedge the UI", () => {
-    const cooldown = recordRateLimit(
-      "api.github.com",
-      new Headers({ "retry-after": String(60 * 60 * 24 * 30) }),
-      NOW,
-    );
-    expect(cooldown.until - NOW).toBeLessThanOrEqual(60 * 60_000);
-  });
+	it("honours retry-after in seconds", () => {
+		const cooldown = recordRateLimit(
+			"api.github.com",
+			new Headers({ "retry-after": "120" }),
+			NOW,
+		);
+		expect(cooldown.exact).toBe(true);
+		expect(cooldown.until).toBe(NOW + 120_000);
+		expect(describeCooldown(cooldown, NOW)).toBe(
+			"GitHub rate limit resets in 2m",
+		);
+	});
+
+	it("honours retry-after as an HTTP date", () => {
+		const when = new Date(NOW + 300_000).toUTCString();
+		const cooldown = recordRateLimit(
+			"api.github.com",
+			new Headers({ "retry-after": when }),
+			NOW,
+		);
+		expect(cooldown.exact).toBe(true);
+		// UTCString drops sub-second precision, so allow a second of slack.
+		expect(Math.abs(cooldown.until - (NOW + 300_000))).toBeLessThanOrEqual(
+			1000,
+		);
+	});
+
+	it("reads x-ratelimit-reset as epoch SECONDS, not milliseconds", () => {
+		// Treating it as ms lands in 1970, so the cooldown expires instantly and the
+		// UI reports "not rate limited" while GitHub is still refusing every call.
+		const resetEpochSeconds = Math.floor(NOW / 1000) + 600;
+		const cooldown = recordRateLimit(
+			"api.github.com",
+			new Headers({ "x-ratelimit-reset": String(resetEpochSeconds) }),
+			NOW,
+		);
+		expect(cooldown.exact).toBe(true);
+		expect(cooldown.until).toBe(resetEpochSeconds * 1000);
+		expect(waitMs("api.github.com", NOW)).toBeGreaterThan(0);
+	});
+
+	it("caps an implausible server window so a bad header cannot wedge the UI", () => {
+		const cooldown = recordRateLimit(
+			"api.github.com",
+			new Headers({ "retry-after": String(60 * 60 * 24 * 30) }),
+			NOW,
+		);
+		expect(cooldown.until - NOW).toBeLessThanOrEqual(60 * 60_000);
+	});
 });
 
 describe("recordRateLimit — backoff when GitHub provides nothing", () => {
-  it("does not claim a reset time it was never told", () => {
-    // This is the raw.githubusercontent.com case, measured: a bare 429.
-    const cooldown = recordRateLimit(
-      "raw.githubusercontent.com",
-      new Headers(),
-      NOW,
-    );
-    expect(cooldown.exact).toBe(false);
-    expect(describeCooldown(cooldown, NOW)).toContain("next attempt in");
-    expect(describeCooldown(cooldown, NOW)).not.toContain("resets in");
-  });
-
-  it("backs off further on each consecutive failure", () => {
-    const first = recordRateLimit("raw.githubusercontent.com", undefined, NOW);
-    const second = recordRateLimit("raw.githubusercontent.com", undefined, NOW);
-    const third = recordRateLimit("raw.githubusercontent.com", undefined, NOW);
-    expect(second.until).toBeGreaterThan(first.until);
-    expect(third.until).toBeGreaterThan(second.until);
-    expect(third.strikes).toBe(3);
-  });
-
-  it("ignores a retry-after that is garbage or already past", () => {
-    const garbage = recordRateLimit(
-      "raw.githubusercontent.com",
-      new Headers({ "retry-after": "soon-ish" }),
-      NOW,
-    );
-    expect(garbage.exact).toBe(false);
-    expect(garbage.until).toBeGreaterThan(NOW);
-  });
+	it("does not claim a reset time it was never told", () => {
+		// This is the raw.githubusercontent.com case, measured: a bare 429.
+		const cooldown = recordRateLimit(
+			"raw.githubusercontent.com",
+			new Headers(),
+			NOW,
+		);
+		expect(cooldown.exact).toBe(false);
+		expect(describeCooldown(cooldown, NOW)).toContain("next attempt in");
+		expect(describeCooldown(cooldown, NOW)).not.toContain("resets in");
+	});
+
+	it("backs off further on each consecutive failure", () => {
+		const first = recordRateLimit("raw.githubusercontent.com", undefined, NOW);
+		const second = recordRateLimit("raw.githubusercontent.com", undefined, NOW);
+		const third = recordRateLimit("raw.githubusercontent.com", undefined, NOW);
+		expect(second.until).toBeGreaterThan(first.until);
+		expect(third.until).toBeGreaterThan(second.until);
+		expect(third.strikes).toBe(3);
+	});
+
+	it("ignores a retry-after that is garbage or already past", () => {
+		const garbage = recordRateLimit(
+			"raw.githubusercontent.com",
+			new Headers({ "retry-after": "soon-ish" }),
+			NOW,
+		);
+		expect(garbage.exact).toBe(false);
+		expect(garbage.until).toBeGreaterThan(NOW);
+	});
 });
 
 describe("the gate", () => {
-  it("blocks while cooling and clears when the window passes", () => {
-    const cooldown = recordRateLimit(
-      "raw.githubusercontent.com",
-      undefined,
-      NOW,
-    );
-    expect(cooldownFor("raw.githubusercontent.com", NOW)).not.toBeNull();
-    expect(
-      cooldownFor("raw.githubusercontent.com", cooldown.until + 1),
-    ).toBeNull();
-    expect(waitMs("raw.githubusercontent.com", cooldown.until + 1)).toBe(0);
-  });
-
-  it("keeps the two hosts on separate budgets", () => {
-    // They are separate buckets upstream. Blocking raw because the API is
-    // exhausted would stop work that would have succeeded.
-    recordRateLimit("api.github.com", new Headers({ "retry-after": "60" }), NOW);
-    expect(cooldownFor("api.github.com", NOW)).not.toBeNull();
-    expect(cooldownFor("raw.githubusercontent.com", NOW)).toBeNull();
-  });
-
-  it("clears the cooldown and the strike count on success", () => {
-    // Without resetting strikes, one bad afternoon pins the backoff at ten
-    // minutes for the rest of the session even though calls are succeeding.
-    recordRateLimit("raw.githubusercontent.com", undefined, NOW);
-    recordRateLimit("raw.githubusercontent.com", undefined, NOW);
-    recordSuccess("raw.githubusercontent.com");
-    expect(cooldownFor("raw.githubusercontent.com", NOW)).toBeNull();
-
-    const afterRecovery = recordRateLimit(
-      "raw.githubusercontent.com",
-      undefined,
-      NOW,
-    );
-    expect(afterRecovery.strikes).toBe(1);
-  });
-
-  it("lists active cooldowns soonest first", () => {
-    recordRateLimit(
-      "api.github.com",
-      new Headers({ "retry-after": "600" }),
-      NOW,
-    );
-    recordRateLimit(
-      "raw.githubusercontent.com",
-      new Headers({ "retry-after": "30" }),
-      NOW,
-    );
-    const active = activeCooldowns(NOW);
-    expect(active.map((c) => c.host)).toEqual([
-      "raw.githubusercontent.com",
-      "api.github.com",
-    ]);
-  });
+	it("blocks while cooling and clears when the window passes", () => {
+		const cooldown = recordRateLimit(
+			"raw.githubusercontent.com",
+			undefined,
+			NOW,
+		);
+		expect(cooldownFor("raw.githubusercontent.com", NOW)).not.toBeNull();
+		expect(
+			cooldownFor("raw.githubusercontent.com", cooldown.until + 1),
+		).toBeNull();
+		expect(waitMs("raw.githubusercontent.com", cooldown.until + 1)).toBe(0);
+	});
+
+	it("keeps the two hosts on separate budgets", () => {
+		// They are separate buckets upstream. Blocking raw because the API is
+		// exhausted would stop work that would have succeeded.
+		recordRateLimit(
+			"api.github.com",
+			new Headers({ "retry-after": "60" }),
+			NOW,
+		);
+		expect(cooldownFor("api.github.com", NOW)).not.toBeNull();
+		expect(cooldownFor("raw.githubusercontent.com", NOW)).toBeNull();
+	});
+
+	it("clears the cooldown and the strike count on success", () => {
+		// Without resetting strikes, one bad afternoon pins the backoff at ten
+		// minutes for the rest of the session even though calls are succeeding.
+		recordRateLimit("raw.githubusercontent.com", undefined, NOW);
+		recordRateLimit("raw.githubusercontent.com", undefined, NOW);
+		recordSuccess("raw.githubusercontent.com");
+		expect(cooldownFor("raw.githubusercontent.com", NOW)).toBeNull();
+
+		const afterRecovery = recordRateLimit(
+			"raw.githubusercontent.com",
+			undefined,
+			NOW,
+		);
+		expect(afterRecovery.strikes).toBe(1);
+	});
+
+	it("lists active cooldowns soonest first", () => {
+		recordRateLimit(
+			"api.github.com",
+			new Headers({ "retry-after": "600" }),
+			NOW,
+		);
+		recordRateLimit(
+			"raw.githubusercontent.com",
+			new Headers({ "retry-after": "30" }),
+			NOW,
+		);
+		const active = activeCooldowns(NOW);
+		expect(active.map((c) => c.host)).toEqual([
+			"raw.githubusercontent.com",
+			"api.github.com",
+		]);
+	});
 });
 
 describe("remainingFromHeaders", () => {
-  it("reads the budget so a caller can stop before tripping the limit", () => {
-    expect(
-      remainingFromHeaders(new Headers({ "x-ratelimit-remaining": "51" })),
-    ).toBe(51);
-    expect(remainingFromHeaders(new Headers())).toBeNull();
-  });
+	it("reads the budget so a caller can stop before tripping the limit", () => {
+		expect(
+			remainingFromHeaders(new Headers({ "x-ratelimit-remaining": "51" })),
+		).toBe(51);
+		expect(remainingFromHeaders(new Headers())).toBeNull();
+	});
 });
 
 describe("formatWait", () => {
-  it("reads naturally at every scale", () => {
-    expect(formatWait(0)).toBe("0s");
-    expect(formatWait(45_000)).toBe("45s");
-    expect(formatWait(90_000)).toBe("2m");
-    expect(formatWait(3_600_000)).toBe("1h 0m");
-    expect(formatWait(4_320_000)).toBe("1h 12m");
-  });
+	it("reads naturally at every scale", () => {
+		expect(formatWait(0)).toBe("0s");
+		expect(formatWait(45_000)).toBe("45s");
+		expect(formatWait(90_000)).toBe("2m");
+		expect(formatWait(3_600_000)).toBe("1h 0m");
+		expect(formatWait(4_320_000)).toBe("1h 12m");
+	});
 });