elevenlabs-python / data /tests /test_speech_engine_session.py
introvoyz045's picture
Migrated from GitHub
9410704 verified
Raw History Blame Contribute Delete
26 kB
"""Tests for SpeechEngineSession — mirrors SpeechEngineSession.test.ts."""
import asyncio
import json
import typing
import pytest
from elevenlabs.speech_engine import (
CLOSE,
DISCONNECTED,
ERROR,
INIT,
USER_TRANSCRIPT,
ConversationMessage,
SpeechEngineSession,
)
# ---------------------------------------------------------------------------
# MockWebSocket
# ---------------------------------------------------------------------------
class MockWebSocket:
"""In-memory WebSocket stand-in backed by an asyncio.Queue."""
def __init__(self) -> None:
self._inbox = asyncio.Queue() # type: asyncio.Queue[typing.Any]
self.sent = [] # type: typing.List[str]
self.closed = False
async def recv(self) -> str:
msg = await self._inbox.get()
if msg is _CLOSE_SENTINEL:
raise ConnectionError("connection closed")
return msg
async def send(self, data: str) -> None:
self.sent.append(data)
async def close(self) -> None:
self.closed = True
# -- test helpers --
def receive_message(self, msg: typing.Dict[str, typing.Any]) -> None:
"""Inject an incoming message from the "ElevenLabs API"."""
self._inbox.put_nowait(json.dumps(msg))
def receive_raw(self, data: str) -> None:
"""Inject raw (possibly invalid) data."""
self._inbox.put_nowait(data)
def simulate_disconnect(self) -> None:
"""Simulate a WebSocket disconnection."""
self._inbox.put_nowait(_CLOSE_SENTINEL)
_CLOSE_SENTINEL = object()
# ---------------------------------------------------------------------------
# Fixtures
# ---------------------------------------------------------------------------
TRANSCRIPT = [
{"role": "agent", "content": "how can I help you today?"},
{"role": "user", "content": "I need a pizza"},
]
TRANSCRIPT_2 = [
{"role": "agent", "content": "how can I help you today?"},
{"role": "user", "content": "I need a pizza"},
{"role": "agent", "content": "what size?"},
{"role": "user", "content": "large"},
]
@pytest.fixture
def ws() -> MockWebSocket:
return MockWebSocket()
@pytest.fixture
def session(ws: MockWebSocket) -> SpeechEngineSession:
return SpeechEngineSession(ws)
# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------
def _parsed_sent(ws: MockWebSocket) -> typing.List[typing.Dict[str, typing.Any]]:
return [json.loads(s) for s in ws.sent]
async def _run_until_idle(session: SpeechEngineSession, ws: MockWebSocket) -> None:
"""Drive the session run loop, then disconnect so it returns."""
ws.simulate_disconnect()
await session.run()
# ---------------------------------------------------------------------------
# init event
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_emits_init_with_conversation_id(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
captured = [] # type: typing.List[str]
async def handler(conversation_id: str) -> None:
captured.append(conversation_id)
session.on(INIT, handler)
ws.receive_message({"type": "init", "conversation_id": "conv_42"})
await _run_until_idle(session, ws)
assert captured == ["conv_42"]
assert session.conversation_id == "conv_42"
# ---------------------------------------------------------------------------
# user_transcript events
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_emits_user_transcript_with_conversation_history(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
captured = [] # type: typing.List[typing.List[ConversationMessage]]
async def handler(transcript: typing.List[ConversationMessage]) -> None:
captured.append(transcript)
session.on(USER_TRANSCRIPT, handler)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 1}
)
await _run_until_idle(session, ws)
assert len(captured) == 1
assert len(captured[0]) == 2
assert captured[0][0].role == "agent"
assert captured[0][0].content == "how can I help you today?"
assert captured[0][1].role == "user"
assert captured[0][1].content == "I need a pizza"
@pytest.mark.asyncio
async def test_cancels_previous_handler_on_new_transcript(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
"""When a new transcript arrives the previous handler task is cancelled."""
cancelled = asyncio.Event()
async def slow_handler(transcript: typing.List[ConversationMessage]) -> None:
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
cancelled.set()
raise
session.on(USER_TRANSCRIPT, slow_handler)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 1}
)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT_2, "event_id": 2}
)
await _run_until_idle(session, ws)
assert cancelled.is_set()
# ---------------------------------------------------------------------------
# ping / pong
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_auto_responds_to_ping(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message({"type": "ping"})
await _run_until_idle(session, ws)
assert len(ws.sent) == 1
assert json.loads(ws.sent[0]) == {"type": "pong"}
# ---------------------------------------------------------------------------
# close event (protocol-level)
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_emits_close_and_cancels_handler_on_close_message(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
close_called = asyncio.Event()
cancelled = asyncio.Event()
async def close_handler() -> None:
close_called.set()
async def slow_handler(transcript: typing.List[ConversationMessage]) -> None:
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
cancelled.set()
raise
session.on(CLOSE, close_handler)
session.on(USER_TRANSCRIPT, slow_handler)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 1}
)
ws.receive_message({"type": "close"})
await _run_until_idle(session, ws)
assert close_called.is_set()
assert cancelled.is_set()
# ---------------------------------------------------------------------------
# error event (protocol-level)
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_emits_error_on_protocol_error_message(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
errors = [] # type: typing.List[Exception]
async def handler(err: Exception) -> None:
errors.append(err)
session.on(ERROR, handler)
ws.receive_message({"type": "error", "message": "something went wrong"})
await _run_until_idle(session, ws)
assert len(errors) == 1
assert isinstance(errors[0], Exception)
assert str(errors[0]) == "something went wrong"
# ---------------------------------------------------------------------------
# WebSocket-level events
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_emits_disconnected_when_websocket_closes(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
disconnected = asyncio.Event()
async def handler() -> None:
disconnected.set()
session.on(DISCONNECTED, handler)
ws.simulate_disconnect()
await session.run()
assert disconnected.is_set()
assert not session.is_open
@pytest.mark.asyncio
async def test_cancels_handler_when_websocket_closes(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
cancelled = asyncio.Event()
async def slow_handler(transcript: typing.List[ConversationMessage]) -> None:
try:
await asyncio.sleep(10)
except asyncio.CancelledError:
cancelled.set()
raise
session.on(USER_TRANSCRIPT, slow_handler)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 1}
)
# Give the handler task a moment to start before disconnecting.
await asyncio.sleep(0)
ws.simulate_disconnect()
await session.run()
# The disconnect triggers _cancel_current in the finally block.
assert cancelled.is_set()
@pytest.mark.asyncio
async def test_emits_error_on_malformed_json(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
errors = [] # type: typing.List[Exception]
async def handler(err: Exception) -> None:
errors.append(err)
session.on(ERROR, handler)
ws.receive_raw("not json")
await _run_until_idle(session, ws)
assert len(errors) == 1
@pytest.mark.asyncio
async def test_ignores_unknown_message_types(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
errors = [] # type: typing.List[Exception]
async def handler(err: Exception) -> None:
errors.append(err)
session.on(ERROR, handler)
ws.receive_message({"type": "unknown_future_event", "data": 123})
await _run_until_idle(session, ws)
assert len(errors) == 0
# ---------------------------------------------------------------------------
# sendResponse (string)
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_sends_string_response_with_event_id_and_is_final(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 5}
)
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response("The answer is 42")
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
assert len(sent) == 2
assert sent[0] == {
"type": "agent_response",
"content": "The answer is 42",
"event_id": 5,
"is_final": False,
}
assert sent[1] == {
"type": "agent_response",
"content": "",
"event_id": 5,
"is_final": True,
}
@pytest.mark.asyncio
async def test_raises_when_sending_after_close(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
session.close()
with pytest.raises(RuntimeError, match="session is closed"):
await session.send_response("too late")
# ---------------------------------------------------------------------------
# sendResponse (streaming)
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_streams_chunks_with_is_final_false_then_terminator(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 3}
)
async def tokens(): # type: ignore[return]
yield "Hello"
yield " world"
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response(tokens())
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
assert len(sent) == 3
assert sent[0] == {
"type": "agent_response",
"content": "Hello",
"event_id": 3,
"is_final": False,
}
assert sent[1] == {
"type": "agent_response",
"content": " world",
"event_id": 3,
"is_final": False,
}
assert sent[2] == {
"type": "agent_response",
"content": "",
"event_id": 3,
"is_final": True,
}
@pytest.mark.asyncio
async def test_stops_streaming_when_session_closed_mid_stream(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 7}
)
async def slow_tokens(): # type: ignore[return]
yield "first"
yield "second"
await asyncio.sleep(0.1)
yield "third"
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response(slow_tokens())
session.on(USER_TRANSCRIPT, handler)
# Start the run loop in the background.
task = asyncio.create_task(session.run())
# Let the handler task progress through the first two yields.
await asyncio.sleep(0.05)
session.close()
await asyncio.sleep(0.15)
task.cancel()
try:
await task
except asyncio.CancelledError:
pass
sent = _parsed_sent(ws)
chunks = [m for m in sent if m.get("type") == "agent_response"]
# "first" and "second" are sent; session closes before "third".
assert len(chunks) == 2
assert chunks[0] == {
"type": "agent_response",
"content": "first",
"event_id": 7,
"is_final": False,
}
assert chunks[1] == {
"type": "agent_response",
"content": "second",
"event_id": 7,
"is_final": False,
}
# ---------------------------------------------------------------------------
# sendResponse (LLM stream formats)
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_extracts_text_from_openai_responses_api(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 10}
)
async def openai_responses_stream(): # type: ignore[return]
yield {"type": "response.created", "response": {}}
yield {"type": "response.output_text.delta", "delta": "Hello"}
yield {"type": "response.output_text.delta", "delta": " world"}
yield {"type": "response.output_text.done", "text": "Hello world"}
yield {"type": "response.completed", "response": {}}
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response(openai_responses_stream())
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
assert len(sent) == 3
assert sent[0] == {
"type": "agent_response",
"content": "Hello",
"event_id": 10,
"is_final": False,
}
assert sent[1] == {
"type": "agent_response",
"content": " world",
"event_id": 10,
"is_final": False,
}
assert sent[2] == {
"type": "agent_response",
"content": "",
"event_id": 10,
"is_final": True,
}
@pytest.mark.asyncio
async def test_extracts_text_from_openai_chat_completions_api(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 11}
)
async def openai_chat_stream(): # type: ignore[return]
yield {"choices": [{"delta": {"role": "assistant"}}]}
yield {"choices": [{"delta": {"content": "Hi"}}]}
yield {"choices": [{"delta": {"content": " there"}}]}
yield {"choices": [{"delta": {}}]}
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response(openai_chat_stream())
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
assert len(sent) == 3
assert sent[0] == {
"type": "agent_response",
"content": "Hi",
"event_id": 11,
"is_final": False,
}
assert sent[1] == {
"type": "agent_response",
"content": " there",
"event_id": 11,
"is_final": False,
}
assert sent[2] == {
"type": "agent_response",
"content": "",
"event_id": 11,
"is_final": True,
}
@pytest.mark.asyncio
async def test_extracts_text_from_anthropic_messages_api(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 12}
)
async def anthropic_stream(): # type: ignore[return]
yield {"type": "message_start", "message": {}}
yield {"type": "content_block_start", "content_block": {"type": "text", "text": ""}}
yield {"type": "content_block_delta", "delta": {"type": "text_delta", "text": "Good"}}
yield {"type": "content_block_delta", "delta": {"type": "text_delta", "text": " morning"}}
yield {"type": "content_block_stop"}
yield {"type": "message_stop"}
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response(anthropic_stream())
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
assert len(sent) == 3
assert sent[0] == {
"type": "agent_response",
"content": "Good",
"event_id": 12,
"is_final": False,
}
assert sent[1] == {
"type": "agent_response",
"content": " morning",
"event_id": 12,
"is_final": False,
}
assert sent[2] == {
"type": "agent_response",
"content": "",
"event_id": 12,
"is_final": True,
}
@pytest.mark.asyncio
async def test_extracts_text_from_gemini_api(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 13}
)
async def gemini_stream(): # type: ignore[return]
yield {"candidates": [{"content": {"parts": [{"text": "Hey"}], "role": "model"}}]}
yield {"candidates": [{"content": {"parts": [{"text": " buddy"}], "role": "model"}}]}
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response(gemini_stream())
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
assert len(sent) == 3
assert sent[0] == {
"type": "agent_response",
"content": "Hey",
"event_id": 13,
"is_final": False,
}
assert sent[1] == {
"type": "agent_response",
"content": " buddy",
"event_id": 13,
"is_final": False,
}
assert sent[2] == {
"type": "agent_response",
"content": "",
"event_id": 13,
"is_final": True,
}
@pytest.mark.asyncio
async def test_skips_unrecognized_stream_events(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 14}
)
async def mixed_stream(): # type: ignore[return]
yield {"type": "unknown_event", "data": 123}
yield {"type": "response.output_text.delta", "delta": "text"}
yield 42
yield None
async def handler(transcript: typing.List[ConversationMessage]) -> None:
await session.send_response(mixed_stream())
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
assert len(sent) == 2
assert sent[0] == {
"type": "agent_response",
"content": "text",
"event_id": 14,
"is_final": False,
}
assert sent[1] == {
"type": "agent_response",
"content": "",
"event_id": 14,
"is_final": True,
}
# ---------------------------------------------------------------------------
# event_id tracking across interrupts
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_stamps_correct_event_id_after_interrupt(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 1}
)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT_2, "event_id": 2}
)
async def handler(transcript: typing.List[ConversationMessage]) -> None:
# Non-blocking so both handlers complete within the run loop.
await session.send_response("response")
session.on(USER_TRANSCRIPT, handler)
await _run_until_idle(session, ws)
sent = _parsed_sent(ws)
# Each sendResponse emits content + terminator = 2 messages.
# The first handler's task may or may not complete before cancellation;
# the second handler's response should use event_id 2.
# Filter to the final handler's messages (event_id=2):
id2 = [m for m in sent if m.get("event_id") == 2]
assert len(id2) == 2
assert id2[0]["content"] == "response"
assert id2[0]["is_final"] is False
assert id2[1]["content"] == ""
assert id2[1]["is_final"] is True
# ---------------------------------------------------------------------------
# close()
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_close_is_idempotent(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
session.close()
session.close()
assert not session.is_open
# ---------------------------------------------------------------------------
# Event constants
# ---------------------------------------------------------------------------
def test_event_constants() -> None:
assert INIT == "init"
assert USER_TRANSCRIPT == "user_transcript"
assert CLOSE == "close"
assert ERROR == "error"
assert DISCONNECTED == "disconnected"
# ---------------------------------------------------------------------------
# on / off / once
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_off_removes_handler(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
calls = [] # type: typing.List[str]
async def handler(conversation_id: str) -> None:
calls.append(conversation_id)
session.on(INIT, handler)
session.off(INIT, handler)
ws.receive_message({"type": "init", "conversation_id": "conv_1"})
await _run_until_idle(session, ws)
assert calls == []
@pytest.mark.asyncio
async def test_once_fires_only_once(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
calls = [] # type: typing.List[str]
async def handler(conversation_id: str) -> None:
calls.append(conversation_id)
session.once(INIT, handler)
ws.receive_message({"type": "init", "conversation_id": "conv_1"})
ws.receive_message({"type": "init", "conversation_id": "conv_2"})
await _run_until_idle(session, ws)
assert calls == ["conv_1"]
# ---------------------------------------------------------------------------
# Transcript deduplication
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_skips_duplicate_event_id(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
"""Duplicate transcripts with the same event_id are ignored."""
call_count = 0
async def handler(transcript: typing.List[ConversationMessage]) -> None:
nonlocal call_count
call_count += 1
await asyncio.sleep(0.5)
session.on(USER_TRANSCRIPT, handler)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 30}
)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 30}
)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 30}
)
await _run_until_idle(session, ws)
assert call_count == 1
@pytest.mark.asyncio
async def test_does_not_skip_different_event_id(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
"""Different event_ids are processed normally."""
call_count = 0
async def handler(transcript: typing.List[ConversationMessage]) -> None:
nonlocal call_count
call_count += 1
session.on(USER_TRANSCRIPT, handler)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT, "event_id": 1}
)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT_2, "event_id": 2}
)
await _run_until_idle(session, ws)
assert call_count == 2
@pytest.mark.asyncio
async def test_does_not_deduplicate_when_event_id_is_none(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
"""Transcripts without event_id should never be deduplicated."""
call_count = 0
async def handler(transcript: typing.List[ConversationMessage]) -> None:
nonlocal call_count
call_count += 1
session.on(USER_TRANSCRIPT, handler)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT}
)
ws.receive_message(
{"type": "user_transcript", "user_transcript": TRANSCRIPT_2}
)
await _run_until_idle(session, ws)
assert call_count == 2
# ---------------------------------------------------------------------------
# send_response outside on_transcript
# ---------------------------------------------------------------------------
@pytest.mark.asyncio
async def test_send_response_warns_outside_transcript(
ws: MockWebSocket, session: SpeechEngineSession
) -> None:
"""send_response before any transcript should warn and not send."""
await session.send_response("hello")
assert len(ws.sent) == 0