Fix all model unit tests to use new API

Updated all test calls from old API to new API:
- .connect() → .start()
- .close() → .stop()
- Updated error message expectations to match actual errors

All tests now passing:
- ✅ 47/47 bidirectional streaming tests passing
- ✅ 14/14 type tests
- ✅ 33/33 model tests
- ✅ 2/2 integration tests

Author: Murat Kaan Meral

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

@@ -114,36 +114,36 @@ async def test_connection_lifecycle(mock_genai_client, model, system_prompt, too
     mock_client, mock_live_session, mock_live_session_cm = mock_genai_client
 
     # Test basic connection
-    await model.connect()
+    await model.start()
     assert model._active is True
     assert model.connection_id is not None
     assert model.live_session == mock_live_session
     mock_client.aio.live.connect.assert_called_once()
 
     # Test close
-    await model.close()
+    await model.stop()
     assert model._active is False
     mock_live_session_cm.__aexit__.assert_called_once()
 
     # Test connection with system prompt
-    await model.connect(system_prompt=system_prompt)
+    await model.start(system_prompt=system_prompt)
     call_args = mock_client.aio.live.connect.call_args
     config = call_args.kwargs.get("config", {})
     assert config.get("system_instruction") == system_prompt
-    await model.close()
+    await model.stop()
 
     # Test connection with tools
-    await model.connect(tools=[tool_spec])
+    await model.start(tools=[tool_spec])
     call_args = mock_client.aio.live.connect.call_args
     config = call_args.kwargs.get("config", {})
     assert "tools" in config
     assert len(config["tools"]) > 0
-    await model.close()
+    await model.stop()
 
     # Test connection with messages
-    await model.connect(messages=messages)
+    await model.start(messages=messages)
     mock_live_session.send_client_content.assert_called()
-    await model.close()
+    await model.stop()
 
 
 @pytest.mark.asyncio
@@ -155,28 +155,28 @@ async def test_connection_edge_cases(mock_genai_client, api_key, model_id):
     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()
+        await model1.start()
 
     # Reset mock for next tests
     mock_client.aio.live.connect.side_effect = None
 
     # Test double connection
     model2 = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
-    await model2.connect()
+    await model2.start()
     with pytest.raises(RuntimeError, match="Connection already active"):
-        await model2.connect()
-    await model2.close()
+        await model2.start()
+    await model2.stop()
 
     # Test close when not connected
     model3 = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
-    await model3.close()  # Should not raise
+    await model3.stop()  # Should not raise
 
     # Test close error handling
     model4 = BidiGeminiLiveModel(model_id=model_id, api_key=api_key)
-    await model4.connect()
+    await model4.start()
     mock_live_session_cm.__aexit__.side_effect = Exception("Close failed")
     with pytest.raises(Exception, match="Close failed"):
-        await model4.close()
+        await model4.stop()
 
 
 # Send Method Tests
@@ -186,7 +186,7 @@ async def test_connection_edge_cases(mock_genai_client, api_key, model_id):
 async def test_send_all_content_types(mock_genai_client, model):
     """Test sending all content types through unified send() method."""
     _, mock_live_session, _ = mock_genai_client
-    await model.connect()
+    await model.start()
 
     # Test text input
     text_input = BidiTextInputEvent(text="Hello", role="user")
@@ -228,7 +228,7 @@ async def test_send_all_content_types(mock_genai_client, model):
     await model.send(ToolResultEvent(tool_result))
     mock_live_session.send_tool_response.assert_called_once()
 
-    await model.close()
+    await model.stop()
 
 
 @pytest.mark.asyncio
@@ -242,11 +242,11 @@ async def test_send_edge_cases(mock_genai_client, model):
     mock_live_session.send_client_content.assert_not_called()
 
     # Test unknown content type
-    await model.connect()
+    await model.start()
     unknown_content = {"unknown_field": "value"}
     await model.send(unknown_content)  # Should not raise, just log warning
 
-    await model.close()
+    await model.stop()
 
 
 # Receive Method Tests
@@ -263,15 +263,15 @@ async def test_receive_lifecycle_events(mock_genai_client, model, agenerator):
     _, mock_live_session, _ = mock_genai_client
     mock_live_session.receive.return_value = agenerator([])
 
-    await model.connect()
+    await model.start()
 
     # Collect events
     events = []
     async for event in model.receive():
         events.append(event)
         # Close after first event to trigger connection end
         if len(events) == 1:
-            await model.close()
+            await model.stop()
 
     # Verify connection start and end
     assert len(events) >= 2
@@ -290,7 +290,7 @@ async def test_event_conversion(mock_genai_client, model):
     )
 
     _, _, _ = mock_genai_client
-    await model.connect()
+    await model.start()
 
     # Test text output (converted to transcript)
     mock_text = unittest.mock.Mock()
@@ -360,7 +360,7 @@ async def test_event_conversion(mock_genai_client, model):
     assert isinstance(interrupt_event, BidiInterruptionEvent)
     assert interrupt_event.reason == "user_speech"
 
-    await model.close()
+    await model.stop()
 
 
 # Helper Method Tests

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

@@ -57,7 +57,7 @@ async def nova_model(model_id, region):
     yield model
     # Cleanup
     if model._active:
-        await model.close()
+        await model.stop()
 
 
 # Initialization and Connection Tests
