feat: add output directory and save audio fixture for integration tests

Signed-off-by: James Ding <jamesding365@gmail.com>

Author: twangodev

.github/workflows/python.yml

@@ -85,6 +85,13 @@ jobs:
         env:
           FISH_AUDIO_API_KEY: ${{ secrets.FISH_AUDIO_API_KEY }}
 
+      - name: Upload Test Artifacts
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: test-audio-output
+          path: output/
+
   build:
     name: Build Package
     runs-on: ubuntu-latest

.gitignore

@@ -159,4 +159,7 @@ cython_debug/
 #  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
+.idea/
+
+# Test output
+output/

tests/integration/conftest.py

@@ -1,6 +1,7 @@
 """Fixtures for integration tests."""
 
 import os
+from pathlib import Path
 
 import pytest
 from dotenv import load_dotenv
@@ -9,6 +10,10 @@
 
 load_dotenv()
 
+# Create output directory for test audio files
+OUTPUT_DIR = Path("output")
+OUTPUT_DIR.mkdir(exist_ok=True)
+
 
 @pytest.fixture
 def api_key():
@@ -33,3 +38,29 @@ async def async_client(api_key):
     client = AsyncFishAudio(api_key=api_key)
     yield client
     await client.close()
+
+
+@pytest.fixture
+def save_audio():
+    """Fixture that provides a helper to save audio chunks to the output directory.
+
+    Returns:
+        A callable that takes audio chunks and filename and saves to output/
+    """
+
+    def _save(audio_chunks: list[bytes], filename: str) -> Path:
+        """Save audio chunks to output directory.
+
+        Args:
+            audio_chunks: List of audio byte chunks
+            filename: Name of the output file (including extension)
+
+        Returns:
+            Path to the saved file
+        """
+        complete_audio = b"".join(audio_chunks)
+        output_file = OUTPUT_DIR / filename
+        output_file.write_bytes(complete_audio)
+        return output_file
+
+    return _save

tests/integration/test_tts_integration.py

@@ -5,13 +5,13 @@
 import pytest
 
 from fishaudio.types import Prosody, TTSConfig
-from fishaudio.types.shared import Model
+from fishaudio.types.shared import AudioFormat, Model
 
 
 class TestTTSIntegration:
     """Test TTS with real API."""
 
-    def test_basic_tts(self, client):
+    def test_basic_tts(self, client, save_audio):
         """Test basic text-to-speech generation."""
         audio_chunks = list(client.tts.convert(text="Hello, this is a test."))
 
@@ -20,18 +20,24 @@ def test_basic_tts(self, client):
         complete_audio = b"".join(audio_chunks)
         assert len(complete_audio) > 1000  # Should have substantial audio data
 
-    def test_tts_with_different_formats(self, client):
+        # Write to output directory
+        save_audio(audio_chunks, "test_basic_tts.mp3")
+
+    def test_tts_with_different_formats(self, client, save_audio):
         """Test TTS with different audio formats."""
-        formats = ["mp3", "wav", "pcm"]
+        formats = get_args(AudioFormat)
 
         for fmt in formats:
             config = TTSConfig(format=fmt, chunk_length=100)
             audio_chunks = list(
-                client.tts.convert(text="Testing format", config=config)
+                client.tts.convert(text=f"Testing format {fmt}", config=config)
             )
             assert len(audio_chunks) > 0, f"Failed for format: {fmt}"
 
-    def test_tts_with_prosody(self, client):
+            # Write to output directory
+            save_audio(audio_chunks, f"test_format_{fmt}.{fmt}")
+
+    def test_tts_with_prosody(self, client, save_audio):
         """Test TTS with prosody settings."""
         prosody = Prosody(speed=1.2, volume=0.5)
         config = TTSConfig(prosody=prosody)
@@ -42,21 +48,27 @@ def test_tts_with_prosody(self, client):
 
         assert len(audio_chunks) > 0
 
-    def test_tts_with_different_backends(self, client):
-        """Test TTS with different backend models."""
+        # Write to output directory
+        save_audio(audio_chunks, "test_prosody.mp3")
+
+    def test_tts_with_different_models(self, client, save_audio):
+        """Test TTS with different models."""
         models = get_args(Model)
 
         for model in models:
             try:
                 audio_chunks = list(
-                    client.tts.convert(text="Testing model", model=model)
+                    client.tts.convert(text=f"Testing model {model}", model=model)
                 )
                 assert len(audio_chunks) > 0, f"Failed for model: {model}"
+
+                # Write to output directory
+                save_audio(audio_chunks, f"test_model_{model}.mp3")
             except Exception as e:
                 # Some models might not be available
                 pytest.skip(f"Model {model} not available: {e}")
 
-    def test_tts_longer_text(self, client):
+    def test_tts_longer_text(self, client, save_audio):
         """Test TTS with longer text."""
         long_text = "This is a longer piece of text for testing. " * 10
         config = TTSConfig(chunk_length=200)
@@ -68,6 +80,9 @@ def test_tts_longer_text(self, client):
         # Longer text should produce more audio
         assert len(complete_audio) > 5000
 
+        # Write to output directory
+        save_audio(audio_chunks, "test_longer_text.mp3")
+
     def test_tts_empty_text_should_fail(self, client):
         """Test that empty text is handled."""
         # This might succeed with silence or fail - test behavior
@@ -84,7 +99,7 @@ class TestAsyncTTSIntegration:
     """Test async TTS with real API."""
 
     @pytest.mark.asyncio
-    async def test_basic_async_tts(self, async_client):
+    async def test_basic_async_tts(self, async_client, save_audio):
         """Test basic async text-to-speech generation."""
         audio_chunks = []
         async for chunk in async_client.tts.convert(text="Hello from async"):
@@ -94,8 +109,11 @@ async def test_basic_async_tts(self, async_client):
         complete_audio = b"".join(audio_chunks)
         assert len(complete_audio) > 1000
 
+        # Write to output directory
+        save_audio(audio_chunks, "test_async_basic.mp3")
+
     @pytest.mark.asyncio
-    async def test_async_tts_with_prosody(self, async_client):
+    async def test_async_tts_with_prosody(self, async_client, save_audio):
         """Test async TTS with prosody."""
         prosody = Prosody(speed=0.8, volume=-0.2)
         config = TTSConfig(prosody=prosody)
@@ -107,3 +125,6 @@ async def test_async_tts_with_prosody(self, async_client):
             audio_chunks.append(chunk)
 
         assert len(audio_chunks) > 0
+
+        # Write to output directory
+        save_audio(audio_chunks, "test_async_prosody.mp3")