Merge branch 'worktree-agent-a404596e1b4db6b5d'

This commit is contained in:
2026-10-25 15:24:28 +01:00
67 changed files with 6607 additions and 3 deletions
+109
View File
@@ -0,0 +1,109 @@
#pragma once
// Shared test rig: an AzureClient over RecordingTransports. A recorder only
// records what was sent and answers a fixed body (a documented example where
// a call parses its answer, "{}" otherwise); no vendor behavior is scripted.
#include <map>
#include <memory>
#include <mutex>
#include <string>
#include <vector>
#include "clients/transport.h"
#include "framework.h"
#include "llm/error.h"
#include "vendors/azure/client.h"
namespace az_test {
using molo::azure::AzureClient;
using molo::azure::Channel;
using molo::azure::Settings;
using molo::clients::body::Json;
struct Seen {
std::string method;
std::string target; // path?query
std::string body;
molo::clients::HeaderMap headers;
};
class Recorder : public molo::clients::Transport {
public:
const char* name() const override { return "recorder"; }
molo::clients::Task<molo::clients::ClientResponse> send(const molo::clients::ClientRequest& r) override {
Seen s;
s.method = molo::clients::method_name(r.method());
s.target = r.url().target();
s.headers = r.headers();
if (r.has_body() && !r.is_stream_body()) s.body = r.body_bytes();
{
std::lock_guard<std::mutex> lock(mu);
seen.push_back(std::move(s));
}
molo::clients::HeaderMap h;
h.set("Content-Type", content_type);
co_return molo::clients::ClientResponse(status, h, answer);
}
std::mutex mu;
std::vector<Seen> seen;
std::string answer = "{}";
std::string content_type = "application/json";
int status = 200;
};
struct Rig {
std::shared_ptr<AzureClient> client;
std::map<Channel, Recorder*> rec;
explicit Rig(Settings s, molo::azure::EntraTokenSource::Clock clock = nullptr) {
client = AzureClient::create(
std::move(s),
[this](Channel ch) -> std::unique_ptr<molo::clients::Transport> {
auto r = std::make_unique<Recorder>();
rec[ch] = r.get();
return r;
},
std::move(clock));
}
Recorder& openai() { return *rec.at(Channel::kOpenAi); }
Recorder& foundry() { return *rec.at(Channel::kFoundry); }
Recorder& safety() { return *rec.at(Channel::kSafety); }
Recorder& token() { return *rec.at(Channel::kToken); }
const Seen& last() { return openai().seen.back(); }
Json last_body() { return Json::parse(openai().seen.back().body); }
};
inline Settings key_settings(const std::string& version = "") {
Settings s;
s.endpoint = "https://res.openai.azure.com";
s.foundry_endpoint = "https://res.services.ai.azure.com";
s.safety_endpoint = "https://res.cognitiveservices.azure.com";
s.api_key = "az-test-KEY";
s.safety_key = "az-safety-KEY";
s.api_version = molo::azure::ApiVersion::parse(version);
return s;
}
inline Settings entra_settings(const std::string& version = "") {
Settings s = key_settings(version);
s.api_key.clear();
s.safety_key.clear();
s.entra.tenant_id = "contoso.onmicrosoft.com";
s.entra.client_id = "11111111-2222-3333-4444-555555555555";
s.entra.client_secret = "s3cr3t-value";
return s;
}
template <typename F>
bool rejects(F&& fn, const std::string& needle = "") {
try {
fn();
} catch (const molo::llm::ApiError& e) {
return needle.empty() || e.message().find(needle) != std::string::npos;
}
return false;
}
} // namespace az_test
+105
View File
@@ -0,0 +1,105 @@
// Azure: the call table (shape, rendering, ids, fields, queries).
#include <set>
#include "rig.h"
#include "vendors/azure/calls.h"
using namespace molo::azure;
using namespace az_test;
TEST(azure_calls, table_shape) {
ASSERT_EQ(Calls::count(), static_cast<std::size_t>(147));
std::set<std::string> names;
std::size_t openai = 0, foundry = 0, safety = 0, both = 0;
for (std::size_t i = 0; i < Calls::count(); ++i) {
const CallSpec& c = Calls::at(i);
ASSERT_TRUE(names.insert(c.name).second);
ASSERT_EQ(static_cast<std::size_t>(c.op), i); // enum order is table order
ASSERT_TRUE(c.v1.present() || c.dated.present());
for (Side s : {Side::kV1, Side::kDated}) {
if (!c.side(s).present()) continue;
ASSERT_TRUE(std::string(c.side(s).path).rfind("/", 0) == 0);
ASSERT_TRUE(std::string(c.side(s).doc).size() >= 2);
}
(void)Calls::method(c.op);
if (c.surface == Surface::kOpenAi) {
++openai;
if (c.v1.present() && c.dated.present()) ++both;
}
if (c.surface == Surface::kFoundry) ++foundry;
if (c.surface == Surface::kSafety) ++safety;
if (c.surface != Surface::kOpenAi) ASSERT_FALSE(c.v1.present()); // single-sided
}
ASSERT_EQ(foundry, static_cast<std::size_t>(4));
ASSERT_EQ(safety, static_cast<std::size_t>(12));
ASSERT_EQ(openai, static_cast<std::size_t>(131));
ASSERT_TRUE(both > 50);
}
TEST(azure_calls, every_side_renders_with_dummy_ids) {
for (std::size_t i = 0; i < Calls::count(); ++i) {
const CallSpec& c = Calls::at(i);
for (Side s : {Side::kV1, Side::kDated}) {
if (!c.side(s).present()) continue;
std::vector<std::string> ids(Calls::id_count(c.op, s), "id1");
std::string path = Calls::render(c.op, s, ids, "dep1");
ASSERT_TRUE(path.find('{') == std::string::npos);
ASSERT_TRUE(path.find("dep1") != std::string::npos || !c.deployment || s == Side::kV1);
// one id too many and one too few are both rejected
auto more = ids;
more.push_back("x");
ASSERT_TRUE(rejects([&] { Calls::render(c.op, s, more, "dep1"); }));
if (!ids.empty()) {
auto fewer = ids;
fewer.pop_back();
ASSERT_TRUE(rejects([&] { Calls::render(c.op, s, fewer, "dep1"); }));
}
}
}
}
TEST(azure_calls, deployment_paths) {
ASSERT_EQ(Calls::render(Op::kCreateChatCompletion, Side::kDated, {}, "gpt4o"),
std::string("/deployments/gpt4o/chat/completions"));
ASSERT_EQ(Calls::render(Op::kCreateChatCompletion, Side::kV1, {}, "gpt4o"), std::string("/chat/completions"));
ASSERT_EQ(Calls::prefix(Op::kCreateChatCompletion, Side::kV1), std::string("/openai/v1"));
ASSERT_EQ(Calls::prefix(Op::kCreateChatCompletion, Side::kDated), std::string("/openai"));
ASSERT_EQ(Calls::prefix(Op::kFoundryGetChatCompletions, Side::kDated), std::string("/models"));
ASSERT_EQ(Calls::prefix(Op::kSafetyTextOperationsAnalyzeText, Side::kDated), std::string("/contentsafety"));
ASSERT_EQ(Calls::render(Op::kSafetyTextOperationsAnalyzeText, Side::kDated, {}), std::string("/text:analyze"));
ASSERT_EQ(Calls::render(Op::kSafetyTextBlocklistsAddOrUpdateBlocklistItems, Side::kDated, {"my-list"}),
std::string("/text/blocklists/my-list:addOrUpdateBlocklistItems"));
ASSERT_TRUE(rejects([] { Calls::render(Op::kCreateChatCompletion, Side::kDated, {}, "../x"); }, "deployment"));
ASSERT_TRUE(rejects([] { Calls::render(Op::kCreateChatCompletion, Side::kDated, {}, ""); }, "deployment"));
}
TEST(azure_calls, ids_are_single_segments) {
ASSERT_EQ(Calls::render(Op::kRetrieveModel, Side::kV1, {"ft:gpt-4o:org::abc"}), std::string("/models/ft:gpt-4o:org::abc"));
for (const char* bad : {"../x", "a/b", "", "a b", "a?x=1", "%2e%2e", ".."})
ASSERT_TRUE(rejects([&] { Calls::render(Op::kRetrieveFile, Side::kV1, {bad}); }, "bad id"));
}
TEST(azure_calls, fields_and_queries_come_from_the_spec) {
ASSERT_TRUE(Calls::accepts_field(Op::kCreateChatCompletion, Side::kV1, "messages"));
ASSERT_TRUE(Calls::accepts_field(Op::kCreateChatCompletion, Side::kV1, "model"));
ASSERT_FALSE(Calls::accepts_field(Op::kCreateChatCompletion, Side::kDated, "model"));
ASSERT_FALSE(Calls::accepts_field(Op::kCreateChatCompletion, Side::kV1, "nonsense"));
ASSERT_FALSE(Calls::accepts_field(Op::kCreateChatCompletion, Side::kV1, "mess")); // whole-name match
ASSERT_TRUE(Calls::accepts_query(Op::kListFiles, Side::kV1, "after"));
ASSERT_FALSE(Calls::accepts_query(Op::kListFiles, Side::kDated, "after"));
ASSERT_TRUE(Calls::accepts_query(Op::kListFiles, Side::kDated, "purpose"));
ASSERT_TRUE(Calls::accepts_query(Op::kGetResponse, Side::kV1, "include[]"));
ASSERT_TRUE(Calls::accepts_query(Op::kGetResponse, Side::kDated, "include[]"));
ASSERT_FALSE(Calls::accepts_query(Op::kGetResponse, Side::kV1, "api-version")); // the gateway owns it
ASSERT_TRUE(Calls::find("CreateImage") != nullptr);
ASSERT_TRUE(Calls::find("NoSuchCall") == nullptr);
}
TEST(azure_calls, sides_that_exist_only_once) {
ASSERT_FALSE(Calls::has(Op::kCreateAssistant, Side::kV1)); // the v1 documents have no /assistants
ASSERT_TRUE(Calls::has(Op::kCreateAssistant, Side::kDated));
ASSERT_TRUE(Calls::has(Op::kCreateConversation, Side::kV1));
ASSERT_FALSE(Calls::has(Op::kCreateConversation, Side::kDated));
ASSERT_TRUE(Calls::has(Op::kCreateChatCompletion, Side::kV1) && Calls::has(Op::kCreateChatCompletion, Side::kDated));
ASSERT_TRUE(rejects([] { Calls::render(Op::kCreateAssistant, Side::kV1, {}); }, "not available"));
}
+152
View File
@@ -0,0 +1,152 @@
// AzureChatModel: wire bodies per dialect and parsing of the documented
// examples (chat completion, stream transcript, response object).
#include "rig.h"
#include "vendors/azure/chat_model.h"
using namespace molo::azure;
using namespace az_test;
namespace {
// Documented chat completion example (OpenAI / Azure OpenAI reference).
const char kChat[] =
R"({"id":"chatcmpl-123","object":"chat.completion","created":1677652288,"model":"gpt-4o-mini","choices":[{"index":0,"message":{"role":"assistant","content":"Hello there, how may I assist you today?"},"finish_reason":"stop"}],"usage":{"prompt_tokens":9,"completion_tokens":12,"total_tokens":21}})";
// Documented stream transcript (chat.completion.chunk).
const char kStream[] =
"data: {\"id\":\"chatcmpl-123\",\"object\":\"chat.completion.chunk\",\"created\":1694268190,\"model\":\"gpt-4o-mini\",\"choices\":[{\"index\":0,\"delta\":{\"role\":\"assistant\",\"content\":\"\"},\"finish_reason\":null}]}\n\n"
"data: {\"id\":\"chatcmpl-123\",\"object\":\"chat.completion.chunk\",\"created\":1694268190,\"model\":\"gpt-4o-mini\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"Hello\"},\"finish_reason\":null}]}\n\n"
"data: {\"id\":\"chatcmpl-123\",\"object\":\"chat.completion.chunk\",\"created\":1694268190,\"model\":\"gpt-4o-mini\",\"choices\":[{\"index\":0,\"delta\":{},\"finish_reason\":\"stop\"}]}\n\n"
"data: [DONE]\n\n";
// Documented Responses example.
const char kResponse[] =
R"({"id":"resp_67ccd2bed1ec8190b14f964abc0542670bb6a6b452d3795b","object":"response","created_at":1741476542,"status":"completed","model":"gpt-4.1-2025-04-14","output":[{"type":"message","id":"msg_67ccd2bf17f0819081ff3bb2cf6508e60bb6a6b452d3795b","status":"completed","role":"assistant","content":[{"type":"output_text","text":"In a peaceful grove beneath a silver moon, a unicorn named Lumina discovered a hidden pool.","annotations":[]}]}],"usage":{"input_tokens":36,"output_tokens":87,"total_tokens":123}})";
molo::llm::ChatRequest req(const std::string& model = "gpt4o") {
molo::llm::ChatRequest r;
r.model = model;
r.system = "Be brief.";
r.messages.push_back(molo::llm::Message::user("Say hi"));
r.max_tokens = 32;
return r;
}
} // namespace
TEST(azure_chat_model, generate_over_chat_completions_v1) {
Rig rig(key_settings());
rig.openai().answer = kChat;
AzureChatModel m(rig.client);
ASSERT_EQ(m.vendor(), std::string("azure"));
auto out = m.generate(req());
ASSERT_EQ(out.text(), std::string("Hello there, how may I assist you today?"));
ASSERT_EQ(out.finish_reason, std::string("stop"));
ASSERT_EQ(out.usage.total_tokens, 21);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/chat/completions"));
Json b = rig.last_body();
ASSERT_EQ(b.find("model")->as_string(), std::string("gpt4o"));
ASSERT_TRUE(b.has("messages"));
ASSERT_FALSE(b.has("stream"));
}
TEST(azure_chat_model, generate_over_the_dated_api_uses_the_deployment_url) {
Rig rig(key_settings("2024-10-21"));
rig.openai().answer = kChat;
AzureChatModel m(rig.client);
m.generate(req());
ASSERT_EQ(rig.last().target, std::string("/openai/deployments/gpt4o/chat/completions?api-version=2024-10-21"));
ASSERT_FALSE(rig.last_body().has("model"));
}
TEST(azure_chat_model, stream_decodes_the_documented_transcript) {
Rig rig(key_settings());
rig.openai().content_type = "text/event-stream";
rig.openai().answer = kStream;
AzureChatModel m(rig.client);
std::string text, finish;
m.stream(req(), [&](const molo::llm::ChatChunk& c) {
text += c.text_delta;
if (!c.finish_reason.empty()) finish = c.finish_reason;
return true;
});
ASSERT_EQ(text, std::string("Hello"));
ASSERT_EQ(finish, std::string("stop"));
Json b = rig.last_body();
ASSERT_TRUE(b.find("stream")->as_bool());
ASSERT_TRUE(b.find("stream_options")->find("include_usage")->as_bool());
}
TEST(azure_chat_model, stream_stops_when_the_consumer_says_so) {
Rig rig(key_settings());
rig.openai().content_type = "text/event-stream";
rig.openai().answer = kStream;
AzureChatModel m(rig.client);
int calls = 0;
m.stream(req(), [&](const molo::llm::ChatChunk&) { return ++calls < 2; });
ASSERT_EQ(calls, 2);
}
TEST(azure_chat_model, responses_dialect) {
Rig rig(key_settings());
rig.openai().answer = kResponse;
ChatModelConfig cfg;
cfg.dialect = Dialect::kResponses;
AzureChatModel m(rig.client, cfg);
auto out = m.generate(req("gpt41"));
ASSERT_TRUE(out.text().rfind("In a peaceful grove", 0) == 0);
ASSERT_EQ(out.usage.total_tokens, 123);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/responses"));
ASSERT_EQ(rig.last_body().find("model")->as_string(), std::string("gpt41"));
}
TEST(azure_chat_model, foundry_dialect_goes_to_the_model_inference_host) {
Rig rig(key_settings());
rig.foundry().answer = kChat;
ChatModelConfig cfg;
cfg.dialect = Dialect::kFoundry;
cfg.extra_parameters = "drop";
AzureChatModel m(rig.client, cfg);
auto out = m.generate(req("Phi-4"));
ASSERT_TRUE(out.text().rfind("Hello there", 0) == 0);
const Seen& s = rig.foundry().seen.back();
ASSERT_EQ(s.target, std::string("/models/chat/completions?api-version=2024-05-01-preview"));
ASSERT_EQ(s.headers.get_or("extra-parameters", ""), std::string("drop"));
Json b = Json::parse(s.body);
ASSERT_TRUE(b.has("max_tokens"));
ASSERT_FALSE(b.has("max_completion_tokens"));
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
TEST(azure_chat_model, validation_before_traffic) {
Rig rig(key_settings());
AzureChatModel m(rig.client);
molo::llm::ChatRequest r = req();
r.model = "";
ASSERT_TRUE(rejects([&] { m.generate(r); }, "deployment"));
r.model = "bad name";
ASSERT_TRUE(rejects([&] { m.generate(r); }, "deployment"));
r = req();
r.messages.clear();
ASSERT_TRUE(rejects([&] { m.generate(r); }, "messages"));
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
TEST(azure_chat_model, not_configured_is_a_503_before_traffic) {
Settings none;
none.endpoint = "https://res.openai.azure.com";
Rig rig(none);
AzureChatModel m(rig.client);
ASSERT_FALSE(m.configured());
try {
m.generate(req());
FAIL("expected not configured");
} catch (const molo::llm::NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
}
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
TEST(azure_chat_model, wire_body_is_exposed_without_traffic) {
Rig rig(key_settings());
AzureChatModel m(rig.client);
Json b = m.wire_body(req(), false);
ASSERT_EQ(b.find("model")->as_string(), std::string("gpt4o"));
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
+161
View File
@@ -0,0 +1,161 @@
// Microsoft Entra client-credentials flow: wire shape, parsing of the
// documented success body and of an error body observed live (2026-10-25),
// caching, refresh, failure floor, bearer on every surface.
#include "clients/body/form.h"
#include "rig.h"
#include "vendors/azure/entra.h"
#include "vendors/azure/files.h"
#include "vendors/azure/safety.h"
using namespace molo::azure;
using namespace az_test;
namespace {
// Documented success body (Microsoft identity platform, client credentials flow).
const char kOk[] =
R"({"token_type":"Bearer","expires_in":3599,"ext_expires_in":3599,"access_token":"eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIsIng1dCI6Imk2bEdrM0ZaenhSY1ViMkMzbkVRN3N5SEpsWSJ9"})";
// Observed live from login.microsoftonline.com for a client id that does not exist.
const char kErr[] =
R"({"error":"unauthorized_client","error_description":"AADSTS700038: 00000000-0000-0000-0000-000000000000 is not a valid application identifier. Trace ID: 856e791a-6d26-41ce-a6d4-be68759f9101 Correlation ID: 93a74863-808b-4409-88a1-c2563d0fb599 Timestamp: 2026-10-25 09:24:16Z","error_codes":[700038],"timestamp":"2026-10-25 09:24:16Z","trace_id":"856e791a-6d26-41ce-a6d4-be68759f9101","correlation_id":"93a74863-808b-4409-88a1-c2563d0fb599"})";
struct Clock {
std::int64_t now = 1000000;
EntraTokenSource::Clock fn() {
return [this] { return now; };
}
};
} // namespace
TEST(azure_entra, parses_the_documented_success_body) {
auto p = EntraTokenSource::parse(200, kOk);
ASSERT_TRUE(p.access_token.rfind("eyJ0eXAi", 0) == 0);
ASSERT_EQ(p.expires_in, 3599L);
ASSERT_TRUE(rejects([] { EntraTokenSource::parse(200, R"({"token_type":"Bearer","expires_in":3599})"); }, "access_token"));
ASSERT_TRUE(rejects([] { EntraTokenSource::parse(200, R"({"access_token":"x","expires_in":0})"); }, "expires_in"));
ASSERT_TRUE(rejects([] { EntraTokenSource::parse(200, R"({"access_token":"x","expires_in":999999999})"); }, "expires_in"));
ASSERT_TRUE(rejects([] { EntraTokenSource::parse(200, "<html>"); }, "non-JSON"));
ASSERT_EQ(EntraTokenSource::parse(200, R"({"access_token":"x","expires_in":"3600"})").expires_in, 3600L);
}
TEST(azure_entra, parses_the_observed_error_body) {
try {
EntraTokenSource::parse(400, kErr);
FAIL("expected an error");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.http_status(), 400);
ASSERT_EQ(e.type(), std::string("unauthorized_client"));
ASSERT_TRUE(e.message().rfind("AADSTS700038", 0) == 0);
ASSERT_EQ(e.request_id(), std::string("856e791a-6d26-41ce-a6d4-be68759f9101"));
}
}
TEST(azure_entra, exchange_request_has_the_documented_shape) {
Clock clock;
Rig rig(entra_settings(), clock.fn());
rig.token().answer = kOk;
std::string tok = rig.client->tokens()->token();
ASSERT_TRUE(tok.rfind("eyJ0eXAi", 0) == 0);
const Seen& s = rig.token().seen.back();
ASSERT_EQ(s.method, std::string("POST"));
ASSERT_EQ(s.target, std::string("/contoso.onmicrosoft.com/oauth2/v2.0/token"));
ASSERT_EQ(s.headers.get_or("Content-Type", ""), std::string("application/x-www-form-urlencoded"));
auto form = molo::clients::body::UrlEncodedForm::decode(s.body);
std::map<std::string, std::string> f(form.fields().begin(), form.fields().end());
ASSERT_EQ(f["grant_type"], std::string("client_credentials"));
ASSERT_EQ(f["client_id"], std::string("11111111-2222-3333-4444-555555555555"));
ASSERT_EQ(f["client_secret"], std::string("s3cr3t-value"));
ASSERT_EQ(f["scope"], std::string("https://cognitiveservices.azure.com/.default"));
ASSERT_EQ(f.size(), static_cast<std::size_t>(4));
}
TEST(azure_entra, token_is_cached_and_refreshed_before_expiry) {
Clock clock;
Rig rig(entra_settings(), clock.fn());
rig.token().answer = kOk;
auto src = rig.client->tokens();
src->token();
clock.now += 3000; // 599 s left, above the 300 s skew
src->token();
ASSERT_EQ(src->exchanges(), static_cast<std::size_t>(1));
clock.now += 400; // 199 s left: inside the skew, refresh
src->token();
ASSERT_EQ(src->exchanges(), static_cast<std::size_t>(2));
ASSERT_EQ(src->expires_at(), clock.now + 3599);
}
TEST(azure_entra, failed_exchange_has_a_floor_and_never_leaks_the_secret) {
Clock clock;
Rig rig(entra_settings(), clock.fn());
rig.token().status = 400;
rig.token().answer = kErr;
auto src = rig.client->tokens();
try {
src->token();
FAIL("expected failure");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.type(), std::string("unauthorized_client"));
ASSERT_TRUE(std::string(e.what()).find("s3cr3t-value") == std::string::npos);
}
// Within the floor: no second network call.
try {
src->token();
FAIL("expected backoff");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.type(), std::string("TOKEN_BACKOFF"));
ASSERT_EQ(e.http_status(), 503);
ASSERT_TRUE(std::string(e.what()).find("s3cr3t-value") == std::string::npos);
}
ASSERT_EQ(src->exchanges(), static_cast<std::size_t>(1));
clock.now += 5; // floor passed: one more try
rig.token().status = 200;
rig.token().answer = kOk;
ASSERT_FALSE(src->token().empty());
ASSERT_EQ(src->exchanges(), static_cast<std::size_t>(2));
}
TEST(azure_entra, every_surface_sends_the_bearer_token) {
Clock clock;
Rig rig(entra_settings(), clock.fn());
rig.token().answer = kOk;
FilesService f(rig.client);
f.get("file-1");
std::string want = "Bearer " + rig.client->tokens()->token();
ASSERT_EQ(rig.last().headers.get_or("Authorization", ""), want);
ASSERT_FALSE(rig.last().headers.has("api-key"));
SafetyService s(rig.client);
s.list_blocklists();
ASSERT_EQ(rig.safety().seen.back().headers.get_or("Authorization", ""), want);
ASSERT_FALSE(rig.safety().seen.back().headers.has("Ocp-Apim-Subscription-Key"));
ASSERT_EQ(rig.client->tokens()->exchanges(), static_cast<std::size_t>(1)); // one token serves all
ASSERT_TRUE(rig.last().target.find("eyJ") == std::string::npos);
}
TEST(azure_entra, a_failed_exchange_fails_the_api_call_without_sending_it) {
Clock clock;
Rig rig(entra_settings(), clock.fn());
rig.token().status = 400;
rig.token().answer = kErr;
FilesService f(rig.client);
ASSERT_TRUE(rejects([&] { f.get("file-1"); }, "AADSTS700038"));
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
TEST(azure_entra, key_wins_and_no_exchange_happens_in_key_mode) {
Settings s = entra_settings();
s.api_key = "k";
s.safety_key = "k";
Rig rig(s);
ASSERT_TRUE(rig.client->tokens() == nullptr);
ASSERT_TRUE(rig.client->auth() == AuthKind::kApiKey);
ASSERT_EQ(rig.rec.count(Channel::kToken), static_cast<std::size_t>(0)); // no token transport at all
}
TEST(azure_entra, sovereign_authority_hosts) {
Settings s = entra_settings();
s.entra.authority = "https://login.microsoftonline.us";
Rig rig(s);
rig.token().answer = kOk;
rig.client->tokens()->token();
ASSERT_EQ(rig.token().seen.back().target, std::string("/contoso.onmicrosoft.com/oauth2/v2.0/token"));
ASSERT_EQ(s.entra.token_url(), std::string("https://login.microsoftonline.us/contoso.onmicrosoft.com/oauth2/v2.0/token"));
}
+239
View File
@@ -0,0 +1,239 @@
// Azure gateway: api side and api-version choice, path building, body and
// query rules, credentials on the wire, caps. Recorders only record.
#include "rig.h"
#include "vendors/azure/assistants.h"
#include "vendors/azure/chat.h"
#include "vendors/azure/files.h"
#include "vendors/azure/foundry.h"
#include "vendors/azure/responses.h"
#include "vendors/azure/safety.h"
using namespace molo::azure;
using namespace az_test;
namespace {
Json chat_body() {
return Json::parse(R"({"messages":[{"role":"user","content":"hi"}],"max_tokens":16})");
}
} // namespace
TEST(azure_gateway, v1_chat_puts_deployment_in_the_body_and_omits_api_version) {
Rig rig(key_settings());
ChatService chat(rig.client);
chat.create("gpt4o", chat_body());
ASSERT_EQ(rig.last().method, std::string("POST"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/chat/completions"));
ASSERT_EQ(rig.last_body().find("model")->as_string(), std::string("gpt4o"));
}
TEST(azure_gateway, preview_adds_api_version_preview) {
Rig rig(key_settings("preview"));
ChatService chat(rig.client);
chat.create("gpt4o", chat_body());
ASSERT_EQ(rig.last().target, std::string("/openai/v1/chat/completions?api-version=preview"));
}
TEST(azure_gateway, dated_chat_puts_deployment_in_the_url_and_drops_model) {
Rig rig(key_settings("2024-10-21"));
ChatService chat(rig.client);
Json body = chat_body();
body.set("model", Json("gpt4o")); // allowed when equal to the deployment, then dropped
chat.create("gpt4o", body);
ASSERT_EQ(rig.last().target, std::string("/openai/deployments/gpt4o/chat/completions?api-version=2024-10-21"));
ASSERT_FALSE(rig.last_body().has("model"));
ASSERT_TRUE(rig.last_body().has("messages"));
}
TEST(azure_gateway, model_must_match_the_deployment) {
Rig rig(key_settings());
ChatService chat(rig.client);
Json body = chat_body();
body.set("model", Json("other"));
ASSERT_TRUE(rejects([&] { chat.create("gpt4o", body); }, "deployment"));
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
TEST(azure_gateway, unknown_fields_are_rejected_before_traffic) {
Rig rig(key_settings());
ChatService chat(rig.client);
Json body = chat_body();
body.set("not_a_field", Json(1));
ASSERT_TRUE(rejects([&] { chat.create("gpt4o", body); }, "not_a_field"));
ASSERT_TRUE(rejects([&] { chat.create("gpt4o", Json::object()); }, "messages"));
ASSERT_TRUE(rejects([&] { chat.create("bad name", chat_body()); }, "deployment"));
ASSERT_TRUE(rejects([&] { chat.create("", chat_body()); }, "deployment"));
ASSERT_TRUE(rejects([&] { chat.create(std::string(65, 'a'), chat_body()); }, "deployment"));
ASSERT_TRUE(rejects([&] { chat.create("gpt4o", Json::parse("[1]")); }, "object"));
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
TEST(azure_gateway, dated_only_operations_use_the_fallback_version_under_v1) {
Rig rig(key_settings());
AssistantsService a(rig.client);
a.get_assistant("asst_1");
ASSERT_EQ(rig.last().target, std::string("/openai/assistants/asst_1?api-version=2025-04-01-preview"));
Rig dated(key_settings("2024-10-21"));
AssistantsService b(dated.client);
b.get_assistant("asst_1");
ASSERT_EQ(dated.last().target, std::string("/openai/assistants/asst_1?api-version=2024-10-21"));
}
TEST(azure_gateway, v1_only_operations_use_preview_under_a_dated_version) {
Rig rig(key_settings("2024-10-21"));
molo::azure::Route r = AzureService(rig.client, Surface::kOpenAi).route(Op::kCreateConversation);
ASSERT_TRUE(r.side == Side::kV1);
ASSERT_EQ(r.version, std::string("preview"));
ASSERT_EQ(r.path, std::string("/openai/v1/conversations"));
}
TEST(azure_gateway, shared_operations_follow_the_configured_api) {
Rig v1(key_settings());
Rig dated(key_settings("2025-04-01-preview"));
AzureService a(v1.client, Surface::kOpenAi), b(dated.client, Surface::kOpenAi);
ASSERT_EQ(a.request_path(Op::kRetrieveFile, {"", {"file-1"}}), std::string("/openai/v1/files/file-1"));
ASSERT_EQ(b.request_path(Op::kRetrieveFile, {"", {"file-1"}}),
std::string("/openai/files/file-1?api-version=2025-04-01-preview"));
ASSERT_EQ(b.request_path(Op::kListModels), std::string("/openai/models?api-version=2025-04-01-preview"));
}
TEST(azure_gateway, query_names_come_from_the_spec_and_are_encoded) {
Rig rig(key_settings());
FilesService f(rig.client);
f.list("fine-tune", [] {
ListParams p;
p.limit = 5;
p.order = "desc";
return p;
}());
ASSERT_EQ(rig.last().target, std::string("/openai/v1/files?purpose=fine-tune&limit=5&order=desc"));
Rig dated(key_settings("2024-10-21"));
FilesService g(dated.client);
ListParams p;
p.limit = 5;
ASSERT_TRUE(rejects([&] { g.list("", p); }, "limit")); // the dated spec only lists purpose
ASSERT_EQ(dated.openai().seen.size(), static_cast<std::size_t>(0));
ResponsesService r(rig.client);
r.retrieve("resp_1", {"file_search_call.results", "a b"});
// clients::Url percent-encodes the brackets of query names (src/llm/SPEC.md gap); servers decode them.
std::string t = rig.last().target;
ASSERT_TRUE(t.find("include%5B%5D=file_search_call.results") != std::string::npos ||
t.find("include[]=file_search_call.results") != std::string::npos);
ASSERT_TRUE(t.find("=a%20b") != std::string::npos);
ListParams bad;
bad.limit = 101;
ASSERT_TRUE(rejects([&] { f.list("", bad); }, "limit"));
bad.limit = 1;
bad.order = "sideways";
ASSERT_TRUE(rejects([&] { f.list("", bad); }, "order"));
}
TEST(azure_gateway, ids_are_validated_before_a_path_is_built) {
Rig rig(key_settings());
FilesService f(rig.client);
for (const char* bad : {"../x", "a/b", "", "a b"}) ASSERT_TRUE(rejects([&] { f.get(bad); }, "bad file id"));
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
}
TEST(azure_gateway, key_goes_in_a_header_only) {
Rig rig(key_settings());
FilesService f(rig.client);
f.get("file-1");
ASSERT_EQ(rig.last().headers.get_or("api-key", ""), std::string("az-test-KEY"));
ASSERT_FALSE(rig.last().headers.has("Authorization"));
ASSERT_TRUE(rig.last().target.find("az-test-KEY") == std::string::npos);
SafetyService s(rig.client);
s.list_blocklists();
const Seen& seen = rig.safety().seen.back();
ASSERT_EQ(seen.headers.get_or("Ocp-Apim-Subscription-Key", ""), std::string("az-safety-KEY"));
ASSERT_FALSE(seen.headers.has("api-key"));
FoundryService fy(rig.client);
fy.info();
ASSERT_EQ(rig.foundry().seen.back().headers.get_or("api-key", ""), std::string("az-test-KEY"));
}
TEST(azure_gateway, errors_never_carry_the_key) {
Rig rig(key_settings());
rig.openai().status = 401;
rig.openai().answer =
R"({"error":{"code":"401","message":"Access denied due to invalid subscription key or wrong API endpoint."}})";
FilesService f(rig.client);
try {
f.get("file-1");
FAIL("expected 401");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.http_status(), 401);
ASSERT_EQ(e.type(), std::string("401"));
ASSERT_TRUE(std::string(e.what()).find("az-test-KEY") == std::string::npos);
}
}
TEST(azure_gateway, not_configured_means_no_traffic) {
Settings none;
none.endpoint = "https://res.openai.azure.com";
Rig rig(none);
FilesService f(rig.client);
ASSERT_FALSE(f.configured());
try {
f.get("file-1");
FAIL("expected not configured");
} catch (const molo::llm::NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
ASSERT_EQ(e.type(), std::string("NOT_CONFIGURED"));
}
ASSERT_EQ(rig.openai().seen.size(), static_cast<std::size_t>(0));
Settings no_endpoint;
no_endpoint.api_key = "k";
Rig rig2(no_endpoint);
FilesService g(rig2.client);
try {
g.get("file-1");
FAIL("expected not configured");
} catch (const molo::llm::NotConfiguredError& e) {
ASSERT_TRUE(e.message().find("AZURE_OPENAI_ENDPOINT") != std::string::npos);
}
}
TEST(azure_gateway, a_service_refuses_operations_of_another_surface) {
Rig rig(key_settings());
AzureService openai(rig.client, Surface::kOpenAi);
ASSERT_TRUE(rejects([&] { openai.call(Op::kFoundryGetModelInfo); }, "does not belong"));
}
TEST(azure_gateway, list_walk_is_capped_and_reports_truncation) {
Rig rig(key_settings());
rig.openai().answer = R"({"object":"list","data":[{"id":"a"}],"has_more":true,"last_id":"a"})";
AzureService s(rig.client, Surface::kOpenAi);
Listing l = s.walk(Op::kListVectorStores, {}, ListParams(), Query(), 3);
// last_id == the cursor after the first page: the walk stops loudly instead of looping
ASSERT_TRUE(l.truncated);
ASSERT_TRUE(l.pages <= 3);
ASSERT_TRUE(rejects([&] { s.walk(Op::kListVectorStores, {}, ListParams(), Query(), 0); }, "max_pages"));
ASSERT_TRUE(rejects([&] { s.walk(Op::kListVectorStores, {}, ListParams(), Query(), 21); }, "max_pages"));
}
TEST(azure_gateway, list_walk_follows_cursors_and_stops_at_the_cap) {
Rig rig(key_settings());
AzureService s(rig.client, Surface::kOpenAi);
rig.openai().answer = R"({"data":[{"id":"x"}],"has_more":false})";
Listing l = s.walk(Op::kListVectorStores, {}, ListParams(), Query(), 5);
ASSERT_FALSE(l.truncated);
ASSERT_EQ(l.items.size(), static_cast<std::size_t>(1));
ASSERT_EQ(l.pages, static_cast<std::size_t>(1));
}
TEST(azure_gateway, stream_requires_a_streaming_operation_and_sets_stream_true) {
Rig rig(key_settings());
rig.openai().content_type = "text/event-stream";
rig.openai().answer = "data: {\"id\":\"1\"}\n\ndata: [DONE]\n\n";
ChatService chat(rig.client);
std::size_t n = 0;
chat.stream("gpt4o", chat_body(), [&](const Json& c) {
++n;
ASSERT_EQ(c.find("id")->as_string(), std::string("1"));
return true;
});
ASSERT_EQ(n, static_cast<std::size_t>(1));
ASSERT_TRUE(rig.last_body().find("stream")->as_bool());
AzureService s(rig.client, Surface::kOpenAi);
ASSERT_TRUE(rejects([&] { s.call_stream(Op::kRetrieveFile, {"", {"f"}}, Json::object(), [](const molo::llm::SseEvent&) { return true; }); }));
}
+108
View File
@@ -0,0 +1,108 @@
// Azure: opt-in live checks. MOLO_LIVE_NET=1 enables them.
// - Unauthenticated probes (no credential needed): the Entra token endpoint
// answers the documented error for a client id that does not exist, and the
// regional Azure OpenAI / Content Safety host answers 401 with the
// documented error body for a bad key.
// - With AZURE_OPENAI_ENDPOINT + a credential (key, or tenant / client id /
// secret): read-only models list. One smallest chat completion needs
// MOLO_LIVE_PAID=1 and AZURE_OPENAI_DEPLOYMENT.
// Everything else prints a loud SKIP. Nothing is created, updated or deleted.
#include <cstdlib>
#include <iostream>
#include "clients/transports/http_transport.h"
#include "llm/config.h"
#include "rig.h"
#include "vendors/azure/chat_model.h"
#include "vendors/azure/models.h"
#include "vendors/azure/safety.h"
using namespace molo::azure;
using namespace az_test;
namespace {
// Read once at static init: other suites in this binary edit the environment.
const bool kNet = std::getenv("MOLO_LIVE_NET") && std::string(std::getenv("MOLO_LIVE_NET")) == "1";
const bool kPaid = std::getenv("MOLO_LIVE_PAID") && std::string(std::getenv("MOLO_LIVE_PAID")) == "1";
const std::string kEndpoint = molo::llm::Config::get("AZURE_OPENAI_ENDPOINT");
const std::string kKey = molo::llm::Config::get("AZURE_OPENAI_API_KEY");
const std::string kTenant = molo::llm::Config::get("AZURE_TENANT_ID");
const std::string kDeployment = molo::llm::Config::get("AZURE_OPENAI_DEPLOYMENT");
std::shared_ptr<AzureClient> http_client(Settings s) {
return AzureClient::create(std::move(s), [](Channel) -> std::unique_ptr<molo::clients::Transport> {
return std::make_unique<molo::clients::transports::HttpTransport>();
});
}
} // namespace
TEST(azure_live, entra_token_endpoint_answers_the_documented_error) {
if (!kNet) {
std::cout << "SKIP azure_live entra probe: MOLO_LIVE_NET=1 not set\n";
return;
}
Settings s = entra_settings();
s.entra.client_id = "00000000-0000-0000-0000-000000000000";
auto client = http_client(s);
try {
client->tokens()->token();
FAIL("expected an AAD error");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.http_status(), 400);
ASSERT_EQ(e.type(), std::string("unauthorized_client"));
ASSERT_TRUE(e.message().rfind("AADSTS", 0) == 0);
std::cout << " probe: " << e.http_status() << " " << e.type() << " " << e.message().substr(0, 40) << "\n";
}
}
TEST(azure_live, regional_host_answers_401_for_a_bad_key) {
if (!kNet) {
std::cout << "SKIP azure_live host probe: MOLO_LIVE_NET=1 not set\n";
return;
}
Settings s;
s.endpoint = "https://eastus.api.cognitive.microsoft.com";
s.safety_endpoint = s.endpoint;
s.api_key = "invalid-probe-key";
s.safety_key = "invalid-probe-key";
auto client = http_client(s);
ModelsService models(client);
try {
models.list();
FAIL("expected 401");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.http_status(), 401);
ASSERT_EQ(e.type(), std::string("401"));
ASSERT_TRUE(e.message().find("invalid subscription key") != std::string::npos);
}
SafetyService safety(client);
try {
safety.analyze_text(Json::parse(R"({"text":"hello"})"));
FAIL("expected 401");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.http_status(), 401);
}
}
TEST(azure_live, models_list_and_one_tiny_completion) {
bool have_cred = !kKey.empty() || !kTenant.empty();
if (!kNet || kEndpoint.empty() || !have_cred) {
std::cout << "SKIP azure_live models: needs MOLO_LIVE_NET=1, AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY"
" (or AZURE_TENANT_ID / AZURE_CLIENT_ID / AZURE_CLIENT_SECRET)\n";
return;
}
auto client = AzureClient::from_env();
ModelsService models(client);
ASSERT_TRUE(!models.ids().empty());
if (!kPaid || kDeployment.empty()) {
std::cout << "SKIP azure_live completion: needs MOLO_LIVE_PAID=1 and AZURE_OPENAI_DEPLOYMENT\n";
return;
}
AzureChatModel model(client);
molo::llm::ChatRequest in;
in.model = kDeployment;
in.messages.push_back(molo::llm::Message::user("Reply with the single word: ok"));
in.max_tokens = 16;
auto out = model.generate(in);
ASSERT_TRUE(!out.text().empty());
}
+145
View File
@@ -0,0 +1,145 @@
// Azure realtime: URL builder, header choice, and a WebSocket session over a
// test-owned loopback server (the protocol is not Microsoft's to script; the
// server only speaks RFC 6455).
#include "../../google/live/loopback.h"
#include "rig.h"
#include "vendors/azure/realtime.h"
using namespace molo::azure;
using namespace az_test;
using live_test::LoopbackServer;
using live_test::ServerConn;
namespace {
Settings local(const LoopbackServer& s, const std::string& version = "") {
Settings st = key_settings(version);
st.endpoint = "http://127.0.0.1:" + std::to_string(s.port());
return st;
}
bool contains(const std::string& hay, const std::string& needle) { return hay.find(needle) != std::string::npos; }
} // namespace
TEST(azure_realtime, urls_per_api) {
Settings s = key_settings();
ASSERT_EQ(RealtimeUrl::build(s, "gpt-rt"), std::string("wss://res.openai.azure.com/openai/v1/realtime?model=gpt-rt"));
s = key_settings("preview");
ASSERT_EQ(RealtimeUrl::build(s, "gpt-rt"),
std::string("wss://res.openai.azure.com/openai/v1/realtime?model=gpt-rt&api-version=preview"));
s = key_settings("2025-04-01-preview");
ASSERT_EQ(RealtimeUrl::build(s, "gpt-rt"),
std::string("wss://res.openai.azure.com/openai/realtime?api-version=2025-04-01-preview&deployment=gpt-rt"));
ASSERT_TRUE(rejects([&] { RealtimeUrl::build(s, "bad name"); }, "deployment"));
ASSERT_TRUE(rejects([&] { RealtimeUrl::build(s, ""); }, "deployment"));
ASSERT_TRUE(RealtimeUrl::build(s, "gpt-rt").find("az-test-KEY") == std::string::npos);
Settings none;
ASSERT_TRUE(rejects([&] { RealtimeUrl::build(none, "d"); }, "endpoint"));
}
TEST(azure_realtime, not_configured_means_no_connection) {
Settings none;
none.endpoint = "https://res.openai.azure.com";
Rig rig(none);
RealtimeSocket sock(rig.client);
try {
sock.connect("gpt-rt");
FAIL("expected not configured");
} catch (const molo::llm::NotConfiguredError& e) {
ASSERT_EQ(e.http_status(), 503);
}
ASSERT_FALSE(sock.connected());
ASSERT_TRUE(rejects([&] { sock.send(Json::parse(R"({"type":"x"})")); }, "not connected"));
}
TEST(azure_realtime, session_over_a_loopback_server) {
std::string got;
LoopbackServer server([&](ServerConn& c) {
c.send_text(R"({"type":"session.created","session":{"id":"sess_1"}})");
auto m = c.read_message();
if (m) got = *m;
c.send_text(R"({"type":"response.done"})");
c.send_close(1000);
});
Rig rig(local(server));
RealtimeSocket sock(rig.client);
sock.connect("gpt-rt");
ASSERT_TRUE(sock.connected());
sock.send(Json::parse(R"({"type":"response.create"})"));
std::vector<std::string> types;
RealtimeStats st = sock.run(
[&](const Json& ev) {
types.push_back(ev.find("type")->as_string());
return true;
},
5);
ASSERT_EQ(types.size(), static_cast<std::size_t>(2));
ASSERT_EQ(types[0], std::string("session.created"));
ASSERT_EQ(types[1], std::string("response.done"));
ASSERT_EQ(st.stop_reason, std::string("closed"));
ASSERT_EQ(st.close_code, 1000);
ASSERT_EQ(got, std::string(R"({"type":"response.create"})"));
std::string req = server.request();
ASSERT_TRUE(contains(req, "GET /openai/v1/realtime?model=gpt-rt HTTP/1.1"));
ASSERT_TRUE(contains(req, "api-key: az-test-KEY"));
ASSERT_FALSE(contains(req, "Authorization"));
sock.close();
ASSERT_FALSE(sock.connected());
}
TEST(azure_realtime, dated_url_reaches_the_server) {
LoopbackServer server([](ServerConn& c) { c.send_close(1000); });
Rig rig(local(server, "2025-04-01-preview"));
RealtimeSocket sock(rig.client);
sock.connect("gpt-rt");
ASSERT_TRUE(contains(server.request(), "GET /openai/realtime?api-version=2025-04-01-preview&deployment=gpt-rt "));
RealtimeStats st = sock.run([](const Json&) { return true; }, 2);
ASSERT_EQ(st.stop_reason, std::string("closed"));
}
TEST(azure_realtime, entra_uses_a_bearer_header) {
LoopbackServer server([](ServerConn& c) { c.send_close(1000); });
Settings s = entra_settings();
s.endpoint = "http://127.0.0.1:" + std::to_string(server.port());
Rig rig(s);
rig.token().answer = R"({"token_type":"Bearer","expires_in":3599,"access_token":"tok-rt"})";
RealtimeSocket sock(rig.client);
sock.connect("gpt-rt");
std::string req = server.request();
ASSERT_TRUE(contains(req, "Authorization: Bearer tok-rt"));
ASSERT_FALSE(contains(req, "api-key"));
}
TEST(azure_realtime, caps_and_validation) {
LoopbackServer server([](ServerConn& c) {
for (int i = 0; i < 5; ++i) c.send_text(R"({"type":"x"})");
c.read_message();
});
Rig rig(local(server));
RealtimeSocket sock(rig.client);
sock.connect("gpt-rt");
ASSERT_TRUE(rejects([&] { sock.send(Json::object()); }, "type"));
ASSERT_TRUE(rejects([&] { sock.send(Json::parse(R"({"type":""})")); }, "type"));
Json big = Json::object();
big.set("type", Json("x"));
big.set("pad", Json(std::string(RealtimeSocket::kMaxEventBytes + 1, 'a')));
ASSERT_TRUE(rejects([&] { sock.send(big); }, "byte cap"));
ASSERT_TRUE(rejects([&] { sock.run([](const Json&) { return true; }, 0); }, "seconds"));
ASSERT_TRUE(rejects([&] { sock.run([](const Json&) { return true; }, 3601); }, "seconds"));
std::size_t seen = 0;
RealtimeStats st = sock.run([&](const Json&) { return ++seen < 3; }, 5);
ASSERT_EQ(st.stop_reason, std::string("sink_stopped"));
ASSERT_EQ(seen, static_cast<std::size_t>(3));
ASSERT_TRUE(rejects([&] { sock.connect("gpt-rt"); }, "already connected"));
}
TEST(azure_realtime, refused_upgrade_is_an_api_error) {
LoopbackServer server([](ServerConn&) {}, LoopbackServer::Handshake::Status403);
Rig rig(local(server));
RealtimeSocket sock(rig.client);
try {
sock.connect("gpt-rt");
FAIL("expected a refused upgrade");
} catch (const molo::llm::ApiError& e) {
ASSERT_EQ(e.http_status(), 403);
ASSERT_EQ(e.type(), std::string("HANDSHAKE_REFUSED"));
}
}
+419
View File
@@ -0,0 +1,419 @@
// Azure services: request shapes per concern (paths, methods, bodies, content
// types) over recorders, plus validation and caps. Answers that a call parses
// are the documented examples (labelled), nothing else is scripted.
#include <set>
#include "rig.h"
#include "vendors/azure/assistants.h"
#include "vendors/azure/audio.h"
#include "vendors/azure/batches.h"
#include "vendors/azure/chat.h"
#include "vendors/azure/embeddings.h"
#include "vendors/azure/files.h"
#include "vendors/azure/fine_tuning.h"
#include "vendors/azure/foundry.h"
#include "vendors/azure/images.h"
#include "vendors/azure/models.h"
#include "vendors/azure/operations.h"
#include "vendors/azure/realtime.h"
#include "vendors/azure/responses.h"
#include "vendors/azure/safety.h"
#include "vendors/azure/vector_stores.h"
using namespace molo::azure;
using namespace az_test;
namespace {
bool contains(const std::string& hay, const std::string& needle) { return hay.find(needle) != std::string::npos; }
// A text part exactly as MultipartBody encodes it.
std::string part(const std::string& name, const std::string& value) {
return "name=\"" + name + "\"\r\nContent-Type: text/plain\r\n\r\n" + value;
}
} // namespace
TEST(azure_services, embeddings_parse_the_documented_example) {
// Documented example: Azure OpenAI embeddings reference (shape: data[].embedding).
Rig rig(key_settings("2024-10-21"));
rig.openai().answer =
R"({"object":"list","data":[{"object":"embedding","index":0,"embedding":[0.0023064255,-0.009327292,0.5]}],"model":"text-embedding-ada-002","usage":{"prompt_tokens":5,"total_tokens":5}})";
EmbeddingsService e(rig.client);
auto v = e.embed("emb", {"hello"}, 3);
ASSERT_EQ(v.size(), static_cast<std::size_t>(1));
ASSERT_EQ(v[0].size(), static_cast<std::size_t>(3));
ASSERT_EQ(rig.last().target, std::string("/openai/deployments/emb/embeddings?api-version=2024-10-21"));
ASSERT_EQ(rig.last_body().find("dimensions")->as_int(), 3L);
ASSERT_TRUE(rejects([&] { e.embed("emb", {}); }, "texts"));
ASSERT_TRUE(rejects([&] { e.embed("emb", {""}); }, "text"));
Json many = Json::array();
for (int i = 0; i < 2049; ++i) many.push(Json("x"));
Json b = Json::object();
b.set("input", many);
ASSERT_TRUE(rejects([&] { e.create("emb", b); }, "2048"));
}
TEST(azure_services, completions_need_a_prompt) {
Rig rig(key_settings());
CompletionsService c(rig.client);
ASSERT_TRUE(rejects([&] { c.create("d", Json::object()); }, "prompt"));
Json b = Json::object();
b.set("prompt", Json("hi"));
c.create("d", b);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/completions"));
}
TEST(azure_services, images_generate_and_edit) {
Rig rig(key_settings());
ImagesService im(rig.client);
Json b = Json::object();
b.set("prompt", Json("a cat"));
b.set("size", Json("1024x1024"));
im.generate("img", b);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/images/generations"));
ASSERT_EQ(rig.last_body().find("model")->as_string(), std::string("img"));
ASSERT_TRUE(rejects([&] { im.generate("img", Json::object()); }, "prompt"));
Json big = Json::object();
big.set("prompt", Json(std::string(32001, 'x')));
ASSERT_TRUE(rejects([&] { im.generate("img", big); }, "32000"));
UploadFile png{"a.png", "image/png", "PNGDATA"};
im.edit("img", "add a hat", {png}, std::nullopt, {{"n", "1"}});
ASSERT_TRUE(contains(rig.last().headers.get_or("Content-Type", ""), "multipart/form-data"));
ASSERT_TRUE(contains(rig.last().body, part("model", "img")));
ASSERT_TRUE(contains(rig.last().body, "name=\"image\"; filename=\"a.png\""));
ASSERT_TRUE(contains(rig.last().body, "name=\"prompt\""));
im.edit("img", "x", {png, png}, UploadFile{"m.png", "image/png", "M"});
ASSERT_TRUE(contains(rig.last().body, "name=\"image[]\""));
ASSERT_TRUE(contains(rig.last().body, "name=\"mask\""));
ASSERT_TRUE(rejects([&] { im.edit("img", "x", {}); }, "1..16"));
ASSERT_TRUE(rejects([&] { im.edit("img", "x", {UploadFile{"e.png", "image/png", ""}}); }, "empty"));
ASSERT_TRUE(rejects([&] { im.edit("img", "x", {png}, std::nullopt, {{"bogus", "1"}}); }, "bogus"));
Rig dated(key_settings("2025-04-01-preview"));
ImagesService di(dated.client);
di.edit("img", "x", {png});
ASSERT_EQ(dated.last().target, std::string("/openai/deployments/img/images/edits?api-version=2025-04-01-preview"));
ASSERT_FALSE(contains(dated.last().body, "name=\"model\""));
di.variation("img", png); // v1-only operation, preview fallback
ASSERT_EQ(dated.last().target, std::string("/openai/v1/images/variations?api-version=preview"));
ASSERT_TRUE(contains(dated.last().body, part("model", "img")));
}
TEST(azure_services, audio_speech_transcription_translation) {
Rig rig(key_settings());
rig.openai().content_type = "audio/mpeg";
rig.openai().answer = "ID3BYTES";
AudioService a(rig.client);
Json b = Json::object();
b.set("input", Json("Hello"));
b.set("voice", Json("alloy"));
auto sp = a.speech("tts", b);
ASSERT_EQ(sp.body, std::string("ID3BYTES"));
ASSERT_EQ(sp.content_type, std::string("audio/mpeg"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/audio/speech"));
ASSERT_EQ(rig.last().headers.get_or("Content-Type", ""), std::string("application/json"));
ASSERT_TRUE(rejects([&] { a.speech("tts", Json::parse(R"({"voice":"alloy"})")); }, "input"));
Json longb = b;
longb.set("input", Json(std::string(4097, 'x')));
ASSERT_TRUE(rejects([&] { a.speech("tts", longb); }, "4096"));
rig.openai().content_type = "application/json";
rig.openai().answer = R"({"text":"Hello world"})";
UploadFile wav{"a.wav", "audio/wav", "RIFF"};
auto t = a.transcribe("whisper", wav, {{"language", "en"}, {"response_format", "json"}});
ASSERT_EQ(AudioService::as_json(t).find("text")->as_string(), std::string("Hello world"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/audio/transcriptions"));
ASSERT_TRUE(contains(rig.last().body, "name=\"file\"; filename=\"a.wav\""));
ASSERT_TRUE(contains(rig.last().body, part("language", "en")));
rig.openai().content_type = "text/plain";
rig.openai().answer = "1\n00:00:00,000 --> 00:00:01,000\nHi\n";
auto srt = a.transcribe("whisper", wav, {{"response_format", "srt"}});
ASSERT_EQ(AudioService::as_json(srt).find("text")->as_string(), srt.body);
a.translate("whisper", wav);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/audio/translations"));
UploadFile huge{"h.wav", "audio/wav", std::string(25u * 1024u * 1024u + 1, 'x')};
ASSERT_TRUE(rejects([&] { a.transcribe("whisper", huge); }, "25 MiB"));
ASSERT_TRUE(rejects([&] { a.transcribe("whisper", UploadFile{"", "audio/wav", "x"}); }, "filename"));
ASSERT_TRUE(rejects([&] { a.transcribe("whisper", wav, {{"nonsense", "1"}}); }, "nonsense"));
Rig dated(key_settings("2024-10-21"));
AudioService d(dated.client);
d.transcribe("whisper", wav);
ASSERT_EQ(dated.last().target, std::string("/openai/deployments/whisper/audio/transcriptions?api-version=2024-10-21"));
}
TEST(azure_services, responses_calls) {
Rig rig(key_settings());
ResponsesService r(rig.client);
Json b = Json::parse(R"({"model":"gpt41","input":"hi"})");
r.create(b);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/responses"));
ASSERT_TRUE(rejects([&] { r.create(Json::parse(R"({"input":"hi"})")); }, "model"));
ASSERT_TRUE(rejects([&] { r.create(Json::parse(R"({"model":"x","input":"hi","stream":true})")); }, "stream()"));
r.retrieve("resp_1");
ASSERT_EQ(rig.last().method, std::string("GET"));
r.cancel("resp_1");
ASSERT_EQ(rig.last().target, std::string("/openai/v1/responses/resp_1/cancel"));
r.remove("resp_1");
ASSERT_EQ(rig.last().method, std::string("DELETE"));
ListParams p;
p.limit = 10;
p.order = "asc";
r.input_items("resp_1", p);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/responses/resp_1/input_items?limit=10&order=asc"));
Rig dated(key_settings("2025-04-01-preview"));
ResponsesService d(dated.client);
d.create(b);
ASSERT_EQ(dated.last().target, std::string("/openai/responses?api-version=2025-04-01-preview"));
}
TEST(azure_services, assistants_threads_runs) {
Rig rig(key_settings("2025-04-01-preview"));
AssistantsService a(rig.client);
a.create_assistant(Json::parse(R"({"model":"gpt4o","name":"x"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/assistants?api-version=2025-04-01-preview"));
ASSERT_TRUE(rejects([&] { a.create_assistant(Json::object()); }, "model"));
a.create_thread();
ASSERT_EQ(rig.last().target, std::string("/openai/threads?api-version=2025-04-01-preview"));
a.create_message("thread_1", Json::parse(R"({"role":"user","content":"hi"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/threads/thread_1/messages?api-version=2025-04-01-preview"));
a.create_run("thread_1", Json::parse(R"({"assistant_id":"asst_1"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/threads/thread_1/runs?api-version=2025-04-01-preview"));
a.submit_tool_outputs("thread_1", "run_1", Json::parse(R"([{"tool_call_id":"c1","output":"4"}])"));
ASSERT_EQ(rig.last().target,
std::string("/openai/threads/thread_1/runs/run_1/submit_tool_outputs?api-version=2025-04-01-preview"));
a.get_run_step("thread_1", "run_1", "step_1");
ASSERT_TRUE(contains(rig.last().target, "/steps/step_1"));
ASSERT_TRUE(rejects([&] { a.create_run("thread_1", Json::object()); }, "assistant_id"));
ASSERT_TRUE(rejects([&] { a.create_message("../x", Json::object()); }, "bad thread id"));
ASSERT_TRUE(rejects([&] { a.submit_tool_outputs("t", "r", Json::array()); }, "non-empty"));
a.remove_thread("thread_1");
ASSERT_EQ(rig.last().method, std::string("DELETE"));
a.cancel_run("thread_1", "run_1");
ASSERT_EQ(rig.last().method, std::string("POST"));
}
TEST(azure_services, batches_and_fine_tuning) {
Rig rig(key_settings());
BatchesService b(rig.client);
b.create(Json::parse(R"({"input_file_id":"file-1","endpoint":"/chat/completions","completion_window":"24h"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/batches"));
ASSERT_TRUE(rejects([&] { b.create(Json::parse(R"({"endpoint":"/chat/completions","completion_window":"24h"})")); }, "input_file_id"));
b.cancel("batch_1");
ASSERT_EQ(rig.last().target, std::string("/openai/v1/batches/batch_1/cancel"));
FineTuningService f(rig.client);
f.create(Json::parse(R"({"model":"gpt-4o-mini","training_file":"file-1"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/fine_tuning/jobs"));
ASSERT_TRUE(rejects([&] { f.create(Json::parse(R"({"model":"gpt-4o-mini"})")); }, "training_file"));
f.events("ftjob-1");
ASSERT_EQ(rig.last().target, std::string("/openai/v1/fine_tuning/jobs/ftjob-1/events"));
f.pause("ftjob-1");
f.resume("ftjob-1");
ASSERT_EQ(rig.last().target, std::string("/openai/v1/fine_tuning/jobs/ftjob-1/resume"));
f.remove("ftjob-1"); // dated only: fallback version
ASSERT_EQ(rig.last().method, std::string("DELETE"));
ASSERT_EQ(rig.last().target, std::string("/openai/fine_tuning/jobs/ftjob-1?api-version=2025-04-01-preview"));
f.copy_checkpoint("ftjob-1", "ftckpt-1", Json::parse(R"({"destinationResourceId":"/subscriptions/x","region":"eastus"})"));
ASSERT_TRUE(contains(rig.last().target, "/checkpoints/ftckpt-1/copy"));
ASSERT_TRUE(rejects([&] { f.copy_checkpoint("j", "c", Json::object()); }, "destinationResourceId"));
}
TEST(azure_services, files_and_uploads) {
Rig rig(key_settings());
FilesService f(rig.client);
f.upload(UploadFile{"train.jsonl", "application/jsonl", "{}\n"}, "fine-tune");
ASSERT_EQ(rig.last().target, std::string("/openai/v1/files"));
ASSERT_TRUE(contains(rig.last().body, part("purpose", "fine-tune")));
ASSERT_TRUE(contains(rig.last().body, "filename=\"train.jsonl\""));
ASSERT_TRUE(rejects([&] { f.upload(UploadFile{"a", "x", ""}, "batch"); }, "empty"));
ASSERT_TRUE(rejects([&] { f.upload(UploadFile{"a", "x", "d"}, ""); }, "purpose"));
ASSERT_TRUE(rejects([&] { f.upload(UploadFile{"a\nb", "x", "d"}, "batch"); }, "control"));
rig.openai().content_type = "application/octet-stream";
rig.openai().answer = "RAW";
ASSERT_EQ(f.content("file-1").body, std::string("RAW"));
rig.openai().content_type = "application/json";
rig.openai().answer = "{}";
f.remove("file-1");
ASSERT_EQ(rig.last().method, std::string("DELETE"));
f.start_upload(Json::parse(R"({"purpose":"batch","filename":"big.jsonl","bytes":123,"mime_type":"application/jsonl"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/uploads?api-version=2025-04-01-preview"));
f.add_part("upload_1", UploadFile{"p", "application/octet-stream", "abc"});
ASSERT_TRUE(contains(rig.last().target, "/uploads/upload_1/parts"));
f.complete_upload("upload_1", {"part_1", "part_2"}, "d41d8cd98f00b204e9800998ecf8427e");
ASSERT_TRUE(contains(rig.last().body, "\"part_ids\":[\"part_1\",\"part_2\"]"));
ASSERT_TRUE(rejects([&] { f.complete_upload("upload_1", {}); }, "part_ids"));
f.cancel_upload("upload_1");
ASSERT_TRUE(contains(rig.last().target, "/uploads/upload_1/cancel"));
}
TEST(azure_services, vector_stores) {
Rig rig(key_settings());
VectorStoresService v(rig.client);
v.create(Json::parse(R"({"name":"docs"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/vector_stores"));
v.search("vs_1", Json::parse(R"({"query":"what"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/vector_stores/vs_1/search"));
ASSERT_TRUE(rejects([&] { v.search("vs_1", Json::object()); }, "query"));
v.add_file("vs_1", Json::parse(R"({"file_id":"file-1"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/vector_stores/vs_1/files"));
v.list_files("vs_1", ListParams(), "completed");
ASSERT_TRUE(contains(rig.last().target, "filter=completed"));
ASSERT_TRUE(rejects([&] { v.list_files("vs_1", ListParams(), "weird"); }, "filter"));
v.create_file_batch("vs_1", Json::parse(R"({"file_ids":["a","b"]})"));
ASSERT_TRUE(rejects([&] { v.create_file_batch("vs_1", Json::object()); }, "file_ids"));
v.update_file_attributes("vs_1", "file-1", Json::parse(R"({"team":"x"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/vector_stores/vs_1/files/file-1"));
v.remove_file("vs_1", "file-1");
ASSERT_EQ(rig.last().method, std::string("DELETE"));
v.cancel_file_batch("vs_1", "vsfb_1");
ASSERT_TRUE(contains(rig.last().target, "/file_batches/vsfb_1/cancel"));
}
TEST(azure_services, models) {
Rig rig(key_settings());
// Documented example: models list shape (data[].id).
rig.openai().answer = R"({"object":"list","data":[{"id":"gpt-4o","object":"model"},{"id":"text-embedding-3-small","object":"model"}]})";
ModelsService m(rig.client);
auto ids = m.ids();
ASSERT_EQ(ids.size(), static_cast<std::size_t>(2));
ASSERT_EQ(ids[0], std::string("gpt-4o"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/models"));
m.get("gpt-4o");
ASSERT_EQ(rig.last().target, std::string("/openai/v1/models/gpt-4o"));
m.remove("ft:gpt-4o:org::abc");
ASSERT_EQ(rig.last().method, std::string("DELETE"));
}
TEST(azure_services, foundry_model_inference) {
Rig rig(key_settings());
FoundryService f(rig.client);
f.info();
ASSERT_EQ(rig.foundry().seen.back().target, std::string("/models/info?api-version=2024-05-01-preview"));
Json body = Json::parse(R"({"messages":[{"role":"user","content":"hi"}],"max_tokens":8,"model":"Phi-4"})");
f.chat(body, "drop");
const Seen& s = rig.foundry().seen.back();
ASSERT_EQ(s.target, std::string("/models/chat/completions?api-version=2024-05-01-preview"));
ASSERT_EQ(s.headers.get_or("extra-parameters", ""), std::string("drop"));
ASSERT_EQ(s.headers.get_or("api-key", ""), std::string("az-test-KEY"));
f.chat(body);
ASSERT_FALSE(rig.foundry().seen.back().headers.has("extra-parameters"));
ASSERT_TRUE(rejects([&] { f.chat(body, "maybe"); }, "extra_parameters"));
ASSERT_TRUE(rejects([&] { f.chat(Json::object()); }, "messages"));
f.embeddings(Json::parse(R"({"input":["a","b"],"dimensions":256})"));
ASSERT_TRUE(contains(rig.foundry().seen.back().target, "/models/embeddings"));
ASSERT_TRUE(rejects([&] { f.embeddings(Json::parse(R"({"input":"a"})")); }, "array"));
f.image_embeddings(Json::parse(R"({"input":[{"image":"data:image/png;base64,AA=="}]})"));
ASSERT_TRUE(contains(rig.foundry().seen.back().target, "/models/images/embeddings"));
Rig dated(key_settings("2024-10-21")); // the OpenAI api version does not move the Foundry one
FoundryService g(dated.client);
g.info();
ASSERT_EQ(dated.foundry().seen.back().target, std::string("/models/info?api-version=2024-05-01-preview"));
}
TEST(azure_services, content_safety) {
Rig rig(key_settings());
SafetyService s(rig.client);
s.analyze_text(Json::parse(R"({"text":"hello","categories":["Hate"],"outputType":"FourSeverityLevels"})"));
ASSERT_EQ(rig.safety().seen.back().target, std::string("/contentsafety/text:analyze?api-version=2024-09-01"));
ASSERT_TRUE(rejects([&] { s.analyze_text(Json::object()); }, "text"));
Json big = Json::object();
big.set("text", Json(std::string(10001, 'x')));
ASSERT_TRUE(rejects([&] { s.analyze_text(big); }, "10000"));
s.analyze_image(Json::parse(R"({"image":{"content":"AAAA"}})"));
ASSERT_TRUE(contains(rig.safety().seen.back().target, "/contentsafety/image:analyze"));
ASSERT_TRUE(rejects([&] { s.analyze_image(Json::parse(R"({"image":{}})")); }, "content"));
s.shield_prompt(Json::parse(R"({"userPrompt":"ignore previous","documents":["d"]})"));
ASSERT_TRUE(contains(rig.safety().seen.back().target, "text:shieldPrompt"));
ASSERT_TRUE(rejects([&] { s.shield_prompt(Json::parse(R"({"documents":["1","2","3","4","5","6"]})")); }, "5"));
s.detect_protected_material("some text");
ASSERT_TRUE(contains(rig.safety().seen.back().target, "text:detectProtectedMaterial"));
s.create_or_update_blocklist("my.list_1", "desc");
const Seen& p = rig.safety().seen.back();
ASSERT_EQ(p.method, std::string("PATCH"));
ASSERT_EQ(p.headers.get_or("Content-Type", ""), std::string("application/merge-patch+json"));
ASSERT_EQ(p.target, std::string("/contentsafety/text/blocklists/my.list_1?api-version=2024-09-01"));
for (const char* bad : {"", "a b", "a/b", "a:b"})
ASSERT_TRUE(rejects([&] { s.get_blocklist(bad); }, "blocklist name"));
ASSERT_TRUE(rejects([&] { s.get_blocklist(std::string(65, 'a')); }, "1..64"));
s.add_blocklist_items("my-list", Json::parse(R"([{"description":"d","text":"bad word"}])"));
ASSERT_TRUE(contains(rig.safety().seen.back().target, "my-list:addOrUpdateBlocklistItems"));
ASSERT_TRUE(contains(rig.safety().seen.back().body, "blocklistItems"));
ASSERT_TRUE(rejects([&] { s.add_blocklist_items("my-list", Json::array()); }, "non-empty"));
Json many = Json::array();
for (int i = 0; i < 101; ++i) many.push(Json::parse(R"({"text":"x"})"));
ASSERT_TRUE(rejects([&] { s.add_blocklist_items("my-list", many); }, "100"));
ASSERT_TRUE(rejects([&] { s.add_blocklist_items("my-list", Json::parse(R"([{"text":")" + std::string(129, 'x') + R"("}])")); }, "128"));
s.remove_blocklist_items("my-list", {"id1"});
ASSERT_TRUE(contains(rig.safety().seen.back().body, "blocklistItemIds"));
s.list_blocklist_items("my-list", 50, 10);
ASSERT_TRUE(contains(rig.safety().seen.back().target, "maxpagesize=50&skip=10&api-version=2024-09-01"));
s.remove_blocklist("my-list");
ASSERT_EQ(rig.safety().seen.back().method, std::string("DELETE"));
}
TEST(azure_services, realtime_rest) {
Rig rig(key_settings());
RealtimeService r(rig.client);
r.create_client_secret(Json::parse(R"({"expires_after":{"anchor":"created_at","seconds":600},"session":{"type":"realtime","model":"gpt-realtime"}})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/realtime/client_secrets"));
ASSERT_TRUE(rejects([&] { r.create_client_secret(Json::parse(R"({"expires_after":{"seconds":5}})")); }, "10"));
ASSERT_TRUE(rejects([&] { r.create_client_secret(Json::parse(R"({"expires_after":{"seconds":9999}})")); }, "7200"));
r.create_session(Json::parse(R"({"instructions":"be brief"})"));
ASSERT_EQ(rig.last().target, std::string("/openai/v1/realtime/sessions"));
r.hangup_call("call_1");
ASSERT_EQ(rig.last().target, std::string("/openai/v1/realtime/calls/call_1/hangup"));
r.reject_call("call_1", 603);
ASSERT_TRUE(rejects([&] { r.reject_call("call_1", 200); }, "400"));
ASSERT_TRUE(rejects([&] { r.accept_call("call_1", Json::object()); }, "type"));
Rig dated(key_settings("2025-04-01-preview"));
RealtimeService d(dated.client);
d.create_session(Json::parse(R"({"model":"gpt-4o-realtime-preview"})"));
ASSERT_EQ(dated.last().target, std::string("/openai/realtimeapi/sessions?api-version=2025-04-01-preview"));
d.create_transcription_session();
ASSERT_EQ(dated.last().target, std::string("/openai/realtimeapi/transcription_sessions?api-version=2025-04-01-preview"));
}
TEST(azure_services, generic_operations_plan_every_op_in_every_mode) {
for (const char* version : {"", "preview", "2024-10-21", "2025-04-01-preview"}) {
Rig rig(key_settings(version));
OperationsService ops(rig.client);
std::size_t planned = 0;
for (std::size_t i = 0; i < Calls::count(); ++i) {
const CallSpec& c = Calls::at(i);
if (!OperationsService::generic(c)) continue;
AzureService g(rig.client, c.surface);
// Both sides of an operation take the same number of ids (checked by gen_calls.py).
Side any = c.v1.present() ? Side::kV1 : Side::kDated;
Target t{"dep1", std::vector<std::string>(Calls::id_count(c.op, any), "id1")};
Side side = g.route(c.op, t).side;
auto plan = ops.plan(c.name, t);
ASSERT_TRUE(plan.path.rfind(Calls::prefix(c.op, side), 0) == 0);
ASSERT_EQ(plan.method, std::string(c.method));
++planned;
}
ASSERT_TRUE(planned > 120);
}
}
TEST(azure_services, generic_operations_reject_what_the_spec_rejects) {
Rig rig(key_settings());
OperationsService ops(rig.client);
ASSERT_TRUE(rejects([&] { ops.invoke("NoSuchCall", {}); }, "unknown operation"));
ASSERT_TRUE(rejects([&] { ops.invoke("CreateFile", {}); }, "typed service"));
ASSERT_TRUE(rejects([&] { ops.invoke("CreateSpeech", {"d", {}}); }, "typed service"));
Json bad = Json::parse(R"({"bogus":1})");
ASSERT_TRUE(rejects([&] { ops.invoke("CreateConversation", {}, &bad); }, "bogus"));
ASSERT_TRUE(rejects([&] { ops.invoke("RetrieveConversation", {"", {"../x"}}); }, "bad id"));
Json body = Json::parse(R"({"metadata":{"a":"b"}})");
ops.invoke("CreateConversation", {}, &body);
ASSERT_EQ(rig.last().target, std::string("/openai/v1/conversations"));
ASSERT_TRUE(rejects([&] { ops.invoke("RetrieveConversation", {"", {"c1"}}, &body); }, "no request body"));
ops.invoke("ListContainers", {}, nullptr, {{"limit", "5"}});
ASSERT_EQ(rig.last().target, std::string("/openai/v1/containers?limit=5"));
ASSERT_TRUE(rejects([&] { ops.invoke("ListContainers", {}, nullptr, {{"zzz", "5"}}); }, "zzz"));
ASSERT_TRUE(OperationsService::destructive(*Calls::find("DeleteContainer")));
ASSERT_TRUE(OperationsService::destructive(*Calls::find("CancelEvalRun")));
ASSERT_TRUE(OperationsService::destructive(*Calls::find("HangupRealtimeCall")));
ASSERT_FALSE(OperationsService::destructive(*Calls::find("ListContainers")));
ASSERT_FALSE(OperationsService::destructive(*Calls::find("CreateChatCompletion")));
}
+115
View File
@@ -0,0 +1,115 @@
// Azure: api version parsing, endpoint rules, settings from the environment.
#include <cstdlib>
#include "rig.h"
#include "vendors/azure/api_version.h"
#include "vendors/azure/settings.h"
using namespace molo::azure;
using namespace az_test;
TEST(azure_settings, api_version_modes) {
ASSERT_TRUE(ApiVersion::parse("").mode() == ApiVersion::Mode::kV1);
ASSERT_TRUE(ApiVersion::parse("v1").mode() == ApiVersion::Mode::kV1);
ASSERT_EQ(ApiVersion::parse("v1").v1_query(), std::string(""));
ASSERT_TRUE(ApiVersion::parse("preview").mode() == ApiVersion::Mode::kPreview);
ASSERT_EQ(ApiVersion::parse("preview").v1_query(), std::string("preview"));
ApiVersion d = ApiVersion::parse("2024-10-21");
ASSERT_TRUE(d.is_dated());
ASSERT_EQ(d.value(), std::string("2024-10-21"));
ASSERT_TRUE(ApiVersion::parse("2025-04-01-preview").is_dated());
ASSERT_TRUE(ApiVersion::parse("2025-04-01-preview").is_dated() && !ApiVersion::parse("preview").is_dated());
}
TEST(azure_settings, api_version_rejects_junk) {
for (const char* bad : {"latest", "2024-10", "2024-10-21-beta", "20241021", "v2", "2024-10-21 ", "../x"})
ASSERT_TRUE(rejects([&] { ApiVersion::parse(bad); }, "api version"));
}
TEST(azure_settings, endpoint_normalization) {
ASSERT_EQ(Settings::normalize_endpoint("https://a.openai.azure.com/"), std::string("https://a.openai.azure.com"));
ASSERT_EQ(Settings::normalize_endpoint(" https://a.openai.azure.com "), std::string("https://a.openai.azure.com"));
ASSERT_EQ(Settings::normalize_endpoint(""), std::string(""));
ASSERT_EQ(Settings::normalize_endpoint("http://127.0.0.1:8080"), std::string("http://127.0.0.1:8080"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("http://a.openai.azure.com"); }, "https"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("a.openai.azure.com"); }, "https"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("https://a.openai.azure.com/openai"); }, "no path"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("https://a.openai.azure.com?x=1"); }, "no path"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("https://user:pw@a.openai.azure.com"); }, "no path"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("https://"); }, "no host"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("https://a b.openai.azure.com"); }, "invalid"));
ASSERT_TRUE(rejects([] { Settings::normalize_endpoint("https://" + std::string(300, 'a') + ".com"); }, "too long"));
}
TEST(azure_settings, auth_kind_priority) {
Settings s;
s.endpoint = "https://a.openai.azure.com";
ASSERT_TRUE(s.auth() == AuthKind::kNone);
ASSERT_FALSE(s.configured());
s.entra.tenant_id = "t";
s.entra.client_id = "c";
ASSERT_TRUE(s.auth() == AuthKind::kNone); // secret missing
s.entra.client_secret = "s";
ASSERT_TRUE(s.auth() == AuthKind::kEntra);
s.api_key = "k";
ASSERT_TRUE(s.auth() == AuthKind::kApiKey); // a key wins over Entra
ASSERT_TRUE(s.configured());
}
TEST(azure_settings, entra_validation) {
EntraConfig e;
e.tenant_id = "contoso.onmicrosoft.com";
e.client_id = "11111111-2222-3333-4444-555555555555";
e.client_secret = "x";
e.validate();
ASSERT_EQ(e.token_url(), std::string("https://login.microsoftonline.com/contoso.onmicrosoft.com/oauth2/v2.0/token"));
EntraConfig bad = e;
bad.tenant_id = "../common";
ASSERT_TRUE(rejects([&] { bad.validate(); }, "tenant"));
bad = e;
bad.client_id = "a b";
ASSERT_TRUE(rejects([&] { bad.validate(); }, "client id"));
bad = e;
bad.client_secret = std::string("a\nb");
ASSERT_TRUE(rejects([&] { bad.validate(); }, "control"));
bad = e;
bad.authority = "https://login.microsoftonline.us/";
ASSERT_EQ(bad.token_url(), std::string("https://login.microsoftonline.us/contoso.onmicrosoft.com/oauth2/v2.0/token"));
bad.authority = "http://evil.example";
ASSERT_TRUE(rejects([&] { bad.validate(); }, "https"));
}
TEST(azure_settings, from_env_reads_every_variable) {
setenv("MOLO_ENV_FILES", "off", 1);
setenv("AZURE_OPENAI_ENDPOINT", "https://r1.openai.azure.com/", 1);
setenv("AZURE_OPENAI_API_KEY", "key-1", 1);
setenv("AZURE_OPENAI_API_VERSION", "2024-10-21", 1);
setenv("AZURE_TENANT_ID", "tenant-1", 1);
setenv("AZURE_CLIENT_ID", "client-1", 1);
setenv("AZURE_CLIENT_SECRET", "secret-1", 1);
Settings s = Settings::from_env();
ASSERT_EQ(s.endpoint, std::string("https://r1.openai.azure.com"));
ASSERT_EQ(s.foundry_endpoint, s.endpoint); // fallback
ASSERT_EQ(s.safety_endpoint, s.endpoint);
ASSERT_EQ(s.api_key, std::string("key-1"));
ASSERT_EQ(s.safety_key, std::string("key-1"));
ASSERT_TRUE(s.api_version.is_dated());
ASSERT_EQ(s.entra.tenant_id, std::string("tenant-1"));
ASSERT_EQ(s.entra.client_secret, std::string("secret-1"));
setenv("AZURE_AI_ENDPOINT", "https://r1.services.ai.azure.com", 1);
setenv("AZURE_CONTENT_SAFETY_ENDPOINT", "https://r1.cognitiveservices.azure.com", 1);
setenv("AZURE_CONTENT_SAFETY_KEY", "key-safety", 1);
Settings t = Settings::from_env();
ASSERT_EQ(t.foundry_endpoint, std::string("https://r1.services.ai.azure.com"));
ASSERT_EQ(t.safety_endpoint, std::string("https://r1.cognitiveservices.azure.com"));
ASSERT_EQ(t.safety_key, std::string("key-safety"));
setenv("AZURE_OPENAI_API_VERSION", "nonsense", 1);
ASSERT_TRUE(rejects([] { Settings::from_env(); }, "api version"));
for (const char* v : {"AZURE_OPENAI_ENDPOINT", "AZURE_OPENAI_API_KEY", "AZURE_OPENAI_API_VERSION",
"AZURE_TENANT_ID", "AZURE_CLIENT_ID", "AZURE_CLIENT_SECRET", "AZURE_AI_ENDPOINT",
"AZURE_CONTENT_SAFETY_ENDPOINT", "AZURE_CONTENT_SAFETY_KEY"})
unsetenv(v);
Settings none = Settings::from_env();
ASSERT_FALSE(none.configured());
ASSERT_TRUE(none.api_version.mode() == ApiVersion::Mode::kV1);
}