fix unit test

Author: luukunn

fastdeploy/input/ernie4_5_vl_processor/ernie4_5_vl_processor.py

@@ -246,15 +246,6 @@ def process_request_dict(self, request, max_model_len=None):
                             request[k] = v
                 else:
                     raise ValueError("Invalid input: chat_template_kwargs must be a dict")
-                options = chat_template_kwargs.get("options")
-                if options:
-                    thinking_mode = options.get("thinking_mode")
-                    if thinking_mode:
-                        if thinking_mode == "close" or thinking_mode == "false":
-                            request["enable_thinking"] = False
-                        else:
-                            request["enable_thinking"] = True
-            request.setdefault("enable_thinking", True)
             outputs = self.ernie4_5_processor.request2ids(request)
         else:
             raise ValueError(f"Request must contain 'prompt', or 'messages': {request}")

tests/entrypoints/openai/test_serving_chat.py

@@ -41,35 +41,6 @@ def setUp(self):
             chat_template=None,
         )
 
-    def test_enable_thinking(self):
-        request = ChatCompletionRequest(messages=[], chat_template_kwargs={})
-        enable_thinking = self.chat_completion_handler._get_thinking_status(request)
-        self.assertEqual(enable_thinking, None)
-
-        request = ChatCompletionRequest(messages=[], chat_template_kwargs={"enable_thinking": True})
-        enable_thinking = self.chat_completion_handler._get_thinking_status(request)
-        self.assertEqual(enable_thinking, True)
-
-        request = ChatCompletionRequest(messages=[], chat_template_kwargs={"enable_thinking": False})
-        enable_thinking = self.chat_completion_handler._get_thinking_status(request)
-        self.assertEqual(enable_thinking, False)
-
-        request = ChatCompletionRequest(messages=[], chat_template_kwargs={"options": {"thinking_mode": "close"}})
-        enable_thinking = self.chat_completion_handler._get_thinking_status(request)
-        self.assertEqual(enable_thinking, False)
-
-        request = ChatCompletionRequest(messages=[], chat_template_kwargs={"options": {"thinking_mode": "false"}})
-        enable_thinking = self.chat_completion_handler._get_thinking_status(request)
-        self.assertEqual(enable_thinking, False)
-
-        request = ChatCompletionRequest(messages=[], chat_template_kwargs={"options": {"thinking_mode": "open"}})
-        enable_thinking = self.chat_completion_handler._get_thinking_status(request)
-        self.assertEqual(enable_thinking, True)
-
-        request = ChatCompletionRequest(messages=[], chat_template_kwargs={"options": {"thinking_mode": "123"}})
-        enable_thinking = self.chat_completion_handler._get_thinking_status(request)
-        self.assertEqual(enable_thinking, True)
-
     def test_build_prompt_logprobs_basic(self):
         """Test basic functionality of _build_prompt_logprobs"""
         # Create mock data

tests/input/test_ernie_vl_processor.py

@@ -71,73 +71,6 @@ def mock_pack_outputs(outputs):
         self.mock_tool_parser_obj.return_value = self.mock_tool_parser
         self.processor.tool_parser_obj = self.mock_tool_parser_obj
 
