//! Tests for the pure core. Everything here runs offline: the core has no I/O to fake.
const std = @import("std");
const usage = @import("usage");
const iso8601 = usage.iso8601;
const jwt = "eyJhbGciOiJSUzI1NiJ9.eyJodHRwczovL2FwaS5vcGVuYWkuY29tL2F1dGgiOnsiY2hhdGdwdF9hY2NvdW50X2lkIjoiYWNjdF90ZXN0XzEifSwiaHR0cHM6Ly9hcGkub3BlbmFpLmNvbS9wcm9maWxlIjp7ImVtYWlsIjoiVGVzdC5BY2NvdW50QEV4YW1wbGUuQ09NIn19.c2ln";
fn advanceWithState(alloc: std.mem.Allocator, state: ?*usage.State, provider: []const u8, cred: []const u8, resp: []const u8, now_ms: i64) ![]const u8 {
var w = usage.Writer.init(alloc);
const outcome = try usage.advance(alloc, state, provider, cred, resp, now_ms);
try usage.writeStep(&w, outcome);
return w.items();
}
fn advance(alloc: std.mem.Allocator, provider: []const u8, cred: []const u8, resp: []const u8, now_ms: i64) ![]const u8 {
return advanceWithState(alloc, null, provider, cred, resp, now_ms);
}
test "iso-8601 parser formats" {
const cases = [_]struct { s: []const u8, expected: i64 }{
.{ .s = "2026-09-16T08:00:00.037593+00:00", .expected = 1789545600037 },
.{ .s = "2026-09-15T23:46:00Z", .expected = 1789515960000 },
.{ .s = "2026-06-09T11:28:39.481128Z", .expected = 1781004519481 },
.{ .s = "2026-01-01T00:00:00+05:30", .expected = 1767205800000 },
.{ .s = "2026-01-01T00:00:00-08:00", .expected = 1767254400000 },
.{ .s = "2026-01-01T00:00:00.5Z", .expected = 1767225600500 },
.{ .s = "2026-01-01T00:00:00.12Z", .expected = 1767225600120 },
.{ .s = "2026-01-01T00:00:00.123Z", .expected = 1767225600123 },
.{ .s = "2026-01-01T00:00:00.1234Z", .expected = 1767225600123 },
};
for (cases) |c| {
const got = iso8601.parseIso8601(c.s);
try std.testing.expectEqual(c.expected, got.?);
}
try std.testing.expect(iso8601.parseIso8601("") == null);
try std.testing.expect(iso8601.parseIso8601("not-a-date") == null);
}
test "window labels match the reference formatting" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
try std.testing.expectEqualStrings("5h window", (try usage.formatWindowLabel(a, 18_000)).?);
try std.testing.expectEqualStrings("7d window", (try usage.formatWindowLabel(a, 604_800)).?);
try std.testing.expectEqualStrings("1h window", (try usage.formatWindowLabel(a, 60)).?);
try std.testing.expect((try usage.formatWindowLabel(a, 0)) == null);
try std.testing.expect((try usage.formatWindowLabel(a, -60)) == null);
try std.testing.expect((try usage.formatWindowLabel(a, null)) == null);
}
test "status thresholds: exhausted at 100, warning at 90" {
try std.testing.expectEqualStrings("exhausted", usage.statusFor(100));
try std.testing.expectEqualStrings("exhausted", usage.statusFor(120));
try std.testing.expectEqualStrings("warning", usage.statusFor(90));
try std.testing.expectEqualStrings("ok", usage.statusFor(89.9));
try std.testing.expectEqualStrings("unknown", usage.statusFor(null));
}
test "codex first step requests" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"test-token\"}";
const text = try advance(a, "openai-codex", cred, "[]", 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"url\":\"https://chatgpt.com/backend-api/wham/usage\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "[\"Authorization\",\"Bearer test-token\"]") != null);
}
test "codex second step report with windows and additional limits" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"test-token\",\"email\":\"user@example.com\"}";
const body =
\\[{"status":200,"body":"{\"plan_type\":\"prolite\",\"rate_limit\":{\"primary_window\":{\"used_percent\":100,\"limit_window_seconds\":604800},\"secondary_window\":{\"used_percent\":32.5,\"limit_window_seconds\":18000,\"reset_after_seconds\":3600}},\"additional_rate_limits\":[{\"limit_name\":\"Spark\",\"rate_limit\":{\"primary_window\":{\"used_percent\":0,\"limit_window_seconds\":18000}}}]}"}]
;
const now: i64 = 1_700_000_000_000;
const text = try advance(a, "openai-codex", cred, body, now);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"prolite\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"primary\",\"label\":\"Primary\",\"usedPercent\":100,\"windowLabel\":\"7d window\",\"windowSeconds\":604800,\"status\":\"exhausted\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"Spark.primary\",\"label\":\"Spark · Primary\",\"usedPercent\":0,\"windowLabel\":\"5h window\",\"windowSeconds\":18000,\"scope\":\"Spark\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"resetsAt\":1700003600000") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"email\":\"user@example.com\"") != null);
}
test "anthropic first step requests" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"ant-token\"}";
const text = try advance(a, "anthropic", cred, "[]", 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"https://api.anthropic.com/api/oauth/usage\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"https://api.anthropic.com/api/oauth/profile\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "[\"anthropic-beta\",\"oauth-2025-04-20\"]") != null);
}
test "anthropic second step report" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"ant-token\"}";
const body =
\\[{"status":200,"body":"{\"limits\":[{\"kind\":\"session\",\"percent\":0,\"severity\":\"normal\"},{\"kind\":\"weekly_all\",\"percent\":94,\"severity\":\"critical\",\"resets_at\":\"2026-09-16T08:00:00.037593+00:00\"}],\"extra_usage\":{\"is_enabled\":false,\"credits_ever_enabled\":true}}"},{"status":200,"body":"{\"account\":{\"email\":\"User@Example.Com\",\"uuid\":\"uuid-123\"},\"organization\":{\"seat_tier\":\"team_standard\"}}"}]
;
const text = try advance(a, "anthropic", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"email\":\"user@example.com\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"accountId\":\"uuid-123\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"team_standard\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"session\",\"label\":\"Session\",\"usedPercent\":0,\"windowLabel\":\"5h window\",\"windowSeconds\":18000,\"status\":\"ok\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"weekly_all\",\"label\":\"Weekly\",\"usedPercent\":94,\"windowLabel\":\"7d window\",\"windowSeconds\":604800,\"resetsAt\":1789545600037,\"status\":\"warning\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"notes\":[\"Extra usage is off\"]") != null);
}
test "anthropic extra usage enabled" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"ant-token\"}";
const body =
\\[{"status":200,"body":"{\"limits\":[],\"extra_usage\":{\"is_enabled\":true,\"monthly_limit\":100,\"used_credits\":25}}"},{"status":200,"body":"{}"}]
;
const text = try advance(a, "anthropic", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"extra_usage\",\"label\":\"Extra usage\",\"usedPercent\":25") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"detail\":\"25 of 100 credits\"") != null);
}
test "anthropic scoped windows carry their scope, and the body's scope wins" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"ant-token\"}";
const body =
\\[{"status":200,"body":"{\"limits\":[{\"kind\":\"weekly_opus\",\"percent\":40},{\"kind\":\"daily_all\",\"percent\":5},{\"kind\":\"weekly_sonnet\",\"percent\":1,\"scope\":\"claude-sonnet\"}]}"},{"status":200,"body":"{}"}]
;
const text = try advance(a, "anthropic", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"weekly_opus\",\"label\":\"Weekly (Opus)\",\"usedPercent\":40,\"windowLabel\":\"7d window\",\"windowSeconds\":604800,\"scope\":\"opus\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"daily_all\",\"label\":\"Daily (All)\",\"usedPercent\":5,\"windowLabel\":\"24h window\",\"windowSeconds\":86400,\"status\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"weekly_sonnet\",\"label\":\"Weekly (Sonnet)\",\"usedPercent\":1,\"windowLabel\":\"7d window\",\"windowSeconds\":604800,\"scope\":\"claude-sonnet\"") != null);
}
test "codex additional limits are keyed by their metered feature" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"test-token\"}";
const body =
\\[{"status":200,"body":"{\"additional_rate_limits\":[{\"limit_name\":\"GPT-5.3-Codex-Spark\",\"metered_feature\":\"codex_bengalfox\",\"rate_limit\":{\"secondary_window\":{\"used_percent\":3,\"limit_window_seconds\":604800}}}]}"}]
;
const text = try advance(a, "openai-codex", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"codex_bengalfox.secondary\",\"label\":\"GPT-5.3-Codex-Spark · Secondary\",\"usedPercent\":3,\"windowLabel\":\"7d window\",\"windowSeconds\":604800,\"scope\":\"GPT-5.3-Codex-Spark\"") != null);
}
test "zai keys a limit by type and period, and counts unit 3 in hours" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"key\"}";
const body =
\\[{"status":200,"body":"{\"code\":200,\"success\":true,\"data\":{\"limits\":[{\"type\":\"TOKENS_LIMIT\",\"unit\":3,\"number\":5,\"percentage\":12},{\"type\":\"TIME_LIMIT\",\"unit\":5,\"number\":1,\"usage\":100,\"currentValue\":0,\"percentage\":0}]}}"}]
;
const text = try advance(a, "zai", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"tokens_limit:3:5\",\"label\":\"Tokens\",\"usedPercent\":12,\"windowLabel\":\"5h window\",\"windowSeconds\":18000,") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"time_limit:5:1\",\"label\":\"Requests\",\"usedPercent\":0,\"detail\"") != null);
}
test "access token claims give account id and a normalized email" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
var w = usage.Writer.init(a);
const outcome = try usage.claimsFromAccessToken(a, jwt, &w);
try std.testing.expect(outcome == .ok);
try std.testing.expectEqualStrings("{\"accountId\":\"acct_test_1\",\"email\":\"test.account@example.com\"}", w.items());
var broken = usage.Writer.init(a);
try std.testing.expect((try usage.claimsFromAccessToken(a, "not-a-jwt", &broken)) == .err);
}
test "antigravity first step and report conversion" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"ya29.test\",\"extra\":{\"projectId\":\"test-proj\"}}";
const req_text = try advance(a, "google-antigravity", cred, "[]", 0);
try std.testing.expect(std.mem.indexOf(u8, req_text, "https://daily-cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "antigravity/hub/2.8.0") != null);
// Remaining fraction 0.16592255 converted to 83.4% used and 17% free
const body =
\\[{"status":200,"body":"{\"buckets\":[{\"modelId\":\"gemini-2.5-flash\",\"remainingFraction\":0.16592255,\"resetTime\":\"2026-09-15T23:46:00Z\"},{\"modelId\":\"chat_tab_drop\",\"remainingFraction\":1.0}]}"}]
;
const now: i64 = 1_789_514_000_000;
const rep_text = try advance(a, "google-antigravity", cred, body, now);
try std.testing.expect(std.mem.indexOf(u8, rep_text, "\"id\":\"gemini\",\"label\":\"Gemini\"") != null);
try std.testing.expect(std.mem.indexOf(u8, rep_text, "\"scope\":\"Gemini\"") != null);
try std.testing.expect(std.mem.indexOf(u8, rep_text, "\"usedPercent\":83.4") != null);
try std.testing.expect(std.mem.indexOf(u8, rep_text, "\"detail\":\"17% free\"") != null);
// The feed gives a reset time, not a window length, so no window is claimed.
try std.testing.expect(std.mem.indexOf(u8, rep_text, "\"windowLabel\"") == null);
try std.testing.expect(std.mem.indexOf(u8, rep_text, "\"notes\":[\"Project: test-proj\"]") != null);
}
test "antigravity HTTP error message unwrapping" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"ya29.test\"}";
const body =
\\[{"status":401,"body":"{\"error\":{\"code\":401,\"message\":\"Invalid token\"}}"}]
;
const rep_text = try advance(a, "google-antigravity", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, rep_text, "\"error\":\"HTTP 401: Invalid token\"") != null);
}
test "hyper two-step flow and unit conversion" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
var state = usage.State.init(a);
defer state.deinit();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"sk-hyper-123\"}";
// Step 0 -> /v1/teams
const step0 = try advanceWithState(a, &state, "hyper", cred, "[]", 0);
try std.testing.expect(std.mem.indexOf(u8, step0, "https://hyper.charm.land/v1/teams") != null);
// Step 1 -> receives teams, asks for billing and members
const teams_resp =
\\[{"status":200,"body":"{\"items\":[{\"id\":\"team_123\",\"name\":\"My Team\"}]}"}]
;
const step1 = try advanceWithState(a, &state, "hyper", cred, teams_resp, 0);
try std.testing.expect(std.mem.indexOf(u8, step1, "https://hyper.charm.land/v1/teams/team_123/billing") != null);
try std.testing.expect(std.mem.indexOf(u8, step1, "https://hyper.charm.land/v1/teams/team_123/members") != null);
// Step 2 -> billing: 237 remaining of 250 credits -> (250-237)/250 = 5.2% used
const billing_resp =
\\[{"status":200,"body":"{\"status\":\"active\",\"plan\":{\"name\":\"Shred\",\"hypercredits\":250},\"balances\":{\"plan\":{\"hypercredits\":\"237\"},\"total\":{\"usd\":\"11.83\"}},\"hypercredit_refresh\":{\"last_at\":\"2026-09-15T22:26:09Z\",\"next_at\":\"2026-09-16T22:26:09Z\"}}"},{"status":200,"body":"{\"items\":[{\"email\":\"user@example.com\"}]}"}]
;
const step2 = try advanceWithState(a, &state, "hyper", cred, billing_resp, 0);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"planType\":\"shred\"") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"accountId\":\"team_123\"") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"email\":\"user@example.com\"") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"usedPercent\":5.2") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"detail\":\"237 of 250 credits\"") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"id\":\"hypercredits\"") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"windowLabel\":\"24h window\",\"windowSeconds\":86400") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"balance\":\"11.83\"") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"notes\":[\"Team: My Team\"]") != null);
}
test "opencode-go status mapping and windows" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"opencode-key\"}";
const body =
\\[{"status":200,"body":"{\"usage\":{\"rolling\":{\"status\":\"ok\",\"percent\":10,\"resetsAt\":\"2026-09-16T04:40:14Z\"},\"monthly\":{\"status\":\"rate-limited\",\"percent\":50,\"resetsAt\":\"2026-09-29T07:01:56Z\"}}}"}]
;
const text = try advance(a, "opencode-go", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"Go\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"rolling\",\"label\":\"Session\",\"usedPercent\":10,\"windowLabel\":\"5h window\",\"windowSeconds\":18000,\"resetsAt\":1789533614000,\"status\":\"ok\"") != null);
// rate-limited status -> exhausted even though percent is 50
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"monthly\",\"label\":\"Monthly\",\"usedPercent\":50,\"windowLabel\":\"30d window\",\"windowSeconds\":2592000,\"resetsAt\":1790665316000,\"status\":\"exhausted\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"notes\":[\"OpenCode Go unified models\"]") != null);
const oauth_cred = "{\"kind\":\"oauth\",\"access\":\"opencode-oauth-tok\",\"email\":\"go@example.com\"}";
const oauth_req = try advance(a, "opencode-go", oauth_cred, "[]", 0);
try std.testing.expect(std.mem.indexOf(u8, oauth_req, "[\"Authorization\",\"Bearer opencode-oauth-tok\"]") != null);
const oauth_rep = try advance(a, "opencode-go", oauth_cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, oauth_rep, "\"email\":\"go@example.com\"") != null);
}
test "zai authorization without Bearer, epoch seconds/ms, and ratio fallback" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"raw-zai-key\"}";
const req_text = try advance(a, "zai", cred, "[]", 0);
// Authorization MUST NOT have Bearer prefix
try std.testing.expect(std.mem.indexOf(u8, req_text, "[\"Authorization\",\"raw-zai-key\"]") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "Bearer") == null);
// Case 1: TIME_LIMIT with epoch ms (> 1e11)
// Case 2: TOKENS_LIMIT with epoch seconds (< 1e11) and ratio fallback (cur 25 / total 100 = 25%)
const body =
\\[{"status":200,"body":"{\"code\":200,\"success\":true,\"data\":{\"level\":\"lite\",\"limits\":[{\"type\":\"TIME_LIMIT\",\"unit\":5,\"currentValue\":10,\"usage\":100,\"percentage\":10,\"nextResetTime\":1792027143998},{\"type\":\"TOKENS_LIMIT\",\"currentValue\":25,\"number\":100,\"nextResetTime\":1792027143}]}}"}]
;
const text = try advance(a, "zai", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"Lite\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"time_limit\",\"label\":\"Requests\",\"usedPercent\":10,\"resetsAt\":1792027143998,\"detail\":\"10 / 100 reqs\",\"status\":\"ok\"") != null);
// 1792027143 (< 1e11) converted from epoch seconds to 1792027143000 ms, ratio 25%
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"tokens_limit\",\"label\":\"Tokens\",\"usedPercent\":25,\"windowLabel\":\"5h window\",\"resetsAt\":1792027143000,\"status\":\"ok\"") != null);
}
test "zai error return when code != 200" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"key\"}";
const body =
\\[{"status":200,"body":"{\"code\":401,\"success\":false,\"msg\":\"Token invalid\"}"}]
;
const text = try advance(a, "zai", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"error\":\"Token invalid\"") != null);
}
test "deepseek balance formatting and unavailable account note" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"ds-key\"}";
const body =
\\[{"status":200,"body":"{\"is_available\":false,\"balance_infos\":[{\"currency\":\"USD\",\"total_balance\":\"0.03\"}]}"}]
;
const text = try advance(a, "deepseek", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"Pay-as-you-go\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"balance\":\"$0.03 USD\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"limits\":[]") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"notes\":[\"Account is unavailable\"]") != null);
}
test "alibaba CLI answer parse: fraction to percent and epoch ms kept" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"cli\",\"config\":{\"region\":\"intl-personal\"},\"accountId\":\"custom-id\",\"email\":\"dev@example.com\"}";
const cli_body =
\\[{"status":0,"body":"{\"per5HourPercentage\":0.5,\"per1WeekPercentage\":0.83603712139856,\"per1WeekResetTime\":1790021160000}"}]
;
const text = try advance(a, "alibaba", cred, cli_body, 1_700_000_000_000);
try std.testing.expect(std.mem.indexOf(u8, text, "\"id\":\"five_hour\",\"label\":\"Session\",\"usedPercent\":50,\"windowLabel\":\"5h window\",\"windowSeconds\":18000,\"status\":\"ok\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"label\":\"Weekly\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"resetsAt\":1790021160000") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"windowLabel\":\"7d window\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"notes\":[\"read through the bailian CLI (intl-personal)\"]") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"accountId\":\"custom-id\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"email\":\"dev@example.com\"") != null);
}
test "alibaba wrapped console parse" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const raw_json =
\\{"data":{"DataV2":{"data":{"data":{"per1WeekPercentage":0.83603712139856,"per1WeekResetTime":1790021160000}}}}}
;
const parsed_val = try std.json.parseFromSlice(std.json.Value, a, raw_json, .{});
const parsed = try usage.alibaba.parseAlibabaUsage(a, parsed_val.value);
try std.testing.expectEqual(@as(usize, 1), parsed.limits.len);
try std.testing.expectEqualStrings("Weekly", parsed.limits[0].label);
try std.testing.expectEqualStrings("7d window", parsed.limits[0].windowLabel.?);
try std.testing.expectEqual(@as(i64, 1790021160000), parsed.limits[0].resetsAt.?);
try std.testing.expect(parsed.limits[0].usedPercent.? > 83.6 and parsed.limits[0].usedPercent.? < 83.7);
}
test "alibaba argument vector for two regions" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
// intl-personal
const cred_intl = "{\"kind\":\"cli\",\"config\":{\"region\":\"intl-personal\"}}";
const req_intl = try advance(a, "alibaba", cred_intl, "[]", 0);
try std.testing.expect(std.mem.indexOf(u8, req_intl, "\"kind\":\"command\"") != null);
try std.testing.expect(std.mem.indexOf(u8, req_intl, "\"command\":\"bl\"") != null);
try std.testing.expect(std.mem.indexOf(u8, req_intl, "\"ap-southeast-1\"") != null);
try std.testing.expect(std.mem.indexOf(u8, req_intl, "\"international\"") != null);
try std.testing.expect(std.mem.indexOf(u8, req_intl, "\"timeoutMs\":15000") != null);
// cn-personal
const cred_cn = "{\"kind\":\"cli\",\"config\":{\"region\":\"cn-personal\"}}";
const req_cn = try advance(a, "alibaba", cred_cn, "[]", 0);
try std.testing.expect(std.mem.indexOf(u8, req_cn, "\"cn-beijing\"") != null);
try std.testing.expect(std.mem.indexOf(u8, req_cn, "\"domestic\"") != null);
}
test "alibaba CLI failure quotes a JSON error body's message and hint" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"cli\",\"config\":{\"region\":\"intl-personal\"}}";
const body = "[{\"status\":3,\"body\":\"{\\n \\\"error\\\": {\\n \\\"code\\\": 3,\\n \\\"message\\\": \\\"No console access token found.\\\",\\n \\\"hint\\\": \\\"Run `bl auth login --console`.\\\"\\n }\\n}\"}]";
const text = try advance(a, "alibaba", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "bailian CLI failed (exit 3)") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "No console access token found. Run `bl auth login --console`.") != null);
try std.testing.expect(std.mem.indexOf(u8, text, ": {") == null);
}
test "alibaba CLI failure stays the bare exit code when the JSON body has no message" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"cli\",\"config\":{\"region\":\"intl-personal\"}}";
const body = "[{\"status\":3,\"body\":\"{\\\"trace\\\":\\\"abc\\\"}\"}]";
const text = try advance(a, "alibaba", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "bailian CLI failed (exit 3)\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "trace") == null);
}
test "alibaba 127 with session fallback" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"session\",\"session\":{\"secToken\":\"sec123\",\"region\":\"ap-southeast-1\"}}";
const resp_127 = "[{\"status\":127,\"body\":\"this host does not run commands (bl)\"}]";
const req_text = try advance(a, "alibaba", cred, resp_127, 0);
// 4 console HTTP requests issued
try std.testing.expect(std.mem.indexOf(u8, req_text, "\"kind\":\"http\"") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "zeldaHttp.apikeyMgr.%2Ftokenplan%2Fpersonal%2Fapi%2Fv2%2Fusage") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "zeldaHttp.apikeyMgr.%2Ftokenplan%2Fpersonal%2Fapi%2Fv2%2Fsubscription") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "zeldaHttp.apikeyMgr.%2Ftokenplan%2Fpersonal%2Fapi%2Fv2%2Fquota-config") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "zeldaHttp.apikeyMgr.%2Ftokenplan%2Fpersonal%2Fapi%2Fv2%2Freset-card%2Flist") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "sec_token=sec123") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "region=ap-southeast-1") != null);
}
test "alibaba 127 without session error" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"cli\"}";
const resp_127 = "[{\"status\":127,\"body\":\"this host does not run commands (bl)\"}]";
const text = try advance(a, "alibaba", cred, resp_127, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "capture-alibaba-session.mjs") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "prime-agent") != null);
}
test "alibaba missing sec_token is omitted from form body" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"session\",\"session\":{\"region\":\"ap-southeast-1\"}}";
const resp_127 = "[{\"status\":127,\"body\":\"no commands\"}]";
const req_text = try advance(a, "alibaba", cred, resp_127, 0);
try std.testing.expect(std.mem.indexOf(u8, req_text, "\"kind\":\"http\"") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "params=") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "region=ap-southeast-1") != null);
try std.testing.expect(std.mem.indexOf(u8, req_text, "sec_token") == null);
}
test "alibaba console answers: plan, remaining days, tier credits and reset cards" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"session\",\"session\":{\"secToken\":\"sec123\",\"region\":\"ap-southeast-1\"}}";
const body =
\\[{"status":200,"body":"{\"data\":{\"DataV2\":{\"data\":{\"data\":{\"per1WeekPercentage\":0.83603712139856,\"per1WeekResetTime\":1790021160000}}}}}"},{"status":200,"body":"{\"data\":{\"DataV2\":{\"data\":{\"data\":{\"specCode\":\"pro\",\"instanceCode\":\"inst-123\",\"remainingDays\":29}}}}}"},{"status":200,"body":"{\"data\":{\"DataV2\":{\"data\":{\"data\":{\"pro\":{\"weekly\":40000,\"five_hour\":12000}}}}}}"},{"status":200,"body":"{\"data\":{\"DataV2\":{\"data\":{\"data\":[{\"cardId\":\"c1\"}]}}}}"}]
;
const text = try advance(a, "alibaba", cred, body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"pro\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"accountId\":\"inst-123\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"label\":\"Weekly\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"resetsAt\":1790021160000") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "\"windowLabel\":\"7d window\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "Token plan pro: weekly 40000, 5h 12000 credits") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "29 days remaining in the plan") != null);
try std.testing.expect(std.mem.indexOf(u8, text, "1 reset cards available") != null);
}
test "hyper state persists team across rounds even when arena is freed" {
var state = usage.State.init(std.testing.allocator);
defer state.deinit();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"sk-hyper-123\"}";
const teams_resp =
\\[{"status":200,"body":"{\"items\":[{\"id\":\"team_live_123\",\"name\":\"Hyper Squad\"}]}"}]
;
// Round 1 in its own arena, which is deinitialized immediately after
{
var arena1 = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena1.deinit();
const step1 = try advanceWithState(arena1.allocator(), &state, "hyper", cred, teams_resp, 0);
try std.testing.expect(std.mem.indexOf(u8, step1, "team_live_123/billing") != null);
}
// arena1 is now dead and its memory is released
// Round 2 in a fresh arena: must read team_id and team_name from state, not freed memory
{
var arena2 = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena2.deinit();
const billing_resp =
\\[{"status":200,"body":"{\"status\":\"active\",\"plan\":{\"name\":\"Pro\",\"hypercredits\":500},\"balances\":{\"plan\":{\"hypercredits\":\"450\"},\"total\":{\"usd\":\"25.00\"}}}"},{"status":200,"body":"{\"items\":[{\"email\":\"member@example.com\"}]}"}]
;
const step2 = try advanceWithState(arena2.allocator(), &state, "hyper", cred, billing_resp, 0);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"accountId\":\"team_live_123\"") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "Team: Hyper Squad") != null);
try std.testing.expect(std.mem.indexOf(u8, step2, "\"planType\":\"pro\"") != null);
}
// Passing NULL state to round 2 does not panic, but cannot emit team name
{
var arena3 = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena3.deinit();
const billing_resp =
\\[{"status":200,"body":"{\"status\":\"active\",\"plan\":{\"name\":\"Pro\",\"hypercredits\":500},\"balances\":{\"plan\":{\"hypercredits\":\"450\"}}}"},{"status":200,"body":"{\"items\":[]}"}]
;
const step_no_state = try advanceWithState(arena3.allocator(), null, "hyper", cred, billing_resp, 0);
try std.testing.expect(std.mem.indexOf(u8, step_no_state, "Team: Hyper Squad") == null);
}
}
test "number safety: NaN does not panic integer cast or emit invalid JSON" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"tok\"}";
const nan_body =
\\[{"status":200,"body":"{\"plan_type\":\"plus\",\"rate_limit\":{\"primary_window\":{\"used_percent\":\"nan\",\"reset_at\":\"nan\"}}}"}]
;
const text = try advance(a, "openai-codex", cred, nan_body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"plus\"") != null);
try std.testing.expect(std.mem.indexOf(u8, text, ":nan") == null);
try std.testing.expect(std.mem.indexOf(u8, text, ":NaN") == null);
_ = try std.json.parseFromSlice(std.json.Value, a, text, .{});
}
test "number safety: inf does not serialize as usedPercent:inf" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"oauth\",\"access\":\"tok\"}";
const inf_body =
\\[{"status":200,"body":"{\"plan_type\":\"plus\",\"rate_limit\":{\"primary_window\":{\"used_percent\":\"inf\"}}}"}]
;
const text = try advance(a, "openai-codex", cred, inf_body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, ":inf") == null);
try std.testing.expect(std.mem.indexOf(u8, text, ":Infinity") == null);
_ = try std.json.parseFromSlice(std.json.Value, a, text, .{});
}
test "number safety: out-of-range 1e30 does not panic integer cast" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"key\"}";
const big_body =
\\[{"status":200,"body":"{\"code\":200,\"success\":true,\"data\":{\"level\":\"pro\",\"limits\":[{\"type\":\"TIME_LIMIT\",\"percentage\":50,\"nextResetTime\":1e30,\"currentValue\":1e30,\"usage\":1e30}]}}"}]
;
const text = try advance(a, "zai", cred, big_body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"Pro\"") != null);
_ = try std.json.parseFromSlice(std.json.Value, a, text, .{});
}
test "number safety: non-number string in numeric field does not panic" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
const cred = "{\"kind\":\"apiKey\",\"apiKey\":\"key\"}";
const string_body =
\\[{"status":200,"body":"{\"code\":200,\"success\":true,\"data\":{\"level\":\"pro\",\"limits\":[{\"type\":\"TIME_LIMIT\",\"percentage\":\"not-a-number\",\"currentValue\":\"bad\"}]}}"}]
;
const text = try advance(a, "zai", cred, string_body, 0);
try std.testing.expect(std.mem.indexOf(u8, text, "\"planType\":\"Pro\"") != null);
_ = try std.json.parseFromSlice(std.json.Value, a, text, .{});
}
test "json escaping: a quote or backslash in a value stays parseable" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
var w = usage.Writer.init(a);
try usage.writeJsonString(&w, "Team: Hyper \"Squad\" \\ back");
const text = w.items();
// The whole point of the escape table: a value the provider controls must not be able to end
// the JSON string early.
const parsed = try std.json.parseFromSlice([]const u8, a, text, .{});
try std.testing.expectEqualStrings("Team: Hyper \"Squad\" \\ back", parsed.value);
}
test "reset already in the past keeps the reference's 1h window" {
var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
defer arena.deinit();
const a = arena.allocator();
// driver.ts epochToWindowLabel is `Math.max(1, Math.round((resetsAt - nowMs) / 1000))`, so a
// past reset still names a window instead of vanishing from the report. Parity depends on this.
const overdue = try usage.epochToWindowLabel(a, 1_000_000, 9_000_000);
try std.testing.expect(overdue != null);
try std.testing.expectEqualStrings("1h window", overdue.?);
}