Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

test: use concrete audio provider recorders (#43539)

Asuka Minato2de5d891cbd5
diff --git a/api/tests/unit_tests/services/test_audio_service.py b/api/tests/unit_tests/services/test_audio_service.py
index 1ce0aa53270..730ea49ece8 100644
--- a/api/tests/unit_tests/services/test_audio_service.py
+++ b/api/tests/unit_tests/services/test_audio_service.py
@@ -32,10 +32,10 @@ Tests available voice retrieval:
## Testing Approach
-- **Isolation Strategy**: ModelManager is mocked; uploads use real FileStorage byte streams,
+- **Isolation Strategy**: ModelManager uses a recording implementation; uploads use real FileStorage byte streams,
while database paths use isolated in-memory SQLite sessions
- **Factory Pattern**: AudioServiceTestDataFactory provides consistent test data
-- **Fixtures**: Mock objects are configured per test method
+- **Fixtures**: Recording provider objects are configured per test method
- **Assertions**: Each test verifies return values, side effects, and error conditions
## Key Concepts
@@ -55,9 +55,10 @@ Tests available voice retrieval:
import json
from collections.abc import Generator
+from dataclasses import dataclass, field
from decimal import Decimal
from io import BytesIO
-from unittest.mock import MagicMock, patch
+from typing import Any
from uuid import uuid4
import pytest
@@ -66,8 +67,10 @@ from sqlalchemy.orm import Session
from werkzeug.datastructures import FileStorage
from core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy
+from core.model_manager import ModelInstance, ModelManager
from core.plugin.entities.plugin_daemon import TTSAudioChunk
from extensions.ext_database import db
+from graphon.model_runtime.entities.model_entities import ModelType
from graphon.model_runtime.errors.invoke import InvokeBadRequestError
from models.agent import Agent, AgentConfigSnapshot, AgentScope, AgentSource
from models.agent_config_entities import AgentSoulConfig
@@ -95,6 +98,71 @@ ACCOUNT_ID = "66666666-6666-6666-6666-666666666666"
OTHER_ID = "77777777-7777-7777-7777-777777777777"
+@dataclass
+class RecordingAudioModel(ModelInstance):
+ """Concrete audio model with configurable results and recorded invocations."""
+
+ speech_to_text_result: str = "Transcribed text"
+ tts_result: bytes | Generator[bytes | TTSAudioChunk] = b"audio data"
+ voices: list[dict[str, str]] = field(default_factory=list)
+ voices_error: Exception | None = None
+ speech_to_text_calls: list[bytes] = field(default_factory=list)
+ tts_calls: list[dict[str, str]] = field(default_factory=list)
+ voice_calls: list[tuple[str, ...]] = field(default_factory=list)
+
+ def invoke_speech2text(self, *, file: BytesIO) -> str:
+ self.speech_to_text_calls.append(file.read())
+ return self.speech_to_text_result
+
+ def invoke_tts(self, *, content_text: str, voice: str) -> bytes | Generator[bytes | TTSAudioChunk]:
+ self.tts_calls.append({"content_text": content_text, "voice": voice})
+ return self.tts_result
+
+ def get_tts_voices(self, *args: str) -> list[dict[str, str]]:
+ self.voice_calls.append(args)
+ if self.voices_error is not None:
+ raise self.voices_error
+ return self.voices
+
+
+@dataclass
+class RecordingModelManager(ModelManager):
+ """Concrete manager that returns the configured audio model."""
+
+ model: RecordingAudioModel | None
+ model_requests: list[tuple[str, ModelType]] = field(default_factory=list)
+
+ def get_default_model_instance(self, tenant_id: str, model_type: ModelType) -> RecordingAudioModel | None:
+ self.model_requests.append((tenant_id, model_type))
+ return self.model
+
+
+@dataclass
+class AudioProviderHarness:
+ """Provider assembly exposed to tests without dynamic stand-ins."""
+
+ model: RecordingAudioModel
+ manager: RecordingModelManager
+ manager_requests: list[dict[str, Any]] = field(default_factory=list)
+
+
+def audio_provider(monkeypatch: pytest.MonkeyPatch) -> AudioProviderHarness:
+ model = RecordingAudioModel()
+ harness = AudioProviderHarness(model=model, manager=RecordingModelManager(model=model))
+
+ def for_tenant(
+ *, tenant_id: str, user_id: str | None = None, request_metadata: dict[str, object] | None = None
+ ) -> RecordingModelManager:
+ harness.manager_requests.append(
+ {"tenant_id": tenant_id, "user_id": user_id, "request_metadata": request_metadata}
+ )
+ return harness.manager
+
+ monkeypatch.setattr(ModelManager, "for_tenant", staticmethod(for_tenant))
+ return harness
+
+
def _message(*, answer: str = "Message answer") -> Message:
return make_message(
message_id=MESSAGE_ID,
@@ -287,9 +355,8 @@ class TestAudioServiceASR:
def _bind_sqlite_session(self, sqlite_session: Session) -> None:
self.session = sqlite_session
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_asr_success_chat_mode(
- self, mock_model_manager_class: MagicMock, factory: AudioServiceTestDataFactory
+ self, audio_provider: AudioProviderHarness, factory: AudioServiceTestDataFactory
) -> None:
"""Test successful ASR transcription in CHAT mode."""
# Arrange
@@ -300,50 +367,44 @@ class TestAudioServiceASR:
)
file = factory.create_file_storage()
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_speech2text.return_value = "Transcribed text"
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.speech_to_text_result = "Transcribed text"
# Act
result = AudioService.transcript_asr(app_model=app, file=file, session=self.session, end_user="user-123")
# Assert
assert result == {"text": "Transcribed text"}
- mock_model_instance.invoke_speech2text.assert_called_once()
- mock_model_manager_class.assert_called_once_with(
- tenant_id=app.tenant_id,
- user_id="user-123",
- request_metadata={
- "app_type": CreditUsageAppType.CHATBOT,
- "created_by": CreditUsageCreatedBy.AUDIO,
+ assert audio_provider.model.speech_to_text_calls == [b"fake audio content"]
+ assert audio_provider.manager_requests == [
+ {
+ "tenant_id": app.tenant_id,
+ "user_id": "user-123",
+ "request_metadata": {
+ "app_type": CreditUsageAppType.CHATBOT,
+ "created_by": CreditUsageCreatedBy.AUDIO,
+ },
},
- )
+ ]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_asr_accepts_x_m4a_mimetype(
- self, mock_model_manager_class: MagicMock, factory: AudioServiceTestDataFactory
+ self, audio_provider: AudioProviderHarness, factory: AudioServiceTestDataFactory
) -> None:
"""Test that the x-m4a MIME alias follows the normal m4a transcription flow."""
# Arrange
app_model_config = factory.create_app_model_config_mock(speech_to_text_dict={"enabled": True})
app = factory.create_app_mock(mode=AppMode.CHAT, app_model_config=app_model_config)
file = factory.create_file_storage(filename="audio.m4a", mimetype="audio/x-m4a")
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_speech2text.return_value = "M4A transcript"
- mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.speech_to_text_result = "M4A transcript"
# Act
result = AudioService.transcript_asr(app_model=app, file=file, session=self.session)
# Assert
assert result == {"text": "M4A transcript"}
- mock_model_instance.invoke_speech2text.assert_called_once()
+ assert audio_provider.model.speech_to_text_calls == [b"fake audio content"]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_asr_success_advanced_chat_mode(
- self, mock_model_manager_class: MagicMock, factory: AudioServiceTestDataFactory
+ self, audio_provider: AudioProviderHarness, factory: AudioServiceTestDataFactory
) -> None:
"""Test successful ASR transcription in ADVANCED_CHAT mode."""
# Arrange
@@ -354,11 +415,7 @@ class TestAudioServiceASR:
)
file = factory.create_file_storage()
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_speech2text.return_value = "Workflow transcribed text"
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.speech_to_text_result = "Workflow transcribed text"
# Act
result = AudioService.transcript_asr(app_model=app, file=file, session=self.session)
@@ -366,10 +423,9 @@ class TestAudioServiceASR:
# Assert
assert result == {"text": "Workflow transcribed text"}
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_asr_success_published_agent_mode(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
) -> None:
app = factory.create_app_mock(mode=AppMode.AGENT)
@@ -391,49 +447,43 @@ class TestAudioServiceASR:
self.session.flush()
agent.active_config_snapshot_id = snapshot.id
self.session.commit()
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_speech2text.return_value = "Published Agent transcript"
- mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.speech_to_text_result = "Published Agent transcript"
result = AudioService.transcript_asr(app_model=app, file=file, session=self.session, end_user="end-user-1")
assert result == {"text": "Published Agent transcript"}
- mock_model_manager_class.assert_called_once_with(
- tenant_id=app.tenant_id,
- user_id="end-user-1",
- request_metadata={
- "app_type": CreditUsageAppType.AGENT_V2,
- "created_by": CreditUsageCreatedBy.AUDIO,
+ assert audio_provider.manager_requests == [
+ {
+ "tenant_id": app.tenant_id,
+ "user_id": "end-user-1",
+ "request_metadata": {
+ "app_type": CreditUsageAppType.AGENT_V2,
+ "created_by": CreditUsageCreatedBy.AUDIO,
+ },
},
- )
+ ]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_asr_legacy_agent_falls_back_to_app_model_config(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
) -> None:
app_model_config = factory.create_app_model_config_mock(speech_to_text_dict={"enabled": True})
app = factory.create_app_mock(mode=AppMode.AGENT, app_model_config=app_model_config)
file = factory.create_file_storage()
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_speech2text.return_value = "Legacy Agent transcript"
- mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.speech_to_text_result = "Legacy Agent transcript"
result = AudioService.transcript_asr(app_model=app, file=file, session=self.session)
assert result == {"text": "Legacy Agent transcript"}
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_agent_asr_uses_agent_soul_feature(
- self, mock_model_manager_class: MagicMock, factory: AudioServiceTestDataFactory
+ self, audio_provider: AudioProviderHarness, factory: AudioServiceTestDataFactory
) -> None:
app = factory.create_app_mock(mode=AppMode.AGENT)
file = factory.create_file_storage()
agent_soul = AgentSoulConfig.model_validate({"app_features": {"speech_to_text": {"enabled": True}}})
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_speech2text.return_value = "Agent transcript"
- mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.speech_to_text_result = "Agent transcript"
result = AudioService.transcript_agent_asr(
app_model=app,
@@ -444,14 +494,16 @@ class TestAudioServiceASR:
)
assert result == {"text": "Agent transcript"}
- mock_model_manager_class.assert_called_once_with(
- tenant_id=app.tenant_id,
- user_id="account-1",
- request_metadata={
- "app_type": CreditUsageAppType.AGENT_V2,
- "created_by": CreditUsageCreatedBy.AUDIO,
+ assert audio_provider.manager_requests == [
+ {
+ "tenant_id": app.tenant_id,
+ "user_id": "account-1",
+ "request_metadata": {
+ "app_type": CreditUsageAppType.AGENT_V2,
+ "created_by": CreditUsageCreatedBy.AUDIO,
+ },
},
- )
+ ]
@pytest.mark.parametrize(
"agent_soul",
@@ -469,16 +521,13 @@ class TestAudioServiceASR:
with pytest.raises(SpeechToTextDisabledServiceError):
AudioService.transcript_agent_asr(app_model=app, agent_soul=agent_soul, file=file, session=self.session)
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_agent_asr_preserves_legacy_feature_fallback(
- self, mock_model_manager_class: MagicMock, factory: AudioServiceTestDataFactory
+ self, audio_provider: AudioProviderHarness, factory: AudioServiceTestDataFactory
) -> None:
app_model_config = factory.create_app_model_config_mock(speech_to_text_dict={"enabled": True})
app = factory.create_app_mock(mode=AppMode.AGENT, app_model_config=app_model_config)
file = factory.create_file_storage()
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_speech2text.return_value = "Legacy feature transcript"
- mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.speech_to_text_result = "Legacy feature transcript"
result = AudioService.transcript_agent_asr(
app_model=app,
@@ -588,9 +637,8 @@ class TestAudioServiceASR:
with pytest.raises(AudioTooLargeServiceError, match="Audio size larger than 30 mb"):
AudioService.transcript_asr(app_model=app, file=file, session=self.session)
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_asr_raises_error_when_no_model_instance(
- self, mock_model_manager_class: MagicMock, factory: AudioServiceTestDataFactory
+ self, audio_provider: AudioProviderHarness, factory: AudioServiceTestDataFactory
) -> None:
"""Test that ASR raises error when no model instance is available."""
# Arrange
@@ -601,9 +649,7 @@ class TestAudioServiceASR:
)
file = factory.create_file_storage()
- # Mock ModelManager to return None
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_manager.get_default_model_instance.return_value = None
+ audio_provider.manager.model = None
# Act & Assert
with pytest.raises(ProviderNotSupportSpeechToTextServiceError):
@@ -613,18 +659,16 @@ class TestAudioServiceASR:
class TestAudioServiceTTS:
"""Test text-to-speech (TTS) operations."""
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_legacy_tts_preserves_the_callers_uncommitted_transaction(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
) -> None:
app = factory.create_app_mock()
sqlite_session.add(_message())
sqlite_session.flush()
- mock_model_instance = mock_model_manager_class.return_value.get_default_model_instance.return_value
- mock_model_instance.invoke_tts.return_value = b"pending message audio"
+ audio_provider.model.tts_result = b"pending message audio"
result = AudioService.transcript_tts(
app_model=app,
@@ -638,14 +682,13 @@ class TestAudioServiceTTS:
assert result is not None
assert result.get_data() == b"pending message audio"
assert sqlite_session.in_transaction()
- mock_model_instance.invoke_tts.assert_called_once_with(content_text="Message answer", voice="pending-voice")
+ assert audio_provider.model.tts_calls == [{"content_text": "Message answer", "voice": "pending-voice"}]
sqlite_session.rollback()
assert sqlite_session.get(Message, MESSAGE_ID) is None
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_with_text_success(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
) -> None:
@@ -659,11 +702,7 @@ class TestAudioServiceTTS:
app_model_config=app_model_config,
)
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_tts.return_value = b"audio data"
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.tts_result = b"audio data"
# Act
result = AudioService.transcript_tts(
@@ -678,23 +717,21 @@ class TestAudioServiceTTS:
assert result is not None
assert result.content_type == "audio/mpeg"
assert result.get_data() == b"audio data"
- mock_model_manager_class.assert_called_once_with(
- tenant_id=app.tenant_id,
- user_id="user-123",
- request_metadata={
- "app_type": CreditUsageAppType.CHATBOT,
- "created_by": CreditUsageCreatedBy.AUDIO,
+ assert audio_provider.manager_requests == [
+ {
+ "tenant_id": app.tenant_id,
+ "user_id": "user-123",
+ "request_metadata": {
+ "app_type": CreditUsageAppType.CHATBOT,
+ "created_by": CreditUsageCreatedBy.AUDIO,
+ },
},
- )
- mock_model_instance.invoke_tts.assert_called_once_with(
- content_text="Hello world",
- voice="en-US-Neural",
- )
+ ]
+ assert audio_provider.model.tts_calls == [{"content_text": "Hello world", "voice": "en-US-Neural"}]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_with_default_voice(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
) -> None:
@@ -708,11 +745,7 @@ class TestAudioServiceTTS:
app_model_config=app_model_config,
)
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_tts.return_value = b"audio data"
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.tts_result = b"audio data"
# Act
result = AudioService.transcript_tts(
@@ -726,13 +759,11 @@ class TestAudioServiceTTS:
assert result.content_type == "audio/mpeg"
assert result.get_data() == b"audio data"
# Verify default voice was used
- call_args = mock_model_instance.invoke_tts.call_args
- assert call_args.kwargs["voice"] == "default-voice"
+ assert audio_provider.model.tts_calls == [{"content_text": "Test", "voice": "default-voice"}]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_gets_first_available_voice_when_none_configured(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
) -> None:
@@ -746,12 +777,8 @@ class TestAudioServiceTTS:
app_model_config=app_model_config,
)
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.get_tts_voices.return_value = [{"value": "auto-voice"}]
- mock_model_instance.invoke_tts.return_value = b"audio data"
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.voices = [{"value": "auto-voice"}]
+ audio_provider.model.tts_result = b"audio data"
# Act
result = AudioService.transcript_tts(
@@ -764,13 +791,11 @@ class TestAudioServiceTTS:
assert result is not None
assert result.content_type == "audio/mpeg"
assert result.get_data() == b"audio data"
- call_args = mock_model_instance.invoke_tts.call_args
- assert call_args.kwargs["voice"] == "auto-voice"
+ assert audio_provider.model.tts_calls == [{"content_text": "Test", "voice": "auto-voice"}]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_workflow_mode_with_draft(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
) -> None:
@@ -781,11 +806,7 @@ class TestAudioServiceTTS:
mode=AppMode.WORKFLOW,
)
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_tts.return_value = b"draft audio"
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.tts_result = b"draft audio"
# WorkflowService constructs its default repository from db.engine.
# Leave that database empty so the draft must come from sqlite_session.
flask_app = Flask(__name__)
@@ -807,12 +828,11 @@ class TestAudioServiceTTS:
assert result is not None
assert result.content_type == "audio/mpeg"
assert result.get_data() == b"draft audio"
- mock_model_instance.invoke_tts.assert_called_once_with(content_text="Draft test", voice="draft-voice")
+ assert audio_provider.model.tts_calls == [{"content_text": "Draft test", "voice": "draft-voice"}]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_message_id_uses_provided_session(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
) -> None:
@@ -828,10 +848,7 @@ class TestAudioServiceTTS:
sqlite_session.add(_message())
sqlite_session.commit()
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_tts.return_value = b"message audio"
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.tts_result = b"message audio"
# Act
for wrong_ref in (
@@ -875,15 +892,11 @@ class TestAudioServiceTTS:
assert result is not None
assert result.content_type == "audio/mpeg"
assert result.get_data() == b"message audio"
- mock_model_instance.invoke_tts.assert_called_once_with(
- content_text="Message answer",
- voice="message-voice",
- )
+ assert audio_provider.model.tts_calls == [{"content_text": "Message answer", "voice": "message-voice"}]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_uses_detected_wav_mime_type_for_streams(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
app: Flask,
@@ -892,11 +905,9 @@ class TestAudioServiceTTS:
text_to_speech_dict={"enabled": True, "voice": "en-US-Neural"}
)
app_model = factory.create_app_mock(mode=AppMode.CHAT, app_model_config=app_model_config)
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_tts.return_value = iter(
- [b"RIFF\x24\x00\x00\x00WAVEfmt ", b"\x10\x00\x00\x00audio-data"]
+ audio_provider.model.tts_result = (
+ chunk for chunk in [b"RIFF\x24\x00\x00\x00WAVEfmt ", b"\x10\x00\x00\x00audio-data"]
)
- mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance
with app.test_request_context("/text-to-audio", method="POST"):
result = AudioService.transcript_tts(
@@ -910,10 +921,9 @@ class TestAudioServiceTTS:
assert result.content_type == "audio/wav"
assert result.get_data() == b"RIFF\x24\x00\x00\x00WAVEfmt \x10\x00\x00\x00audio-data"
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_returns_provider_output_error_for_mime_magic_mismatch(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
app: Flask,
@@ -922,11 +932,9 @@ class TestAudioServiceTTS:
text_to_speech_dict={"enabled": True, "voice": "en-US-Neural"}
)
app_model = factory.create_app_mock(mode=AppMode.CHAT, app_model_config=app_model_config)
- mock_model_instance = MagicMock()
- mock_model_instance.invoke_tts.return_value = iter(
- [TTSAudioChunk(b"RIFF\x24\x00\x00\x00WAVEfmt \x10\x00\x00\x00audio-data", "audio/mpeg")]
+ audio_provider.model.tts_result = (
+ chunk for chunk in [TTSAudioChunk(b"RIFF\x24\x00\x00\x00WAVEfmt \x10\x00\x00\x00audio-data", "audio/mpeg")]
)
- mock_model_manager_class.return_value.get_default_model_instance.return_value = mock_model_instance
with app.test_request_context("/text-to-audio", method="POST"):
with pytest.raises(InvokeBadRequestError, match="output MIME does not match"):
@@ -950,10 +958,9 @@ class TestAudioServiceTTS:
with pytest.raises(ValueError, match="Text is required"):
AudioService.transcript_tts(app_model=app, session=sqlite_session, text=None)
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_raises_error_when_no_voices_available(
self,
- mock_model_manager_class: MagicMock,
+ audio_provider: AudioProviderHarness,
factory: AudioServiceTestDataFactory,
sqlite_session: Session,
) -> None:
@@ -967,11 +974,7 @@ class TestAudioServiceTTS:
app_model_config=app_model_config,
)
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.get_tts_voices.return_value = list[dict[str, str]]() # No voices available
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.voices = []
# Act & Assert
with pytest.raises(ValueError, match="Sorry, no voice available"):
@@ -981,8 +984,7 @@ class TestAudioServiceTTS:
class TestAudioServiceTTSVoices:
"""Test TTS voice listing operations."""
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
- def test_transcript_tts_voices_success(self, mock_model_manager_class: MagicMock) -> None:
+ def test_transcript_tts_voices_success(self, audio_provider: AudioProviderHarness) -> None:
"""Test successful retrieval of TTS voices."""
# Arrange
tenant_id = "tenant-123"
@@ -993,48 +995,36 @@ class TestAudioServiceTTSVoices:
{"name": "Voice 2", "value": "voice-2"},
]
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.get_tts_voices.return_value = expected_voices
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.voices = expected_voices
# Act
result = AudioService.transcript_tts_voices(tenant_id=tenant_id, language=language)
# Assert
assert result == expected_voices
- mock_model_instance.get_tts_voices.assert_called_once_with(language)
+ assert audio_provider.model.voice_calls == [(language,)]
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
def test_transcript_tts_voices_raises_error_when_no_model_instance(
- self, mock_model_manager_class: MagicMock
+ self, audio_provider: AudioProviderHarness
) -> None:
"""Test that TTS voices raises error when no model instance is available."""
# Arrange
tenant_id = "tenant-123"
language = "en-US"
- # Mock ModelManager to return None
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_manager.get_default_model_instance.return_value = None
+ audio_provider.manager.model = None
# Act & Assert
with pytest.raises(ProviderNotSupportTextToSpeechServiceError):
AudioService.transcript_tts_voices(tenant_id=tenant_id, language=language)
- @patch("services.audio_provider_gateway.ModelManager.for_tenant", autospec=True)
- def test_transcript_tts_voices_propagates_exceptions(self, mock_model_manager_class: MagicMock) -> None:
+ def test_transcript_tts_voices_propagates_exceptions(self, audio_provider: AudioProviderHarness) -> None:
"""Test that TTS voices propagates exceptions from model instance."""
# Arrange
tenant_id = "tenant-123"
language = "en-US"
- # Mock ModelManager
- mock_model_manager = mock_model_manager_class.return_value
- mock_model_instance = MagicMock()
- mock_model_instance.get_tts_voices.side_effect = RuntimeError("Model error")
- mock_model_manager.get_default_model_instance.return_value = mock_model_instance
+ audio_provider.model.voices_error = RuntimeError("Model error")
# Act & Assert
with pytest.raises(RuntimeError, match="Model error"):