Files
moloapp/tests/src/vendors/azure/test_realtime.cpp
T

146 lines
5.8 KiB
C++

// 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"));
}
}