Update model unit tests to use new class names

Updated test imports and usages:
- GeminiLiveModel → BidiGeminiLiveModel
- NovaSonicModel → BidiNovaSonicModel
- OpenAIRealtimeModel → BidiOpenAIRealtimeModel

Note: 21 model tests still failing because they call .connect()
but models now use .start(). This is a pre-existing issue that
needs separate fix - tests need API update.

Author: Murat Kaan Meral

tests/strands/experimental/bidirectional_streaming/models/test_gemini_live.py

@@ -1,6 +1,6 @@
 """Unit tests for Gemini Live bidirectional streaming model.
 
-Tests the unified GeminiLiveModel interface including:
+Tests the unified BidiGeminiLiveModel interface including:
 - Model initialization and configuration
 - Connection establishment and lifecycle
 - Unified send() method with different content types
@@ -13,7 +13,7 @@
 from google import genai
 from google.genai import types as genai_types
 
-from strands.experimental.bidirectional_streaming.models.gemini_live import GeminiLiveModel
+from strands.experimental.bidirectional_streaming.models.gemini_live import BidiGeminiLiveModel
 from strands.experimental.bidirectional_streaming.types.events import (
     BidiAudioInputEvent,
     BidiImageInputEvent,
@@ -56,9 +56,9 @@ def api_key():
 
 @pytest.fixture
 def model(mock_genai_client, model_id, api_key):
-    """Create a GeminiLiveModel instance."""
+    """Create a BidiGeminiLiveModel instance."""
     _ = mock_genai_client
-    return GeminiLiveModel(model_id=model_id, api_key=api_key)
+    return BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
 
 
 @pytest.fixture
@@ -88,20 +88,20 @@ def test_model_initialization(mock_genai_client, model_id, api_key):
     _ = mock_genai_client
 
     # Test default config
-    model_default = GeminiLiveModel()
+    model_default = BidiGeminiLiveModel()
     assert model_default.model_id == "models/gemini-2.0-flash-live-preview-04-09"
     assert model_default.api_key is None
     assert model_default._active is False
     assert model_default.live_session is None
 
     # Test with API key
-    model_with_key = GeminiLiveModel(model_id=model_id, api_key=api_key)
+    model_with_key = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
     assert model_with_key.model_id == model_id
     assert model_with_key.api_key == api_key
 
     # Test with custom config
     live_config = {"temperature": 0.7, "top_p": 0.9}
-    model_custom = GeminiLiveModel(model_id=model_id, live_config=live_config)
+    model_custom = BidiGeminiLiveModel(model_id=model_id, live_config=live_config)
     assert model_custom.live_config == live_config
 
 
@@ -152,7 +152,7 @@ async def test_connection_edge_cases(mock_genai_client, api_key, model_id):
     mock_client, _, mock_live_session_cm = mock_genai_client
 
     # Test connection error
-    model1 = GeminiLiveModel(model_id=model_id, api_key=api_key)
+    model1 = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
     mock_client.aio.live.connect.side_effect = Exception("Connection failed")
     with pytest.raises(Exception, match="Connection failed"):
         await model1.connect()
@@ -161,18 +161,18 @@ async def test_connection_edge_cases(mock_genai_client, api_key, model_id):
     mock_client.aio.live.connect.side_effect = None
 
     # Test double connection
-    model2 = GeminiLiveModel(model_id=model_id, api_key=api_key)
+    model2 = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
     await model2.connect()
     with pytest.raises(RuntimeError, match="Connection already active"):
         await model2.connect()
     await model2.close()
 
     # Test close when not connected
-    model3 = GeminiLiveModel(model_id=model_id, api_key=api_key)
+    model3 = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
     await model3.close()  # Should not raise
 
     # Test close error handling
-    model4 = GeminiLiveModel(model_id=model_id, api_key=api_key)
+    model4 = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
     await model4.connect()
     mock_live_session_cm.__aexit__.side_effect = Exception("Close failed")
     with pytest.raises(Exception, match="Close failed"):

tests/strands/experimental/bidirectional_streaming/models/test_novasonic.py

@@ -13,7 +13,7 @@
 import pytest_asyncio
 
 from strands.experimental.bidirectional_streaming.models.novasonic import (
-    NovaSonicModel,
+    BidiNovaSonicModel,
 )
 from strands.types.tools import ToolResult
 
@@ -53,7 +53,7 @@ def mock_client(mock_stream):
 @pytest_asyncio.fixture
 async def nova_model(model_id, region):
     """Create Nova Sonic model instance."""
-    model = NovaSonicModel(model_id=model_id, region=region)
+    model = BidiNovaSonicModel(model_id=model_id, region=region)
     yield model
     # Cleanup
     if model._active:
@@ -66,7 +66,7 @@ async def nova_model(model_id, region):
 @pytest.mark.asyncio
 async def test_model_initialization(model_id, region):
     """Test model initialization with configuration."""
-    model = NovaSonicModel(model_id=model_id, region=region)
+    model = BidiNovaSonicModel(model_id=model_id, region=region)
 
     assert model.model_id == model_id
     assert model.region == region
@@ -120,7 +120,7 @@ async def test_connection_edge_cases(nova_model, mock_client, mock_stream, model
         await nova_model.close()
 
     # Test close when already closed
-    model2 = NovaSonicModel(model_id=model_id, region=region)
+    model2 = BidiNovaSonicModel(model_id=model_id, region=region)
     await model2.close()  # Should not raise
     await model2.close()  # Second call should also be safe
 

tests/strands/experimental/bidirectional_streaming/models/test_openai_realtime.py

@@ -1,6 +1,6 @@
 """Unit tests for OpenAI Realtime bidirectional streaming model.
 
