|
|
|
@@ -0,0 +1,480 @@
|
|
|
|
|
// OpenAI organization administration: call table, credential kinds,
|
|
|
|
|
// destructive guards, request construction, query validation, paging
|
|
|
|
|
// ceilings, webhook verification and event envelopes. Local and
|
|
|
|
|
// deterministic; the mock transport only records the requests we send.
|
|
|
|
|
#include <cstdlib>
|
|
|
|
|
#include <iostream>
|
|
|
|
|
#include <memory>
|
|
|
|
|
|
|
|
|
|
#include "framework.h"
|
|
|
|
|
#include "clients/transports/mock_transport.h"
|
|
|
|
|
#include "clients/transports/http_transport.h"
|
|
|
|
|
#include "openai/admin/caps.h"
|
|
|
|
|
#include "openai/admin/openai_admin.h"
|
|
|
|
|
|
|
|
|
|
using namespace molo::openai::admin;
|
|
|
|
|
using molo::clients::ClientResponse;
|
|
|
|
|
using molo::clients::HeaderMap;
|
|
|
|
|
using molo::clients::Method;
|
|
|
|
|
using molo::clients::body::Json;
|
|
|
|
|
using molo::clients::transports::MockTransport;
|
|
|
|
|
using molo::llm::ApiError;
|
|
|
|
|
using molo::llm::NotConfiguredError;
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
ClientResponse ok_json(const std::string& body = "{}") {
|
|
|
|
|
HeaderMap h;
|
|
|
|
|
h.set("Content-Type", "application/json");
|
|
|
|
|
return ClientResponse(200, h, body);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct Rig {
|
|
|
|
|
MockTransport* mock;
|
|
|
|
|
std::shared_ptr<AdminApiClient> client;
|
|
|
|
|
explicit Rig(const std::string& key = "sk-admin-TESTKEY") {
|
|
|
|
|
auto t = std::make_unique<MockTransport>();
|
|
|
|
|
mock = t.get();
|
|
|
|
|
client = AdminApiClient::with_transport(std::move(t), key);
|
|
|
|
|
}
|
|
|
|
|
void accept(Method m, const std::string& path) {
|
|
|
|
|
molo::clients::transports::MockExpectation ex;
|
|
|
|
|
ex.method = m;
|
|
|
|
|
ex.path = path;
|
|
|
|
|
ex.response = ok_json();
|
|
|
|
|
ex.times = 1000;
|
|
|
|
|
mock->expect(ex);
|
|
|
|
|
}
|
|
|
|
|
MockTransport::SeenRequest last() { return mock->seen().back(); }
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
bool throws_invalid(const std::function<void()>& f) {
|
|
|
|
|
try {
|
|
|
|
|
f();
|
|
|
|
|
} catch (const ApiError& e) {
|
|
|
|
|
return e.http_status() == 400 && e.type() == "INVALID_ARGUMENT";
|
|
|
|
|
}
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, table_is_ordered_complete_and_renders_every_path) {
|
|
|
|
|
ASSERT_EQ(CallTable::size(), 121u);
|
|
|
|
|
int project_calls = 0;
|
|
|
|
|
for (std::size_t i = 0; i < CallTable::size(); ++i) {
|
|
|
|
|
const CallSpec& s = CallTable::at(i);
|
|
|
|
|
ASSERT_EQ(static_cast<std::size_t>(s.call), i);
|
|
|
|
|
std::vector<std::string> ids(CallTable::path_params(s.call).size(), "id1");
|
|
|
|
|
std::string path = CallTable::render(s.call, ids);
|
|
|
|
|
ASSERT_TRUE(path.find('{') == std::string::npos);
|
|
|
|
|
if (CallTable::auth(s.call) == AuthKind::kProject) ++project_calls;
|
|
|
|
|
if (std::string(s.http_method) == "DELETE") ASSERT_TRUE(CallTable::destructive(s.call));
|
|
|
|
|
}
|
|
|
|
|
ASSERT_EQ(project_calls, 8); // /webhook_endpoints* and /webhook_event_types
|
|
|
|
|
ASSERT_TRUE(CallTable::schema_count() > 80u);
|
|
|
|
|
ASSERT_EQ(AuditEventCatalog::all().size(), 149u);
|
|
|
|
|
ASSERT_EQ(WebhookEvents::sent().size(), 30u);
|
|
|
|
|
ASSERT_EQ(WebhookEvents::subscribable().size(), 27u);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, render_rejects_bad_ids_and_wrong_arity) {
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { CallTable::render(Call::kUsersGet, {"../x"}); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { CallTable::render(Call::kUsersGet, {"a/b"}); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { CallTable::render(Call::kUsersGet, {}); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { CallTable::render(Call::kUsersGet, {"a", "b"}); }));
|
|
|
|
|
ASSERT_EQ(CallTable::render(Call::kProjectsUsersGet, {"proj_1", "user-2"}),
|
|
|
|
|
"/organization/projects/proj_1/users/user-2");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, only_admin_keys_reach_the_organization_api) {
|
|
|
|
|
for (const char* key : {"sk-proj-abc", "sk-abc", "sk-svcacct-x"}) {
|
|
|
|
|
try {
|
|
|
|
|
Rig r(key);
|
|
|
|
|
FAIL("regular key accepted");
|
|
|
|
|
} catch (const ApiError& e) {
|
|
|
|
|
ASSERT_EQ(e.http_status(), 401);
|
|
|
|
|
ASSERT_EQ(e.type(), "WRONG_KEY_KIND");
|
|
|
|
|
ASSERT_EQ(e.message().find(key), std::string::npos);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
Rig good;
|
|
|
|
|
ASSERT_TRUE(good.client->configured());
|
|
|
|
|
Rig none("");
|
|
|
|
|
ASSERT_FALSE(none.client->configured());
|
|
|
|
|
Users users(none.client);
|
|
|
|
|
ASSERT_THROW(users.list(), NotConfiguredError);
|
|
|
|
|
ASSERT_EQ(none.mock->send_count(), 0u);
|
|
|
|
|
// The webhook endpoint client is the mirror image: no admin keys.
|
|
|
|
|
ASSERT_THROW(ProjectApiClient::with_transport(std::make_unique<MockTransport>(), "sk-admin-x"),
|
|
|
|
|
ApiError);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, bearer_header_region_and_base_url) {
|
|
|
|
|
Rig r;
|
|
|
|
|
r.accept(Method::kGet, "/v1/organization/users");
|
|
|
|
|
Users(r.client).list();
|
|
|
|
|
ASSERT_EQ(r.last().headers.get_or("Authorization", ""), "Bearer sk-admin-TESTKEY");
|
|
|
|
|
ASSERT_EQ(Regions::base_url(Region::kEu), "https://eu.api.openai.com/v1");
|
|
|
|
|
ASSERT_EQ(Regions::base_url(Region::kGlobal), "https://api.openai.com/v1");
|
|
|
|
|
ASSERT_TRUE(Regions::parse("JP").has_value());
|
|
|
|
|
ASSERT_FALSE(Regions::parse("zz").has_value());
|
|
|
|
|
ASSERT_TRUE(*Regions::from_residency("EU_STORAGE_PROCESSING") == Region::kEu);
|
|
|
|
|
ASSERT_FALSE(Regions::from_residency("MOON").has_value());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, service_refuses_a_call_of_the_other_credential_kind) {
|
|
|
|
|
Rig r;
|
|
|
|
|
WebhookEndpoints wrong(
|
|
|
|
|
ProjectApiClient::with_transport(std::make_unique<MockTransport>(), "sk-proj-1"));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { wrong.list(); }) == false); // fine: project call
|
|
|
|
|
// An admin service cannot run a project call: probe through Users with a webhook row.
|
|
|
|
|
struct Probe : AdminService {
|
|
|
|
|
explicit Probe(std::shared_ptr<AdminApiClient> c) : AdminService(std::move(c)) {}
|
|
|
|
|
Json run() { return execute(Call::kWebhookEndpointsList); }
|
|
|
|
|
} probe(r.client);
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { probe.run(); }));
|
|
|
|
|
ASSERT_EQ(r.mock->send_count(), 0u);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, destructive_calls_need_confirm_and_send_nothing_without_it) {
|
|
|
|
|
Rig r;
|
|
|
|
|
r.accept(Method::kDelete, "/v1/organization/users/user_1");
|
|
|
|
|
r.accept(Method::kPost, "/v1/organization/projects/proj_1/archive");
|
|
|
|
|
Users users(r.client);
|
|
|
|
|
Projects projects(r.client);
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { users.destroy("user_1", false); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { projects.archive("proj_1", false); }));
|
|
|
|
|
ASSERT_EQ(r.mock->send_count(), 0u);
|
|
|
|
|
users.destroy("user_1", true);
|
|
|
|
|
ASSERT_EQ(r.last().method, "DELETE");
|
|
|
|
|
projects.archive("proj_1", true);
|
|
|
|
|
ASSERT_EQ(r.last().method, "POST");
|
|
|
|
|
ASSERT_TRUE(r.last().target.find("/organization/projects/proj_1/archive") != std::string::npos);
|
|
|
|
|
// retention change and certificate deactivation are guarded too
|
|
|
|
|
ProjectPolicies pol(r.client);
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { pol.set_data_retention("proj_1", "none", false); }));
|
|
|
|
|
Certificates certs(r.client);
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { certs.deactivate({"cert_1"}, false); }));
|
|
|
|
|
OrganizationPolicies org(r.client);
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { org.set_data_retention("zero_data_retention", false); }));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, request_bodies_follow_the_table) {
|
|
|
|
|
Rig r;
|
|
|
|
|
r.accept(Method::kPost, "/v1/organization/invites");
|
|
|
|
|
r.accept(Method::kPost, "/v1/organization/projects");
|
|
|
|
|
r.accept(Method::kPost, "/v1/organization/projects/proj_1/rate_limits/rl-x");
|
|
|
|
|
Invites(r.client).create({"a@example.com", "reader", {{"proj_1", "member"}}});
|
|
|
|
|
ASSERT_EQ(r.last().body,
|
|
|
|
|
"{\"email\":\"a@example.com\",\"projects\":[{\"id\":\"proj_1\",\"role\":\"member\"}],"
|
|
|
|
|
"\"role\":\"reader\"}");
|
|
|
|
|
ProjectCreate pc;
|
|
|
|
|
pc.name = "Prod";
|
|
|
|
|
pc.residency = "EU_STORAGE_PROCESSING";
|
|
|
|
|
Projects(r.client).create(pc);
|
|
|
|
|
ASSERT_EQ(r.last().body, "{\"name\":\"Prod\",\"residency\":\"EU_STORAGE_PROCESSING\"}");
|
|
|
|
|
RateLimitUpdate rl;
|
|
|
|
|
rl.max_requests_per_1_minute = 100;
|
|
|
|
|
RateLimits(r.client).update("proj_1", "rl-x", rl);
|
|
|
|
|
ASSERT_EQ(r.last().body, "{\"max_requests_per_1_minute\":100}");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, request_validation_rejects_before_traffic) {
|
|
|
|
|
Rig r;
|
|
|
|
|
Invites inv(r.client);
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { inv.create({"not-an-email", "reader", {}}); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { inv.create({"a@b.co", "admin", {}}); }));
|
|
|
|
|
ProjectCreate bad;
|
|
|
|
|
bad.name = "x";
|
|
|
|
|
bad.residency = "MOON";
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { Projects(r.client).create(bad); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { Projects(r.client).update("p", ProjectUpdate{}); }));
|
|
|
|
|
ProjectUserCreate both{"u1", "a@b.co", "owner"};
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { both.to_json(); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { AdminApiKeys(r.client).create("k", 31536001); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { CertificateUpload{"", "-----BEGIN PRIVATE KEY-----"}.to_json(); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { SpendAlertSpec{0, {"a@b.co"}, ""}.to_json(); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { (ListOptions{0, "", "", ""}).to_query(); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { (ListOptions{101, "", "", ""}).to_query(); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { (ListOptions{std::nullopt, "", "", "up"}).to_query(); }));
|
|
|
|
|
// users.list has no `order` parameter in the table
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { Users(r.client).list(ListOptions{std::nullopt, "", "", "asc"}); }));
|
|
|
|
|
ASSERT_EQ(r.mock->send_count(), 0u);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, usage_queries_are_checked_per_endpoint) {
|
|
|
|
|
Rig r;
|
|
|
|
|
r.accept(Method::kGet, "/v1/organization/usage/completions");
|
|
|
|
|
r.accept(Method::kGet, "/v1/organization/costs");
|
|
|
|
|
Usage usage(r.client);
|
|
|
|
|
UsageQuery q;
|
|
|
|
|
q.start_time = 1730419200;
|
|
|
|
|
q.bucket_width = "1h";
|
|
|
|
|
q.limit = 24;
|
|
|
|
|
q.project_ids = {"proj_a", "proj_b"};
|
|
|
|
|
q.group_by = {"model", "project_id"};
|
|
|
|
|
q.batch = false;
|
|
|
|
|
usage.query(UsageKind::kCompletions, q);
|
|
|
|
|
const std::string target = r.last().target;
|
|
|
|
|
ASSERT_TRUE(target.find("start_time=1730419200") != std::string::npos);
|
|
|
|
|
ASSERT_TRUE(target.find("project_ids=proj_a&project_ids=proj_b") != std::string::npos);
|
|
|
|
|
ASSERT_TRUE(target.find("group_by=model&group_by=project_id") != std::string::npos);
|
|
|
|
|
ASSERT_TRUE(target.find("batch=false") != std::string::npos);
|
|
|
|
|
|
|
|
|
|
UsageQuery bad = q;
|
|
|
|
|
bad.limit = 169; // 1h max is 168
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { usage.query(UsageKind::kCompletions, bad); }));
|
|
|
|
|
bad = q;
|
|
|
|
|
bad.sizes = {"1024x1024"}; // images only
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { usage.query(UsageKind::kCompletions, bad); }));
|
|
|
|
|
bad = q;
|
|
|
|
|
bad.group_by = {"size"}; // images only
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { usage.query(UsageKind::kCompletions, bad); }));
|
|
|
|
|
bad = q;
|
|
|
|
|
bad.start_time = 0;
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { usage.query(UsageKind::kCompletions, bad); }));
|
|
|
|
|
bad = q;
|
|
|
|
|
bad.end_time = 5;
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { usage.query(UsageKind::kCompletions, bad); }));
|
|
|
|
|
|
|
|
|
|
CostQuery c;
|
|
|
|
|
c.start_time = 1730419200;
|
|
|
|
|
c.limit = 180;
|
|
|
|
|
c.line_items = {"gpt, input"};
|
|
|
|
|
Costs(r.client).query(c);
|
|
|
|
|
ASSERT_TRUE(r.last().target.find("line_items=gpt%2C%20input") != std::string::npos);
|
|
|
|
|
c.limit = 181;
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { Costs(r.client).query(c); }));
|
|
|
|
|
c.limit = 7;
|
|
|
|
|
c.bucket_width = "1h"; // costs are daily only
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { Costs(r.client).query(c); }));
|
|
|
|
|
ASSERT_EQ(UsageEndpoints::all().size(), 11u);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, audit_queries_use_spec_names_and_the_catalog) {
|
|
|
|
|
Rig r;
|
|
|
|
|
r.accept(Method::kGet, "/v1/organization/audit_logs");
|
|
|
|
|
AuditQuery q;
|
|
|
|
|
q.event_types = {"project.created", "api_key.deleted"};
|
|
|
|
|
q.project_ids = {"proj_1"};
|
|
|
|
|
q.effective_at_gte = 1730419200;
|
|
|
|
|
q.limit = 100;
|
|
|
|
|
q.tenant_only = true;
|
|
|
|
|
AuditLogs(r.client).list(q);
|
|
|
|
|
const std::string t = r.last().target;
|
|
|
|
|
ASSERT_TRUE(t.find("event_types%5B%5D=project.created&event_types%5B%5D=api_key.deleted") != std::string::npos);
|
|
|
|
|
ASSERT_TRUE(t.find("effective_at%5Bgte%5D=1730419200") != std::string::npos);
|
|
|
|
|
ASSERT_TRUE(t.find("tenant_only=true") != std::string::npos);
|
|
|
|
|
AuditQuery bad;
|
|
|
|
|
bad.event_types = {"project.exploded"};
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { AuditLogs(r.client).list(bad); }));
|
|
|
|
|
bad = AuditQuery{};
|
|
|
|
|
bad.after = "a";
|
|
|
|
|
bad.before = "b";
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { AuditLogs(r.client).list(bad); }));
|
|
|
|
|
ASSERT_TRUE(AuditEventCatalog::known("tenant.user.added"));
|
|
|
|
|
ASSERT_EQ(AuditEventCatalog::family("rate_limit.updated"), "rate_limit");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, walks_stop_at_ceilings_and_say_so) {
|
|
|
|
|
int calls = 0;
|
|
|
|
|
WalkResult r = PageWalker::walk([&](const std::string& cursor) {
|
|
|
|
|
++calls;
|
|
|
|
|
Json page = Json::object();
|
|
|
|
|
Json data = Json::array();
|
|
|
|
|
data.push(Json(cursor.empty() ? "first" : cursor));
|
|
|
|
|
page.set("data", data);
|
|
|
|
|
page.set("has_more", Json(true));
|
|
|
|
|
page.set("last_id", Json("id" + std::to_string(calls)));
|
|
|
|
|
return page;
|
|
|
|
|
});
|
|
|
|
|
ASSERT_TRUE(r.truncated);
|
|
|
|
|
ASSERT_EQ(r.reason, "page ceiling");
|
|
|
|
|
ASSERT_EQ(r.pages, AdminCaps::kMaxListPages);
|
|
|
|
|
ASSERT_TRUE(r.to_json().find("truncated_reason") != nullptr);
|
|
|
|
|
|
|
|
|
|
int n = 0;
|
|
|
|
|
WalkResult done = PageWalker::walk([&](const std::string&) {
|
|
|
|
|
Json page = Json::object();
|
|
|
|
|
page.set("data", Json::array());
|
|
|
|
|
page.set("has_more", Json(++n < 3));
|
|
|
|
|
page.set("next_page", Json("tok" + std::to_string(n)));
|
|
|
|
|
return page;
|
|
|
|
|
});
|
|
|
|
|
ASSERT_FALSE(done.truncated);
|
|
|
|
|
ASSERT_EQ(done.pages, 3);
|
|
|
|
|
ASSERT_THROW(PageWalker::walk([](const std::string&) { return Json::object(); }), ApiError);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, usage_summary_adds_up_buckets) {
|
|
|
|
|
// Shape from the OpenAPI document: UsageResponse / UsageCompletionsResult / CostsResult.
|
|
|
|
|
Json doc = Json::parse(
|
|
|
|
|
"{\"object\":\"page\",\"has_more\":false,\"next_page\":null,\"data\":[{\"object\":\"bucket\","
|
|
|
|
|
"\"start_time\":1,\"end_time\":2,\"results\":[{\"object\":\"organization.usage.completions.result\","
|
|
|
|
|
"\"input_tokens\":10,\"output_tokens\":5,\"num_model_requests\":1},{\"object\":\"x\",\"input_tokens\":2,"
|
|
|
|
|
"\"output_tokens\":1,\"num_model_requests\":1}]}]}");
|
|
|
|
|
auto totals = UsageSummary::totals(doc);
|
|
|
|
|
ASSERT_EQ(totals["input_tokens"], 12.0);
|
|
|
|
|
ASSERT_EQ(totals["num_model_requests"], 2.0);
|
|
|
|
|
Json costs = Json::parse(
|
|
|
|
|
"{\"data\":[{\"results\":[{\"amount\":{\"value\":0.5,\"currency\":\"usd\"}},"
|
|
|
|
|
"{\"amount\":{\"value\":0.25,\"currency\":\"usd\"}}]}]}");
|
|
|
|
|
ASSERT_EQ(UsageSummary::cost_by_currency(costs)["usd"], 0.75);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
// Standard Webhooks reference vector (secret, id, timestamp, body) used by the
|
|
|
|
|
// libraries' own tests; the expected signature was recomputed independently
|
|
|
|
|
// with python3 hmac/hashlib (it is not copied from OpenAI).
|
|
|
|
|
const char* kSecret = "whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSw";
|
|
|
|
|
const char* kId = "msg_p5jXN8AQM9LWM0D4loKWxJek";
|
|
|
|
|
const char* kTs = "1614265330";
|
|
|
|
|
const char* kBody = "{\"test\": 2432232314}";
|
|
|
|
|
const char* kSig = "v1,g0hM9SsE+OTPJTGt/tmIKtSyZlE3uFJELVlNIOLJ1OE=";
|
|
|
|
|
} // namespace
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, webhook_signature_known_vector) {
|
|
|
|
|
WebhookVerifier v(kSecret);
|
|
|
|
|
ASSERT_EQ(v.sign(kId, kTs, kBody), kSig);
|
|
|
|
|
WebhookHeaders h{kId, kTs, kSig};
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, h, 1614265330).ok);
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, h, 1614265330 + 300).ok); // edge of tolerance
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, h, 1614265330 - 300).ok);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, webhook_rejections_are_specific_and_counted) {
|
|
|
|
|
WebhookVerifier v(kSecret);
|
|
|
|
|
WebhookHeaders h{kId, kTs, kSig};
|
|
|
|
|
const auto before = WebhookCounters::value(WebhookFailure::kMismatch);
|
|
|
|
|
ASSERT_TRUE(v.verify("{\"test\": 2432232315}", h, 1614265330).failure == WebhookFailure::kMismatch);
|
|
|
|
|
ASSERT_EQ(WebhookCounters::value(WebhookFailure::kMismatch), before + 1);
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, h, 1614265330 + 301).failure == WebhookFailure::kTooOld);
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, h, 1614265330 - 301).failure == WebhookFailure::kTooNew);
|
|
|
|
|
WebhookHeaders w = h;
|
|
|
|
|
w.id = "msg_other";
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).failure == WebhookFailure::kMismatch);
|
|
|
|
|
w = h;
|
|
|
|
|
w.timestamp = "";
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).failure == WebhookFailure::kMissingTimestamp);
|
|
|
|
|
w = h;
|
|
|
|
|
w.timestamp = "16x4";
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).failure == WebhookFailure::kBadTimestamp);
|
|
|
|
|
w = h;
|
|
|
|
|
w.signature = "";
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).failure == WebhookFailure::kMissingSignature);
|
|
|
|
|
w = h;
|
|
|
|
|
w.id = "";
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).failure == WebhookFailure::kMissingId);
|
|
|
|
|
// unprefixed and other-version entries are never accepted
|
|
|
|
|
w = h;
|
|
|
|
|
w.signature = std::string(kSig).substr(3);
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).failure == WebhookFailure::kBadSignatureHeader);
|
|
|
|
|
w.signature = "v1a," + std::string(kSig).substr(3);
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).failure == WebhookFailure::kBadSignatureHeader);
|
|
|
|
|
// several entries: any match passes
|
|
|
|
|
w.signature = "v1,AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA= " + std::string(kSig);
|
|
|
|
|
ASSERT_TRUE(v.verify(kBody, w, 1614265330).ok);
|
|
|
|
|
// wrong secret
|
|
|
|
|
WebhookVerifier other("whsec_MfKQ9r8GKYqrTwjUPD8ILPZIo2LaLaSx");
|
|
|
|
|
ASSERT_FALSE(other.verify(kBody, h, 1614265330).ok);
|
|
|
|
|
ASSERT_THROW(other.require(kBody, h, 1614265330), ApiError);
|
|
|
|
|
// body cap
|
|
|
|
|
ASSERT_TRUE(v.verify(std::string(AdminCaps::kMaxWebhookBodyBytes + 1, 'x'), h, 1614265330).failure ==
|
|
|
|
|
WebhookFailure::kBodyTooLarge);
|
|
|
|
|
ASSERT_TRUE(WebhookCounters::snapshot().count("signature_mismatch") == 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, webhook_secret_rules) {
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookVerifier(""); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookVerifier("whsec_!!!!"); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookVerifier("whsec_YWJj"); })); // 3 bytes
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookVerifier(kSecret, 3601); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookVerifier(kSecret, -1); }));
|
|
|
|
|
WebhookVerifier raw("plain-secret-bytes"); // no prefix: used as raw bytes (as the SDKs do)
|
|
|
|
|
WebhookHeaders h = WebhookHeaders::from({{"Webhook-Id", "i1"}, {"WEBHOOK-TIMESTAMP", "100"},
|
|
|
|
|
{"webhook-signature", raw.sign("i1", "100", "{}")}});
|
|
|
|
|
ASSERT_TRUE(raw.verify("{}", h, 100).ok);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, webhook_unwrap_parses_after_verifying) {
|
|
|
|
|
// Envelope shape from the OpenAPI `webhooks` map (batch.completed).
|
|
|
|
|
const std::string body =
|
|
|
|
|
"{\"id\":\"evt_1\",\"object\":\"event\",\"created_at\":1750287018,\"type\":\"batch.completed\","
|
|
|
|
|
"\"data\":{\"id\":\"batch_abc\"}}";
|
|
|
|
|
WebhookVerifier v(kSecret);
|
|
|
|
|
WebhookHeaders h{"wh_1", "1750287078", v.sign("wh_1", "1750287078", body)};
|
|
|
|
|
WebhookEvent e = v.unwrap(body, h, 1750287080);
|
|
|
|
|
ASSERT_EQ(e.type, "batch.completed");
|
|
|
|
|
ASSERT_EQ(e.family(), "batch");
|
|
|
|
|
ASSERT_EQ(e.resource_id(), "batch_abc");
|
|
|
|
|
ASSERT_TRUE(e.known);
|
|
|
|
|
ASSERT_TRUE(e.missing_data_fields.empty());
|
|
|
|
|
ASSERT_THROW(v.unwrap(body + " ", h, 1750287080), ApiError); // not parsed unverified
|
|
|
|
|
WebhookEvent unknown = WebhookEnvelope::parse(
|
|
|
|
|
"{\"id\":\"e\",\"object\":\"event\",\"created_at\":1,\"type\":\"future.thing\",\"data\":{}}");
|
|
|
|
|
ASSERT_FALSE(unknown.known);
|
|
|
|
|
WebhookEvent partial = WebhookEnvelope::parse(
|
|
|
|
|
"{\"id\":\"e\",\"created_at\":1,\"type\":\"agent.session.created\",\"data\":{\"id\":\"s\"}}");
|
|
|
|
|
ASSERT_EQ(partial.missing_data_fields.size(), 1u); // environment_type
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookEnvelope::parse("[]"); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookEnvelope::parse("{\"id\":\"e\"}"); }));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, webhook_endpoint_calls_validate_event_types) {
|
|
|
|
|
WebhookEndpointSpec s;
|
|
|
|
|
s.name = "n";
|
|
|
|
|
s.url = "http://insecure.example/x";
|
|
|
|
|
s.event_types = {"batch.completed"};
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { s.to_json(true); }));
|
|
|
|
|
s.url = "https://hooks.example/x";
|
|
|
|
|
s.event_types = {"live.call.incoming"}; // sent, but not selectable
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { s.to_json(true); }));
|
|
|
|
|
s.event_types = {"video.completed"};
|
|
|
|
|
ASSERT_EQ(s.to_json(true).dump(),
|
|
|
|
|
"{\"event_types\":[\"video.completed\"],\"name\":\"n\",\"url\":\"https://hooks.example/x\"}");
|
|
|
|
|
ASSERT_TRUE(throws_invalid([] { WebhookEndpointSpec{}.to_json(false); }));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, certificate_scope_rules) {
|
|
|
|
|
Rig r;
|
|
|
|
|
Certificates proj(r.client, "proj_1");
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { proj.rename("c1", "n"); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { proj.get("c1", false); }));
|
|
|
|
|
ASSERT_TRUE(throws_invalid([&] { proj.activate({}); }));
|
|
|
|
|
ASSERT_EQ(r.mock->send_count(), 0u);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Opt-in live checks (plan rule 7): unauthenticated-grade probe with an
|
|
|
|
|
// invalid key, and read-only list calls with a real admin key.
|
|
|
|
|
// Captured at startup: other suites change the environment while running.
|
|
|
|
|
static const bool kLiveNet = std::getenv("MOLO_LIVE_NET") && std::string(std::getenv("MOLO_LIVE_NET")) == "1";
|
|
|
|
|
static const std::string kLiveAdminKey = std::getenv("OPENAI_ADMIN_KEY") ? std::getenv("OPENAI_ADMIN_KEY") : "";
|
|
|
|
|
|
|
|
|
|
TEST(openai_admin, live_read_only) {
|
|
|
|
|
if (!kLiveNet) {
|
|
|
|
|
std::cout << "SKIP openai_admin.live_read_only: set MOLO_LIVE_NET=1 (and OPENAI_ADMIN_KEY)\n";
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
auto probe = AdminApiClient::with_transport(
|
|
|
|
|
std::make_unique<molo::clients::transports::HttpTransport>(), "sk-admin-invalid");
|
|
|
|
|
try {
|
|
|
|
|
Users(probe).list();
|
|
|
|
|
FAIL("invalid key accepted");
|
|
|
|
|
} catch (const ApiError& e) {
|
|
|
|
|
ASSERT_EQ(e.http_status(), 401);
|
|
|
|
|
ASSERT_EQ(e.type(), "invalid_request_error");
|
|
|
|
|
}
|
|
|
|
|
auto client = AdminApiClient::with_transport(
|
|
|
|
|
std::make_unique<molo::clients::transports::HttpTransport>(), kLiveAdminKey);
|
|
|
|
|
if (!client->configured()) {
|
|
|
|
|
std::cout << "SKIP openai_admin.live_read_only (key part): OPENAI_ADMIN_KEY not set\n";
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
ListOptions one;
|
|
|
|
|
one.limit = 1;
|
|
|
|
|
Json projects = Projects(client).list(one);
|
|
|
|
|
ASSERT_TRUE(projects.find("data") != nullptr);
|
|
|
|
|
Json users = Users(client).list(one);
|
|
|
|
|
ASSERT_TRUE(users.find("data") != nullptr);
|
|
|
|
|
}
|