Files
moloapp/tests/src/openai/platform/test_calls.cpp
T

356 lines
16 KiB
C++

// OpenAI platform: the call table, local validation, request construction,
// forms, list walking. Nothing here plays the vendor.
#include <cstdlib>
#include <set>
#include "framework.h"
#include "llm/error.h"
#include "openai/platform/batches_api.h"
#include "openai/platform/caps.h"
#include "openai/platform/uploads_api.h"
#include "rig.h"
using namespace molo::openai::platform;
using molo::clients::body::Json;
using molo::llm::ApiError;
using molo::llm::NotConfiguredError;
using oai_test::Rig;
namespace {
PathArgs dummy_ids(const CallSpec& s) {
PathArgs a;
for (const std::string& n : Calls::placeholders(s)) a.emplace_back(n, "id_1");
return a;
}
Json minimal_body(const CallSpec& s) {
Json b = Json::object();
for (const std::string& r : Calls::list(s.required_fields)) b.set(r, Json("x"));
return b;
}
} // namespace
TEST(oai_calls, table_shape) {
ASSERT_EQ(Calls::count(), 188u);
std::set<std::string> ids, enums;
for (std::size_t i = 0; i < Calls::count(); ++i) {
const CallSpec& s = Calls::at(i);
ASSERT_EQ(static_cast<std::size_t>(s.op), i);
ASSERT_TRUE(ids.insert(s.operation_id).second);
ASSERT_TRUE(s.path[0] == '/');
ASSERT_TRUE(std::string(s.method) == "GET" || std::string(s.method) == "POST" ||
std::string(s.method) == "DELETE");
ASSERT_TRUE(Calls::find(s.operation_id) == &s);
}
ASSERT_TRUE(Calls::find("nope") == nullptr);
}
TEST(oai_calls, every_call_prepares_with_minimal_input) {
for (std::size_t i = 0; i < Calls::count(); ++i) {
const CallSpec& s = Calls::at(i);
bool json = (s.req & kReqJson) != 0;
Json body = minimal_body(s);
auto p = PlatformService::prepare(s.op, dummy_ids(s), json ? &body : nullptr);
ASSERT_EQ(p.method, std::string(s.method));
ASSERT_EQ(p.target.find("{"), std::string::npos);
ASSERT_EQ(p.target.substr(0, 1), "/");
ASSERT_EQ(p.has_body, json);
// Flags drive the beta headers.
ASSERT_EQ(p.headers.count("OpenAI-Beta") != 0, Calls::has(s, kBetaAssistants) || Calls::has(s, kBetaChatkit));
}
}
TEST(oai_calls, unknown_and_missing_body_fields_are_rejected_before_the_network) {
Rig r;
Json bad = Json::object();
bad.set("model", Json("gpt-x"));
bad.set("not_a_field", Json(1));
ASSERT_THROW(r.platform->assistants.create(bad), ApiError);
ASSERT_THROW(r.platform->assistants.create(Json::object()), ApiError); // model is required
ASSERT_THROW(r.platform->fine_tuning_jobs.create(Json::object()), ApiError);
ASSERT_THROW(r.platform->files.retrieve("a/b"), ApiError);
ASSERT_THROW(r.platform->files.retrieve(".."), ApiError);
ASSERT_THROW(r.platform->files.retrieve(""), ApiError);
ASSERT_THROW(r.platform->files.retrieve(std::string(300, 'a')), ApiError);
ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {}), ApiError); // id missing
ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}, {"x", "b"}}), ApiError); // extra id
Json body = Json::object();
ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}}, &body), ApiError); // GET body
ASSERT_EQ(r.sent(), 0u);
}
TEST(oai_calls, validation_runs_before_the_credential_check) {
Rig r("");
ASSERT_FALSE(r.platform->configured());
try {
r.platform->files.retrieve("a/b");
FAIL("expected invalid");
} catch (const NotConfiguredError&) {
FAIL("validation must come first");
} catch (const ApiError& e) {
ASSERT_EQ(e.http_status(), 400);
}
try {
r.platform->files.retrieve("file-1");
FAIL("expected not configured");
} catch (const NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
ASSERT_TRUE(e.message().find("OPENAI_API_KEY") != std::string::npos);
}
ASSERT_EQ(r.sent(), 0u);
}
TEST(oai_calls, requests_carry_the_expected_method_path_auth_and_beta_headers) {
Rig r;
r.platform->files.retrieve("file-abc");
ASSERT_EQ(r.last().method, "GET");
ASSERT_EQ(r.last().target, "/v1/files/file-abc");
ASSERT_EQ(r.last().headers.get_or("Authorization", ""), "Bearer sk-test-KEY");
ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), "");
ASSERT_EQ(r.last().target.find("sk-test"), std::string::npos);
r.platform->threads.retrieve("thread_1");
ASSERT_EQ(r.last().target, "/v1/threads/thread_1");
ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), "assistants=v2");
r.platform->chatkit.retrieve_thread("cthr_1");
ASSERT_EQ(r.last().target, "/v1/chatkit/threads/cthr_1");
ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), "chatkit_beta=v1");
r.platform->files.remove("file-abc");
ASSERT_EQ(r.last().method, "DELETE");
r.platform->fine_tuning_jobs.cancel("ftjob-1");
ASSERT_EQ(r.last().method, "POST");
ASSERT_EQ(r.last().target, "/v1/fine_tuning/jobs/ftjob-1/cancel");
Json body = Json::object();
body.set("project_ids", Json::array());
r.platform->fine_tuning_permissions.remove("ft:gpt-4o:org::abc:ckpt-step-1", "cp_1");
ASSERT_EQ(r.last().target, "/v1/fine_tuning/checkpoints/ft:gpt-4o:org::abc:ckpt-step-1/permissions/cp_1");
}
TEST(oai_calls, org_and_project_headers_come_from_config) {
setenv("OPENAI_ORG_ID", "org-test_1", 1);
setenv("OPENAI_PROJECT_ID", "proj_test-2", 1);
auto cfg = PlatformConfig::api_config();
ASSERT_EQ(cfg.default_headers["OpenAI-Organization"], "org-test_1");
ASSERT_EQ(cfg.default_headers["OpenAI-Project"], "proj_test-2");
ASSERT_EQ(cfg.key_env, "OPENAI_API_KEY");
setenv("OPENAI_ORG_ID", "bad\r\nX: y", 1);
ASSERT_THROW(PlatformConfig::api_config(), ApiError);
unsetenv("OPENAI_ORG_ID");
unsetenv("OPENAI_PROJECT_ID");
ASSERT_TRUE(PlatformConfig::api_config().default_headers.empty());
}
TEST(oai_calls, query_strings) {
Rig r;
Json q = Json::object();
q.set("limit", Json(5));
q.set("order", Json("desc"));
q.set("after", Json("file a&b"));
r.platform->files.list(q);
ASSERT_EQ(r.last().target, "/v1/files?after=file%20a%26b&limit=5&order=desc");
Json bad = Json::object();
bad.set("nope", Json(1));
ASSERT_THROW(r.platform->files.list(bad), ApiError);
Json big = Json::object();
big.set("limit", Json(10001));
ASSERT_THROW(r.platform->files.list(big), ApiError);
Json zero = Json::object();
zero.set("limit", Json(0));
ASSERT_THROW(r.platform->files.list(zero), ApiError);
// array: repeated key; deepObject: key[sub]
Json inc = Json::object();
Json arr = Json::array();
arr.push(Json("a.b"));
arr.push(Json("c"));
inc.set("include", arr);
r.platform->conversation_items.list("conv_1", inc);
ASSERT_EQ(r.last().target, "/v1/conversations/conv_1/items?include=a.b&include=c");
Json meta = Json::object();
Json m = Json::object();
m.set("team", Json("x y"));
meta.set("metadata", m);
r.platform->fine_tuning_jobs.list(meta);
ASSERT_EQ(r.last().target, "/v1/fine_tuning/jobs?metadata%5Bteam%5D=x%20y");
Json steps = Json::object();
Json sa = Json::array();
sa.push(Json("step_details.tool_calls[*].file_search.results[*].content"));
steps.set("include[]", sa);
r.platform->runs.steps("t_1", "run_1", steps);
ASSERT_TRUE(r.last().target.find("include%5B%5D=step_details.tool_calls%5B%2A%5D") != std::string::npos);
}
TEST(oai_calls, idempotency_key_only_where_the_spec_allows) {
Rig r;
Json body = Json::object();
Json env = Json::object();
env.set("type", Json("x"));
body.set("environment", env);
r.platform->agent_environments.create(body, "key-123");
ASSERT_EQ(r.last().headers.get_or("Idempotency-Key", ""), "key-123");
ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}}, nullptr, Json::object(),
{{"Idempotency-Key", "k"}}),
ApiError);
ASSERT_THROW(r.platform->agent_environments.create(body, "has space"), ApiError);
ASSERT_THROW(r.platform->generic.invoke(Op::kRetrieveFile, {{"file_id", "a"}}, nullptr, Json::object(),
{{"OpenAI-Beta", "x"}}),
ApiError);
}
TEST(oai_forms, files_create_is_multipart_with_bracket_notation) {
Rig r;
Json exp = Json::object();
exp.set("anchor", Json("created_at"));
exp.set("seconds", Json(3600));
r.platform->files.create("data.jsonl", "{\"a\":1}\n", "fine-tune", "application/jsonl", &exp);
ASSERT_EQ(r.last().method, "POST");
ASSERT_EQ(r.last().target, "/v1/files");
ASSERT_TRUE(r.last().headers.get_or("Content-Type", "").rfind("multipart/form-data; boundary=", 0) == 0);
const std::string& b = r.last().body;
ASSERT_TRUE(b.find("name=\"file\"; filename=\"data.jsonl\"") != std::string::npos);
ASSERT_TRUE(b.find("name=\"purpose\"") != std::string::npos);
ASSERT_TRUE(b.find("fine-tune") != std::string::npos);
ASSERT_TRUE(b.find("name=\"expires_after[anchor]\"") != std::string::npos);
ASSERT_TRUE(b.find("name=\"expires_after[seconds]\"") != std::string::npos);
ASSERT_TRUE(b.find("3600") != std::string::npos);
ASSERT_THROW(r.platform->files.create("x", "d", "bogus-purpose"), ApiError);
ASSERT_THROW(r.platform->files.create("a/b", "d", "batch"), ApiError);
ASSERT_THROW(r.platform->files.create("a\"b", "d", "batch"), ApiError);
ASSERT_THROW(r.platform->files.create("", "d", "batch"), ApiError);
}
TEST(oai_forms, form_fields_are_checked_against_the_table) {
Form f;
f.text("purpose", "batch");
ASSERT_THROW(Calls::check_form(Op::kCreateFile, f.names()), ApiError); // file missing
Form g;
g.file("file", "a", "text/plain", "x");
g.text("purpose", "batch");
g.text("surprise", "1");
ASSERT_THROW(Calls::check_form(Op::kCreateFile, g.names()), ApiError);
ASSERT_THROW(Calls::check_form(Op::kListFiles, {}), ApiError); // not multipart
Form skills;
skills.file("files[]", "SKILL.md", "text/markdown", "# x");
Calls::check_form(Op::kCreateSkill, skills.names());
}
TEST(oai_uploads, plan_and_sequence) {
auto plan = UploadPlan::make(10, 4);
ASSERT_EQ(plan.parts.size(), 3u);
ASSERT_EQ(plan.parts[2].offset, 8u);
ASSERT_EQ(plan.parts[2].size, 2u);
ASSERT_THROW(UploadPlan::make(0, 4), ApiError);
ASSERT_THROW(UploadPlan::make(10, 0), ApiError);
ASSERT_THROW(UploadPlan::make(10, Caps::kMaxUploadPartBytes + 1), ApiError);
ASSERT_THROW(UploadPlan::make(Caps::kMaxFileBytes + 1, Caps::kMaxUploadPartBytes), ApiError);
ASSERT_THROW(UploadPlan::make(Caps::kMaxUploadParts + 1, 1), ApiError);
// The module's own request sequence for a three-part upload. The queued
// bodies only carry the ids the next call needs (documented field `id`).
Rig r;
r.transport->queue = {"{\"id\":\"upload_1\"}", "{\"id\":\"part_1\"}", "{\"id\":\"part_2\"}",
"{\"id\":\"part_3\"}", "{\"id\":\"upload_1\",\"status\":\"completed\"}"};
r.platform->uploads.upload_all("big.jsonl", "application/jsonl", "batch", "0123456789", 4);
ASSERT_EQ(r.sent(), 5u);
ASSERT_EQ(r.transport->seen[0].target, "/v1/uploads");
ASSERT_TRUE(r.transport->seen[0].body.find("\"bytes\":10") != std::string::npos);
ASSERT_EQ(r.transport->seen[1].target, "/v1/uploads/upload_1/parts");
ASSERT_EQ(r.transport->seen[3].target, "/v1/uploads/upload_1/parts");
ASSERT_EQ(r.transport->seen[4].target, "/v1/uploads/upload_1/complete");
ASSERT_EQ(r.transport->seen[4].body, "{\"part_ids\":[\"part_1\",\"part_2\",\"part_3\"]}");
}
TEST(oai_batches, jsonl_builder_caps) {
BatchInput in("/v1/chat/completions");
Json body = Json::object();
body.set("model", Json("gpt-x"));
in.add("req-1", body).add("req-2", body);
ASSERT_EQ(in.size(), 2u);
ASSERT_EQ(in.jsonl().substr(0, in.jsonl().find('\n')),
"{\"body\":{\"model\":\"gpt-x\"},\"custom_id\":\"req-1\",\"method\":\"POST\",\"url\":\"/v1/chat/completions\"}");
ASSERT_THROW(in.add("req-1", body), ApiError);
ASSERT_THROW(in.add("", body), ApiError);
ASSERT_THROW(in.add(std::string(513, 'x'), body), ApiError);
ASSERT_THROW(in.add("r3", Json("not an object")), ApiError);
ASSERT_THROW(BatchInput("/v1/nope"), ApiError);
Rig r;
ASSERT_THROW(r.platform->batches.create("file-1", "/v1/nope"), ApiError);
r.platform->batches.create("file-1", "/v1/embeddings");
ASSERT_EQ(r.last().body, "{\"completion_window\":\"24h\",\"endpoint\":\"/v1/embeddings\",\"input_file_id\":\"file-1\"}");
}
TEST(oai_conversations, twenty_items_at_most) {
Rig r;
Json body = Json::object();
Json items = Json::array();
for (int i = 0; i < 21; ++i) items.push(Json::object());
body.set("items", items);
ASSERT_THROW(r.platform->conversation_items.create("conv_1", body), ApiError);
ASSERT_THROW(r.platform->conversations.create(body), ApiError);
ASSERT_EQ(r.sent(), 0u);
}
TEST(oai_list, walks_cursor_pages_and_reports_truncation) {
// Page shape per the spec's list schemas: data[], has_more, last_id.
Rig r;
r.transport->queue = {"{\"data\":[{\"id\":\"a\"},{\"id\":\"b\"}],\"has_more\":true,\"last_id\":\"b\"}",
"{\"data\":[{\"id\":\"c\"}],\"has_more\":false,\"last_id\":\"c\"}"};
auto l = r.platform->generic.list_all(Op::kListFiles, {}, Json::object(), 5);
ASSERT_EQ(l.pages, 2u);
ASSERT_EQ(l.data.as_array().size(), 3u);
ASSERT_FALSE(l.truncated);
ASSERT_EQ(r.transport->seen[1].target, "/v1/files?after=b");
Rig t;
t.transport->queue = {"{\"data\":[{\"id\":\"a\"}],\"has_more\":true,\"last_id\":\"a\"}",
"{\"data\":[{\"id\":\"b\"}],\"has_more\":true,\"last_id\":\"b\"}"};
auto cut = t.platform->generic.list_all(Op::kListFiles, {}, Json::object(), 2);
ASSERT_TRUE(cut.truncated);
ASSERT_TRUE(cut.has_more);
ASSERT_EQ(cut.stop_reason, "page_cap");
ASSERT_EQ(cut.pages, 2u);
ASSERT_THROW(t.platform->generic.list_all(Op::kRetrieveFile, {{"file_id", "a"}}), ApiError); // not a list
ASSERT_THROW(t.platform->generic.list_all(Op::kListFiles, {}, Json::object(), 0), ApiError);
}
TEST(oai_streams, only_streamable_calls_stream) {
Rig r;
Json body = Json::object();
body.set("assistant_id", Json("asst_1"));
ASSERT_THROW(r.platform->generic.invoke_stream(Op::kRetrieveFile, {{"file_id", "a"}}, Json::object(),
[](const molo::llm::SseEvent&) { return true; }),
ApiError);
// A streamable call sets "stream": true before sending.
r.transport->queue = {"data: [DONE]\n\n"};
r.platform->runs.create_stream("thread_1", body, [](const molo::llm::SseEvent&) { return true; });
ASSERT_EQ(r.last().target, "/v1/threads/thread_1/runs");
ASSERT_TRUE(r.last().body.find("\"stream\":true") != std::string::npos);
ASSERT_EQ(r.last().headers.get_or("OpenAI-Beta", ""), "assistants=v2");
}
TEST(oai_realtime_rest, call_and_secret_requests) {
Rig r;
r.platform->realtime.create_client_secret();
ASSERT_EQ(r.last().target, "/v1/realtime/client_secrets");
ASSERT_THROW(r.platform->realtime.create_call("not sdp"), ApiError);
r.platform->realtime.create_call("v=0\r\no=- 1 1 IN IP4 0.0.0.0\r\n");
ASSERT_EQ(r.last().target, "/v1/realtime/calls");
ASSERT_EQ(r.last().headers.get_or("Content-Type", ""), "application/sdp");
r.platform->realtime.create_call("v=0\r\n", Json::object());
ASSERT_TRUE(r.last().headers.get_or("Content-Type", "").rfind("multipart/form-data", 0) == 0);
ASSERT_TRUE(r.last().body.find("name=\"sdp\"") != std::string::npos);
ASSERT_TRUE(r.last().body.find("name=\"session\"") != std::string::npos);
ASSERT_THROW(r.platform->realtime.refer_call("call_1", "http://x"), ApiError);
r.platform->realtime.refer_call("call_1", "tel:+14155550123");
ASSERT_EQ(r.last().body, "{\"target_uri\":\"tel:+14155550123\"}");
ASSERT_THROW(r.platform->realtime.reject_call("call_1", 200), ApiError);
r.platform->realtime.reject_call("call_1", 486);
ASSERT_EQ(r.last().body, "{\"status_code\":486}");
r.platform->realtime.hangup_call("call_1");
ASSERT_EQ(r.last().target, "/v1/realtime/calls/call_1/hangup");
ASSERT_THROW(r.platform->live.reject("s_1", 0), ApiError);
}