-Tests the unified OpenAIRealtimeModel interface including:
+Tests the unified BidiOpenAIRealtimeModel interface including:
 - Model initialization and configuration
 - Connection establishment with WebSocket
 - Unified send() method with different content types
@@ -15,7 +15,7 @@
 
 import pytest
 
-from strands.experimental.bidirectional_streaming.models.openai import OpenAIRealtimeModel
+from strands.experimental.bidirectional_streaming.models.openai import BidiOpenAIRealtimeModel
 from strands.experimental.bidirectional_streaming.types.events import (
     BidiAudioInputEvent,
     BidiImageInputEvent,
@@ -56,8 +56,8 @@ def api_key():
 
 @pytest.fixture
 def model(api_key, model_name):
-    """Create an OpenAIRealtimeModel instance."""
-    return OpenAIRealtimeModel(model=model_name, api_key=api_key)
+    """Create an BidiOpenAIRealtimeModel instance."""
+    return BidiOpenAIRealtimeModel(model=model_name, api_key=api_key)
 
 
 @pytest.fixture
@@ -85,19 +85,19 @@ def messages():
 def test_model_initialization(api_key, model_name):
     """Test model initialization with various configurations."""
     # Test default config
-    model_default = OpenAIRealtimeModel(api_key="test-key")
+    model_default = BidiOpenAIRealtimeModel(api_key="test-key")
     assert model_default.model == "gpt-realtime"
     assert model_default.api_key == "test-key"
     assert model_default._active is False
     assert model_default.websocket is None
 
     # Test with custom model
-    model_custom = OpenAIRealtimeModel(model=model_name, api_key=api_key)
+    model_custom = BidiOpenAIRealtimeModel(model=model_name, api_key=api_key)
     assert model_custom.model == model_name
     assert model_custom.api_key == api_key
 
     # Test with organization and project
-    model_org = OpenAIRealtimeModel(
+    model_org = BidiOpenAIRealtimeModel(
         model=model_name,
         api_key=api_key,
         organization="org-123",
@@ -108,15 +108,15 @@ def test_model_initialization(api_key, model_name):
 
     # Test with env API key
     with unittest.mock.patch.dict("os.environ", {"OPENAI_API_KEY": "env-key"}):
-        model_env = OpenAIRealtimeModel()
+        model_env = BidiOpenAIRealtimeModel()
         assert model_env.api_key == "env-key"
 
 
 def test_init_without_api_key_raises():
     """Test that initialization without API key raises error."""
     with unittest.mock.patch.dict("os.environ", {}, clear=True):
         with pytest.raises(ValueError, match="OpenAI API key is required"):
-            OpenAIRealtimeModel()
+            BidiOpenAIRealtimeModel()
 
 
 # Connection Tests
@@ -171,7 +171,7 @@ async def test_connection_lifecycle(mock_websockets_connect, model, system_promp
     await model.close()
 
     # Test connection with organization header
-    model_org = OpenAIRealtimeModel(api_key="test-key", organization="org-123")
+    model_org = BidiOpenAIRealtimeModel(api_key="test-key", organization="org-123")
     await model_org.connect()
     call_kwargs = mock_connect.call_args.kwargs
     headers = call_kwargs.get("additional_headers", [])
@@ -187,7 +187,7 @@ async def test_connection_edge_cases(mock_websockets_connect, api_key, model_nam
     mock_connect, mock_ws = mock_websockets_connect
 
     # Test connection error
-    model1 = OpenAIRealtimeModel(model=model_name, api_key=api_key)
+    model1 = BidiOpenAIRealtimeModel(model=model_name, api_key=api_key)
     mock_connect.side_effect = Exception("Connection failed")
     with pytest.raises(Exception, match="Connection failed"):
         await model1.connect()
@@ -198,18 +198,18 @@ async def async_connect(*args, **kwargs):
     mock_connect.side_effect = async_connect
 
     # Test double connection
-    model2 = OpenAIRealtimeModel(model=model_name, api_key=api_key)
+    model2 = BidiOpenAIRealtimeModel(model=model_name, api_key=api_key)
     await model2.connect()
     with pytest.raises(RuntimeError, match="Connection already active"):
         await model2.connect()
     await model2.close()
 
     # Test close when not connected
-    model3 = OpenAIRealtimeModel(model=model_name, api_key=api_key)
+    model3 = BidiOpenAIRealtimeModel(model=model_name, api_key=api_key)
     await model3.close()  # Should not raise
 
     # Test close error handling (should not raise, just log)
-    model4 = OpenAIRealtimeModel(model=model_name, api_key=api_key)
+    model4 = BidiOpenAIRealtimeModel(model=model_name, api_key=api_key)
     await model4.connect()
     mock_ws.close.side_effect = Exception("Close failed")
     await model4.close()  # Should not raise