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