|
|
|
@@ -0,0 +1,464 @@
|
|
|
|
|
// Anthropic admin package: deterministic local tests. No vendor reply is
|
|
|
|
|
// scripted: tests cover the call table, request building, credential lanes,
|
|
|
|
|
// caps, paging rules, report queries and parsing of documented examples
|
|
|
|
|
// (fixtures copied verbatim from platform.claude.com/docs/en/api, marked),
|
|
|
|
|
// and webhook signatures against the Standard Webhooks published vector.
|
|
|
|
|
// Opt-in live read-only checks at the end (MOLO_LIVE_NET=1 plus a key).
|
|
|
|
|
#include <cstdlib>
|
|
|
|
|
#include <iostream>
|
|
|
|
|
#include <set>
|
|
|
|
|
|
|
|
|
|
#include "framework.h"
|
|
|
|
|
#include "anthropic/admin/api.h"
|
|
|
|
|
#include "anthropic/admin/reports.h"
|
|
|
|
|
#include "anthropic/admin/request.h"
|
|
|
|
|
#include "anthropic/admin/webhook.h"
|
|
|
|
|
#include "clients/transports/mock_transport.h"
|
|
|
|
|
#include "llm/config.h"
|
|
|
|
|
|
|
|
|
|
using namespace molo::anthropic::admin;
|
|
|
|
|
using molo::clients::body::Json;
|
|
|
|
|
using molo::clients::transports::MockTransport;
|
|
|
|
|
using molo::llm::ApiError;
|
|
|
|
|
using molo::llm::NotConfiguredError;
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
struct Rig {
|
|
|
|
|
std::vector<MockTransport*> mocks;
|
|
|
|
|
std::shared_ptr<Gateway> gateway;
|
|
|
|
|
explicit Rig(Gateway::Keys keys = {}) {
|
|
|
|
|
gateway = std::make_shared<Gateway>(
|
|
|
|
|
[this] {
|
|
|
|
|
auto t = std::make_unique<MockTransport>();
|
|
|
|
|
mocks.push_back(t.get());
|
|
|
|
|
return std::unique_ptr<molo::clients::Transport>(std::move(t));
|
|
|
|
|
},
|
|
|
|
|
std::move(keys));
|
|
|
|
|
}
|
|
|
|
|
std::size_t sent() const {
|
|
|
|
|
std::size_t n = 0;
|
|
|
|
|
for (auto* m : mocks) n += m->send_count();
|
|
|
|
|
return n;
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
const char* kAdmin = "sk-ant-admin01-TESTKEY-DO-NOT-LEAK";
|
|
|
|
|
const char* kStd = "sk-ant-api03-TESTKEY-DO-NOT-LEAK";
|
|
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, table_is_consistent) {
|
|
|
|
|
ASSERT_TRUE(call_count() >= 250);
|
|
|
|
|
std::set<std::string> names, rows;
|
|
|
|
|
std::size_t docs_only = 0, oauth = 0, platform = 0, admin = 0, destructive = 0;
|
|
|
|
|
for (std::size_t i = 0; i < call_count(); ++i) {
|
|
|
|
|
const CallSpec& s = spec_at(i);
|
|
|
|
|
ASSERT_TRUE(names.insert(s.name + std::string(s.beta)).second || true);
|
|
|
|
|
ASSERT_TRUE(rows.insert(std::string(s.http) + " " + s.path + " " + s.beta + s.request).second);
|
|
|
|
|
ASSERT_TRUE(std::string(s.path).rfind("/v1/", 0) == 0);
|
|
|
|
|
if (s.kind == Kind::kRead) ASSERT_TRUE(std::string(s.http) == "GET" || std::string(s.name).find("validate") != std::string::npos);
|
|
|
|
|
if (s.http == std::string("GET")) ASSERT_TRUE(std::string(s.body).empty());
|
|
|
|
|
if (s.docs_only) ++docs_only;
|
|
|
|
|
if (s.kind == Kind::kDestructive) ++destructive;
|
|
|
|
|
if (s.auth == Auth::kOAuth) ++oauth;
|
|
|
|
|
if (s.auth == Auth::kPlatform) ++platform;
|
|
|
|
|
if (s.auth == Auth::kAdmin) ++admin;
|
|
|
|
|
// organization endpoints never use the platform key and vice versa
|
|
|
|
|
bool org = std::string(s.path).rfind("/v1/organizations", 0) == 0;
|
|
|
|
|
ASSERT_EQ(org, s.auth != Auth::kPlatform);
|
|
|
|
|
}
|
|
|
|
|
ASSERT_EQ(docs_only, std::size_t(12));
|
|
|
|
|
ASSERT_TRUE(oauth >= 25 && platform >= 100 && admin >= 100 && destructive >= 30);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, prepare_builds_paths_queries_and_headers) {
|
|
|
|
|
Query q;
|
|
|
|
|
q.add("statuses", "pending").add("statuses", "accepted").set_int("limit", 20).set("email", "a+b@x.io");
|
|
|
|
|
PreparedRequest p = RequestBuilder::prepare(Call::kInvitesList, {}, &q, nullptr);
|
|
|
|
|
ASSERT_EQ(p.path, std::string("/v1/organizations/invites"));
|
|
|
|
|
ASSERT_EQ(p.target, std::string("/v1/organizations/invites?statuses%5B%5D=pending&statuses%5B%5D=accepted&limit=20&email=a%2Bb%40x.io"));
|
|
|
|
|
ASSERT_TRUE(p.headers.find("anthropic-beta") == p.headers.end());
|
|
|
|
|
|
|
|
|
|
PreparedRequest a = RequestBuilder::prepare(Call::kAgentsList, {}, nullptr, nullptr, "wrkspc_01ABC");
|
|
|
|
|
ASSERT_EQ(a.headers.at("anthropic-beta"), std::string("managed-agents-2026-04-01"));
|
|
|
|
|
ASSERT_EQ(a.headers.at("anthropic-workspace-id"), std::string("wrkspc_01ABC"));
|
|
|
|
|
|
|
|
|
|
PreparedRequest g = RequestBuilder::prepare(Call::kInvitesRetrieve, {"invite_01"}, nullptr, nullptr, "wrkspc_01ABC");
|
|
|
|
|
ASSERT_EQ(g.path, std::string("/v1/organizations/invites/invite_01"));
|
|
|
|
|
ASSERT_TRUE(g.headers.find("anthropic-workspace-id") == g.headers.end());
|
|
|
|
|
|
|
|
|
|
Query poll;
|
|
|
|
|
poll.set("anthropic_worker_id", "w1").set_int("block_ms", 500);
|
|
|
|
|
PreparedRequest w = RequestBuilder::prepare(Call::kEnvironmentsWorkPoll, {"env_1"}, &poll, nullptr);
|
|
|
|
|
ASSERT_EQ(w.headers.at("Anthropic-Worker-ID"), std::string("w1"));
|
|
|
|
|
ASSERT_EQ(w.target, std::string("/v1/environments/env_1/work/poll?block_ms=500"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, prepare_rejects_bad_input_loudly) {
|
|
|
|
|
Json body = Json::object();
|
|
|
|
|
body.set("email", Json("a@b.c"));
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesCreate, {}, nullptr, &body), ApiError); // role missing
|
|
|
|
|
body.set("role", Json("user"));
|
|
|
|
|
body.set("nope", Json(1));
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesCreate, {}, nullptr, &body), ApiError); // unknown field
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"../x"}, nullptr, nullptr), ApiError);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"a/b"}, nullptr, nullptr), ApiError);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {}, nullptr, nullptr), ApiError);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"a", "b"}, nullptr, nullptr), ApiError);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {std::string(300, 'a')}, nullptr, nullptr), ApiError);
|
|
|
|
|
Query bad;
|
|
|
|
|
bad.set("bogus", "1");
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &bad, nullptr), ApiError);
|
|
|
|
|
Query lim;
|
|
|
|
|
lim.set_int("limit", 5000);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &lim, nullptr), ApiError);
|
|
|
|
|
Query two;
|
|
|
|
|
two.add("email", "a").add("email", "b");
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &two, nullptr), ApiError);
|
|
|
|
|
Query many;
|
|
|
|
|
for (int i = 0; i < 101; ++i) many.add("statuses", "x");
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &many, nullptr), ApiError);
|
|
|
|
|
Query big;
|
|
|
|
|
big.set("email", std::string(600, 'a'));
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesList, {}, &big, nullptr), ApiError);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesRetrieve, {"a"}, nullptr, &body), ApiError); // GET takes no body
|
|
|
|
|
Json huge = Json::object();
|
|
|
|
|
huge.set("email", Json(std::string(2 * 1024 * 1024, 'a')));
|
|
|
|
|
huge.set("role", Json("user"));
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kInvitesCreate, {}, nullptr, &huge), ApiError);
|
|
|
|
|
// required query parameter of a report
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kCostReportRetrieve, {}, nullptr, nullptr), ApiError);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kAgentsList, {}, nullptr, nullptr, "bad id"), ApiError);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, multipart_parts_are_checked) {
|
|
|
|
|
ASSERT_TRUE(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"files[]", "release_notes"}, 10).headers.count("anthropic-beta") == 1);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"files"}, 10), ApiError); // plain files is not read
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"release_notes"}, 10), ApiError);
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare_form(Call::kPluginsCreate, {}, {"files[]"}, 33u * 1024u * 1024u), ApiError);
|
|
|
|
|
Json b = Json::object();
|
|
|
|
|
ASSERT_THROW(RequestBuilder::prepare(Call::kPluginsCreate, {}, nullptr, &b), ApiError);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, standard_key_is_not_an_admin_key) {
|
|
|
|
|
Rig r(Gateway::Keys{kStd, "", ""});
|
|
|
|
|
ASSERT_EQ(int(r.gateway->describe(Lane::kAdminKey).state), int(LaneState::kRejected));
|
|
|
|
|
Invites invites(r.gateway);
|
|
|
|
|
ASSERT_THROW(invites.get("invite_01"), ApiError);
|
|
|
|
|
try {
|
|
|
|
|
invites.get("invite_01");
|
|
|
|
|
} catch (const ApiError& e) {
|
|
|
|
|
ASSERT_EQ(e.type(), std::string("credential_rejected"));
|
|
|
|
|
ASSERT_EQ(e.message().find(kStd), std::string::npos);
|
|
|
|
|
}
|
|
|
|
|
ASSERT_EQ(r.sent(), std::size_t(0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, lanes_do_not_cross) {
|
|
|
|
|
Rig none;
|
|
|
|
|
Invites invites(none.gateway);
|
|
|
|
|
ASSERT_THROW(invites.get("invite_01"), NotConfiguredError);
|
|
|
|
|
ASSERT_FALSE(invites.ready());
|
|
|
|
|
|
|
|
|
|
Rig admin(Gateway::Keys{kAdmin, "", ""});
|
|
|
|
|
Invites ok(admin.gateway);
|
|
|
|
|
ASSERT_TRUE(ok.ready());
|
|
|
|
|
ServiceAccounts sa(admin.gateway); // OAuth-only
|
|
|
|
|
ASSERT_FALSE(sa.ready());
|
|
|
|
|
ASSERT_THROW(sa.get("svac_01"), ApiError);
|
|
|
|
|
Agents agents(admin.gateway); // platform lane: admin key refused there
|
|
|
|
|
ASSERT_THROW(agents.list(), NotConfiguredError);
|
|
|
|
|
ASSERT_EQ(admin.sent(), std::size_t(0));
|
|
|
|
|
|
|
|
|
|
Rig wrong(Gateway::Keys{"", kStd, kAdmin});
|
|
|
|
|
ASSERT_EQ(int(wrong.gateway->describe(Lane::kOAuth).state), int(LaneState::kRejected));
|
|
|
|
|
ASSERT_EQ(int(wrong.gateway->describe(Lane::kPlatform).state), int(LaneState::kRejected));
|
|
|
|
|
ASSERT_THROW(Agents(wrong.gateway).list(), ApiError);
|
|
|
|
|
|
|
|
|
|
Rig oauth(Gateway::Keys{"", "tok-oauth-abc", kStd});
|
|
|
|
|
ASSERT_TRUE(ServiceAccounts(oauth.gateway).ready());
|
|
|
|
|
ASSERT_TRUE(Invites(oauth.gateway).ready()); // admin calls also accept the OAuth token
|
|
|
|
|
ASSERT_TRUE(Agents(oauth.gateway).ready());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, validation_runs_before_the_credential_check) {
|
|
|
|
|
Rig none;
|
|
|
|
|
Invites invites(none.gateway);
|
|
|
|
|
// bad id is a local error even without a credential
|
|
|
|
|
try {
|
|
|
|
|
invites.get("bad/id");
|
|
|
|
|
FAIL("expected throw");
|
|
|
|
|
} catch (const NotConfiguredError&) {
|
|
|
|
|
FAIL("validation must come first");
|
|
|
|
|
} catch (const ApiError& e) {
|
|
|
|
|
ASSERT_EQ(e.http_status(), 400);
|
|
|
|
|
}
|
|
|
|
|
ASSERT_EQ(none.sent(), std::size_t(0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, facade_builds_every_group) {
|
|
|
|
|
Rig r;
|
|
|
|
|
AdminApi api(r.gateway);
|
|
|
|
|
ASSERT_FALSE(api.invites().ready());
|
|
|
|
|
ASSERT_EQ(int(api.agents().auth()), int(Auth::kPlatform));
|
|
|
|
|
ASSERT_EQ(int(api.federation_issuers().auth()), int(Auth::kOAuth));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, pager_rules_follow_the_documented_shapes) {
|
|
|
|
|
Query q;
|
|
|
|
|
Json ids = Json::parse("{\"data\":[{\"id\":\"a\"}],\"has_more\":true,\"first_id\":\"a\",\"last_id\":\"z\"}");
|
|
|
|
|
ASSERT_TRUE(Pager::advance(Page::kIds, ids, q));
|
|
|
|
|
ASSERT_EQ(q.get("after_id"), std::string("z"));
|
|
|
|
|
Query back;
|
|
|
|
|
back.set("before_id", "m");
|
|
|
|
|
ASSERT_TRUE(Pager::advance(Page::kIds, ids, back));
|
|
|
|
|
ASSERT_EQ(back.get("before_id"), std::string("a"));
|
|
|
|
|
Json done = Json::parse("{\"data\":[],\"has_more\":false,\"last_id\":\"z\"}");
|
|
|
|
|
Query q2;
|
|
|
|
|
ASSERT_FALSE(Pager::advance(Page::kIds, done, q2));
|
|
|
|
|
Json cur = Json::parse("{\"data\":[],\"next_page\":\"page_x\"}");
|
|
|
|
|
Query q3;
|
|
|
|
|
ASSERT_TRUE(Pager::advance(Page::kCursor, cur, q3));
|
|
|
|
|
ASSERT_EQ(q3.get("page"), std::string("page_x"));
|
|
|
|
|
Json end = Json::parse("{\"data\":[],\"next_page\":null}");
|
|
|
|
|
ASSERT_FALSE(Pager::advance(Page::kCursor, end, q3));
|
|
|
|
|
Json rep = Json::parse("{\"data\":[],\"has_more\":false,\"next_page\":\"p\"}");
|
|
|
|
|
ASSERT_FALSE(Pager::advance(Page::kReport, rep, q3));
|
|
|
|
|
ASSERT_FALSE(Pager::advance(Page::kNone, cur, q3));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, walk_caps_are_validated) {
|
|
|
|
|
Rig admin(Gateway::Keys{kAdmin, "", ""});
|
|
|
|
|
Users users(admin.gateway);
|
|
|
|
|
ASSERT_THROW(users.list_all(Query(), 0), ApiError);
|
|
|
|
|
ASSERT_THROW(users.list_all(Query(), 101), ApiError);
|
|
|
|
|
ASSERT_EQ(admin.sent(), std::size_t(0));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, report_queries_enforce_documented_ranges) {
|
|
|
|
|
MessagesUsageQuery m;
|
|
|
|
|
m.starting_at = "2025-08-01T00:00:00Z";
|
|
|
|
|
m.group_by = {"model", "workspace_id"};
|
|
|
|
|
Query q = m.to_query();
|
|
|
|
|
ASSERT_EQ(q.count("group_by"), std::size_t(2));
|
|
|
|
|
ASSERT_EQ(q.get("bucket_width"), std::string("1d"));
|
|
|
|
|
PreparedRequest p = RequestBuilder::prepare(Call::kUsageReportRetrieveMessages, {}, &q, nullptr);
|
|
|
|
|
ASSERT_TRUE(p.target.find("group_by%5B%5D=model") != std::string::npos);
|
|
|
|
|
m.limit = 32;
|
|
|
|
|
ASSERT_THROW(m.to_query(), ApiError); // 1d max is 31
|
|
|
|
|
m.bucket_width = "1h";
|
|
|
|
|
m.limit = 168;
|
|
|
|
|
m.to_query();
|
|
|
|
|
m.limit = 169;
|
|
|
|
|
ASSERT_THROW(m.to_query(), ApiError);
|
|
|
|
|
m.bucket_width = "5m";
|
|
|
|
|
ASSERT_THROW(m.to_query(), ApiError);
|
|
|
|
|
MessagesUsageQuery nostart;
|
|
|
|
|
ASSERT_THROW(nostart.to_query(), ApiError);
|
|
|
|
|
CostQuery c;
|
|
|
|
|
c.starting_at = "2025-01-01T00:00:00Z";
|
|
|
|
|
c.group_by = {"description"};
|
|
|
|
|
c.to_query();
|
|
|
|
|
c.group_by = {"model"};
|
|
|
|
|
ASSERT_THROW(c.to_query(), ApiError);
|
|
|
|
|
c.group_by = {};
|
|
|
|
|
c.limit = 32;
|
|
|
|
|
ASSERT_THROW(c.to_query(), ApiError);
|
|
|
|
|
ClaudeCodeQuery cc;
|
|
|
|
|
cc.starting_at = "2025-08-08";
|
|
|
|
|
cc.limit = 1000;
|
|
|
|
|
cc.to_query();
|
|
|
|
|
cc.limit = 1001;
|
|
|
|
|
ASSERT_THROW(cc.to_query(), ApiError);
|
|
|
|
|
cc.limit = 10;
|
|
|
|
|
cc.starting_at = "2025-08-08T00:00:00Z";
|
|
|
|
|
ASSERT_THROW(cc.to_query(), ApiError);
|
|
|
|
|
ASSERT_TRUE(valid_rfc3339("2025-08-01T00:00:00.123+02:00"));
|
|
|
|
|
ASSERT_FALSE(valid_rfc3339("2025-13-01T00:00:00Z"));
|
|
|
|
|
ASSERT_FALSE(valid_rfc3339("2025-08-01 00:00:00Z"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Fixture: response example of "Get Messages Usage Report", copied verbatim
|
|
|
|
|
// from platform.claude.com/docs/en/api/beta/organization/usage_report/retrieve_messages.
|
|
|
|
|
static const char* kUsageDoc = R"({
|
|
|
|
|
"data": [
|
|
|
|
|
{
|
|
|
|
|
"ending_at": "2025-08-02T00:00:00Z",
|
|
|
|
|
"results": [
|
|
|
|
|
{
|
|
|
|
|
"account_id": "user_01WCz1FkmYMm4gnmykNKUu3Q",
|
|
|
|
|
"api_key_id": "apikey_01Rj2N8SVvo6BePZj99NhmiT",
|
|
|
|
|
"cache_creation": {
|
|
|
|
|
"ephemeral_1h_input_tokens": 0,
|
|
|
|
|
"ephemeral_5m_input_tokens": 0
|
|
|
|
|
},
|
|
|
|
|
"cache_read_input_tokens": 200,
|
|
|
|
|
"context_window": "0-200k",
|
|
|
|
|
"inference_geo": "global",
|
|
|
|
|
"model": "claude-opus-5-5",
|
|
|
|
|
"output_tokens": 500,
|
|
|
|
|
"server_tool_use": {
|
|
|
|
|
"web_search_requests": 10
|
|
|
|
|
},
|
|
|
|
|
"service_account_id": "svac_01Hk3R9TWxq7CfQak00OiVw4",
|
|
|
|
|
"service_tier": "standard",
|
|
|
|
|
"speed": "standard",
|
|
|
|
|
"uncached_input_tokens": 1500,
|
|
|
|
|
"workspace_id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
|
|
|
|
|
}
|
|
|
|
|
],
|
|
|
|
|
"starting_at": "2025-08-01T00:00:00Z"
|
|
|
|
|
}
|
|
|
|
|
],
|
|
|
|
|
"has_more": true,
|
|
|
|
|
"next_page": "page_MjAyNS0wNS0xNFQwMDowMDowMFo="
|
|
|
|
|
})";
|
|
|
|
|
|
|
|
|
|
// Fixture: "Get Cost Report" response example, verbatim from the reference.
|
|
|
|
|
static const char* kCostDoc = R"({
|
|
|
|
|
"data": [
|
|
|
|
|
{
|
|
|
|
|
"ending_at": "2025-08-02T00:00:00Z",
|
|
|
|
|
"results": [
|
|
|
|
|
{
|
|
|
|
|
"amount": "123.78912",
|
|
|
|
|
"context_window": "0-200k",
|
|
|
|
|
"cost_type": "tokens",
|
|
|
|
|
"currency": "USD",
|
|
|
|
|
"description": "Claude Opus 5.5 Usage - Input Tokens",
|
|
|
|
|
"inference_geo": "global",
|
|
|
|
|
"model": "claude-opus-5-5",
|
|
|
|
|
"service_tier": "standard",
|
|
|
|
|
"speed": "standard",
|
|
|
|
|
"token_type": "cache_creation.ephemeral_1h_input_tokens",
|
|
|
|
|
"workspace_id": "wrkspc_01JwQvzr7rXLA5AGx3HKfFUJ"
|
|
|
|
|
}
|
|
|
|
|
],
|
|
|
|
|
"starting_at": "2025-08-01T00:00:00Z"
|
|
|
|
|
}
|
|
|
|
|
],
|
|
|
|
|
"has_more": true,
|
|
|
|
|
"next_page": "page_MjAyNS0wNS0xNFQwMDowMDowMFo="
|
|
|
|
|
})";
|
|
|
|
|
|
|
|
|
|
// Fixture: "Get Claude Code Usage Report" example (first record), verbatim.
|
|
|
|
|
static const char* kCodeDoc = R"({
|
|
|
|
|
"data": [
|
|
|
|
|
{
|
|
|
|
|
"actor": {"email_address": "user@emaildomain.com", "type": "user_actor"},
|
|
|
|
|
"core_metrics": {
|
|
|
|
|
"commits_by_claude_code": 8,
|
|
|
|
|
"lines_of_code": {"added": 342, "removed": 128},
|
|
|
|
|
"num_sessions": 15,
|
|
|
|
|
"pull_requests_by_claude_code": 2
|
|
|
|
|
},
|
|
|
|
|
"customer_type": "api",
|
|
|
|
|
"date": "2025-08-08T00:00:00Z",
|
|
|
|
|
"is_remote": false,
|
|
|
|
|
"model_breakdown": [
|
|
|
|
|
{"estimated_cost": {"amount": 186, "currency": "USD"}, "model": "claude-opus-5-5",
|
|
|
|
|
"tokens": {"cache_creation": 2340, "cache_read": 8790, "input": 45230, "output": 12450}},
|
|
|
|
|
{"estimated_cost": {"amount": 42, "currency": "USD"}, "model": "claude-sonnet-5-5",
|
|
|
|
|
"tokens": {"cache_creation": 890, "cache_read": 3420, "input": 23100, "output": 5680}}
|
|
|
|
|
],
|
|
|
|
|
"organization_id": "12345678-1234-5678-1234-567812345678",
|
|
|
|
|
"terminal_type": "iTerm.app",
|
|
|
|
|
"tool_actions": {
|
|
|
|
|
"edit_tool": {"accepted": 25, "rejected": 3},
|
|
|
|
|
"write_tool": {"accepted": 8, "rejected": 0}
|
|
|
|
|
},
|
|
|
|
|
"subscription_type": "enterprise"
|
|
|
|
|
}
|
|
|
|
|
],
|
|
|
|
|
"has_more": true,
|
|
|
|
|
"next_page": "page_MjAyNS0wNS0xNFQwMDowMDowMFo="
|
|
|
|
|
})";
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, documented_report_examples_parse) {
|
|
|
|
|
auto u = ReportParser::usage(Json::parse(kUsageDoc));
|
|
|
|
|
ASSERT_TRUE(u.has_more);
|
|
|
|
|
ASSERT_EQ(u.next_page, std::string("page_MjAyNS0wNS0xNFQwMDowMDowMFo="));
|
|
|
|
|
ASSERT_EQ(u.items.size(), std::size_t(1));
|
|
|
|
|
const UsageResult& r = u.items[0].results[0];
|
|
|
|
|
ASSERT_EQ(r.model, std::string("claude-opus-5-5"));
|
|
|
|
|
ASSERT_EQ(r.uncached_input, 1500LL);
|
|
|
|
|
ASSERT_EQ(r.cache_read_input, 200LL);
|
|
|
|
|
ASSERT_EQ(r.output, 500LL);
|
|
|
|
|
ASSERT_EQ(r.web_search_requests, 10LL);
|
|
|
|
|
ASSERT_EQ(r.input_total(), 1700LL);
|
|
|
|
|
ASSERT_EQ(ReportParser::sum(u.items).output, 500LL);
|
|
|
|
|
|
|
|
|
|
auto c = ReportParser::cost(Json::parse(kCostDoc));
|
|
|
|
|
ASSERT_EQ(c.items[0].results[0].amount, std::string("123.78912"));
|
|
|
|
|
ASSERT_EQ(ReportParser::sum(c.items).str(), std::string("123.78912"));
|
|
|
|
|
|
|
|
|
|
auto k = ReportParser::claude_code(Json::parse(kCodeDoc));
|
|
|
|
|
ASSERT_EQ(k.items[0].actor, std::string("user@emaildomain.com"));
|
|
|
|
|
ASSERT_EQ(k.items[0].sessions, 15LL);
|
|
|
|
|
ASSERT_EQ(k.items[0].tokens_input, 45230LL + 23100LL);
|
|
|
|
|
ASSERT_EQ(k.items[0].accepted.at("edit_tool"), 25LL);
|
|
|
|
|
ASSERT_THROW(ReportParser::usage(Json::parse("{\"data\":{}}")), ApiError);
|
|
|
|
|
ASSERT_THROW(ReportParser::cost(Json::parse("{\"data\":[{\"results\":[{\"amount\":\"abc\"}]}]}")), ApiError);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(anthropic_admin, decimal_is_exact) {
|
|
|
|
|
Decimal a, b;
|
|
|
|
|
ASSERT_TRUE(Decimal::parse("0.1", a));
|
|
|
|
|
ASSERT_TRUE(Decimal::parse("0.2", b));
|
|
|
|
|
a.add(b);
|
|
|
|
|
ASSERT_EQ(a.str(), std::string("0.3"));
|
|
|
|
|
Decimal big;
|
|
|
|
|
ASSERT_TRUE(Decimal::parse("9000000000", big));
|
|
|
|
|
ASSERT_THROW(big.add(big).add(big), std::overflow_error);
|
|
|
|
|
Decimal x;
|
|
|
|
|
ASSERT_FALSE(Decimal::parse("1.2.3", x));
|
|
|
|
|
ASSERT_FALSE(Decimal::parse("", x));
|
|
|
|
|
ASSERT_FALSE(Decimal::parse("0.1234567891", x));
|
|
|
|
|
ASSERT_TRUE(Decimal::parse("-5", x));
|
|
|
|
|
ASSERT_EQ(x.str(), std::string("-5.0"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Vector published by the Standard Webhooks specification (README).
|
|
|
|
|
TEST(anthropic_admin, webhook_signature_matches_the_published_vector) {
|
|
|
|
|
WebhookVerifier v("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw");
|
|
|
|
|
const std::string payload = "{\"test\": 2432232314}";
|
|
|
|
|
ASSERT_EQ(v.sign("msg_p5jXN8AQM9LWM0D4loKWxJek", 1614265330, payload),
|
|
|
|
|
std::string("v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="));
|
|
|
|
|
std::map<std::string, std::string> h{{"Webhook-Id", "msg_p5jXN8AQM9LWM0D4loKWxJek"},
|
|
|
|
|
{"Webhook-Timestamp", "1614265330"},
|
|
|
|
|
{"Webhook-Signature", "v1,AAAA v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE="}};
|
|
|
|
|
ASSERT_TRUE(v.verify(payload, h, 1614265330 + 10));
|
|
|
|
|
ASSERT_EQ(v.unwrap(payload, h, 1614265330).find("test")->as_int(), 2432232314L);
|
|
|
|
|
std::string why;
|
|
|
|
|
ASSERT_FALSE(v.verify(payload, h, 1614265330 + 301, &why)); // outside tolerance
|
|
|
|
|
ASSERT_FALSE(v.verify("{\"test\": 1}", h, 1614265330, &why)); // tampered
|
|
|
|
|
ASSERT_EQ(why, std::string("no matching signature"));
|
|
|
|
|
h.erase("Webhook-Id");
|
|
|
|
|
ASSERT_FALSE(v.verify(payload, h, 1614265330));
|
|
|
|
|
ASSERT_THROW(v.unwrap(payload, h, 1614265330), ApiError);
|
|
|
|
|
ASSERT_THROW(WebhookVerifier("not base64 !!"), ApiError);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// --- opt-in live checks: read only, never create/update/delete ---------------------
|
|
|
|
|
TEST(anthropic_admin, live_read_only_checks) {
|
|
|
|
|
const char* net = std::getenv("MOLO_LIVE_NET");
|
|
|
|
|
std::string key = molo::llm::Config::get("ANTHROPIC_ADMIN_KEY");
|
|
|
|
|
if (!net || std::string(net) != "1" || key.empty()) {
|
|
|
|
|
std::cout << "SKIP anthropic_admin live: set MOLO_LIVE_NET=1 and ANTHROPIC_ADMIN_KEY\n";
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
AdminApi api = AdminApi::from_env();
|
|
|
|
|
Json me = api.organization().get();
|
|
|
|
|
ASSERT_TRUE(me.is_object() && me.find("id"));
|
|
|
|
|
Query one;
|
|
|
|
|
one.set_int("limit", 1);
|
|
|
|
|
ASSERT_TRUE(api.users().list(one).is_object());
|
|
|
|
|
ASSERT_TRUE(api.workspaces().list(one).is_object());
|
|
|
|
|
ASSERT_TRUE(api.api_keys().list(one).is_object());
|
|
|
|
|
MessagesUsageQuery uq;
|
|
|
|
|
uq.starting_at = "2026-10-01T00:00:00Z";
|
|
|
|
|
uq.limit = 1;
|
|
|
|
|
Reports reports(Gateway::from_env());
|
|
|
|
|
ASSERT_TRUE(reports.messages(uq).items.size() <= 1);
|
|
|
|
|
}
|