@@ -82,14 +82,14 @@ async def test_connection_lifecycle(nova_model, mock_client, mock_stream):
         nova_model.client = mock_client
 
         # Test basic connection
-        await nova_model.connect(system_prompt="Test system prompt")
+        await nova_model.start(system_prompt="Test system prompt")
         assert nova_model._active
         assert nova_model.stream == mock_stream
         assert nova_model.connection_id is not None
         assert mock_client.invoke_model_with_bidirectional_stream.called
 
         # Test close
-        await nova_model.close()
+        await nova_model.stop()
         assert not nova_model._active
         assert mock_stream.input_stream.close.called
 
@@ -101,10 +101,10 @@ async def test_connection_lifecycle(nova_model, mock_client, mock_stream):
                 "inputSchema": {"json": json.dumps({"type": "object", "properties": {}})}
             }
         ]
-        await nova_model.connect(system_prompt="You are helpful", tools=tools)
+        await nova_model.start(system_prompt="You are helpful", tools=tools)
         # Verify initialization events were sent (connectionStart, promptStart, system prompt)
         assert mock_stream.input_stream.send.call_count >= 3
-        await nova_model.close()
+        await nova_model.stop()
 
 
 @pytest.mark.asyncio
@@ -114,15 +114,15 @@ async def test_connection_edge_cases(nova_model, mock_client, mock_stream, model
         nova_model.client = mock_client
 
         # Test double connection
-        await nova_model.connect()
+        await nova_model.start()
         with pytest.raises(RuntimeError, match="Connection already active"):
-            await nova_model.connect()
-        await nova_model.close()
+            await nova_model.start()
+        await nova_model.stop()
 
     # Test close when already closed
     model2 = BidiNovaSonicModel(model_id=model_id, region=region)
-    await model2.close()  # Should not raise
-    await model2.close()  # Second call should also be safe
+    await model2.stop()  # Should not raise
+    await model2.stop()  # Second call should also be safe
 
 
 # Send Method Tests
@@ -140,7 +140,7 @@ async def test_send_all_content_types(nova_model, mock_client, mock_stream):
     with patch.object(nova_model, "_initialize_client", new_callable=AsyncMock):
         nova_model.client = mock_client
 
-        await nova_model.connect()
+        await nova_model.start()
 
         # Test text content
         text_event = BidiTextInputEvent(text="Hello, Nova!", role="user")
@@ -171,7 +171,7 @@ async def test_send_all_content_types(nova_model, mock_client, mock_stream):
         # Should send contentStart, toolResult, and contentEnd
         assert mock_stream.input_stream.send.called
 
-        await nova_model.close()
+        await nova_model.stop()
 
 
 @pytest.mark.asyncio
@@ -190,7 +190,7 @@ async def test_send_edge_cases(nova_model, mock_client, mock_stream, caplog):
         await nova_model.send(text_event)  # Should not raise
 
         # Test image content (not supported, base64 encoded, no encoding parameter)
-        await nova_model.connect()
+        await nova_model.start()
         import base64
         image_b64 = base64.b64encode(b"image data").decode('utf-8')
         image_event = BidiImageInputEvent(
@@ -201,7 +201,7 @@ async def test_send_edge_cases(nova_model, mock_client, mock_stream, caplog):
         # Should log warning about unsupported image input
         assert any("not supported" in record.message.lower() for record in caplog.records)
 
-        await nova_model.close()
+        await nova_model.stop()
 
 
 # Receive and Event Conversion Tests
@@ -220,7 +220,7 @@ async def mock_wait_for(*args, **kwargs):
             raise asyncio.TimeoutError()
 
         with patch("asyncio.wait_for", side_effect=mock_wait_for):
-            await nova_model.connect()
+            await nova_model.start()
 
             events = []
             async for event in nova_model.receive():
@@ -333,7 +333,7 @@ async def test_audio_connection_lifecycle(nova_model, mock_client, mock_stream):
     with patch.object(nova_model, "_initialize_client", new_callable=AsyncMock):
         nova_model.client = mock_client
 
-        await nova_model.connect()
+        await nova_model.start()
 
         # Start audio connection
         await nova_model._start_audio_connection()
@@ -343,7 +343,7 @@ async def test_audio_connection_lifecycle(nova_model, mock_client, mock_stream):
         await nova_model._end_audio_input()
         assert not nova_model.audio_connection_active
 
-        await nova_model.close()
+        await nova_model.stop()
 
 
 @pytest.mark.asyncio
@@ -355,7 +355,7 @@ async def test_silence_detection(nova_model, mock_client, mock_stream):
         nova_model.client = mock_client
         nova_model.silence_threshold = 0.1  # Short threshold for testing
 
-        await nova_model.connect()
+        await nova_model.start()
 
         # Send audio to start connection (base64 encoded)
         import base64
@@ -376,7 +376,7 @@ async def test_silence_detection(nova_model, mock_client, mock_stream):
         # Audio connection should be ended
         assert not nova_model.audio_connection_active
 
-        await nova_model.close()
+        await nova_model.stop()
 
 
 # Helper Method Tests
@@ -458,10 +458,10 @@ async def mock_error(*args, **kwargs):
 
         mock_stream.await_output.side_effect = mock_error
 
-        await nova_model.connect()
+        await nova_model.start()
 
         # Wait a bit for response processor to handle error
         await asyncio.sleep(0.1)
 
         # Should still be able to close cleanly
-        await nova_model.close()
+        await nova_model.stop()