feat(clients): google cloud voice: generic client, TTS, STT, Gemini audio, live voice page
src/google: GoogleClient over molo::clients (key in x-goog-api-key, never in
URLs), Service base, TextToSpeech, SpeechToText, Generative (replies, audio
in, audio out), Recognizer/Synthesizer seams with cloud, gemini and vertex
backends, VoicePipeline with bounded history. Example: /voice live
conversation page, /voice/{say,hear,turn,reset}, /google/status. Keys load
from env, .env.json.local, .env.json. Paid routes are excluded from locust.
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -0,0 +1,519 @@
|
||||
// Google Cloud part: request shape, credential placement, error mapping,
|
||||
// caps, and the voice pipeline, all against a scripted transport.
|
||||
#include <memory>
|
||||
|
||||
#include "framework.h"
|
||||
#include "google/caps.h"
|
||||
#include "google/client.h"
|
||||
#include "google/credentials.h"
|
||||
#include "google/endpoints.h"
|
||||
#include "google/gemini_voice.h"
|
||||
#include "google/generative.h"
|
||||
#include "google/voice_backend.h"
|
||||
#include "google/wav.h"
|
||||
#include "google/speech_to_text.h"
|
||||
#include "google/text_to_speech.h"
|
||||
#include "google/voice.h"
|
||||
#include "clients/transports/mock_transport.h"
|
||||
#include "security/crypto/Base64.h"
|
||||
|
||||
using namespace molo::google;
|
||||
using molo::clients::ClientResponse;
|
||||
using molo::clients::HeaderMap;
|
||||
using molo::clients::Method;
|
||||
using molo::clients::transports::MockTransport;
|
||||
using molo::clients::body::Json;
|
||||
using molo::security::crypto::Base64;
|
||||
|
||||
namespace {
|
||||
|
||||
const char* kKey = "AIzaSECRETKEY123";
|
||||
|
||||
ClientResponse json_ok(const std::string& body, int status = 200) {
|
||||
HeaderMap h;
|
||||
h.set("Content-Type", "application/json");
|
||||
return ClientResponse(status, h, body);
|
||||
}
|
||||
|
||||
struct Rig {
|
||||
MockTransport* mock;
|
||||
std::shared_ptr<GoogleClient> client;
|
||||
explicit Rig(bool with_key = true) {
|
||||
auto transport = std::make_unique<MockTransport>();
|
||||
mock = transport.get();
|
||||
client = std::make_shared<GoogleClient>(
|
||||
std::move(transport), with_key ? Credentials::api_key(kKey) : nullptr);
|
||||
}
|
||||
void tts_ok(const std::string& mp3 = "MP3DATA") {
|
||||
mock->expect_response(Method::kPost, "/v1/text:synthesize",
|
||||
json_ok("{\"audioContent\":\"" + Base64::encode(mp3) + "\"}"));
|
||||
}
|
||||
void stt_ok(const std::string& text) {
|
||||
mock->expect_response(
|
||||
Method::kPost, "/v1/speech:recognize",
|
||||
json_ok("{\"results\":[{\"alternatives\":[{\"transcript\":\"" + text +
|
||||
"\",\"confidence\":0.9}]}]}"));
|
||||
}
|
||||
void gemini_ok(const std::string& text) {
|
||||
mock->expect_response(
|
||||
Method::kPost, "/v1beta/models/m1:generateContent",
|
||||
json_ok("{\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"" + text +
|
||||
"\"}]}}]}"));
|
||||
}
|
||||
};
|
||||
|
||||
std::shared_ptr<VoicePipeline> pipeline(Rig& rig,
|
||||
std::shared_ptr<VoiceSessions> s = nullptr) {
|
||||
auto gen = std::make_shared<Generative>(rig.client);
|
||||
return std::make_shared<VoicePipeline>(
|
||||
std::make_shared<SpeechToText>(rig.client),
|
||||
std::make_shared<GenerativeResponder>(gen),
|
||||
std::make_shared<TextToSpeech>(rig.client),
|
||||
s ? s : std::make_shared<VoiceSessions>());
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(google, key_in_header_never_in_url) {
|
||||
Rig rig;
|
||||
rig.tts_ok();
|
||||
TextToSpeech tts(rig.client);
|
||||
SynthesisRequest req;
|
||||
req.text = "hallo";
|
||||
tts.synthesize(req);
|
||||
auto seen = rig.mock->seen();
|
||||
ASSERT_EQ(seen.size(), 1u);
|
||||
ASSERT_EQ(seen[0].headers.get_or("x-goog-api-key", ""), std::string(kKey));
|
||||
ASSERT_TRUE(seen[0].target.find(kKey) == std::string::npos);
|
||||
}
|
||||
|
||||
TEST(google, not_configured_fails_before_network) {
|
||||
Rig rig(false);
|
||||
TextToSpeech tts(rig.client);
|
||||
SynthesisRequest req;
|
||||
req.text = "hallo";
|
||||
try {
|
||||
tts.synthesize(req);
|
||||
FAIL("expected NotConfiguredError");
|
||||
} catch (const NotConfiguredError& e) {
|
||||
ASSERT_EQ(e.http_status(), 503);
|
||||
ASSERT_EQ(e.status(), "NOT_CONFIGURED");
|
||||
}
|
||||
ASSERT_EQ(rig.mock->send_count(), 0u);
|
||||
ASSERT_FALSE(tts.configured());
|
||||
}
|
||||
|
||||
TEST(google, tts_request_shape_and_decode) {
|
||||
Rig rig;
|
||||
rig.tts_ok("AUDIO!");
|
||||
TextToSpeech tts(rig.client);
|
||||
SynthesisRequest req;
|
||||
req.text = "hoi";
|
||||
req.language = "nl-NL";
|
||||
req.voice = "nl-NL-Wavenet-A";
|
||||
Audio a = tts.synthesize(req);
|
||||
ASSERT_EQ(a.bytes, "AUDIO!");
|
||||
ASSERT_EQ(a.mime, "audio/mpeg");
|
||||
Json body = Json::parse(rig.mock->seen()[0].body);
|
||||
ASSERT_EQ(body.find("input")->find("text")->as_string(), "hoi");
|
||||
ASSERT_EQ(body.find("voice")->find("languageCode")->as_string(), "nl-NL");
|
||||
ASSERT_EQ(body.find("voice")->find("name")->as_string(), "nl-NL-Wavenet-A");
|
||||
ASSERT_EQ(body.find("audioConfig")->find("audioEncoding")->as_string(), "MP3");
|
||||
}
|
||||
|
||||
TEST(google, tts_rejects_bad_input_without_network) {
|
||||
Rig rig;
|
||||
TextToSpeech tts(rig.client);
|
||||
SynthesisRequest req;
|
||||
ASSERT_THROW(tts.synthesize(req), GoogleError); // empty
|
||||
req.text = std::string(Caps::kMaxTtsChars + 1, 'a');
|
||||
ASSERT_THROW(tts.synthesize(req), GoogleError); // over cap
|
||||
req.text = "ok";
|
||||
req.speaking_rate = 9.0;
|
||||
ASSERT_THROW(tts.synthesize(req), GoogleError); // rate
|
||||
ASSERT_EQ(rig.mock->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(google, tts_voices_list) {
|
||||
Rig rig;
|
||||
rig.mock->expect_response(
|
||||
Method::kGet, "/v1/voices",
|
||||
json_ok("{\"voices\":[{\"name\":\"nl-NL-Wavenet-A\",\"ssmlGender\":"
|
||||
"\"FEMALE\",\"languageCodes\":[\"nl-NL\"]}]}"));
|
||||
auto v = TextToSpeech(rig.client).voices("nl-NL");
|
||||
ASSERT_EQ(v.size(), 1u);
|
||||
ASSERT_EQ(v[0].name, "nl-NL-Wavenet-A");
|
||||
ASSERT_EQ(v[0].languages[0], "nl-NL");
|
||||
}
|
||||
|
||||
TEST(google, error_mapping_hides_key) {
|
||||
Rig rig;
|
||||
rig.mock->expect_response(
|
||||
Method::kPost, "/v1/text:synthesize",
|
||||
json_ok("{\"error\":{\"code\":403,\"message\":\"API not enabled\","
|
||||
"\"status\":\"PERMISSION_DENIED\"}}",
|
||||
403));
|
||||
SynthesisRequest req;
|
||||
req.text = "x";
|
||||
try {
|
||||
TextToSpeech(rig.client).synthesize(req);
|
||||
FAIL("expected GoogleError");
|
||||
} catch (const GoogleError& e) {
|
||||
ASSERT_EQ(e.http_status(), 403);
|
||||
ASSERT_EQ(e.status(), "PERMISSION_DENIED");
|
||||
ASSERT_EQ(e.service(), "texttospeech");
|
||||
ASSERT_TRUE(std::string(e.what()).find("API not enabled") != std::string::npos);
|
||||
ASSERT_TRUE(std::string(e.what()).find(kKey) == std::string::npos);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(google, non_json_error_body) {
|
||||
Rig rig;
|
||||
rig.mock->expect_status(Method::kPost, "/v1/text:synthesize", 400, "<html>");
|
||||
SynthesisRequest req;
|
||||
req.text = "x";
|
||||
try {
|
||||
TextToSpeech(rig.client).synthesize(req);
|
||||
FAIL("expected GoogleError");
|
||||
} catch (const GoogleError& e) {
|
||||
ASSERT_EQ(e.http_status(), 400);
|
||||
ASSERT_EQ(e.status(), "UNKNOWN");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(google, transport_failure_becomes_unavailable) {
|
||||
Rig rig;
|
||||
rig.mock->expect_error(
|
||||
Method::kPost, "/v1/text:synthesize",
|
||||
std::make_exception_ptr(molo::clients::TransportError("boom")));
|
||||
SynthesisRequest req;
|
||||
req.text = "x";
|
||||
try {
|
||||
TextToSpeech(rig.client).synthesize(req);
|
||||
FAIL("expected GoogleError");
|
||||
} catch (const GoogleError& e) {
|
||||
ASSERT_EQ(e.status(), "UNAVAILABLE");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(google, stt_request_shape_and_join) {
|
||||
Rig rig;
|
||||
rig.mock->expect_response(
|
||||
Method::kPost, "/v1/speech:recognize",
|
||||
json_ok("{\"results\":[{\"alternatives\":[{\"transcript\":\"hallo\","
|
||||
"\"confidence\":0.8}]},{\"alternatives\":[{\"transcript\":"
|
||||
"\"wereld\"}]}]}"));
|
||||
RecognitionRequest req;
|
||||
req.audio = "RAWAUDIO";
|
||||
Transcript t = SpeechToText(rig.client).recognize(req);
|
||||
ASSERT_EQ(t.text, "hallo wereld");
|
||||
ASSERT_TRUE(t.confidence > 0.79 && t.confidence < 0.81);
|
||||
Json body = Json::parse(rig.mock->seen()[0].body);
|
||||
ASSERT_EQ(body.find("config")->find("encoding")->as_string(), "WEBM_OPUS");
|
||||
ASSERT_EQ(body.find("config")->find("languageCode")->as_string(), "nl-NL");
|
||||
ASSERT_EQ(body.find("audio")->find("content")->as_string(),
|
||||
Base64::encode("RAWAUDIO"));
|
||||
}
|
||||
|
||||
TEST(google, stt_silence_is_empty_transcript) {
|
||||
Rig rig;
|
||||
rig.mock->expect_response(Method::kPost, "/v1/speech:recognize", json_ok("{}"));
|
||||
RecognitionRequest req;
|
||||
req.audio = "x";
|
||||
ASSERT_EQ(SpeechToText(rig.client).recognize(req).text, "");
|
||||
}
|
||||
|
||||
TEST(google, stt_rejects_bad_audio_without_network) {
|
||||
Rig rig;
|
||||
SpeechToText stt(rig.client);
|
||||
RecognitionRequest req;
|
||||
ASSERT_THROW(stt.recognize(req), GoogleError);
|
||||
req.audio = std::string(Caps::kMaxSttBytes + 1, 'a');
|
||||
ASSERT_THROW(stt.recognize(req), GoogleError);
|
||||
ASSERT_EQ(rig.mock->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(google, stt_encoding_from_mime) {
|
||||
SpeechEncoding e;
|
||||
ASSERT_TRUE(speech_encoding_from_mime("audio/webm;codecs=opus", e));
|
||||
ASSERT_EQ(std::string(speech_encoding_name(e)), "WEBM_OPUS");
|
||||
ASSERT_TRUE(speech_encoding_from_mime("audio/ogg", e));
|
||||
ASSERT_EQ(std::string(speech_encoding_name(e)), "OGG_OPUS");
|
||||
ASSERT_FALSE(speech_encoding_from_mime("video/mp4", e));
|
||||
}
|
||||
|
||||
TEST(google, generative_request_shape) {
|
||||
Rig rig;
|
||||
rig.gemini_ok("dag");
|
||||
GenerationRequest req;
|
||||
req.model = "m1";
|
||||
req.system = "be brief";
|
||||
req.messages = {{"user", "hoi"}};
|
||||
ASSERT_EQ(Generative(rig.client).generate(req), "dag");
|
||||
Json body = Json::parse(rig.mock->seen()[0].body);
|
||||
ASSERT_EQ(body.find("contents")->as_array()[0].find("role")->as_string(), "user");
|
||||
ASSERT_EQ(body.find("systemInstruction")->find("parts")->as_array()[0]
|
||||
.find("text")->as_string(), "be brief");
|
||||
ASSERT_EQ(body.find("generationConfig")->find("maxOutputTokens")->as_int(), 300);
|
||||
ASSERT_TRUE(body.find("generationConfig")->find("thinkingConfig") == nullptr);
|
||||
}
|
||||
|
||||
TEST(google, generative_validation_and_empty) {
|
||||
Rig rig;
|
||||
Generative gen(rig.client);
|
||||
GenerationRequest req;
|
||||
req.model = "m1";
|
||||
ASSERT_THROW(gen.generate(req), GoogleError); // no messages
|
||||
req.messages = {{"robot", "x"}};
|
||||
ASSERT_THROW(gen.generate(req), GoogleError); // bad role
|
||||
req.messages = {{"user", "x"}};
|
||||
req.max_output_tokens = Caps::kMaxOutputTokens + 1;
|
||||
ASSERT_THROW(gen.generate(req), GoogleError); // token cap
|
||||
ASSERT_EQ(rig.mock->send_count(), 0u);
|
||||
req.max_output_tokens = 10;
|
||||
rig.mock->expect_response(Method::kPost, "/v1beta/models/m1:generateContent",
|
||||
json_ok("{\"candidates\":[]}"));
|
||||
try {
|
||||
gen.generate(req);
|
||||
FAIL("expected EMPTY_RESPONSE");
|
||||
} catch (const GoogleError& e) {
|
||||
ASSERT_EQ(e.status(), "EMPTY_RESPONSE");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(google, voice_turn_full_pipeline) {
|
||||
setenv("GOOGLE_GENAI_MODEL", "m1", 1);
|
||||
Rig rig;
|
||||
rig.stt_ok("wat is het weer");
|
||||
rig.gemini_ok("Zonnig.");
|
||||
rig.tts_ok("SPOKEN");
|
||||
auto p = pipeline(rig);
|
||||
RecognitionRequest heard;
|
||||
heard.audio = "AUDIO";
|
||||
VoiceTurn t = p->turn("conv1", heard);
|
||||
ASSERT_EQ(t.transcript, "wat is het weer");
|
||||
ASSERT_EQ(t.reply, "Zonnig.");
|
||||
ASSERT_EQ(t.audio.bytes, "SPOKEN");
|
||||
ASSERT_EQ(Json::parse(rig.mock->seen()[1].body)
|
||||
.find("generationConfig")->find("thinkingConfig")
|
||||
->find("thinkingBudget")->as_int(), 0);
|
||||
ASSERT_EQ(p->sessions().history_size("conv1"), 2u);
|
||||
rig.mock->verify();
|
||||
unsetenv("GOOGLE_GENAI_MODEL");
|
||||
}
|
||||
|
||||
TEST(google, voice_silence_skips_reply_and_synthesis) {
|
||||
Rig rig;
|
||||
rig.mock->expect_response(Method::kPost, "/v1/speech:recognize", json_ok("{}"));
|
||||
auto p = pipeline(rig);
|
||||
RecognitionRequest heard;
|
||||
heard.audio = "AUDIO";
|
||||
VoiceTurn t = p->turn("conv1", heard);
|
||||
ASSERT_EQ(t.transcript, "");
|
||||
ASSERT_EQ(t.audio.bytes, "");
|
||||
ASSERT_EQ(rig.mock->send_count(), 1u);
|
||||
ASSERT_EQ(p->sessions().size(), 0u);
|
||||
}
|
||||
|
||||
TEST(google, voice_failed_turn_rolls_back_history) {
|
||||
setenv("GOOGLE_GENAI_MODEL", "m1", 1);
|
||||
Rig rig;
|
||||
rig.mock->expect_response(
|
||||
Method::kPost, "/v1beta/models/m1:generateContent",
|
||||
json_ok("{\"error\":{\"code\":429,\"message\":\"quota\",\"status\":"
|
||||
"\"RESOURCE_EXHAUSTED\"}}", 400));
|
||||
auto p = pipeline(rig);
|
||||
ASSERT_THROW(p->turn_text("c", "hoi", "nl-NL"), GoogleError);
|
||||
ASSERT_EQ(p->sessions().history_size("c"), 0u);
|
||||
unsetenv("GOOGLE_GENAI_MODEL");
|
||||
}
|
||||
|
||||
TEST(google, voice_bad_conversation_id) {
|
||||
Rig rig;
|
||||
auto p = pipeline(rig);
|
||||
ASSERT_THROW(p->turn_text("bad id!", "hoi", "nl-NL"), GoogleError);
|
||||
ASSERT_THROW(p->turn_text("", "hoi", "nl-NL"), GoogleError);
|
||||
ASSERT_EQ(rig.mock->send_count(), 0u);
|
||||
}
|
||||
|
||||
TEST(google, sessions_bounded_history_and_count) {
|
||||
VoiceSessions s;
|
||||
for (std::size_t i = 0; i < Caps::kMaxHistoryTurns * 2 + 10; ++i)
|
||||
s.append("a", {i % 2 == 0 ? "user" : "model", "m"});
|
||||
ASSERT_TRUE(s.history_size("a") <= Caps::kMaxHistoryTurns * 2);
|
||||
auto h = s.append("a", {"user", "x"});
|
||||
ASSERT_EQ(h.front().role, "user");
|
||||
for (std::size_t i = 0; i < Caps::kMaxConversations + 5; ++i)
|
||||
s.append("c" + std::to_string(i), {"user", "m"});
|
||||
ASSERT_EQ(s.size(), Caps::kMaxConversations);
|
||||
ASSERT_EQ(s.history_size("a"), 0u); // oldest evicted
|
||||
s.reset("c10");
|
||||
ASSERT_EQ(s.history_size("c10"), 0u);
|
||||
}
|
||||
|
||||
TEST(google, catalog_lists_known_services) {
|
||||
auto c = endpoints::catalog();
|
||||
ASSERT_EQ(c.size(), 4u);
|
||||
ASSERT_EQ(c[0].name, "texttospeech");
|
||||
for (const auto& e : c) ASSERT_TRUE(e.base_url.rfind("https://", 0) == 0);
|
||||
}
|
||||
|
||||
// ---- Gemini audio backends (Vertex paths) ----------------------------------
|
||||
|
||||
namespace {
|
||||
const char* kVertexPrefix = "/v1/publishers/google/models/";
|
||||
|
||||
void vertex_text(Rig& rig, const std::string& model, const std::string& text) {
|
||||
rig.mock->expect_response(
|
||||
Method::kPost, std::string(kVertexPrefix) + model + ":generateContent",
|
||||
json_ok("{\"candidates\":[{\"content\":{\"parts\":[{\"text\":\"" + text +
|
||||
"\"}]}}]}"));
|
||||
}
|
||||
void vertex_pcm(Rig& rig, const std::string& model, const std::string& pcm) {
|
||||
rig.mock->expect_response(
|
||||
Method::kPost, std::string(kVertexPrefix) + model + ":generateContent",
|
||||
json_ok("{\"candidates\":[{\"content\":{\"parts\":[{\"inlineData\":"
|
||||
"{\"mimeType\":\"audio/L16;codec=pcm;rate=24000\",\"data\":\"" +
|
||||
Base64::encode(pcm) + "\"}}]}}]}"));
|
||||
}
|
||||
} // namespace
|
||||
|
||||
TEST(google, wav_wrap_and_rate) {
|
||||
std::string wav = pcm16_to_wav(std::string(10, 'x'), 24000);
|
||||
ASSERT_EQ(wav.size(), 54u);
|
||||
ASSERT_EQ(wav.substr(0, 4), "RIFF");
|
||||
ASSERT_EQ(wav.substr(8, 4), "WAVE");
|
||||
ASSERT_EQ(static_cast<unsigned char>(wav[24]), 0xC0); // 24000 = 0x5DC0
|
||||
ASSERT_EQ(static_cast<unsigned char>(wav[25]), 0x5D);
|
||||
ASSERT_EQ(wav.substr(44), std::string(10, 'x'));
|
||||
ASSERT_EQ(sample_rate_from_mime("audio/L16;codec=pcm;rate=16000"), 16000);
|
||||
ASSERT_EQ(sample_rate_from_mime("audio/L16"), 24000);
|
||||
ASSERT_EQ(sample_rate_from_mime("audio/L16;rate=999999999"), 24000);
|
||||
}
|
||||
|
||||
TEST(google, gemini_transcribe_shape) {
|
||||
Rig rig;
|
||||
vertex_text(rig, "stt-m", " hallo wereld \n");
|
||||
Generative gen(rig.client, endpoints::vertex_generative());
|
||||
std::string text = gen.transcribe("stt-m", "RAW", "audio/webm", "nl-NL");
|
||||
ASSERT_EQ(text, "hallo wereld");
|
||||
Json body = Json::parse(rig.mock->seen()[0].body);
|
||||
const Json& parts = *body.find("contents")->as_array()[0].find("parts");
|
||||
ASSERT_EQ(parts.as_array()[0].find("inlineData")->find("mimeType")->as_string(),
|
||||
"audio/webm");
|
||||
ASSERT_EQ(parts.as_array()[0].find("inlineData")->find("data")->as_string(),
|
||||
Base64::encode("RAW"));
|
||||
ASSERT_TRUE(parts.as_array()[1].find("text")->as_string().find("nl-NL") !=
|
||||
std::string::npos);
|
||||
ASSERT_THROW(gen.transcribe("stt-m", "", "audio/webm", "nl-NL"), GoogleError);
|
||||
ASSERT_EQ(rig.mock->send_count(), 1u);
|
||||
}
|
||||
|
||||
TEST(google, gemini_speak_shape_and_wav) {
|
||||
Rig rig;
|
||||
vertex_pcm(rig, "tts-m", "PCMDATA!");
|
||||
Generative gen(rig.client, endpoints::vertex_generative());
|
||||
Audio a = gen.speak("tts-m", "hoi", "");
|
||||
ASSERT_EQ(a.mime, "audio/wav");
|
||||
ASSERT_EQ(a.bytes.substr(0, 4), "RIFF");
|
||||
ASSERT_EQ(a.bytes.substr(44), "PCMDATA!");
|
||||
Json body = Json::parse(rig.mock->seen()[0].body);
|
||||
const Json& gc = *body.find("generationConfig");
|
||||
ASSERT_EQ(gc.find("responseModalities")->as_array()[0].as_string(), "AUDIO");
|
||||
ASSERT_EQ(gc.find("speechConfig")->find("voiceConfig")->find("prebuiltVoiceConfig")
|
||||
->find("voiceName")->as_string(), "Kore");
|
||||
vertex_text(rig, "tts-m", "no audio here");
|
||||
ASSERT_THROW(gen.speak("tts-m", "hoi", ""), GoogleError); // EMPTY_RESPONSE
|
||||
ASSERT_THROW(gen.speak("tts-m", "", ""), GoogleError);
|
||||
}
|
||||
|
||||
TEST(google, backend_selection) {
|
||||
unsetenv("GOOGLE_API_BACKEND");
|
||||
setenv("GOOGLE_API_KEY", "AQ.vertexstyle", 1);
|
||||
ASSERT_EQ(std::string(voice_backend_name(voice_backend_from_env())), "vertex");
|
||||
setenv("GOOGLE_API_KEY", "AIzaclassic", 1);
|
||||
ASSERT_EQ(std::string(voice_backend_name(voice_backend_from_env())), "cloud");
|
||||
setenv("GOOGLE_API_BACKEND", "gemini", 1);
|
||||
ASSERT_EQ(std::string(voice_backend_name(voice_backend_from_env())), "gemini");
|
||||
unsetenv("GOOGLE_API_BACKEND");
|
||||
unsetenv("GOOGLE_API_KEY");
|
||||
}
|
||||
|
||||
TEST(google, voice_turn_on_vertex_backend) {
|
||||
setenv("GOOGLE_GENAI_MODEL", "chat-m", 1);
|
||||
setenv("GOOGLE_STT_MODEL", "stt-m", 1);
|
||||
setenv("GOOGLE_TTS_MODEL", "tts-m", 1);
|
||||
Rig rig;
|
||||
vertex_text(rig, "stt-m", "wat is het weer");
|
||||
vertex_text(rig, "chat-m", "Zonnig.");
|
||||
vertex_pcm(rig, "tts-m", "SPEECH");
|
||||
VoiceParts parts = make_voice_parts(rig.client, VoiceBackend::kVertex);
|
||||
VoicePipeline p(parts.recognizer, parts.responder, parts.synthesizer,
|
||||
std::make_shared<VoiceSessions>());
|
||||
RecognitionRequest heard;
|
||||
heard.audio = "AUDIO";
|
||||
VoiceTurn t = p.turn("c1", heard);
|
||||
ASSERT_EQ(t.transcript, "wat is het weer");
|
||||
ASSERT_EQ(t.reply, "Zonnig.");
|
||||
ASSERT_EQ(t.audio.mime, "audio/wav");
|
||||
ASSERT_EQ(t.audio.bytes.substr(44), "SPEECH");
|
||||
rig.mock->verify();
|
||||
ASSERT_TRUE(rig.mock->seen()[0].target.rfind("/v1/publishers/google/", 0) == 0);
|
||||
unsetenv("GOOGLE_GENAI_MODEL");
|
||||
unsetenv("GOOGLE_STT_MODEL");
|
||||
unsetenv("GOOGLE_TTS_MODEL");
|
||||
}
|
||||
|
||||
// ---- live tests: real network, opt-in -------------------------------------
|
||||
// MOLO_LIVE_NET=1 enables the TLS check (no key needed). GOOGLE_API_KEY
|
||||
// additionally enables a real synthesis. Without them the case prints SKIP
|
||||
// and passes; the skip is visible in the output, never silent.
|
||||
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
|
||||
#include "clients/transports/http_transport.h"
|
||||
|
||||
TEST(google_live, tls_handshake_with_google) {
|
||||
if (!std::getenv("MOLO_LIVE_NET")) {
|
||||
std::cout << "SKIP google_live.tls_handshake_with_google (set MOLO_LIVE_NET=1)\n";
|
||||
return;
|
||||
}
|
||||
// Regression: a wire-format ALPN list made Google answer a fatal alert.
|
||||
try {
|
||||
TextToSpeech(std::make_shared<GoogleClient>(
|
||||
std::make_unique<molo::clients::transports::HttpTransport>(),
|
||||
Credentials::api_key("not-a-real-key")))
|
||||
.voices();
|
||||
FAIL("a bogus key must be rejected");
|
||||
} catch (const GoogleError& e) {
|
||||
// Reaching Google and being refused proves TLS plus error mapping.
|
||||
ASSERT_TRUE(e.http_status() == 400 || e.http_status() == 403);
|
||||
ASSERT_TRUE(e.status() != "UNAVAILABLE");
|
||||
}
|
||||
}
|
||||
|
||||
TEST(google_live, real_speech_roundtrip) {
|
||||
// Uses whatever backend the key implies (GOOGLE_API_BACKEND / key prefix).
|
||||
// Speaks a sentence, then transcribes the audio it got back.
|
||||
if (!std::getenv("MOLO_LIVE_NET") || Credentials::env().empty()) {
|
||||
std::cout << "SKIP google_live.real_speech_roundtrip (set MOLO_LIVE_NET=1 and a Google key)\n";
|
||||
return;
|
||||
}
|
||||
VoiceParts parts = make_voice_parts(GoogleClient::from_env(), voice_backend_from_env());
|
||||
SynthesisRequest say;
|
||||
say.text = "Hello, this is a test of the voice pipeline.";
|
||||
say.language = "en-US";
|
||||
Audio audio = parts.synthesizer->synthesize(say);
|
||||
ASSERT_TRUE(audio.bytes.size() > 5000);
|
||||
RecognitionRequest heard;
|
||||
heard.audio = audio.bytes;
|
||||
SpeechEncoding enc;
|
||||
ASSERT_TRUE(speech_encoding_from_mime(audio.mime, enc));
|
||||
heard.encoding = enc;
|
||||
heard.language = "en-US";
|
||||
Transcript t = parts.recognizer->recognize(heard);
|
||||
std::cout << " heard: " << t.text << "\n";
|
||||
ASSERT_TRUE(t.text.find("voice") != std::string::npos ||
|
||||
t.text.find("Voice") != std::string::npos);
|
||||
}
|
||||
Reference in New Issue
Block a user