predicate.test.ts

import { describe, expect, test } from "bun:test";
import {
	EXHAUSTED_MIN_FRACTION,
	MAX_PLAUSIBLE_REMAINING_MS,
	evaluateBlock,
	type UsageReportLike,
} from "./predicate";

const NOW = 1_700_000_000_000;

function report(
	limits: Partial<UsageReportLike["limits"][number]>[],
	provider = "anthropic",
): UsageReportLike {
	return {
		provider,
		limits: limits.map(l => ({
			windowId: "5h",
			usedFraction: undefined,
			resetsAt: undefined,
			tiered: false,
			...l,
		})),
	};
}

describe("evaluateBlock", () => {
	test("ignores non-anthropic active provider", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "openai",
			reports: [report([{ windowId: "5h", usedFraction: 1, resetsAt: NOW + 60_000 }])],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "wrong-provider" });
	});

	test("ignores when no window is exhausted", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [report([{ windowId: "5h", usedFraction: 0.5, resetsAt: NOW + 60_000 }])],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "not-exhausted" });
	});

	test("ignores when no report is available", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: undefined,
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "not-exhausted" });
	});

	test("ignores an exhausted window with no reset time", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [report([{ windowId: "5h", usedFraction: 1, resetsAt: undefined }])],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "no-reset-time" });
	});

	test("ignores a reset time already in the past", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [report([{ windowId: "5h", usedFraction: 1, resetsAt: NOW - 1_000 }])],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "reset-in-past" });
	});

	test("ignores an implausibly distant reset time", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [
				report([
					{ windowId: "5h", usedFraction: 1, resetsAt: NOW + MAX_PLAUSIBLE_REMAINING_MS + 1 },
				]),
			],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "reset-implausible" });
	});

	test("ignores an episode already handled", () => {
		const resetsAt = NOW + 60_000;
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [report([{ windowId: "5h", usedFraction: 1, resetsAt }])],
			handledEpisodes: new Set([`5h:${resetsAt}`]),
		});
		expect(decision).toEqual({ act: false, reason: "already-handled" });
	});

	test("acts on a confirmed single-window block", () => {
		const resetsAt = NOW + 90 * 60_000;
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [report([{ windowId: "5h", usedFraction: EXHAUSTED_MIN_FRACTION, resetsAt }])],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: true, windowId: "5h", resetsAt, episodeKey: `5h:${resetsAt}` });
	});

	test("when both windows are exhausted, binds to the later reset", () => {
		const fiveHourReset = NOW + 60_000;
		const sevenDayReset = NOW + 3 * 24 * 3_600_000;
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [
				report([
					{ windowId: "5h", usedFraction: 1, resetsAt: fiveHourReset },
					{ windowId: "7d", usedFraction: 1, resetsAt: sevenDayReset },
				]),
			],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({
			act: true,
			windowId: "7d",
			resetsAt: sevenDayReset,
			episodeKey: `7d:${sevenDayReset}`,
		});
	});

	test("refuses to act when one exhausted window has no reset time even if another does", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [
				report([
					{ windowId: "5h", usedFraction: 1, resetsAt: NOW + 60_000 },
					{ windowId: "7d", usedFraction: 1, resetsAt: undefined },
				]),
			],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "no-reset-time" });
	});

	test("prefers an untiered limit over a tiered one for the same window", () => {
		const untieredReset = NOW + 60_000;
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [
				report([
					{ windowId: "5h", usedFraction: 1, resetsAt: NOW + 120_000, tiered: true },
					{ windowId: "5h", usedFraction: 1, resetsAt: untieredReset, tiered: false },
				]),
			],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({
			act: true,
			windowId: "5h",
			resetsAt: untieredReset,
			episodeKey: `5h:${untieredReset}`,
		});
	});

	test("ignores reports from a different provider", () => {
		const decision = evaluateBlock({
			nowMs: NOW,
			activeProvider: "anthropic",
			reports: [report([{ windowId: "5h", usedFraction: 1, resetsAt: NOW + 60_000 }], "openai")],
			handledEpisodes: new Set(),
		});
		expect(decision).toEqual({ act: false, reason: "not-exhausted" });
	});
});