import asyncio import json import threading from unittest.mock import AsyncMock, MagicMock, patch import pytest from elevenlabs.conversational_ai.conversation import ( AsyncAudioInterface, AsyncConversation, ConversationInitiationData, ) class MockAsyncAudioInterface(AsyncAudioInterface): async def start(self, input_callback): print("Async audio interface started") self.input_callback = input_callback async def stop(self): print("Async audio interface stopped") async def output(self, audio): print(f"Would play audio of length: {len(audio)} bytes") async def interrupt(self): print("Async audio interrupted") # Add test constants and helpers at module level TEST_CONVERSATION_ID = "test123" TEST_AGENT_ID = "test_agent" def create_mock_async_websocket(messages=None): """Helper to create a mock async websocket with predefined responses""" mock_ws = AsyncMock() if messages is None: messages = [ { "type": "conversation_initiation_metadata", "conversation_initiation_metadata_event": {"conversation_id": TEST_CONVERSATION_ID}, }, {"type": "agent_response", "agent_response_event": {"agent_response": "Hello there!"}}, ] # Convert messages to JSON strings json_messages = [json.dumps(msg) for msg in messages] # Create an iterator message_iter = iter(json_messages) async def mock_recv(): try: return next(message_iter) except StopIteration: # After all messages, simulate timeout by sleeping forever # This will be caught by asyncio.wait_for timeout in the conversation await asyncio.sleep(float("inf")) mock_ws.recv = mock_recv return mock_ws @pytest.mark.asyncio async def test_async_conversation_basic_flow(): # Mock setup mock_ws = create_mock_async_websocket() mock_client = MagicMock() mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io" agent_response_callback = AsyncMock() test_user_id = "test_user_123" # Setup the conversation with user_id passed directly to the constructor conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, user_id=test_user_id, requires_auth=False, audio_interface=MockAsyncAudioInterface(), callback_agent_response=agent_response_callback, ) # Run the test with patch("elevenlabs.conversational_ai.conversation.websockets.connect") as mock_connect: mock_connect.return_value.__aenter__.return_value = mock_ws await conversation.start_session() # Wait a bit for the callback to be called await asyncio.sleep(0.1) await conversation.end_session() await conversation.wait_for_session_end() # Assertions - check the call was made with the right structure send_calls = [call[0][0] for call in mock_ws.send.call_args_list] init_messages = [json.loads(call) for call in send_calls if "conversation_initiation_client_data" in call] assert len(init_messages) == 1 init_message = init_messages[0] assert init_message["type"] == "conversation_initiation_client_data" assert init_message["custom_llm_extra_body"] == {} assert init_message["conversation_config_override"] == {} assert init_message["dynamic_variables"] == {} assert init_message["source_info"]["source"] == "python_sdk" assert "version" in init_message["source_info"] assert init_message["user_id"] == test_user_id agent_response_callback.assert_called_once_with("Hello there!") assert conversation._conversation_id == TEST_CONVERSATION_ID assert conversation.user_id == test_user_id @pytest.mark.asyncio async def test_async_conversation_with_auth(): # Mock setup mock_client = MagicMock() mock_client.conversational_ai.conversations.get_signed_url.return_value.signed_url = "wss://signed.url" mock_ws = create_mock_async_websocket( [ { "type": "conversation_initiation_metadata", "conversation_initiation_metadata_event": {"conversation_id": TEST_CONVERSATION_ID}, } ] ) conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, requires_auth=True, audio_interface=MockAsyncAudioInterface(), ) # Run the test with patch("elevenlabs.conversational_ai.conversation.websockets.connect") as mock_connect: mock_connect.return_value.__aenter__.return_value = mock_ws await conversation.start_session() await conversation.end_session() await conversation.wait_for_session_end() # Assertions mock_client.conversational_ai.conversations.get_signed_url.assert_called_once_with(agent_id=TEST_AGENT_ID, environment=None) @pytest.mark.asyncio async def test_async_conversation_gets_signed_url_off_event_loop(): conversation = AsyncConversation(client=MagicMock(), agent_id=TEST_AGENT_ID, requires_auth=True) event_loop_thread = threading.get_ident() def get_signed_url(): assert threading.get_ident() != event_loop_thread return "wss://signed.url" with patch.object(conversation, "_get_signed_url", side_effect=get_signed_url), patch.object( conversation, "_run", new=AsyncMock() ): await conversation.start_session() await conversation.wait_for_session_end() await conversation.end_session() @pytest.mark.asyncio async def test_async_conversation_with_dynamic_variables(): # Mock setup mock_ws = create_mock_async_websocket() mock_client = MagicMock() mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io" agent_response_callback = AsyncMock() dynamic_variables = {"name": "angelo"} config = ConversationInitiationData(dynamic_variables=dynamic_variables) # Setup the conversation conversation = AsyncConversation( client=mock_client, config=config, agent_id=TEST_AGENT_ID, requires_auth=False, audio_interface=MockAsyncAudioInterface(), callback_agent_response=agent_response_callback, ) # Run the test with patch("elevenlabs.conversational_ai.conversation.websockets.connect") as mock_connect: mock_connect.return_value.__aenter__.return_value = mock_ws await conversation.start_session() # Wait a bit for the callback to be called await asyncio.sleep(0.1) await conversation.end_session() await conversation.wait_for_session_end() # Assertions - check the call was made with the right structure send_calls = [call[0][0] for call in mock_ws.send.call_args_list] init_messages = [json.loads(call) for call in send_calls if "conversation_initiation_client_data" in call] assert len(init_messages) == 1 init_message = init_messages[0] assert init_message["type"] == "conversation_initiation_client_data" assert init_message["custom_llm_extra_body"] == {} assert init_message["conversation_config_override"] == {} assert init_message["dynamic_variables"] == {"name": "angelo"} assert init_message["source_info"]["source"] == "python_sdk" assert "version" in init_message["source_info"] agent_response_callback.assert_called_once_with("Hello there!") assert conversation._conversation_id == TEST_CONVERSATION_ID @pytest.mark.asyncio async def test_async_conversation_with_contextual_update(): # Mock setup mock_ws = create_mock_async_websocket([]) mock_client = MagicMock() mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io" # Setup the conversation conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, requires_auth=False, audio_interface=MockAsyncAudioInterface(), ) # Run the test with patch("elevenlabs.conversational_ai.conversation.websockets.connect") as mock_connect: mock_connect.return_value.__aenter__.return_value = mock_ws await conversation.start_session() await asyncio.sleep(0.1) await conversation.send_contextual_update("User appears to be looking at pricing page") # Teardown await conversation.end_session() await conversation.wait_for_session_end() # Assertions expected = json.dumps({"type": "contextual_update", "text": "User appears to be looking at pricing page"}) mock_ws.send.assert_any_call(expected) @pytest.mark.asyncio async def test_async_conversation_send_user_message(): # Mock setup mock_ws = create_mock_async_websocket([]) mock_client = MagicMock() mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io" # Setup the conversation conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, requires_auth=False, audio_interface=MockAsyncAudioInterface(), ) # Run the test with patch("elevenlabs.conversational_ai.conversation.websockets.connect") as mock_connect: mock_connect.return_value.__aenter__.return_value = mock_ws await conversation.start_session() await asyncio.sleep(0.1) await conversation.send_user_message("Hello, how are you?") # Teardown await conversation.end_session() await conversation.wait_for_session_end() # Assertions expected = json.dumps({"type": "user_message", "text": "Hello, how are you?"}) mock_ws.send.assert_any_call(expected) @pytest.mark.asyncio async def test_async_conversation_register_user_activity(): # Mock setup mock_ws = create_mock_async_websocket([]) mock_client = MagicMock() mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io" # Setup the conversation conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, requires_auth=False, audio_interface=MockAsyncAudioInterface(), ) # Run the test with patch("elevenlabs.conversational_ai.conversation.websockets.connect") as mock_connect: mock_connect.return_value.__aenter__.return_value = mock_ws await conversation.start_session() await asyncio.sleep(0.1) await conversation.register_user_activity() # Teardown await conversation.end_session() await conversation.wait_for_session_end() # Assertions expected = json.dumps({"type": "user_activity"}) mock_ws.send.assert_any_call(expected) @pytest.mark.asyncio async def test_async_conversation_callback_flows(): # Mock setup for testing all callback types messages = [ { "type": "conversation_initiation_metadata", "conversation_initiation_metadata_event": {"conversation_id": TEST_CONVERSATION_ID}, }, {"type": "agent_response", "agent_response_event": {"agent_response": "Hello there!"}}, { "type": "agent_response_correction", "agent_response_correction_event": { "original_agent_response": "Hello ther!", "corrected_agent_response": "Hello there!", }, }, {"type": "user_transcript", "user_transcription_event": {"user_transcript": "Hi, how are you?"}}, {"type": "ping", "ping_event": {"event_id": "123", "ping_ms": 50}}, {"type": "interruption", "interruption_event": {"event_id": "456"}}, { "type": "audio", "audio_event": {"event_id": "789", "audio_base_64": "dGVzdA=="}, # "test" in base64 }, ] mock_ws = create_mock_async_websocket(messages) mock_client = MagicMock() mock_client._client_wrapper.get_base_url.return_value = "https://api.elevenlabs.io" # Setup callbacks agent_response_callback = AsyncMock() agent_response_correction_callback = AsyncMock() user_transcript_callback = AsyncMock() latency_measurement_callback = AsyncMock() end_session_callback = AsyncMock() # Setup the conversation conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, requires_auth=False, audio_interface=MockAsyncAudioInterface(), callback_agent_response=agent_response_callback, callback_agent_response_correction=agent_response_correction_callback, callback_user_transcript=user_transcript_callback, callback_latency_measurement=latency_measurement_callback, callback_end_session=end_session_callback, ) # Run the test with patch("elevenlabs.conversational_ai.conversation.websockets.connect") as mock_connect: mock_connect.return_value.__aenter__.return_value = mock_ws await conversation.start_session() # Wait for callbacks to be processed await asyncio.sleep(0.2) await conversation.end_session() await conversation.wait_for_session_end() # Assertions agent_response_callback.assert_called_with("Hello there!") agent_response_correction_callback.assert_called_with("Hello ther!", "Hello there!") user_transcript_callback.assert_called_with("Hi, how are you?") latency_measurement_callback.assert_called_with(50) end_session_callback.assert_called_once() assert conversation._conversation_id == TEST_CONVERSATION_ID assert conversation._last_interrupt_id == 456 @pytest.mark.asyncio async def test_async_conversation_wss_url_generation_without_get_environment(): from elevenlabs.core.client_wrapper import SyncClientWrapper # Test with various base URL formats to ensure robustness test_cases = [ ("https://api.elevenlabs.io", "wss://api.elevenlabs.io"), ("https://api.us.elevenlabs.io", "wss://api.us.elevenlabs.io"), ("https://api.eu.residency.elevenlabs.io", "wss://api.eu.residency.elevenlabs.io"), ("http://localhost:8000", "ws://localhost:8000"), ] for base_url, expected_ws_base in test_cases: # Create a real SyncClientWrapper to ensure it doesn't have get_environment method mock_client = MagicMock() mock_client._client_wrapper = SyncClientWrapper( base_url=base_url, api_key="test_key", httpx_client=MagicMock(), timeout=30.0 ) conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, requires_auth=False, audio_interface=MockAsyncAudioInterface() ) try: wss_url = conversation._get_wss_url() # Verify the URL is correctly generated expected_url = ( f"{expected_ws_base}/v1/convai/conversation?agent_id={TEST_AGENT_ID}&source=python_sdk&version=" ) assert wss_url.startswith(expected_url), f"URL should start with {expected_url}, got {wss_url}" # Verify the URL contains version parameter assert "version=" in wss_url, f"URL should contain version parameter, got {wss_url}" except AttributeError as e: if "get_environment" in str(e): assert False else: raise # Re-raise if it's a different AttributeError except Exception as e: assert False, f"Unexpected error generating WebSocket URL: {e}" @pytest.mark.asyncio async def test_async_websocket_url_construction_edge_cases(): """Test WebSocket URL construction edge cases for async conversation, specifically for trailing slash handling.""" from elevenlabs.conversational_ai.conversation import AsyncConversation from elevenlabs.core.client_wrapper import SyncClientWrapper # Test cases with various base URL formats test_cases = [ # Base URLs without trailing slashes (the main edge case) ("https://api.eu.residency.elevenlabs.io", "wss://api.eu.residency.elevenlabs.io"), ("https://api.elevenlabs.io", "wss://api.elevenlabs.io"), ("http://localhost:8000", "ws://localhost:8000"), # Base URLs with trailing slashes (should still work) ("https://api.eu.residency.elevenlabs.io/", "wss://api.eu.residency.elevenlabs.io"), ("https://api.elevenlabs.io/", "wss://api.elevenlabs.io"), ("http://localhost:8000/", "ws://localhost:8000"), ] for base_url, expected_ws_base in test_cases: # Test async conversation WebSocket URL construction mock_client = MagicMock() mock_client._client_wrapper = SyncClientWrapper( base_url=base_url, api_key="test_key", httpx_client=MagicMock(), timeout=30.0 ) conversation = AsyncConversation( client=mock_client, agent_id=TEST_AGENT_ID, requires_auth=False, audio_interface=MockAsyncAudioInterface() ) # Test conversation URL generation conv_url = conversation._get_wss_url() expected_conv_url = f"{expected_ws_base}/v1/convai/conversation" assert ( expected_conv_url in conv_url ), f"Async conversation URL should contain {expected_conv_url}, got {conv_url}" # Ensure no double slashes in the path (except after the protocol) url_path = conv_url.split("://", 1)[1] # Remove protocol assert "//" not in url_path, f"Async conversation URL should not contain double slashes in path: {conv_url}"