♻️ refactor: simplify test code patterns in test_models.py

Addresses issue #6 by eliminating unnecessary intermediate variables
in test functions, implementing the suggested one-liner pattern for
improved readability and conciseness.

Changes:
- Simplified 21 test functions in tests/unit_tests/test_models.py
- Eliminated `mock_instance = Mock()` declarations
- Removed `mock.return_value = mock_instance` assignments
- Removed `result = function_call()` variables
- Replaced with direct assertion: `assert mock.return_value == function_call()`

Benefits:
- Reduced each test from 4-5 lines to 2-3 lines
- Improved code readability and maintainability
- Maintained identical test coverage and functionality
- All 84 unit tests pass with simplified pattern

Test Coverage:
- Qwen model tests: 9 functions simplified
- SiliconFlow model tests: 10 functions simplified
- Utility function tests: 2 functions simplified

Closes #6

Author: webup

tests/unit_tests/test_models.py

@@ -14,50 +14,30 @@
 @patch.dict(os.environ, {"REGION": ""}, clear=False)
 def test_create_qwen_model_qwq(mock_chat_qwq):
     """Test QwQ model creation uses ChatQwQ."""
-    mock_instance = Mock()
-    mock_chat_qwq.return_value = mock_instance
-
-    result = create_qwen_model("qwq-32b-preview", api_key="test-key")
-
-    assert result == mock_instance
+    assert mock_chat_qwq.return_value == create_qwen_model("qwq-32b-preview", api_key="test-key")
     mock_chat_qwq.assert_called_once_with(model="qwq-32b-preview", api_key="test-key")
 
 
 @patch("common.models.qwen.ChatQwQ")
 @patch.dict(os.environ, {"REGION": ""}, clear=False)
 def test_create_qwen_model_qvq(mock_chat_qwq):
     """Test QvQ model creation also uses ChatQwQ."""
-    mock_instance = Mock()
-    mock_chat_qwq.return_value = mock_instance
-
-    result = create_qwen_model("qvq-72b-preview", api_key="test-key")
-
-    assert result == mock_instance
+    assert mock_chat_qwq.return_value == create_qwen_model("qvq-72b-preview", api_key="test-key")
     mock_chat_qwq.assert_called_once_with(model="qvq-72b-preview", api_key="test-key")
 
 
 @patch("common.models.qwen.ChatQwen")
 @patch.dict(os.environ, {"REGION": ""}, clear=False)
 def test_create_qwen_model_qwen_plus(mock_chat_qwen):
     """Test Qwen+ model creation uses ChatQwen."""
-    mock_instance = Mock()
-    mock_chat_qwen.return_value = mock_instance
-
-    result = create_qwen_model("qwen-plus", api_key="test-key")
-
-    assert result == mock_instance
+    assert mock_chat_qwen.return_value == create_qwen_model("qwen-plus", api_key="test-key")
     mock_chat_qwen.assert_called_once_with(model="qwen-plus", api_key="test-key")
 
 
 @patch("common.models.qwen.ChatQwQ")
 def test_create_qwen_model_qwq_with_prc_region(mock_chat_qwq):
     """Test QwQ model creation with PRC region."""
