// xAI platform REST: call table, ids, caps, request bodies (what would go on // the wire), destructive guards, host and key separation. No scripted vendor // replies: the rig records each request and refuses it. #include #include "rig.h" #include "xai/platform/account.h" #include "xai/platform/api_keys.h" #include "xai/platform/audit.h" #include "xai/platform/billing.h" #include "xai/platform/calls.h" #include "xai/platform/collections.h" #include "xai/platform/documents_search.h" #include "xai/platform/files.h" using namespace molo::xai::platform; using namespace xai_test; using molo::llm::ApiError; using molo::llm::NotConfiguredError; using molo::clients::body::Json; TEST(xai_platform_calls, table_is_ordered_unique_and_renders) { std::set seen; for (std::size_t i = 0; i < call_count(); ++i) { const CallSpec& s = spec_at(i); ASSERT_EQ(static_cast(s.call), i); ASSERT_TRUE(seen.insert(std::string(s.http_method) + " " + s.path).second); ASSERT_TRUE(std::string(s.host) == "api" || std::string(s.host) == "management"); // Fill every placeholder with a valid id; no brace may survive. std::string path = s.path; std::size_t holes = 0; for (char c : path) holes += c == '{'; std::string out; switch (holes) { case 0: out = render(s.call); break; case 1: out = render(s.call, {"a1"}); break; case 2: out = render(s.call, {"a1", "b2"}); break; default: FAIL("unexpected placeholder count"); } ASSERT_TRUE(out.find('{') == std::string::npos); ASSERT_TRUE(out.front() == '/'); } ASSERT_EQ(call_count(), static_cast(59)); } TEST(xai_platform_calls, render_rejects_bad_segments) { ASSERT_EQ(render(Call::kFileGet, {"file_a128090d-f0c9-4873-bd84-e499777e7417"}), std::string("/v1/files/file_a128090d-f0c9-4873-bd84-e499777e7417")); ASSERT_EQ(render(Call::kDocBatchGet, {"collection_x"}), std::string("/v1/collections/collection_x/documents:batchGet")); ASSERT_THROW(render(Call::kFileGet, {"../x"}), ApiError); ASSERT_THROW(render(Call::kFileGet, {"a/b"}), ApiError); ASSERT_THROW(render(Call::kFileGet, {""}), ApiError); ASSERT_THROW(render(Call::kFileGet, {}), ApiError); ASSERT_THROW(render(Call::kFileGet, {"a", "b"}), ApiError); ASSERT_THROW(render(Call::kFileList, {"a"}), ApiError); } TEST(xai_platform_calls, methods_and_hosts) { ASSERT_TRUE(method_of(Call::kKeyUpdate) == molo::clients::Method::kPut); ASSERT_TRUE(method_of(Call::kDocReindex) == molo::clients::Method::kPatch); ASSERT_TRUE(host_of(Call::kCollectionList) == Host::kManagement); ASSERT_TRUE(host_of(Call::kDocumentsSearch) == Host::kApi); } TEST(xai_platform_account, key_info_and_me_use_the_api_key_only) { Rig r; AccountService svc(r.api); auto s = sent(r.api_mock, [&] { svc.api_key_info(); }); ASSERT_EQ(s.method, std::string("GET")); ASSERT_TRUE(has(s.target, "/v1/api-key")); ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer API-SECRET")); auto m = sent(r.api_mock, [&] { svc.me(); }); ASSERT_TRUE(has(m.target, "/v1/me")); // A management client must be refused for an api call. AccountService wrong(r.mgmt); refused(r.mgmt_mock, [&] { wrong.me(); }); } TEST(xai_platform_account, not_configured_before_network) { Rig r("", ""); AccountService svc(r.api); try { svc.me(); FAIL("expected NotConfiguredError"); } catch (const NotConfiguredError& e) { ASSERT_EQ(e.http_status(), 503); ASSERT_TRUE(has(e.message(), "XAI_API_KEY")); } CollectionsService col(r.mgmt); try { col.list(); FAIL("expected NotConfiguredError"); } catch (const NotConfiguredError& e) { ASSERT_TRUE(has(e.message(), "XAI_MANAGEMENT_KEY")); } ASSERT_EQ(r.api_mock->send_count(), static_cast(0)); ASSERT_EQ(r.mgmt_mock->send_count(), static_cast(0)); } TEST(xai_platform_files, upload_orders_expiry_before_file) { Rig r; FilesService svc(r.api); auto s = sent(r.api_mock, [&] { svc.upload("report.pdf", "application/pdf", "PDFDATA", 3600, "assistants"); }); ASSERT_EQ(s.method, std::string("POST")); ASSERT_TRUE(has(s.headers.get_or("Content-Type", ""), "multipart/form-data")); std::size_t exp = s.body.find("name=\"expires_after\""); std::size_t file = s.body.find("name=\"file\""); ASSERT_TRUE(exp != std::string::npos && file != std::string::npos && exp < file); ASSERT_TRUE(has(s.body, "filename=\"report.pdf\"")); ASSERT_TRUE(has(s.body, "name=\"purpose\"")); } TEST(xai_platform_files, upload_caps_and_name_checks) { Rig r; FilesService svc(r.api); refused(r.api_mock, [&] { svc.upload("", "text/plain", "x"); }); refused(r.api_mock, [&] { svc.upload("a/b.txt", "text/plain", "x"); }); refused(r.api_mock, [&] { svc.upload("a\"b.txt", "text/plain", "x"); }); refused(r.api_mock, [&] { svc.upload("a.txt", "text/plain", ""); }); refused(r.api_mock, [&] { svc.upload("a.txt", "text/plain", "x", 3599); }); refused(r.api_mock, [&] { svc.upload("a.txt", "text/plain", "x", 2592001); }); std::string big(PlatformCaps::kMaxFileBytes + 1, 'x'); refused(r.api_mock, [&] { svc.upload("big.bin", "application/octet-stream", big); }); } TEST(xai_platform_files, list_query_is_validated_and_encoded) { Rig r; FilesService svc(r.api); FileListOptions o; o.limit = 50; o.order = "desc"; o.sort_by = "size"; o.filter = "name:\"quarterly report\" AND size_bytes > 1000"; auto s = sent(r.api_mock, [&] { svc.list(o); }); ASSERT_TRUE(has(s.target, "limit=50")); ASSERT_TRUE(has(s.target, "order=desc")); ASSERT_TRUE(has(s.target, "sort_by=size")); ASSERT_TRUE(has(s.target, "filter=name%3A%22quarterly%20report%22")); FileListOptions bad; bad.order = "sideways"; refused(r.api_mock, [&] { svc.list(bad); }); FileListOptions big; big.limit = PlatformCaps::kMaxLimit + 1; refused(r.api_mock, [&] { svc.list(big); }); refused(r.api_mock, [&] { svc.list_all(0); }); refused(r.api_mock, [&] { svc.list_all(101); }); } TEST(xai_platform_files, get_content_public_url_and_guards) { Rig r; FilesService svc(r.api); auto g = sent(r.api_mock, [&] { svc.get("file_abc"); }); ASSERT_TRUE(has(g.target, "/v1/files/file_abc")); auto c = sent(r.api_mock, [&] { svc.content("file_abc", "text"); }); ASSERT_TRUE(has(c.target, "/v1/files/file_abc/content?format=text")); refused(r.api_mock, [&] { svc.content("file_abc", "pdf"); }); auto p = sent(r.api_mock, [&] { svc.create_public_url("file_abc", 7200); }); ASSERT_EQ(p.body, std::string("{\"expires_after\":7200}")); ASSERT_TRUE(has(p.target, "/public-url")); refused(r.api_mock, [&] { svc.create_public_url("file_abc", 10); }); // Destructive: no confirm, no request. refused(r.api_mock, [&] { svc.remove("file_abc", false); }); refused(r.api_mock, [&] { svc.revoke_public_url("file_abc", false); }); auto d = sent(r.api_mock, [&] { svc.remove("file_abc", true); }); ASSERT_EQ(d.method, std::string("DELETE")); auto v = sent(r.api_mock, [&] { svc.revoke_public_url("file_abc", true); }); ASSERT_TRUE(has(v.target, "/public-url/revoke")); refused(r.api_mock, [&] { svc.get("../etc/passwd"); }); } TEST(xai_platform_collections, create_update_list_bodies) { Rig r; CollectionsService svc(r.mgmt); CollectionSpec spec; spec.name = "SEC Filings"; spec.description = "10-K and 10-Q"; spec.embedding_model = "grok-embedding-small"; spec.metric_space = "HNSW_METRIC_COSINE"; Json defs = Json::array(); Json d = Json::object(); d.set("key", "author"); d.set("required", Json(true)); defs.push(d); spec.field_definitions = defs; auto s = sent(r.mgmt_mock, [&] { svc.create(spec); }); ASSERT_EQ(s.method, std::string("POST")); ASSERT_TRUE(has(s.target, "/v1/collections")); ASSERT_EQ(s.headers.get_or("Authorization", ""), std::string("Bearer MGMT-SECRET")); Json body = Json::parse(s.body); ASSERT_EQ(body.find("collection_name")->as_string(), std::string("SEC Filings")); ASSERT_EQ(body.find("index_configuration")->find("model_name")->as_string(), std::string("grok-embedding-small")); ASSERT_EQ(body.find("metric_space")->as_string(), std::string("HNSW_METRIC_COSINE")); ASSERT_EQ(body.find("field_definitions")->as_array().size(), static_cast(1)); CollectionSpec bad; refused(r.mgmt_mock, [&] { svc.create(bad); }); bad.name = "x"; bad.metric_space = "COSINE"; refused(r.mgmt_mock, [&] { svc.create(bad); }); bad.metric_space = ""; bad.team_id = "not-a-uuid"; refused(r.mgmt_mock, [&] { svc.create(bad); }); CollectionSpec ren; ren.name = "SEC Filings (New)"; auto u = sent(r.mgmt_mock, [&] { svc.update("collection_x", ren); }); ASSERT_EQ(u.method, std::string("PUT")); ASSERT_EQ(u.body, std::string("{\"collection_name\":\"SEC Filings (New)\"}")); refused(r.mgmt_mock, [&] { svc.update("collection_x", CollectionSpec()); }); Json ups = Json::array(); Json one = Json::object(); Json def = Json::object(); def.set("key", "year"); one.set("field_definition", def); one.set("operation", "FIELD_DEFINITION_ADD"); ups.push(one); auto u2 = sent(r.mgmt_mock, [&] { svc.update("collection_x", CollectionSpec(), ups); }); ASSERT_TRUE(has(u2.body, "field_definition_updates")); } TEST(xai_platform_collections, list_and_document_queries) { Rig r; CollectionsService svc(r.mgmt); ListOptions o; o.limit = 10; o.order = "ORDERING_DESCENDING"; o.sort_by = "COLLECTIONS_SORT_BY_AGE"; o.team_id = kTeam; auto s = sent(r.mgmt_mock, [&] { svc.list(o); }); ASSERT_TRUE(has(s.target, "team_id=" + std::string(kTeam))); ASSERT_TRUE(has(s.target, "sort_by=COLLECTIONS_SORT_BY_AGE")); ListOptions wrong = o; wrong.sort_by = "DOCUMENTS_SORT_BY_NAME"; refused(r.mgmt_mock, [&] { svc.list(wrong); }); ListOptions docs; docs.sort_by = "DOCUMENTS_SORT_BY_SIZE"; docs.name = "paper.pdf"; auto d = sent(r.mgmt_mock, [&] { svc.list_documents("collection_x", docs); }); ASSERT_TRUE(has(d.target, "/v1/collections/collection_x/documents?")); ASSERT_TRUE(has(d.target, "name=paper.pdf")); auto b = sent(r.mgmt_mock, [&] { svc.batch_get("collection_x", {"file_1", "file_2"}); }); ASSERT_TRUE(has(b.target, "documents:batchGet?file_ids=file_1&file_ids=file_2")); refused(r.mgmt_mock, [&] { svc.batch_get("collection_x", {}); }); std::vector many(PlatformCaps::kMaxBatchFileIds + 1, "f"); refused(r.mgmt_mock, [&] { svc.batch_get("collection_x", many); }); } TEST(xai_platform_collections, documents_add_upload_and_guards) { Rig r; CollectionsService svc(r.mgmt); Json fields = Json::object(); fields.set("author", "Sandra Kim"); auto a = sent(r.mgmt_mock, [&] { svc.add_document("collection_x", "file_y", fields); }); ASSERT_EQ(a.method, std::string("POST")); ASSERT_TRUE(has(a.target, "/v1/collections/collection_x/documents/file_y")); ASSERT_EQ(a.body, std::string("{\"fields\":{\"author\":\"Sandra Kim\"}}")); auto u = sent(r.mgmt_mock, [&] { svc.upload_document("collection_x", "paper.pdf", "application/pdf", "PDF", fields); }); ASSERT_TRUE(has(u.target, "/v1/collections/collection_x/documents")); ASSERT_TRUE(has(u.body, "name=\"data\"; filename=\"paper.pdf\"")); ASSERT_TRUE(has(u.body, "name=\"fields\"")); Json notobj = Json::array(); refused(r.mgmt_mock, [&] { svc.add_document("collection_x", "file_y", notobj); }); auto re = sent(r.mgmt_mock, [&] { svc.reindex_document("collection_x", "file_y"); }); ASSERT_EQ(re.method, std::string("PATCH")); refused(r.mgmt_mock, [&] { svc.remove("collection_x", false); }); refused(r.mgmt_mock, [&] { svc.remove_document("collection_x", "file_y", false); }); auto d = sent(r.mgmt_mock, [&] { svc.remove_document("collection_x", "file_y", true); }); ASSERT_EQ(d.method, std::string("DELETE")); auto c = sent(r.mgmt_mock, [&] { svc.remove("collection_x", true); }); ASSERT_EQ(c.method, std::string("DELETE")); std::string big(PlatformCaps::kMaxCollectionDocBytes + 1, 'x'); refused(r.mgmt_mock, [&] { svc.upload_document("collection_x", "big.txt", "text/plain", big); }); // Collection management is the management host: the api client is refused. CollectionsService wrong(r.api); refused(r.api_mock, [&] { wrong.list(); }); } TEST(xai_platform_search, body_matches_the_documented_example) { Rig r; DocumentSearch svc(r.api); DocumentSearchRequest q; q.query = "What were the key revenue drivers based on the SEC filings?"; q.collection_ids = {"collection_dbc087b1-6c99-493d-86c6-b401fee34a9d"}; q.retrieval_mode = "hybrid"; auto s = sent(r.api_mock, [&] { svc.search(q); }); ASSERT_TRUE(has(s.target, "/v1/documents/search")); Json b = Json::parse(s.body); ASSERT_EQ(b.find("source")->find("collection_ids")->as_array()[0].as_string(), std::string("collection_dbc087b1-6c99-493d-86c6-b401fee34a9d")); ASSERT_EQ(b.find("retrieval_mode")->find("type")->as_string(), std::string("hybrid")); q.group_by = Json::object(); refused(r.api_mock, [&] { svc.search(q); }); DocumentSearchRequest none; refused(r.api_mock, [&] { svc.search(none); }); none.query = "x"; refused(r.api_mock, [&] { svc.search(none); }); none.collection_ids = {"c"}; none.retrieval_mode = "fuzzy"; refused(r.api_mock, [&] { svc.search(none); }); none.retrieval_mode = ""; none.ranking_metric = "RANKING_METRIC_NONE"; refused(r.api_mock, [&] { svc.search(none); }); none.ranking_metric = ""; none.rag_pipeline = "solr"; refused(r.api_mock, [&] { svc.search(none); }); } TEST(xai_platform_keys, create_matches_the_documented_example) { Rig r; ApiKeysService svc(r.mgmt); ApiKeySpec spec; spec.name = "My API key"; spec.acls = {"api-key:model:*", "api-key:endpoint:*"}; spec.qps = 5; spec.qpm = 100; spec.tpm = 100000; auto s = sent(r.mgmt_mock, [&] { svc.create(kTeam, spec); }); ASSERT_TRUE(has(s.target, std::string("/auth/teams/") + kTeam + "/api-keys")); Json b = Json::parse(s.body); ASSERT_EQ(b.find("qps")->as_int(), 5L); ASSERT_TRUE(b.find("tpm")->is_string()); // spec: tpm is a string ASSERT_EQ(b.find("acls")->as_array().size(), static_cast(2)); ApiKeySpec bad; refused(r.mgmt_mock, [&] { svc.create(kTeam, bad); }); bad.name = "k"; bad.acls = {"admin:everything"}; refused(r.mgmt_mock, [&] { svc.create(kTeam, bad); }); bad.acls = {}; bad.qps = -1; refused(r.mgmt_mock, [&] { svc.create(kTeam, bad); }); refused(r.mgmt_mock, [&] { svc.create("team-1", spec); }); } TEST(xai_platform_keys, list_update_rotate_delete) { Rig r; ApiKeysService svc(r.mgmt); auto l = sent(r.mgmt_mock, [&] { svc.list(kTeam, 10); }); ASSERT_TRUE(has(l.target, "pageSize=10")); ASSERT_FALSE(has(l.target, "paginationToken")); // empty token is rejected by the server: never sent auto l2 = sent(r.mgmt_mock, [&] { svc.list(kTeam, 10, "tok", true, {"api-key:model:grok-4"}); }); ASSERT_TRUE(has(l2.target, "paginationToken=tok")); ASSERT_TRUE(has(l2.target, "activeOnly=true")); ASSERT_TRUE(has(l2.target, "aclFilters=api-key%3Amodel%3Agrok-4")); refused(r.mgmt_mock, [&] { svc.list_all(kTeam, 0); }); Json ch = Json::object(); Json inner = Json::object(); inner.set("qpm", Json(200)); ch = inner; auto u = sent(r.mgmt_mock, [&] { svc.update(kKeyId, ch); }); ASSERT_EQ(u.method, std::string("PUT")); ASSERT_EQ(u.body, std::string("{\"apiKey\":{\"qpm\":200},\"fieldMask\":\"qpm\"}")); Json unknown = Json::object(); unknown.set("userId", "x"); refused(r.mgmt_mock, [&] { svc.update(kKeyId, unknown); }); refused(r.mgmt_mock, [&] { svc.update(kKeyId, Json::object()); }); refused(r.mgmt_mock, [&] { svc.rotate(kKeyId, false); }); auto ro = sent(r.mgmt_mock, [&] { svc.rotate(kKeyId, true, "2027-01-01T00:00:00Z", "2026-12-01T00:00:00Z"); }); ASSERT_TRUE(has(ro.target, "/rotate")); ASSERT_TRUE(has(ro.body, "oldSecretExpireTime")); refused(r.mgmt_mock, [&] { svc.remove(kKeyId, false); }); auto d = sent(r.mgmt_mock, [&] { svc.remove(kKeyId, true); }); ASSERT_EQ(d.method, std::string("DELETE")); auto p = sent(r.mgmt_mock, [&] { svc.propagation(kKeyId); }); ASSERT_TRUE(has(p.target, "/propagation")); auto m = sent(r.mgmt_mock, [&] { svc.team_models(kTeam); }); ASSERT_TRUE(has(m.target, "/models")); auto e = sent(r.mgmt_mock, [&] { svc.team_endpoints(kTeam); }); ASSERT_TRUE(has(e.target, "/endpoints")); auto v = sent(r.mgmt_mock, [&] { svc.validate_management_key(); }); ASSERT_TRUE(has(v.target, "/auth/management-keys/validation")); } TEST(xai_platform_billing, guards_amounts_and_bodies) { Rig r; BillingService svc(r.mgmt); ASSERT_TRUE(BillingService::valid_amount("10")); ASSERT_TRUE(BillingService::valid_amount("10.50")); ASSERT_FALSE(BillingService::valid_amount("-1")); ASSERT_FALSE(BillingService::valid_amount("1.234")); ASSERT_FALSE(BillingService::valid_amount("1e3")); ASSERT_FALSE(BillingService::valid_amount("")); refused(r.mgmt_mock, [&] { svc.top_up(kTeam, "10", false); }); refused(r.mgmt_mock, [&] { svc.top_up(kTeam, "ten", true); }); auto t = sent(r.mgmt_mock, [&] { svc.top_up(kTeam, "10", true); }); ASSERT_EQ(t.body, std::string("{\"amount\":{\"val\":\"10\"}}")); ASSERT_TRUE(has(t.target, "/prepaid/top-up")); refused(r.mgmt_mock, [&] { svc.set_soft_spending_limit(kTeam, "100", false); }); auto sl = sent(r.mgmt_mock, [&] { svc.set_soft_spending_limit(kTeam, "100", true); }); ASSERT_EQ(sl.body, std::string("{\"desiredSoftSpendingLimit\":{\"val\":\"100\"}}")); refused(r.mgmt_mock, [&] { svc.set_default_payment_method(kTeam, "pm_1", false); }); refused(r.mgmt_mock, [&] { svc.set_billing_info(kTeam, Json::object(), true); }); Json info = Json::object(); info.set("name", "Acme Inc."); refused(r.mgmt_mock, [&] { svc.set_billing_info(kTeam, info, false); }); auto bi = sent(r.mgmt_mock, [&] { svc.set_billing_info(kTeam, info, true); }); ASSERT_EQ(bi.body, std::string("{\"billingInfo\":{\"name\":\"Acme Inc.\"}}")); refused(r.mgmt_mock, [&] { svc.prepaid_balance("team"); }); auto pb = sent(r.mgmt_mock, [&] { svc.prepaid_balance(kTeam); }); ASSERT_TRUE(has(pb.target, "/prepaid/balance")); } TEST(xai_platform_billing, usage_invoices_and_audit) { Rig r; BillingService svc(r.mgmt); // The documented usage request example. Json range = Json::object(); range.set("startTime", "2025-10-01 00:00:00"); range.set("endTime", "2025-10-07 23:59:59"); range.set("timezone", "Etc/GMT"); Json val = Json::object(); val.set("name", "usd"); val.set("aggregation", "AGGREGATION_SUM"); Json vals = Json::array(); vals.push(val); Json req = Json::object(); req.set("timeRange", range); req.set("timeUnit", "TIME_UNIT_DAY"); req.set("values", vals); auto u = sent(r.mgmt_mock, [&] { svc.usage(kTeam, req); }); ASSERT_TRUE(has(u.target, "/usage")); ASSERT_TRUE(has(u.body, "\"analyticsRequest\"")); refused(r.mgmt_mock, [&] { svc.usage(kTeam, Json::object()); }); InvoiceQuery iq; iq.cycle_year = 2026; iq.cycle_month = 9; auto inv = sent(r.mgmt_mock, [&] { svc.invoices(kTeam, iq); }); ASSERT_TRUE(has(inv.target, "billingCycle.year=2026&billingCycle.month=9")); InvoiceQuery half; half.since_year = 2026; refused(r.mgmt_mock, [&] { svc.invoices(kTeam, half); }); AuditService audit(r.mgmt); AuditQuery a; a.page_size = 50; a.time_from = "2025-01-01T00:00:00Z"; a.order_by = "TIME_DESCENDING"; a.user_id = "user-123"; auto e = sent(r.mgmt_mock, [&] { audit.events(kTeam, a); }); ASSERT_TRUE(has(e.target, "/audit/teams/" + std::string(kTeam) + "/events?")); ASSERT_TRUE(has(e.target, "eventFilter.userId=user-123")); ASSERT_TRUE(has(e.target, "eventTimeFrom=2025-01-01T00%3A00%3A00Z")); AuditQuery bad; bad.order_by = "RANDOM"; refused(r.mgmt_mock, [&] { audit.events(kTeam, bad); }); refused(r.mgmt_mock, [&] { audit.events_all(kTeam, 0); }); }