[Misc] Migrate L1 tests to use pytest-mock (#1315)

Signed-off-by: Yuanheng Zhao <jonathan.zhaoyh@gmail.com>
Signed-off-by: yuanheng <jonathan.zhaoyh@gmail.com>

tests/entrypoints/openai_api/test_image_server.py

@@ -10,11 +10,11 @@ OpenAI-compatible async text-to-image generation API endpoints in api_server.py.
 import base64
 import io
 from argparse import Namespace
-from unittest.mock import AsyncMock, Mock
 
 import pytest
 from fastapi.testclient import TestClient
 from PIL import Image
+from pytest_mock import MockerFixture
 from vllm import SamplingParams
 
 from vllm_omni.entrypoints.openai.image_api_utils import (
@@ -128,11 +128,11 @@ class FakeAsyncOmni:
 
 
 @pytest.fixture
-def mock_async_diffusion():
+def mock_async_diffusion(mocker: MockerFixture):
     """Mock AsyncOmniDiffusion instance that returns fake images"""
-    mock = Mock()
+    mock = mocker.Mock()
     mock.is_running = True  # For health endpoint
-    mock.check_health = AsyncMock()  # For LLM mode health check
+    mock.check_health = mocker.AsyncMock()  # For LLM mode health check
 
     async def generate(**kwargs):
         # Return n PIL images wrapped in result object
@@ -143,7 +143,7 @@ def mock_async_diffusion():
         images = [Image.new("RGB", (64, 64), color="blue") for _ in range(n)]
         return MockGenerationResult(images)
 
-    mock.generate = AsyncMock(side_effect=generate)
+    mock.generate = mocker.AsyncMock(side_effect=generate)
     return mock
 
 

tests/entrypoints/openai_api/test_serving_chat_sampling_params.py

@@ -6,27 +6,26 @@ Tests that standard OpenAI API parameters (max_tokens, temperature, etc.)
 are correctly applied to the comprehension stage while preserving YAML defaults.
 """
 
-from unittest.mock import MagicMock
-
 import pytest
+from pytest_mock import MockerFixture
 from vllm.sampling_params import SamplingParams
 
 pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
 
 
 @pytest.fixture
-def mock_comprehension_stage():
+def mock_comprehension_stage(mocker: MockerFixture):
     """Create a mock comprehension stage with is_comprehension=True."""
-    stage = MagicMock()
+    stage = mocker.MagicMock()
     stage.is_comprehension = True
     stage.model_stage = "comprehension"
     return stage
 
 
 @pytest.fixture
-def mock_other_stage():
+def mock_other_stage(mocker: MockerFixture):
     """Create a mock non-comprehension stage."""
-    stage = MagicMock()
+    stage = mocker.MagicMock()
     stage.is_comprehension = False
     stage.model_stage = "other"
     return stage
@@ -57,9 +56,15 @@ def default_other_params():
 
 
 @pytest.fixture
-def mock_engine_client(mock_comprehension_stage, mock_other_stage, default_comprehension_params, default_other_params):
+def mock_engine_client(
+    mock_comprehension_stage,
+    mock_other_stage,
+    default_comprehension_params,
+    default_other_params,
+    mocker: MockerFixture,
+):
     """Create mock engine client with stage_list and default_sampling_params_list."""
-    engine_client = MagicMock()
+    engine_client = mocker.MagicMock()
     engine_client.stage_list = [mock_comprehension_stage, mock_other_stage]
     engine_client.default_sampling_params_list = [
         default_comprehension_params,
@@ -80,9 +85,9 @@ def serving_chat(mock_engine_client):
 
 
 @pytest.fixture
-def mock_request():
+def mock_request(mocker: MockerFixture):
     """Create a mock request with all OpenAI sampling params set to None."""
-    request = MagicMock()
+    request = mocker.MagicMock()
     # OpenAI standard sampling fields
     request.temperature = None
     request.top_p = None
@@ -294,35 +299,35 @@ def test_get_comprehension_stage_index_finds_first_stage(mock_engine_client):
     assert instance._get_comprehension_stage_index() == 0
 
 
-def test_get_comprehension_stage_index_finds_second_stage():
+def test_get_comprehension_stage_index_finds_second_stage(mocker: MockerFixture):
     """Test finding comprehension stage when it's at index 1."""
     from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
 
     instance = object.__new__(OmniOpenAIServingChat)
 
-    other = MagicMock()
+    other = mocker.MagicMock()
     other.is_comprehension = False
-    comprehension = MagicMock()
+    comprehension = mocker.MagicMock()
     comprehension.is_comprehension = True
 
-    instance.engine_client = MagicMock()
+    instance.engine_client = mocker.MagicMock()
     instance.engine_client.stage_list = [other, comprehension]
 
     assert instance._get_comprehension_stage_index() == 1
 
 
-def test_get_comprehension_stage_index_raises_when_not_found():
+def test_get_comprehension_stage_index_raises_when_not_found(mocker: MockerFixture):
     """Test that ValueError is raised when no comprehension stage exists."""
     from vllm_omni.entrypoints.openai.serving_chat import OmniOpenAIServingChat
 
     instance = object.__new__(OmniOpenAIServingChat)
 
-    stage1 = MagicMock()
+    stage1 = mocker.MagicMock()
     stage1.is_comprehension = False
-    stage2 = MagicMock()
+    stage2 = mocker.MagicMock()
     stage2.is_comprehension = False
 
-    instance.engine_client = MagicMock()
+    instance.engine_client = mocker.MagicMock()
     instance.engine_client.stage_list = [stage1, stage2]
 
     with pytest.raises(ValueError, match="No comprehension stage"):

tests/entrypoints/openai_api/test_serving_speech.py

@@ -1,13 +1,13 @@
 # tests/entrypoints/openai/test_serving_speech.py
 import logging
 from inspect import Signature, signature
-from unittest.mock import MagicMock, patch
 
 import numpy as np
 import pytest
 import torch
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
+from pytest_mock import MockerFixture
 
 from vllm_omni.entrypoints.openai.audio_utils_mixin import AudioMixin
 from vllm_omni.entrypoints.openai.protocol.audio import CreateAudio, OpenAICreateSpeechRequest
@@ -26,25 +26,24 @@ class TestAudioMixin:
     def audio_mixin(self):
         return AudioMixin()
 
-    def test_stereo_to_mono_conversion(self, audio_mixin):
+    def test_stereo_to_mono_conversion(self, audio_mixin, mocker: MockerFixture):
         stereo_tensor = np.random.rand(24000, 2).astype(np.float32)
         audio_obj = CreateAudio(audio_tensor=stereo_tensor)
 
-        with (
-            patch.object(
-                audio_mixin, "_apply_speed_adjustment", side_effect=lambda tensor, speed, sr: (tensor, sr)
-            ) as mock_speed,
-            patch("soundfile.write") as _,
-        ):
-            audio_mixin.create_audio(audio_obj)
+        mock_speed = mocker.patch.object(
+            audio_mixin, "_apply_speed_adjustment", side_effect=lambda tensor, speed, sr: (tensor, sr)
+        )
+        mocker.patch("soundfile.write")
 
-            # Check that the tensor passed to speed adjustment is mono
-            mock_speed.assert_called_once()
-            adjusted_tensor = mock_speed.call_args[0][0]
-            assert len(adjusted_tensor) == 24000
+        audio_mixin.create_audio(audio_obj)
 
-    @patch("librosa.effects.time_stretch")
-    def test_speed_adjustment(self, mock_time_stretch, audio_mixin):
+        # Check that the tensor passed to speed adjustment is mono
+        mock_speed.assert_called_once()
+        adjusted_tensor = mock_speed.call_args[0][0]
+        assert len(adjusted_tensor) == 24000
+
+    def test_speed_adjustment(self, audio_mixin, mocker: MockerFixture):
+        mock_time_stretch = mocker.patch("librosa.effects.time_stretch")
         mock_time_stretch.return_value = np.zeros(12000)
         audio_tensor = np.random.rand(24000).astype(np.float32)
 
@@ -53,8 +52,8 @@ class TestAudioMixin:
         mock_time_stretch.assert_called_with(y=audio_tensor, rate=2.0)
         assert adjusted_audio.shape == (12000,)
 
-    @patch("soundfile.write")
-    def test_unsupported_format_fallback(self, mock_write, audio_mixin, caplog):
+    def test_unsupported_format_fallback(self, audio_mixin, caplog, mocker: MockerFixture):
+        mock_write = mocker.patch("soundfile.write")
         audio_tensor = np.random.rand(24000).astype(np.float32)
         # Use a format that is not in the list of supported formats
         audio_obj = CreateAudio(audio_tensor=audio_tensor, response_format="vorbis")
@@ -66,50 +65,50 @@ class TestAudioMixin:
         write_kwargs = mock_write.call_args.kwargs
         assert write_kwargs["format"] == "WAV"
 
-    def test_mono_audio_preservation(self, audio_mixin):
+    def test_mono_audio_preservation(self, audio_mixin, mocker: MockerFixture):
         """Test that mono (1D) audio tensors are processed correctly and passed to writer."""
         mono_tensor = np.random.rand(24000).astype(np.float32)
         audio_obj = CreateAudio(audio_tensor=mono_tensor)
 
-        with patch("soundfile.write") as mock_write:
-            audio_mixin.create_audio(audio_obj)
+        mock_write = mocker.patch("soundfile.write")
+        audio_mixin.create_audio(audio_obj)
 
-            mock_write.assert_called_once()
-            # Verify the tensor passed to soundfile.write is the exact 1D tensor
-            output_tensor = mock_write.call_args[0][1]
-            assert output_tensor.ndim == 1
-            assert output_tensor.shape == (24000,)
-            assert np.array_equal(output_tensor, mono_tensor)
+        mock_write.assert_called_once()
+        # Verify the tensor passed to soundfile.write is the exact 1D tensor
+        output_tensor = mock_write.call_args[0][1]
+        assert output_tensor.ndim == 1
+        assert output_tensor.shape == (24000,)
+        assert np.array_equal(output_tensor, mono_tensor)
 
-    def test_stereo_audio_preservation(self, audio_mixin):
+    def test_stereo_audio_preservation(self, audio_mixin, mocker: MockerFixture):
         """Test that stereo (2D) audio tensors are processed correctly and preserved."""
         stereo_tensor = np.random.rand(24000, 2).astype(np.float32)
         audio_obj = CreateAudio(audio_tensor=stereo_tensor)
 
-        with patch("soundfile.write") as mock_write:
-            audio_mixin.create_audio(audio_obj)
+        mock_write = mocker.patch("soundfile.write")
+        audio_mixin.create_audio(audio_obj)
 
-            mock_write.assert_called_once()
-            # Verify the tensor passed to soundfile.write is the exact 2D tensor
-            output_tensor = mock_write.call_args[0][1]
-            assert output_tensor.ndim == 2
-            assert output_tensor.shape == (24000, 2)
-            assert np.array_equal(output_tensor, stereo_tensor)
+        mock_write.assert_called_once()
+        # Verify the tensor passed to soundfile.write is the exact 2D tensor
+        output_tensor = mock_write.call_args[0][1]
+        assert output_tensor.ndim == 2
+        assert output_tensor.shape == (24000, 2)
+        assert np.array_equal(output_tensor, stereo_tensor)
 
-    def test_speed_adjustment_bypass(self, audio_mixin):
+    def test_speed_adjustment_bypass(self, audio_mixin, mocker: MockerFixture):
         """Test that speed=1.0 bypasses the expensive librosa time stretching."""
         audio_tensor = np.random.rand(24000).astype(np.float32)
 
-        with patch("librosa.effects.time_stretch") as mock_time_stretch:
-            # speed=1.0 should return immediately without calling librosa
-            result, _ = audio_mixin._apply_speed_adjustment(audio_tensor, speed=1.0, sample_rate=24000)
+        mock_time_stretch = mocker.patch("librosa.effects.time_stretch")
+        # speed=1.0 should return immediately without calling librosa
+        result, _ = audio_mixin._apply_speed_adjustment(audio_tensor, speed=1.0, sample_rate=24000)
 
-            mock_time_stretch.assert_not_called()
-            assert np.array_equal(result, audio_tensor)
+        mock_time_stretch.assert_not_called()
+        assert np.array_equal(result, audio_tensor)
 
-    @patch("librosa.effects.time_stretch")
-    def test_speed_adjustment_stereo_handling(self, mock_time_stretch, audio_mixin):
+    def test_speed_adjustment_stereo_handling(self, audio_mixin, mocker: MockerFixture):
         """Test that speed adjustment is attempted on stereo inputs."""
+        mock_time_stretch = mocker.patch("librosa.effects.time_stretch")
         stereo_tensor = np.random.rand(24000, 2).astype(np.float32)
         # Mock return value representing a sped-up version (half length)
         mock_time_stretch.return_value = np.zeros((12000, 2), dtype=np.float32)
@@ -161,22 +160,22 @@ def create_mock_audio_output_for_test(
 
 
 @pytest.fixture
-def test_app():
+def test_app(mocker: MockerFixture):
     # Mock the engine client
-    mock_engine_client = MagicMock()
+    mock_engine_client = mocker.MagicMock()
     mock_engine_client.errored = False
 
     async def mock_generate_fn(*args, **kwargs):
         yield create_mock_audio_output_for_test(request_id=kwargs.get("request_id"))
 
-    mock_engine_client.generate = MagicMock(side_effect=mock_generate_fn)
+    mock_engine_client.generate = mocker.MagicMock(side_effect=mock_generate_fn)
     mock_engine_client.default_sampling_params_list = [{}]
 
     # Mock models to have an is_base_model method
-    mock_models = MagicMock()
+    mock_models = mocker.MagicMock()
     mock_models.is_base_model.return_value = True
 
-    mock_request_logger = MagicMock()
+    mock_request_logger = mocker.MagicMock()
 
     speech_server = OmniOpenAIServingSpeech(
         engine_client=mock_engine_client,
@@ -186,7 +185,7 @@ def test_app():
 
     # Patch the signature of create_speech to remove 'raw_request' for FastAPI route introspection
     original_create_speech = speech_server.create_speech
-    _ = MagicMock(side_effect=original_create_speech)
+    _ = mocker.MagicMock(side_effect=original_create_speech)
 
     sig = signature(original_create_speech)
 
@@ -253,11 +252,13 @@ class TestSpeechAPI:
         response = client.post("/v1/audio/speech", json=payload)
         assert response.status_code == 422  # Unprocessable Entity
 
-    @patch("vllm_omni.entrypoints.openai.serving_speech.OmniOpenAIServingSpeech.create_audio")
-    def test_speed_parameter_is_used(self, mock_create_audio, test_app):
+    def test_speed_parameter_is_used(self, test_app, mocker: MockerFixture):
+        mock_create_audio = mocker.patch(
+            "vllm_omni.entrypoints.openai.serving_speech.OmniOpenAIServingSpeech.create_audio"
+        )
         client = TestClient(test_app)
 
-        mock_audio_response = MagicMock()
+        mock_audio_response = mocker.MagicMock()
         mock_audio_response.audio_data = b"dummy_audio"
         mock_audio_response.media_type = "audio/wav"
         mock_create_audio.return_value = mock_audio_response
@@ -287,17 +288,17 @@ class TestTTSMethods:
     """Unit tests for TTS validation and parameter building."""
 
     @pytest.fixture
-    def speech_server(self):
-        mock_engine_client = MagicMock()
+    def speech_server(self, mocker: MockerFixture):
+        mock_engine_client = mocker.MagicMock()
         mock_engine_client.errored = False
         mock_engine_client.stage_list = None
         mock_engine_client.tts_max_instructions_length = None
-        mock_models = MagicMock()
+        mock_models = mocker.MagicMock()
         mock_models.is_base_model.return_value = True
         return OmniOpenAIServingSpeech(
             engine_client=mock_engine_client,
             models=mock_models,
-            request_logger=MagicMock(),
+            request_logger=mocker.MagicMock(),
         )
 
     def test_is_tts_detection_no_stage(self, speech_server):
@@ -306,25 +307,25 @@ class TestTTSMethods:
         assert speech_server._is_tts is False
         assert speech_server._tts_stage is None
 
-    def test_is_tts_detection_with_tts_stage(self):
+    def test_is_tts_detection_with_tts_stage(self, mocker: MockerFixture):
         """Test TTS model detection when TTS stage exists."""
-        mock_engine_client = MagicMock()
+        mock_engine_client = mocker.MagicMock()
         mock_engine_client.errored = False
         mock_engine_client.tts_max_instructions_length = None
 
         # Create a TTS stage
-        mock_stage = MagicMock()
+        mock_stage = mocker.MagicMock()
         mock_stage.model_stage = "qwen3_tts"
         mock_stage.tts_args = {}
         mock_engine_client.stage_list = [mock_stage]
 
-        mock_models = MagicMock()
+        mock_models = mocker.MagicMock()
         mock_models.is_base_model.return_value = True
 
         server = OmniOpenAIServingSpeech(
             engine_client=mock_engine_client,
             models=mock_models,
-            request_logger=MagicMock(),
+            request_logger=mocker.MagicMock(),
         )
 
         assert server._is_tts is True
@@ -379,24 +380,24 @@ class TestTTSMethods:
         assert params["language"] == ["English"]
         assert params["task_type"] == ["CustomVoice"]
 
-    def test_load_supported_speakers(self):
+    def test_load_supported_speakers(self, mocker: MockerFixture):
         """Test _load_supported_speakers."""
-        mock_engine_client = MagicMock()
+        mock_engine_client = mocker.MagicMock()
         mock_engine_client.errored = False
         mock_engine_client.stage_list = None
 
         # Mock talker_config with mixed-case speaker names
-        mock_talker_config = MagicMock()
+        mock_talker_config = mocker.MagicMock()
         mock_talker_config.spk_id = {"Ryan": 0, "Vivian": 1, "Aiden": 2}
         mock_engine_client.model_config.hf_config.talker_config = mock_talker_config
 
-        mock_models = MagicMock()
+        mock_models = mocker.MagicMock()
         mock_models.is_base_model.return_value = True
 
         server = OmniOpenAIServingSpeech(
             engine_client=mock_engine_client,
             models=mock_models,
-            request_logger=MagicMock(),
+            request_logger=mocker.MagicMock(),
         )
 
         # Verify speakers are normalized to lowercase
@@ -407,34 +408,34 @@ class TestTTSMethods:
         # Fixture creates server with no CLI override and no TTS stage
         assert speech_server._max_instructions_length == 500
 
-    def test_max_instructions_length_cli_override(self):
+    def test_max_instructions_length_cli_override(self, mocker: MockerFixture):
         """Test CLI override (stored in engine_client) takes highest priority."""
-        mock_engine_client = MagicMock()
+        mock_engine_client = mocker.MagicMock()
         mock_engine_client.errored = False
         mock_engine_client.stage_list = None
         # CLI override is stored in engine_client
         mock_engine_client.tts_max_instructions_length = 1000
-        mock_models = MagicMock()
+        mock_models = mocker.MagicMock()
         mock_models.is_base_model.return_value = True
 
         server = OmniOpenAIServingSpeech(
             engine_client=mock_engine_client,
             models=mock_models,
-            request_logger=MagicMock(),
+            request_logger=mocker.MagicMock(),
         )
         # Value is cached during __init__
         assert server._max_instructions_length == 1000
 
-    def test_max_instructions_length_stage_config(self):
+    def test_max_instructions_length_stage_config(self, mocker: MockerFixture):
         """Test stage config value is used when no CLI override."""
-        mock_engine_client = MagicMock()
+        mock_engine_client = mocker.MagicMock()
         mock_engine_client.errored = False
         mock_engine_client.tts_max_instructions_length = None  # No CLI override
-        mock_models = MagicMock()
+        mock_models = mocker.MagicMock()
         mock_models.is_base_model.return_value = True
 
         # Mock stage with tts_args
-        mock_stage = MagicMock()
+        mock_stage = mocker.MagicMock()
         mock_stage.model_stage = "qwen3_tts"
         mock_stage.tts_args = {"max_instructions_length": 750}
         mock_engine_client.stage_list = [mock_stage]
@@ -442,22 +443,22 @@ class TestTTSMethods:
         server = OmniOpenAIServingSpeech(
             engine_client=mock_engine_client,
             models=mock_models,
-            request_logger=MagicMock(),
+            request_logger=mocker.MagicMock(),
         )
         # Value is cached during __init__
         assert server._max_instructions_length == 750
 
-    def test_max_instructions_length_cli_overrides_stage_config(self):
+    def test_max_instructions_length_cli_overrides_stage_config(self, mocker: MockerFixture):
         """Test CLI override (in engine_client) takes precedence over stage config."""
-        mock_engine_client = MagicMock()
+        mock_engine_client = mocker.MagicMock()
         mock_engine_client.errored = False
         # CLI override stored in engine_client
         mock_engine_client.tts_max_instructions_length = 2000
-        mock_models = MagicMock()
+        mock_models = mocker.MagicMock()
         mock_models.is_base_model.return_value = True
 
         # Mock stage with tts_args
-        mock_stage = MagicMock()
+        mock_stage = mocker.MagicMock()
         mock_stage.model_stage = "qwen3_tts"
         mock_stage.tts_args = {"max_instructions_length": 750}
         mock_engine_client.stage_list = [mock_stage]
@@ -465,25 +466,25 @@ class TestTTSMethods:
         server = OmniOpenAIServingSpeech(
             engine_client=mock_engine_client,
             models=mock_models,
-            request_logger=MagicMock(),
+            request_logger=mocker.MagicMock(),
         )
         # CLI value (2000) should override stage config (750)
         assert server._max_instructions_length == 2000
 
-    def test_validate_instructions_length_uses_cached_value(self):
+    def test_validate_instructions_length_uses_cached_value(self, mocker: MockerFixture):
         """Test instructions length validation uses cached _max_instructions_length."""
-        mock_engine_client = MagicMock()
+        mock_engine_client = mocker.MagicMock()
         mock_engine_client.errored = False
         mock_engine_client.stage_list = None
         # CLI override with max length of 10 characters
         mock_engine_client.tts_max_instructions_length = 10
-        mock_models = MagicMock()
+        mock_models = mocker.MagicMock()
         mock_models.is_base_model.return_value = True
 
         server = OmniOpenAIServingSpeech(
             engine_client=mock_engine_client,
             models=mock_models,
-            request_logger=MagicMock(),
+            request_logger=mocker.MagicMock(),
         )
 
         # Verify cached value

tests/entrypoints/openai_api/test_video_server.py

@@ -5,18 +5,20 @@ Unit tests for OpenAI-compatible video generation endpoints.
 """
 
 import io
-from unittest.mock import patch
 
 import pytest
 from fastapi import FastAPI
 from fastapi.testclient import TestClient
 from PIL import Image
 from pydantic import ValidationError
+from pytest_mock import MockerFixture
 
 from vllm_omni.entrypoints.openai.api_server import router
 from vllm_omni.entrypoints.openai.protocol.videos import VideoGenerationRequest, VideoResponseFormat
 from vllm_omni.entrypoints.openai.serving_video import OmniOpenAIServingVideo
 
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
 
 class MockVideoResult:
     def __init__(self, videos):
@@ -55,27 +57,27 @@ def _make_test_image_bytes(size=(64, 64)) -> bytes:
     return buf.getvalue()
 
 
-def test_t2v_video_generation_form(test_client):
+def test_t2v_video_generation_form(test_client, mocker: MockerFixture):
     fps_values = []
 
     def _fake_encode(video, fps):
         fps_values.append(fps)
         return "Zg=="
 
-    with patch(
+    mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video.encode_video_base64",
         side_effect=_fake_encode,
-    ):
-        response = test_client.post(
-            "/v1/videos",
-            data={
-                "prompt": "A cat runs across the street.",
-                "size": "640x360",
-                "seconds": "2",
-                "fps": "12",
-                "n": "2",
-            },
-        )
+    )
+    response = test_client.post(
+        "/v1/videos",
+        data={
+            "prompt": "A cat runs across the street.",
+            "size": "640x360",
+            "seconds": "2",
+            "fps": "12",
+            "n": "2",
+        },
+    )
 
     assert response.status_code == 200
     data = response.json()
@@ -92,18 +94,18 @@ def test_t2v_video_generation_form(test_client):
     assert fps_values == [12, 12]
 
 
-def test_i2v_video_generation_form(test_client):
+def test_i2v_video_generation_form(test_client, mocker: MockerFixture):
     image_bytes = _make_test_image_bytes((48, 32))
 
-    with patch(
+    mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video.encode_video_base64",
         return_value="Zg==",
-    ):
-        response = test_client.post(
-            "/v1/videos",
-            data={"prompt": "A bear playing with yarn."},
-            files={"input_reference": ("input.png", image_bytes, "image/png")},
-        )
+    )
+    response = test_client.post(
+        "/v1/videos",
+        data={"prompt": "A bear playing with yarn."},
+        files={"input_reference": ("input.png", image_bytes, "image/png")},
+    )
 
     assert response.status_code == 200
     data = response.json()
@@ -119,24 +121,24 @@ def test_i2v_video_generation_form(test_client):
     assert input_image.size == (48, 32)
 
 
-def test_seconds_defaults_fps_and_frames(test_client):
+def test_seconds_defaults_fps_and_frames(test_client, mocker: MockerFixture):
     fps_values = []
 
     def _fake_encode(video, fps):
         fps_values.append(fps)
         return "Zg=="
 
-    with patch(
+    mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video.encode_video_base64",
         side_effect=_fake_encode,
-    ):
-        response = test_client.post(
-            "/v1/videos",
-            data={
-                "prompt": "A bird flying.",
-                "seconds": "3",
-            },
-        )
+    )
+    response = test_client.post(
+        "/v1/videos",
+        data={
+            "prompt": "A bird flying.",
+            "seconds": "3",
+        },
+    )
 
     assert response.status_code == 200
     engine = test_client.app.state.openai_serving_video._engine_client
@@ -146,18 +148,18 @@ def test_seconds_defaults_fps_and_frames(test_client):
     assert fps_values == [24]
 
 
-def test_size_param_sets_width_height(test_client):
-    with patch(
+def test_size_param_sets_width_height(test_client, mocker: MockerFixture):
+    mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video.encode_video_base64",
         return_value="Zg==",
-    ):
-        response = test_client.post(
-            "/v1/videos",
-            data={
-                "prompt": "size test",
-                "size": "320x240",
-            },
-        )
+    )
+    response = test_client.post(
+        "/v1/videos",
+        data={
+            "prompt": "size test",
+            "size": "320x240",
+        },
+    )
 
     assert response.status_code == 200
     engine = test_client.app.state.openai_serving_video._engine_client
@@ -166,23 +168,23 @@ def test_size_param_sets_width_height(test_client):
     assert captured.height == 240
 
 
-def test_sampling_params_pass_through(test_client):
-    with patch(
+def test_sampling_params_pass_through(test_client, mocker: MockerFixture):
+    mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video.encode_video_base64",
         return_value="Zg==",
-    ):
-        response = test_client.post(
-            "/v1/videos",
-            data={
-                "prompt": "param pass",
-                "num_inference_steps": "30",
-                "guidance_scale": "6.5",
-                "guidance_scale_2": "8.0",
-                "true_cfg_scale": "4.0",
-                "boundary_ratio": "0.7",
-                "flow_shift": "0.25",
-            },
-        )
+    )
+    response = test_client.post(
+        "/v1/videos",
+        data={
+            "prompt": "param pass",
+            "num_inference_steps": "30",
+            "guidance_scale": "6.5",
+            "guidance_scale_2": "8.0",
+            "true_cfg_scale": "4.0",
+            "boundary_ratio": "0.7",
+            "flow_shift": "0.25",
+        },
+    )
 
     assert response.status_code == 200
     engine = test_client.app.state.openai_serving_video._engine_client
@@ -264,19 +266,19 @@ def test_invalid_n_raises_validation_error(test_client):
         )
 
 
-def test_negative_prompt_and_seed_pass_through(test_client):
-    with patch(
+def test_negative_prompt_and_seed_pass_through(test_client, mocker: MockerFixture):
+    mocker.patch(
         "vllm_omni.entrypoints.openai.serving_video.encode_video_base64",
         return_value="Zg==",
-    ):
-        response = test_client.post(
-            "/v1/videos",
-            data={
-                "prompt": "snowy mountain",
-                "negative_prompt": "blurry",
-                "seed": "123",
-            },
-        )
+    )
+    response = test_client.post(
+        "/v1/videos",
+        data={
+            "prompt": "snowy mountain",
+            "negative_prompt": "blurry",
+            "seed": "123",
+        },
+    )
 
     assert response.status_code == 200
     engine = test_client.app.state.openai_serving_video._engine_client