-    mock_instance = Mock()
-    mock_chat_qwq.return_value = mock_instance
-
-    result = create_qwen_model("qwq-32b-preview", api_key="test-key", region="prc")
-
-    assert result == mock_instance
+    assert mock_chat_qwq.return_value == create_qwen_model("qwq-32b-preview", api_key="test-key", region="prc")
     mock_chat_qwq.assert_called_once_with(
         model="qwq-32b-preview",
         api_key="test-key",
@@ -68,12 +48,7 @@ def test_create_qwen_model_qwq_with_prc_region(mock_chat_qwq):
 @patch("common.models.qwen.ChatQwen")
 def test_create_qwen_model_qwen_plus_with_international_region(mock_chat_qwen):
     """Test Qwen+ model creation with international region."""
-    mock_instance = Mock()
-    mock_chat_qwen.return_value = mock_instance
-
-    result = create_qwen_model("qwen-plus", api_key="test-key", region="international")
-
-    assert result == mock_instance
+    assert mock_chat_qwen.return_value == create_qwen_model("qwen-plus", api_key="test-key", region="international")
     mock_chat_qwen.assert_called_once_with(
         model="qwen-plus",
         api_key="test-key",
@@ -85,25 +60,15 @@ def test_create_qwen_model_qwen_plus_with_international_region(mock_chat_qwen):
 @patch.dict(os.environ, {"DASHSCOPE_API_KEY": "env-key", "REGION": ""})
 def test_create_qwen_model_with_env_key(mock_chat_qwen):
     """Test Qwen model creation using environment variable for API key."""
-    mock_instance = Mock()
-    mock_chat_qwen.return_value = mock_instance
-
-    result = create_qwen_model("qwen-plus")
-
-    assert result == mock_instance
+    assert mock_chat_qwen.return_value == create_qwen_model("qwen-plus")
     mock_chat_qwen.assert_called_once_with(model="qwen-plus", api_key="env-key")
 
 
 @patch("common.models.qwen.ChatQwen")
 @patch.dict(os.environ, {"DASHSCOPE_API_KEY": "env-key", "REGION": "prc"})
 def test_create_qwen_model_with_env_region_prc(mock_chat_qwen):
     """Test Qwen model creation using environment variable for region (PRC)."""
-    mock_instance = Mock()
-    mock_chat_qwen.return_value = mock_instance
-
-    result = create_qwen_model("qwen-plus")
-
-    assert result == mock_instance
+    assert mock_chat_qwen.return_value == create_qwen_model("qwen-plus")
     mock_chat_qwen.assert_called_once_with(
         model="qwen-plus",
         api_key="env-key",
@@ -115,12 +80,7 @@ def test_create_qwen_model_with_env_region_prc(mock_chat_qwen):
 @patch.dict(os.environ, {"DASHSCOPE_API_KEY": "env-key", "REGION": "international"})
 def test_create_qwq_model_with_env_region_international(mock_chat_qwq):
     """Test QwQ model creation using environment variable for region (international)."""
-    mock_instance = Mock()
-    mock_chat_qwq.return_value = mock_instance
-
-    result = create_qwen_model("qwq-32b-preview")
-
-    assert result == mock_instance
+    assert mock_chat_qwq.return_value == create_qwen_model("qwq-32b-preview")
     mock_chat_qwq.assert_called_once_with(
         model="qwq-32b-preview",
         api_key="env-key",
@@ -131,15 +91,10 @@ def test_create_qwq_model_with_env_region_international(mock_chat_qwq):
 @patch("common.models.qwen.ChatQwQ")
 def test_create_qwq_model_with_custom_base_url(mock_chat_qwq):
     """Test QwQ model creation with custom base URL."""
-    mock_instance = Mock()
-    mock_chat_qwq.return_value = mock_instance
-
     custom_url = "https://custom.example.com/v1"
-    result = create_qwen_model(
+    assert mock_chat_qwq.return_value == create_qwen_model(
         "qwq-32b-preview", api_key="test-key", base_url=custom_url
     )
-
-    assert result == mock_instance
     mock_chat_qwq.assert_called_once_with(
         model="qwq-32b-preview", api_key="test-key", base_url=custom_url
     )
@@ -148,12 +103,7 @@ def test_create_qwq_model_with_custom_base_url(mock_chat_qwq):
 @patch("common.models.create_qwen_model")
 def test_load_chat_model_qwen_provider(mock_create_qwen):
     """Test load_chat_model with Qwen provider."""
-    mock_instance = Mock()
-    mock_create_qwen.return_value = mock_instance
-
-    result = load_chat_model("qwen:qwq-32b-preview")
-
-    assert result == mock_instance
+    assert mock_create_qwen.return_value == load_chat_model("qwen:qwq-32b-preview")
     mock_create_qwen.assert_called_once_with("qwq-32b-preview")
 
 
@@ -162,12 +112,7 @@ def test_load_chat_model_qwen_provider(mock_create_qwen):
 @patch.dict(os.environ, {"REGION": ""}, clear=False)
 def test_create_siliconflow_model_basic(mock_chat_siliconflow):
     """Test basic SiliconFlow model creation."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct", api_key="test-key")
-
-    assert result == mock_instance
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct", api_key="test-key")
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="test-key",
@@ -177,14 +122,9 @@ def test_create_siliconflow_model_basic(mock_chat_siliconflow):
 @patch("common.models.siliconflow.ChatSiliconFlow")
 def test_create_siliconflow_model_with_prc_region(mock_chat_siliconflow):
     """Test SiliconFlow model creation with PRC region."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model(
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model(
         "Qwen/Qwen2.5-72B-Instruct", api_key="test-key", region="prc"
     )
-
-    assert result == mock_instance
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="test-key",
@@ -195,14 +135,9 @@ def test_create_siliconflow_model_with_prc_region(mock_chat_siliconflow):
 @patch("common.models.siliconflow.ChatSiliconFlow")
 def test_create_siliconflow_model_with_international_region(mock_chat_siliconflow):
     """Test SiliconFlow model creation with international region."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model(
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model(
         "Qwen/Qwen2.5-72B-Instruct", api_key="test-key", region="international"
     )
-
-    assert result == mock_instance
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="test-key",
@@ -213,14 +148,9 @@ def test_create_siliconflow_model_with_international_region(mock_chat_siliconflo
 @patch("common.models.siliconflow.ChatSiliconFlow")
 def test_create_siliconflow_model_with_cn_alias(mock_chat_siliconflow):
     """Test SiliconFlow model creation with 'cn' alias for PRC."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model(
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model(
         "Qwen/Qwen2.5-72B-Instruct", api_key="test-key", region="cn"
     )
-
-    assert result == mock_instance
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="test-key",
@@ -231,14 +161,9 @@ def test_create_siliconflow_model_with_cn_alias(mock_chat_siliconflow):
 @patch("common.models.siliconflow.ChatSiliconFlow")
 def test_create_siliconflow_model_with_en_alias(mock_chat_siliconflow):
     """Test SiliconFlow model creation with 'en' alias for international."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model(
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model(
         "Qwen/Qwen2.5-72B-Instruct", api_key="test-key", region="en"
     )
-
-    assert result == mock_instance
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="test-key",
@@ -250,12 +175,7 @@ def test_create_siliconflow_model_with_en_alias(mock_chat_siliconflow):
 @patch.dict(os.environ, {"SILICONFLOW_API_KEY": "env-key", "REGION": ""})
 def test_create_siliconflow_model_with_env_key(mock_chat_siliconflow):
     """Test SiliconFlow model creation using environment variable for API key."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct")
-
-    assert result == mock_instance
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct")
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="env-key",
@@ -266,12 +186,7 @@ def test_create_siliconflow_model_with_env_key(mock_chat_siliconflow):
 @patch.dict(os.environ, {"SILICONFLOW_API_KEY": "env-key", "REGION": "prc"})
 def test_create_siliconflow_model_with_env_region_prc(mock_chat_siliconflow):
     """Test SiliconFlow model creation using environment variable for region (PRC)."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct")
-
-    assert result == mock_instance
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct")
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="env-key",
@@ -283,12 +198,7 @@ def test_create_siliconflow_model_with_env_region_prc(mock_chat_siliconflow):
 @patch.dict(os.environ, {"SILICONFLOW_API_KEY": "env-key", "REGION": "international"})
 def test_create_siliconflow_model_with_env_region_international(mock_chat_siliconflow):
     """Test SiliconFlow model creation using environment variable for region (international)."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
-    result = create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct")
-
-    assert result == mock_instance
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model("Qwen/Qwen2.5-72B-Instruct")
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="env-key",
@@ -299,15 +209,10 @@ def test_create_siliconflow_model_with_env_region_international(mock_chat_silico
 @patch("common.models.siliconflow.ChatSiliconFlow")
 def test_create_siliconflow_model_with_custom_base_url(mock_chat_siliconflow):
     """Test SiliconFlow model creation with custom base URL."""
-    mock_instance = Mock()
-    mock_chat_siliconflow.return_value = mock_instance
-
     custom_url = "https://custom.example.com/v1"
-    result = create_siliconflow_model(
+    assert mock_chat_siliconflow.return_value == create_siliconflow_model(
         "Qwen/Qwen2.5-72B-Instruct", api_key="test-key", base_url=custom_url
     )
-
-    assert result == mock_instance
     mock_chat_siliconflow.assert_called_once_with(
         model="Qwen/Qwen2.5-72B-Instruct",
         api_key="test-key",
@@ -318,24 +223,14 @@ def test_create_siliconflow_model_with_custom_base_url(mock_chat_siliconflow):
 @patch("common.models.create_siliconflow_model")
 def test_load_chat_model_siliconflow_provider(mock_create_siliconflow):
     """Test load_chat_model with SiliconFlow provider."""
-    mock_instance = Mock()
-    mock_create_siliconflow.return_value = mock_instance
-
-    result = load_chat_model("siliconflow:Qwen/Qwen2.5-72B-Instruct")
-
-    assert result == mock_instance
+    assert mock_create_siliconflow.return_value == load_chat_model("siliconflow:Qwen/Qwen2.5-72B-Instruct")
     mock_create_siliconflow.assert_called_once_with("Qwen/Qwen2.5-72B-Instruct")
 
 
 @patch("common.utils.init_chat_model")
 def test_load_chat_model_standard_provider(mock_init_chat_model):
     """Test load_chat_model with standard provider (non-QwQ)."""
-    mock_instance = Mock()
-    mock_init_chat_model.return_value = mock_instance
-
-    result = load_chat_model("openai:gpt-4o-mini")
-
-    assert result == mock_instance
+    assert mock_init_chat_model.return_value == load_chat_model("openai:gpt-4o-mini")
     mock_init_chat_model.assert_called_once_with("gpt-4o-mini", model_provider="openai")