@vodailoc/kilo-kit-mcp 1.1.0 → 1.1.1

package/skills/ai-media/ai-multimodal/scripts/tests/test_gemini_batch_process.py

@@ -1,362 +1,362 @@
-"""
-Tests for gemini_batch_process.py
-"""
-
-import pytest
-import sys
-from pathlib import Path
-from unittest.mock import Mock, patch, MagicMock
-
-# Add parent directory to path
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-import gemini_batch_process as gbp
-
-
-class TestAPIKeyFinder:
-    """Test API key detection."""
-
-    def test_find_api_key_from_env(self, monkeypatch):
-        """Test finding API key from environment variable."""
-        monkeypatch.setenv('GEMINI_API_KEY', 'test_key_123')
-        assert gbp.find_api_key() == 'test_key_123'
-
-    @patch('gemini_batch_process.load_dotenv')
-    def test_find_api_key_not_found(self, mock_load_dotenv, monkeypatch):
-        """Test when API key is not found."""
-        monkeypatch.delenv('GEMINI_API_KEY', raising=False)
-        # Mock load_dotenv to not actually load any files
-        mock_load_dotenv.return_value = None
-        assert gbp.find_api_key() is None
-
-
-class TestMimeTypeDetection:
-    """Test MIME type detection."""
-
-    def test_audio_mime_types(self):
-        """Test audio file MIME types."""
-        assert gbp.get_mime_type('test.mp3') == 'audio/mp3'
-        assert gbp.get_mime_type('test.wav') == 'audio/wav'
-        assert gbp.get_mime_type('test.aac') == 'audio/aac'
-        assert gbp.get_mime_type('test.flac') == 'audio/flac'
-
-    def test_image_mime_types(self):
-        """Test image file MIME types."""
-        assert gbp.get_mime_type('test.jpg') == 'image/jpeg'
-        assert gbp.get_mime_type('test.jpeg') == 'image/jpeg'
-        assert gbp.get_mime_type('test.png') == 'image/png'
-        assert gbp.get_mime_type('test.webp') == 'image/webp'
-
-    def test_video_mime_types(self):
-        """Test video file MIME types."""
-        assert gbp.get_mime_type('test.mp4') == 'video/mp4'
-        assert gbp.get_mime_type('test.mov') == 'video/quicktime'
-        assert gbp.get_mime_type('test.avi') == 'video/x-msvideo'
-
-    def test_document_mime_types(self):
-        """Test document file MIME types."""
-        assert gbp.get_mime_type('test.pdf') == 'application/pdf'
-        assert gbp.get_mime_type('test.txt') == 'text/plain'
-
-    def test_unknown_mime_type(self):
-        """Test unknown file extension."""
-        assert gbp.get_mime_type('test.xyz') == 'application/octet-stream'
-
-    def test_case_insensitive(self):
-        """Test case-insensitive extension matching."""
-        assert gbp.get_mime_type('TEST.MP3') == 'audio/mp3'
-        assert gbp.get_mime_type('Test.JPG') == 'image/jpeg'
-
-
-class TestFileUpload:
-    """Test file upload functionality."""
-
-    @patch('gemini_batch_process.genai.Client')
-    def test_upload_file_success(self, mock_client_class):
-        """Test successful file upload."""
-        # Mock client and file
-        mock_client = Mock()
-        mock_file = Mock()
-        mock_file.state.name = 'ACTIVE'
-        mock_file.name = 'test_file'
-        mock_client.files.upload.return_value = mock_file
-
-        result = gbp.upload_file(mock_client, 'test.jpg', verbose=False)
-
-        assert result == mock_file
-        mock_client.files.upload.assert_called_once_with(file='test.jpg')
-
-    @patch('gemini_batch_process.genai.Client')
-    @patch('gemini_batch_process.time.sleep')
-    def test_upload_video_with_processing(self, mock_sleep, mock_client_class):
-        """Test video upload with processing wait."""
-        mock_client = Mock()
-
-        # First call: PROCESSING, second call: ACTIVE
-        mock_file_processing = Mock()
-        mock_file_processing.state.name = 'PROCESSING'
-        mock_file_processing.name = 'test_video'
-
-        mock_file_active = Mock()
-        mock_file_active.state.name = 'ACTIVE'
-        mock_file_active.name = 'test_video'
-
-        mock_client.files.upload.return_value = mock_file_processing
-        mock_client.files.get.return_value = mock_file_active
-
-        result = gbp.upload_file(mock_client, 'test.mp4', verbose=False)
-
-        assert result.state.name == 'ACTIVE'
-
-    @patch('gemini_batch_process.genai.Client')
-    def test_upload_file_failed(self, mock_client_class):
-        """Test failed file upload."""
-        mock_client = Mock()
-        mock_file = Mock()
-        mock_file.state.name = 'FAILED'
-        mock_client.files.upload.return_value = mock_file
-        mock_client.files.get.return_value = mock_file
-
-        with pytest.raises(ValueError, match="File processing failed"):
-            gbp.upload_file(mock_client, 'test.mp4', verbose=False)
-
-
-class TestProcessFile:
-    """Test file processing functionality."""
-
-    @patch('gemini_batch_process.genai.Client')
-    @patch('builtins.open', create=True)
-    @patch('pathlib.Path.stat')
-    def test_process_small_file_inline(self, mock_stat, mock_open, mock_client_class):
-        """Test processing small file with inline data."""
-        # Mock small file
-        mock_stat.return_value.st_size = 10 * 1024 * 1024  # 10MB
-
-        # Mock file content
-        mock_open.return_value.__enter__.return_value.read.return_value = b'test_data'
-
-        # Mock client and response
-        mock_client = Mock()
-        mock_response = Mock()
-        mock_response.text = 'Test response'
-        mock_client.models.generate_content.return_value = mock_response
-
-        result = gbp.process_file(
-            client=mock_client,
-            file_path='test.jpg',
-            prompt='Describe this image',
-            model='gemini-2.5-flash',
-            task='analyze',
-            format_output='text',
-            verbose=False
-        )
-
-        assert result['status'] == 'success'
-        assert result['response'] == 'Test response'
-
-    @patch('gemini_batch_process.upload_file')
-    @patch('gemini_batch_process.genai.Client')
-    @patch('pathlib.Path.stat')
-    def test_process_large_file_api(self, mock_stat, mock_client_class, mock_upload):
-        """Test processing large file with File API."""
-        # Mock large file
-        mock_stat.return_value.st_size = 50 * 1024 * 1024  # 50MB
-
-        # Mock upload and response
-        mock_file = Mock()
-        mock_upload.return_value = mock_file
-
-        mock_client = Mock()
-        mock_response = Mock()
-        mock_response.text = 'Test response'
-        mock_client.models.generate_content.return_value = mock_response
-
-        result = gbp.process_file(
-            client=mock_client,
-            file_path='test.mp4',
-            prompt='Summarize this video',
-            model='gemini-2.5-flash',
-            task='analyze',
-            format_output='text',
-            verbose=False
-        )
-
-        assert result['status'] == 'success'
-        mock_upload.assert_called_once()
-
-    @patch('gemini_batch_process.genai.Client')
-    @patch('builtins.open', create=True)
-    @patch('pathlib.Path.stat')
-    def test_process_file_error_handling(self, mock_stat, mock_open, mock_client_class):
-        """Test error handling in file processing."""
-        mock_stat.return_value.st_size = 1024
-
-        # Mock file read
-        mock_file = MagicMock()
-        mock_file.__enter__.return_value.read.return_value = b'test_data'
-        mock_open.return_value = mock_file
-
-        mock_client = Mock()
-        mock_client.models.generate_content.side_effect = Exception("API Error")
-
-        result = gbp.process_file(
-            client=mock_client,
-            file_path='test.jpg',
-            prompt='Test',
-            model='gemini-2.5-flash',
-            task='analyze',
-            format_output='text',
-            verbose=False,
-            max_retries=1
-        )
-
-        assert result['status'] == 'error'
-        assert 'API Error' in result['error']
-
-    @patch('gemini_batch_process.genai.Client')
-    @patch('builtins.open', create=True)
-    @patch('pathlib.Path.stat')
-    def test_image_generation_with_aspect_ratio(self, mock_stat, mock_open, mock_client_class):
-        """Test image generation with aspect ratio config."""
-        mock_stat.return_value.st_size = 1024
-
-        # Mock file read
-        mock_file = MagicMock()
-        mock_file.__enter__.return_value.read.return_value = b'test'
-        mock_open.return_value = mock_file
-
-        mock_client = Mock()
-        mock_response = Mock()
-        mock_response.candidates = [Mock()]
-        mock_response.candidates[0].content.parts = [
-            Mock(inline_data=Mock(data=b'fake_image_data'))
-        ]
-        mock_client.models.generate_content.return_value = mock_response
-
-        result = gbp.process_file(
-            client=mock_client,
-            file_path='test.txt',
-            prompt='Generate mountain landscape',
-            model='gemini-2.5-flash-image',
-            task='generate',
-            format_output='text',
-            aspect_ratio='16:9',
-            verbose=False
-        )
-
-        # Verify config was called with correct structure
-        call_args = mock_client.models.generate_content.call_args
-        config = call_args.kwargs.get('config')
-        assert config is not None
-        assert result['status'] == 'success'
-        assert 'generated_image' in result
-
-
-class TestBatchProcessing:
-    """Test batch processing functionality."""
-
-    @patch('gemini_batch_process.find_api_key')
-    @patch('gemini_batch_process.process_file')
-    @patch('gemini_batch_process.genai.Client')
-    def test_batch_process_success(self, mock_client_class, mock_process, mock_find_key):
-        """Test successful batch processing."""
-        mock_find_key.return_value = 'test_key'
-        mock_process.return_value = {'status': 'success', 'response': 'Test'}
-
-        results = gbp.batch_process(
-            files=['test1.jpg', 'test2.jpg'],
-            prompt='Analyze',
-            model='gemini-2.5-flash',
-            task='analyze',
-            format_output='text',
-            verbose=False,
-            dry_run=False
-        )
-
-        assert len(results) == 2
-        assert all(r['status'] == 'success' for r in results)
-
-    @patch('gemini_batch_process.find_api_key')
-    def test_batch_process_no_api_key(self, mock_find_key):
-        """Test batch processing without API key."""
-        mock_find_key.return_value = None
-
-        with pytest.raises(SystemExit):
-            gbp.batch_process(
-                files=['test.jpg'],
-                prompt='Test',
-                model='gemini-2.5-flash',
-                task='analyze',
-                format_output='text',
-                verbose=False,
-                dry_run=False
-            )
-
-    @patch('gemini_batch_process.find_api_key')
-    def test_batch_process_dry_run(self, mock_find_key):
-        """Test dry run mode."""
-        # API key not needed for dry run, but we mock it to avoid sys.exit
-        mock_find_key.return_value = 'test_key'
-
-        results = gbp.batch_process(
-            files=['test1.jpg', 'test2.jpg'],
-            prompt='Test',
-            model='gemini-2.5-flash',
-            task='analyze',
-            format_output='text',
-            verbose=False,
-            dry_run=True
-        )
-
-        assert results == []
-
-
-class TestResultsSaving:
-    """Test results saving functionality."""
-
-    @patch('builtins.open', create=True)
-    @patch('json.dump')
-    def test_save_results_json(self, mock_json_dump, mock_open):
-        """Test saving results as JSON."""
-        results = [
-            {'file': 'test1.jpg', 'status': 'success', 'response': 'Test1'},
-            {'file': 'test2.jpg', 'status': 'success', 'response': 'Test2'}
-        ]
-
-        gbp.save_results(results, 'output.json', 'json')
-
-        mock_json_dump.assert_called_once()
-
-    @patch('builtins.open', create=True)
-    @patch('csv.DictWriter')
-    def test_save_results_csv(self, mock_csv_writer, mock_open):
-        """Test saving results as CSV."""
-        results = [
-            {'file': 'test1.jpg', 'status': 'success', 'response': 'Test1'},
-            {'file': 'test2.jpg', 'status': 'success', 'response': 'Test2'}
-        ]
-
-        gbp.save_results(results, 'output.csv', 'csv')
-
-        # Verify CSV writer was used
-        mock_csv_writer.assert_called_once()
-
-    @patch('builtins.open', create=True)
-    def test_save_results_markdown(self, mock_open):
-        """Test saving results as Markdown."""
-        mock_file = MagicMock()
-        mock_open.return_value.__enter__.return_value = mock_file
-
-        results = [
-            {'file': 'test1.jpg', 'status': 'success', 'response': 'Test1'},
-            {'file': 'test2.jpg', 'status': 'error', 'error': 'Failed'}
-        ]
-
-        gbp.save_results(results, 'output.md', 'markdown')
-
-        # Verify write was called
-        assert mock_file.write.call_count > 0
-
-
-if __name__ == '__main__':
-    pytest.main([__file__, '-v', '--cov=gemini_batch_process', '--cov-report=term-missing'])
+"""
+Tests for gemini_batch_process.py
+"""
+
+import pytest
+import sys
+from pathlib import Path
+from unittest.mock import Mock, patch, MagicMock
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import gemini_batch_process as gbp
+
+
+class TestAPIKeyFinder:
+    """Test API key detection."""
+
+    def test_find_api_key_from_env(self, monkeypatch):
+        """Test finding API key from environment variable."""
+        monkeypatch.setenv('GEMINI_API_KEY', 'test_key_123')
+        assert gbp.find_api_key() == 'test_key_123'
+
+    @patch('gemini_batch_process.load_dotenv')
+    def test_find_api_key_not_found(self, mock_load_dotenv, monkeypatch):
+        """Test when API key is not found."""
+        monkeypatch.delenv('GEMINI_API_KEY', raising=False)
+        # Mock load_dotenv to not actually load any files
+        mock_load_dotenv.return_value = None
+        assert gbp.find_api_key() is None
+
+
+class TestMimeTypeDetection:
+    """Test MIME type detection."""
+
+    def test_audio_mime_types(self):
+        """Test audio file MIME types."""
+        assert gbp.get_mime_type('test.mp3') == 'audio/mp3'
+        assert gbp.get_mime_type('test.wav') == 'audio/wav'
+        assert gbp.get_mime_type('test.aac') == 'audio/aac'
+        assert gbp.get_mime_type('test.flac') == 'audio/flac'
+
+    def test_image_mime_types(self):
+        """Test image file MIME types."""
+        assert gbp.get_mime_type('test.jpg') == 'image/jpeg'
+        assert gbp.get_mime_type('test.jpeg') == 'image/jpeg'
+        assert gbp.get_mime_type('test.png') == 'image/png'
+        assert gbp.get_mime_type('test.webp') == 'image/webp'
+
+    def test_video_mime_types(self):
+        """Test video file MIME types."""
+        assert gbp.get_mime_type('test.mp4') == 'video/mp4'
+        assert gbp.get_mime_type('test.mov') == 'video/quicktime'
+        assert gbp.get_mime_type('test.avi') == 'video/x-msvideo'
+
+    def test_document_mime_types(self):
+        """Test document file MIME types."""
+        assert gbp.get_mime_type('test.pdf') == 'application/pdf'
+        assert gbp.get_mime_type('test.txt') == 'text/plain'
+
+    def test_unknown_mime_type(self):
+        """Test unknown file extension."""
+        assert gbp.get_mime_type('test.xyz') == 'application/octet-stream'
+
+    def test_case_insensitive(self):
+        """Test case-insensitive extension matching."""
+        assert gbp.get_mime_type('TEST.MP3') == 'audio/mp3'
+        assert gbp.get_mime_type('Test.JPG') == 'image/jpeg'
+
+
+class TestFileUpload:
+    """Test file upload functionality."""
+
+    @patch('gemini_batch_process.genai.Client')
+    def test_upload_file_success(self, mock_client_class):
+        """Test successful file upload."""
+        # Mock client and file
+        mock_client = Mock()
+        mock_file = Mock()
+        mock_file.state.name = 'ACTIVE'
+        mock_file.name = 'test_file'
+        mock_client.files.upload.return_value = mock_file
+
+        result = gbp.upload_file(mock_client, 'test.jpg', verbose=False)
+
+        assert result == mock_file
+        mock_client.files.upload.assert_called_once_with(file='test.jpg')
+
+    @patch('gemini_batch_process.genai.Client')
+    @patch('gemini_batch_process.time.sleep')
+    def test_upload_video_with_processing(self, mock_sleep, mock_client_class):
+        """Test video upload with processing wait."""
+        mock_client = Mock()
+
+        # First call: PROCESSING, second call: ACTIVE
+        mock_file_processing = Mock()
+        mock_file_processing.state.name = 'PROCESSING'
+        mock_file_processing.name = 'test_video'
+
+        mock_file_active = Mock()
+        mock_file_active.state.name = 'ACTIVE'
+        mock_file_active.name = 'test_video'
+
+        mock_client.files.upload.return_value = mock_file_processing
+        mock_client.files.get.return_value = mock_file_active
+
+        result = gbp.upload_file(mock_client, 'test.mp4', verbose=False)
+
+        assert result.state.name == 'ACTIVE'
+
+    @patch('gemini_batch_process.genai.Client')
+    def test_upload_file_failed(self, mock_client_class):
+        """Test failed file upload."""
+        mock_client = Mock()
+        mock_file = Mock()
+        mock_file.state.name = 'FAILED'
+        mock_client.files.upload.return_value = mock_file
+        mock_client.files.get.return_value = mock_file
+
+        with pytest.raises(ValueError, match="File processing failed"):
+            gbp.upload_file(mock_client, 'test.mp4', verbose=False)
+
+
+class TestProcessFile:
+    """Test file processing functionality."""
+
+    @patch('gemini_batch_process.genai.Client')
+    @patch('builtins.open', create=True)
+    @patch('pathlib.Path.stat')
+    def test_process_small_file_inline(self, mock_stat, mock_open, mock_client_class):
+        """Test processing small file with inline data."""
+        # Mock small file
+        mock_stat.return_value.st_size = 10 * 1024 * 1024  # 10MB
+
+        # Mock file content
+        mock_open.return_value.__enter__.return_value.read.return_value = b'test_data'
+
+        # Mock client and response
+        mock_client = Mock()
+        mock_response = Mock()
+        mock_response.text = 'Test response'
+        mock_client.models.generate_content.return_value = mock_response
+
+        result = gbp.process_file(
+            client=mock_client,
+            file_path='test.jpg',
+            prompt='Describe this image',
+            model='gemini-2.5-flash',
+            task='analyze',
+            format_output='text',
+            verbose=False
+        )
+
+        assert result['status'] == 'success'
+        assert result['response'] == 'Test response'
+
+    @patch('gemini_batch_process.upload_file')
+    @patch('gemini_batch_process.genai.Client')
+    @patch('pathlib.Path.stat')
+    def test_process_large_file_api(self, mock_stat, mock_client_class, mock_upload):
+        """Test processing large file with File API."""
+        # Mock large file
+        mock_stat.return_value.st_size = 50 * 1024 * 1024  # 50MB
+
+        # Mock upload and response
+        mock_file = Mock()
+        mock_upload.return_value = mock_file
+
+        mock_client = Mock()
+        mock_response = Mock()
+        mock_response.text = 'Test response'
+        mock_client.models.generate_content.return_value = mock_response
+
+        result = gbp.process_file(
+            client=mock_client,
+            file_path='test.mp4',
+            prompt='Summarize this video',
+            model='gemini-2.5-flash',
+            task='analyze',
+            format_output='text',
+            verbose=False
+        )
+
+        assert result['status'] == 'success'
+        mock_upload.assert_called_once()
+
+    @patch('gemini_batch_process.genai.Client')
+    @patch('builtins.open', create=True)
+    @patch('pathlib.Path.stat')
+    def test_process_file_error_handling(self, mock_stat, mock_open, mock_client_class):
+        """Test error handling in file processing."""
+        mock_stat.return_value.st_size = 1024
+
+        # Mock file read
+        mock_file = MagicMock()
+        mock_file.__enter__.return_value.read.return_value = b'test_data'
+        mock_open.return_value = mock_file
+
+        mock_client = Mock()
+        mock_client.models.generate_content.side_effect = Exception("API Error")
+
+        result = gbp.process_file(
+            client=mock_client,
+            file_path='test.jpg',
+            prompt='Test',
+            model='gemini-2.5-flash',
+            task='analyze',
+            format_output='text',
+            verbose=False,
+            max_retries=1
+        )
+
+        assert result['status'] == 'error'
+        assert 'API Error' in result['error']
+
+    @patch('gemini_batch_process.genai.Client')
+    @patch('builtins.open', create=True)
+    @patch('pathlib.Path.stat')
+    def test_image_generation_with_aspect_ratio(self, mock_stat, mock_open, mock_client_class):
+        """Test image generation with aspect ratio config."""
+        mock_stat.return_value.st_size = 1024
+
+        # Mock file read
+        mock_file = MagicMock()
+        mock_file.__enter__.return_value.read.return_value = b'test'
+        mock_open.return_value = mock_file
+
+        mock_client = Mock()
+        mock_response = Mock()
+        mock_response.candidates = [Mock()]
+        mock_response.candidates[0].content.parts = [
+            Mock(inline_data=Mock(data=b'fake_image_data'))
+        ]
+        mock_client.models.generate_content.return_value = mock_response
+
+        result = gbp.process_file(
+            client=mock_client,
+            file_path='test.txt',
+            prompt='Generate mountain landscape',
+            model='gemini-2.5-flash-image',
+            task='generate',
+            format_output='text',
+            aspect_ratio='16:9',
+            verbose=False
+        )
+
+        # Verify config was called with correct structure
+        call_args = mock_client.models.generate_content.call_args
+        config = call_args.kwargs.get('config')
+        assert config is not None
+        assert result['status'] == 'success'
+        assert 'generated_image' in result
+
+
+class TestBatchProcessing:
+    """Test batch processing functionality."""
+
+    @patch('gemini_batch_process.find_api_key')
+    @patch('gemini_batch_process.process_file')
+    @patch('gemini_batch_process.genai.Client')
+    def test_batch_process_success(self, mock_client_class, mock_process, mock_find_key):
+        """Test successful batch processing."""
+        mock_find_key.return_value = 'test_key'
+        mock_process.return_value = {'status': 'success', 'response': 'Test'}
+
+        results = gbp.batch_process(
+            files=['test1.jpg', 'test2.jpg'],
+            prompt='Analyze',
+            model='gemini-2.5-flash',
+            task='analyze',
+            format_output='text',
+            verbose=False,
+            dry_run=False
+        )
+
+        assert len(results) == 2
+        assert all(r['status'] == 'success' for r in results)
+
+    @patch('gemini_batch_process.find_api_key')
+    def test_batch_process_no_api_key(self, mock_find_key):
+        """Test batch processing without API key."""
+        mock_find_key.return_value = None
+
+        with pytest.raises(SystemExit):
+            gbp.batch_process(
+                files=['test.jpg'],
+                prompt='Test',
+                model='gemini-2.5-flash',
+                task='analyze',
+                format_output='text',
+                verbose=False,
+                dry_run=False
+            )
+
+    @patch('gemini_batch_process.find_api_key')
+    def test_batch_process_dry_run(self, mock_find_key):
+        """Test dry run mode."""
+        # API key not needed for dry run, but we mock it to avoid sys.exit
+        mock_find_key.return_value = 'test_key'
+
+        results = gbp.batch_process(
+            files=['test1.jpg', 'test2.jpg'],
+            prompt='Test',
+            model='gemini-2.5-flash',
+            task='analyze',
+            format_output='text',
+            verbose=False,
+            dry_run=True
+        )
+
+        assert results == []
+
+
+class TestResultsSaving:
+    """Test results saving functionality."""
+
+    @patch('builtins.open', create=True)
+    @patch('json.dump')
+    def test_save_results_json(self, mock_json_dump, mock_open):
+        """Test saving results as JSON."""
+        results = [
+            {'file': 'test1.jpg', 'status': 'success', 'response': 'Test1'},
+            {'file': 'test2.jpg', 'status': 'success', 'response': 'Test2'}
+        ]
+
+        gbp.save_results(results, 'output.json', 'json')
+
+        mock_json_dump.assert_called_once()
+
+    @patch('builtins.open', create=True)
+    @patch('csv.DictWriter')
+    def test_save_results_csv(self, mock_csv_writer, mock_open):
+        """Test saving results as CSV."""
+        results = [
+            {'file': 'test1.jpg', 'status': 'success', 'response': 'Test1'},
+            {'file': 'test2.jpg', 'status': 'success', 'response': 'Test2'}
+        ]
+
+        gbp.save_results(results, 'output.csv', 'csv')
+
+        # Verify CSV writer was used
+        mock_csv_writer.assert_called_once()
+
+    @patch('builtins.open', create=True)
+    def test_save_results_markdown(self, mock_open):
+        """Test saving results as Markdown."""
+        mock_file = MagicMock()
+        mock_open.return_value.__enter__.return_value = mock_file
+
+        results = [
+            {'file': 'test1.jpg', 'status': 'success', 'response': 'Test1'},
+            {'file': 'test2.jpg', 'status': 'error', 'error': 'Failed'}
+        ]
+
+        gbp.save_results(results, 'output.md', 'markdown')
+
+        # Verify write was called
+        assert mock_file.write.call_count > 0
+
+
+if __name__ == '__main__':
+    pytest.main([__file__, '-v', '--cov=gemini_batch_process', '--cov-report=term-missing'])