Update test mockings

Author: jakozaur

tests/test_model_client.py

@@ -73,12 +73,10 @@ def test_model_not_available(self, mock_get) -> None:
         client = OllamaClient()
         assert client.is_model_available() is False
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_model_availability_error_handling(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.get')
+    def test_model_availability_error_handling(self, mock_get) -> None:
         """Test error handling in model availability check"""
-        mock_session = MagicMock()
-        mock_session.get.side_effect = RequestsConnectionError("Connection failed")
-        mock_session_class.return_value = mock_session
+        mock_get.side_effect = RequestsConnectionError("Connection failed")
 
         client = OllamaClient()
         assert client.is_model_available() is False
@@ -87,19 +85,18 @@ def test_model_availability_error_handling(self, mock_session_class) -> None:
 class TestOllamaClientGenerate:
     """Test response generation"""
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_generate_simple_response(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_generate_simple_response(self, mock_post) -> None:
         """Test successful response generation"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         mock_response.json.return_value = {
             "model": "gpt-oss:20b",
             "response": "This is a test response",
             "done": True,
             "total_duration": 1500000000,
         }
-        mock_session.post.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
 
         client = OllamaClient()
         response = client.generate("Test prompt")
@@ -110,19 +107,18 @@ def test_generate_simple_response(self, mock_session_class) -> None:
         assert response.error is None
         assert response.timed_out is False
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_generate_with_thinking(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_generate_with_thinking(self, mock_post) -> None:
         """Test response generation with thinking tags"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         mock_response.json.return_value = {
             "model": "gpt-oss:20b",
             "response": "<thinking>Internal thoughts</thinking>Public response",
             "done": True,
             "total_duration": 2000000000,
         }
-        mock_session.post.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
 
         client = OllamaClient()
         response = client.generate("Test prompt")
@@ -132,33 +128,30 @@ def test_generate_with_thinking(self, mock_session_class) -> None:
         # thinking field is set to None since extraction not implemented
         assert response.thinking is None or response.thinking == ""
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_generate_with_system_prompt(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_generate_with_system_prompt(self, mock_post) -> None:
         """Test generation with system prompt"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         mock_response.json.return_value = {
             "model": "gpt-oss:20b",
             "response": "Response with system context",
             "done": True,
         }
-        mock_session.post.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
 
         client = OllamaClient()
         client.generate("User prompt", "System prompt")
 
         # Verify the request was made with system prompt
-        call_args = mock_session.post.call_args
+        call_args = mock_post.call_args
         assert call_args[1]['json']['system'] == "System prompt"
         assert call_args[1]['json']['prompt'] == "User prompt"
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_generate_timeout_handling(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_generate_timeout_handling(self, mock_post) -> None:
         """Test timeout handling during generation"""
-        mock_session = MagicMock()
-        mock_session.post.side_effect = Timeout("Request timed out")
-        mock_session_class.return_value = mock_session
+        mock_post.side_effect = Timeout("Request timed out")
 
         client = OllamaClient()
         response = client.generate("Test prompt")
@@ -167,12 +160,10 @@ def test_generate_timeout_handling(self, mock_session_class) -> None:
         assert response.timed_out is True
         assert response.content == ""
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_generate_connection_error(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_generate_connection_error(self, mock_post) -> None:
         """Test connection error handling"""
-        mock_session = MagicMock()
-        mock_session.post.side_effect = RequestsConnectionError("Connection refused")
-        mock_session_class.return_value = mock_session
+        mock_post.side_effect = RequestsConnectionError("Connection refused")
 
         client = OllamaClient()
         response = client.generate("Test prompt")
@@ -181,18 +172,17 @@ def test_generate_connection_error(self, mock_session_class) -> None:
         assert response.timed_out is False
         assert response.content == ""
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_generate_malformed_response(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_generate_malformed_response(self, mock_post) -> None:
         """Test handling of malformed API responses"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         # Missing 'response' key
         mock_response.json.return_value = {
             "model": "gpt-oss:20b",
             "done": True,
         }
-        mock_session.post.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
 
         client = OllamaClient()
         response = client.generate("Test prompt")
@@ -255,52 +245,48 @@ def test_busy_check_command_failure(self, mock_run) -> None:
 class TestOllamaClientHelpers:
     """Test helper methods"""
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_make_request_get(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.get')
+    def test_make_request_get(self, mock_get) -> None:
         """Test GET request helper"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         mock_response.json.return_value = {"result": "success"}
-        mock_session.get.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_response.raise_for_status.return_value = None
+        mock_get.return_value = mock_response
 
         client = OllamaClient()
         result = client._make_request("api/test", method="GET")
 
         assert result == {"result": "success"}
-        mock_session.get.assert_called_once_with(
+        mock_get.assert_called_once_with(
             "http://localhost:11434/api/test",
             timeout=180
         )
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_make_request_post(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_make_request_post(self, mock_post) -> None:
         """Test POST request helper"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         mock_response.json.return_value = {"result": "success"}
-        mock_session.post.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
 
         client = OllamaClient()
         data = {"key": "value"}
         result = client._make_request("api/test", data=data, method="POST")
 
         assert result == {"result": "success"}
-        mock_session.post.assert_called_once_with(
+        mock_post.assert_called_once_with(
             "http://localhost:11434/api/test",
             json=data,
             timeout=180
         )
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_make_request_error_handling(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_make_request_error_handling(self, mock_post) -> None:
         """Test request error handling"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         mock_response.raise_for_status.side_effect = requests.HTTPError("404 Not Found")
-        mock_session.post.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_post.return_value = mock_response
 
         client = OllamaClient()
 
@@ -313,16 +299,16 @@ def test_make_request_error_handling(self, mock_session_class) -> None:
 class TestOllamaClientIntegration:
     """Integration tests for complete workflows"""
 
-    @patch('src.utils.model_client.requests.Session')
-    def test_full_generation_workflow(self, mock_session_class) -> None:
+    @patch('src.utils.model_client.requests.post')
+    @patch('src.utils.model_client.requests.get')
+    def test_full_generation_workflow(self, mock_get, mock_post) -> None:
         """Test complete generation workflow with all features"""
-        mock_session = MagicMock()
-
         # First call: check model availability
         availability_response = MagicMock()
         availability_response.json.return_value = {
             "models": [{"name": "gpt-oss:20b"}]
         }
+        availability_response.raise_for_status.return_value = None
 
         # Second call: generate response
         generation_response = MagicMock()
@@ -334,10 +320,10 @@ def test_full_generation_workflow(self, mock_session_class) -> None:
             "prompt_eval_count": 15,
             "eval_count": 25,
         }
+        generation_response.raise_for_status.return_value = None
 
-        mock_session.get.return_value = availability_response
-        mock_session.post.return_value = generation_response
-        mock_session_class.return_value = mock_session
+        mock_get.return_value = availability_response
+        mock_post.return_value = generation_response
 
         client = OllamaClient()
 
@@ -356,18 +342,17 @@ def test_full_generation_workflow(self, mock_session_class) -> None:
         assert response.response_time > 0
 
     @patch('src.utils.model_client.time.time')
-    @patch('src.utils.model_client.requests.Session')
-    def test_response_timing(self, mock_session_class, mock_time) -> None:
+    @patch('src.utils.model_client.requests.post')
+    def test_response_timing(self, mock_post, mock_time) -> None:
         """Test accurate response time measurement"""
-        mock_session = MagicMock()
         mock_response = MagicMock()
         mock_response.json.return_value = {
             "model": "gpt-oss:20b",
             "response": "Test",
             "done": True,
         }
-        mock_session.post.return_value = mock_response
-        mock_session_class.return_value = mock_session
+        mock_response.raise_for_status.return_value = None
+        mock_post.return_value = mock_response
 
         # Simulate 2.5 second response time
         mock_time.side_effect = [0.0, 2.5]