-    def test_process_response_dict_streaming_normal_case(self):
-        """测试正常情况下的流式响应处理"""
-        request_dict = {
-            "messages": [{"role": "user", "content": "Hello"}],
-            "chat_template_kwargs": {"enable_thinking": False},
-            "prompt_token_ids": [1, 1, 1],
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], True)
-
-    def test_process_request_dict(self):
-        request_dict = {
-            "request_id": "123",
-            "messages": [{"role": "user", "content": "Hello!"}],
-            "chat_template_kwargs": {"chat_template": "Hello!"},
-            "eos_token_ids": [1],
-            "temperature": 1,
-            "top_p": 1,
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], True)
-
-        request_dict = {
-            "messages": [{"role": "user", "content": "Hello"}],
-            "chat_template_kwargs": {"options": {"thinking_mode": "close"}},
-            "prompt_token_ids": [1, 1, 1],
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], True)
-
-        request_dict = {
-            "messages": [{"role": "user", "content": "Hello"}],
-            "chat_template_kwargs": {"options": {"thinking_mode": "false"}},
-            "prompt_token_ids": [1, 1, 1],
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], True)
-
-        request_dict = {
-            "messages": [{"role": "user", "content": "Hello"}],
-            "chat_template_kwargs": {"options": {"thinking_mode": "123"}},
-            "prompt_token_ids": [1, 1, 1],
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], True)
-
-        request_dict = {
-            "messages": [{"role": "user", "content": "Hello"}],
-            "chat_template_kwargs": {"options": {"thinking_mode": "close"}},
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], False)
-
-        request_dict = {
-            "messages": [{"role": "user", "content": "Hello"}],
-            "chat_template_kwargs": {"options": {"thinking_mode": "false"}},
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], False)
-
-        request_dict = {
-            "messages": [{"role": "user", "content": "Hello"}],
-            "chat_template_kwargs": {"enable_thinking": False},
-        }
-        self.processor.process_request_dict(request_dict, 100)
-        self.assertEqual(request_dict["enable_thinking"], False)
-
 
 class TestDataProcessorTargetMethods(unittest.TestCase):
     def setUp(self):

tests/input/test_paddleocr_vl_processor.py

@@ -777,6 +777,8 @@ def setUp(self):
         self.processor.processor = MagicMock()
         self.processor.limit_mm_per_prompt = {"image": 1, "video": 1, "audio": 1}
         self.processor.eos_token_ids = [1]
+        self.processor.reasoning_parser = None
+        self.processor.model_status_dict = {}
 
         # 模拟 _apply_default_parameters
         def mock_apply_default_parameters(request_or_dict):
@@ -955,6 +957,7 @@ def test_process_request_wrapper(self):
             "prompt": "test prompt",
             "multimodal_data": {"image": ["image1"]},
             "metadata": {"generated_token_ids": []},
+            "request_id": "test-request",
         }
         request_obj.to_dict.return_value = request_dict
 

tests/input/test_text_processor.py

@@ -266,7 +266,7 @@ class DummyReasoning:
             def __init__(self, tokenizer):
                 self.tokenizer = tokenizer
 
-            def extract_reasoning_content(self, full_text, response_dict):
+            def extract_reasoning_content(self, full_text, response_dict, model_status):
                 return reasoning_content, f"{full_text}!"
 
         return DummyReasoning(tokenizer)
@@ -409,6 +409,7 @@ def test_data_processor_init_handles_missing_generation_config(self):
 
     def test_process_response_with_reasoning_and_tools(self):
         processor = self.processor
+        processor.model_status_dict = {"resp": "normal"}
 
         processor.reasoning_parser = self.create_dummy_reasoning(processor.tokenizer)
         processor.tool_parser_obj = self.create_dummy_tool_parser(processor.tokenizer, content="tool-only")
@@ -435,7 +436,7 @@ def test_process_response_streaming_clears_state(self):
 
     def test_process_response_dict_normal_with_reasoning(self):
         processor = self.processor
-
+        processor.model_status_dict = {"normal": "normal"}
         processor.reasoning_parser = self.create_dummy_reasoning(processor.tokenizer, reasoning_content="because")
         processor.tool_parser_obj = self.create_dummy_tool_parser(processor.tokenizer, content="tool-text")
 
@@ -471,10 +472,10 @@ def fake_normal(response_dict, **kwargs):
         self.addCleanup(lambda: setattr(processor, "process_response_dict_normal", original_normal))
 
         response = {"outputs": {}, "finished": False, "request_id": "req"}
-        self.assertEqual(processor.process_response_dict(response), "stream")
+        self.assertEqual(processor.process_response_dict(response, stream=True, enable_thinking=True), "stream")
         self.assertTrue(calls["stream"]["enable_thinking"])
         self.assertEqual(
-            processor.process_response_dict(response, stream=False, enable_thinking=None),
+            processor.process_response_dict(response, stream=False, enable_thinking=True),
             "normal",
         )
         self.assertTrue(calls["normal"]["enable_thinking"])