Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

18.3 KB
Raw Blame
"""Unit tests for Xinference ASR model."""

from __future__ import annotations

from unittest.mock import AsyncMock, MagicMock, Mock, patch

import pytest

try:
    import xinference_client  # noqa: F401
except ImportError:
    pytest.skip("xinference_client is not installed", allow_module_level=True)

from xagent.core.model.asr import ASRResult, ASRSegment, XinferenceASR

_ASYNC_CLIENT_PATH = "xagent.core.model.xinference_base.PublicAsyncXinferenceClient"


class TestXinferenceASR:
    """Test cases for Xinference ASR model."""

    def test_init_with_defaults(self) -> None:
        """Test initialization with default values."""
        asr = XinferenceASR()
        assert asr.model == "whisper-base"
        assert asr.base_url == "http://localhost:9997"
        assert asr.api_key is None

    def test_init_with_custom_model(self) -> None:
        """Test initialization with custom model."""
        asr = XinferenceASR(model="seaco-paraformer-zh")
        assert asr.model == "seaco-paraformer-zh"

    def test_init_with_model_uid(self) -> None:
        """Test initialization with model UID."""
        asr = XinferenceASR(model="whisper-base", model_uid="custom-whisper")
        assert asr._model_uid == "custom-whisper"

    def test_init_with_base_url(self) -> None:
        """Test initialization with custom base URL."""
        asr = XinferenceASR(base_url="http://localhost:8080")
        assert asr.base_url == "http://localhost:8080"

    def test_init_with_base_url_trailing_slash(self) -> None:
        """Test initialization removes trailing slash from base URL."""
        asr = XinferenceASR(base_url="http://localhost:9997/")
        assert asr.base_url == "http://localhost:9997"

    def test_init_with_language(self) -> None:
        """Test initialization with language."""
        asr = XinferenceASR(language="zh")
        assert asr.language == "zh"

    def test_init_with_api_key(self) -> None:
        """Test initialization with API key."""
        asr = XinferenceASR(api_key="test-api-key")
        assert asr.api_key == "test-api-key"

    def test_abilities(self) -> None:
        """Test that abilities property returns expected list."""
        asr = XinferenceASR()
        abilities = asr.abilities
        assert isinstance(abilities, list)
        assert "asr" in abilities
        assert "speech_recognition" in abilities
        assert "audio" in abilities
        assert "timestamps" in abilities
        assert "speaker_diarization" in abilities
        assert "verbose_json" in abilities
        assert "hotword" in abilities

    def test_supports_speaker_diarization(self) -> None:
        """Test that supports_speaker_diarization property works."""
        asr = XinferenceASR()
        assert asr.supports_speaker_diarization is True

    def test_supports_timestamps(self) -> None:
        """Test that supports_timestamps property works."""
        asr = XinferenceASR()
        assert asr.supports_timestamps is True

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_simple_text_only(self, mock_client_class: Mock) -> None:
        """Test simple transcription returning text only (verbose=False)."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        mock_model.transcriptions = AsyncMock(return_value={"text": "test text"})
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        # Use audio bytes to avoid file system operations
        audio_bytes = b"fake audio data"
        result = await asr.transcribe(audio_bytes, format="wav", verbose=False)

        # Verify
        assert isinstance(result, str)
        assert result == "test text"
        mock_model.transcriptions.assert_called_once()

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_verbose_with_segments(
        self, mock_client_class: Mock
    ) -> None:
        """Test verbose transcription returning ASRResult with segments."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        segments_data = [
            {"id": 0, "start": 0.0, "end": 2.5, "text": "test text", "speaker": 0}
        ]
        mock_result = {"text": "test text", "segments": segments_data}
        mock_model.transcriptions = AsyncMock(return_value=mock_result)
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"
        result = await asr.transcribe(audio_bytes, format="wav", verbose=True)

        # Verify
        assert isinstance(result, ASRResult)
        assert result.text == "test text"
        assert result.segments is not None
        assert len(result.segments) == 1
        assert result.segments[0].text == "test text"
        assert result.segments[0].start == 0.0
        assert result.segments[0].end == 2.5
        assert result.segments[0].speaker == "0"

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_with_speaker_zero(self, mock_client_class: Mock) -> None:
        """Test that speaker ID 0 is correctly parsed (not treated as falsy)."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        segments_data = [
            {"id": 0, "start": 0.0, "end": 1.0, "text": "speech", "speaker": 0}
        ]
        mock_result = {"text": "speech", "segments": segments_data}
        mock_model.transcriptions = AsyncMock(return_value=mock_result)
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"
        result = await asr.transcribe(audio_bytes, format="wav", verbose=True)

        # Verify speaker ID is preserved
        assert result.segments[0].speaker == "0"

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_with_multiple_speakers(
        self, mock_client_class: Mock
    ) -> None:
        """Test transcription with multiple speakers."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        segments_data = [
            {"id": 0, "start": 0.0, "end": 1.0, "text": "hello", "speaker": 0},
            {"id": 1, "start": 1.0, "end": 2.0, "text": "world", "speaker": 1},
        ]
        mock_result = {"text": "hello world", "segments": segments_data}
        mock_model.transcriptions = AsyncMock(return_value=mock_result)
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"
        result = await asr.transcribe(audio_bytes, format="wav", verbose=True)

        # Verify
        assert len(result.segments) == 2
        assert result.segments[0].speaker == "0"
        assert result.segments[1].speaker == "1"
        assert result.segments[0].text == "hello"
        assert result.segments[1].text == "world"

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_with_hotword(self, mock_client_class: Mock) -> None:
        """Test transcription with hotword parameter."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        mock_model.transcriptions = AsyncMock(return_value={"text": "test"})
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"
        result = await asr.transcribe(
            audio_bytes, format="wav", hotword="test word", verbose=False
        )

        # Verify hotword was passed to the API
        mock_model.transcriptions.assert_called_once()
        call_kwargs = mock_model.transcriptions.call_args.kwargs
        assert "hotword" in call_kwargs
        assert call_kwargs["hotword"] == "test word"
        assert result == "test"

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_with_bytes(self, mock_client_class: Mock) -> None:
        """Test transcription with audio bytes."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        mock_model.transcriptions = AsyncMock(return_value={"text": "test"})
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"
        result = await asr.transcribe(audio_bytes, format="wav", verbose=False)

        # Verify
        assert result == "test"
        mock_model.transcriptions.assert_called_once()

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_with_language_parameter(
        self, mock_client_class: Mock
    ) -> None:
        """Test transcription with language parameter."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        mock_model.transcriptions = AsyncMock(return_value={"text": "test"})
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"
        await asr.transcribe(audio_bytes, format="wav", language="zh", verbose=False)

        # Verify language was passed
        call_kwargs = mock_model.transcriptions.call_args.kwargs
        assert "language" in call_kwargs
        assert call_kwargs["language"] == "zh"

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_response_format_verbose_json(
        self, mock_client_class: Mock
    ) -> None:
        """Test that verbose=True sets response_format to verbose_json."""
        # Setup mock
        mock_client = MagicMock()
        mock_model = MagicMock()
        mock_model.transcriptions = AsyncMock(return_value={"text": "test"})
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"
        await asr.transcribe(audio_bytes, format="wav", verbose=True)

        # Verify response_format was set
        call_kwargs = mock_model.transcriptions.call_args.kwargs
        assert call_kwargs.get("response_format") == "verbose_json"

    def test_parse_segments_with_dict(self) -> None:
        """Test _parse_segments with dict input."""
        asr = XinferenceASR()
        segments_data = [
            {
                "text": "hello world",
                "start": 0.0,
                "end": 2.5,
                "speaker": "spk0",
                "confidence": 0.95,
            },
            {"text": "test completed", "start": 2.5, "end": 4.0, "speaker": "spk1"},
        ]

        segments = asr._parse_segments(segments_data)
        assert len(segments) == 2
        assert segments[0].text == "hello world"
        assert segments[0].start == 0.0
        assert segments[0].end == 2.5
        assert segments[0].speaker == "spk0"
        assert segments[0].confidence == 0.95
        assert segments[1].speaker == "spk1"

    def test_parse_segments_preserves_speaker_zero(self) -> None:
        """Test that speaker ID 0 is preserved (not treated as falsy)."""
        asr = XinferenceASR()
        segments_data = [
            {
                "text": "test",
                "start": 0.0,
                "end": 1.0,
                "speaker": 0,  # This should be preserved
            }
        ]

        segments = asr._parse_segments(segments_data)
        assert len(segments) == 1
        assert segments[0].speaker == "0"  # Should be string "0", not None

    def test_parse_segments_with_object(self) -> None:
        """Test _parse_segments with object input."""
        asr = XinferenceASR()

        # Create a mock segment object
        class MockSegment:
            def __init__(self, text, start, end, speaker=None):
                self.text = text
                self.start = start
                self.end = end
                self.speaker = speaker

        segments_data = [MockSegment("Test text", 1.0, 3.0, "spk0")]
        segments = asr._parse_segments(segments_data)

        assert len(segments) == 1
        assert segments[0].text == "Test text"
        assert segments[0].start == 1.0
        assert segments[0].end == 3.0
        assert segments[0].speaker == "spk0"

    def test_parse_segments_empty_list(self) -> None:
        """Test _parse_segments with empty list."""
        asr = XinferenceASR()
        segments = asr._parse_segments([])
        assert len(segments) == 0

    def test_parse_segments_without_text_field(self) -> None:
        """Test _parse_segments ignores segments without text field."""
        asr = XinferenceASR()
        segments_data = [
            {
                "start": 0.0,
                "end": 1.0,
                # No "text" field - should be ignored
            }
        ]

        segments = asr._parse_segments(segments_data)
        assert len(segments) == 0

    @patch(_ASYNC_CLIENT_PATH)
    def test_context_manager(self, mock_client_class: Mock) -> None:
        """Test context manager functionality."""
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        with asr:
            assert asr is not None

        # After exiting, resources should be cleaned up
        assert asr._client is None
        assert asr._model_handle is None

    @patch(_ASYNC_CLIENT_PATH)
    async def test_close(self, mock_client_class: Mock) -> None:
        """Test close method cleans up resources."""
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        # Create a client by accessing _get_session
        await asr._get_session()
        assert asr._client is not None

        # Close should clean up resources
        asr.close()
        assert asr._client is None
        assert asr._model_handle is None

    @patch(_ASYNC_CLIENT_PATH)
    async def test_transcribe_error_handling(self, mock_client_class: Mock) -> None:
        """Test error handling when transcription fails."""
        # Setup mock to raise exception
        mock_client = MagicMock()
        mock_model = MagicMock()
        mock_model.transcriptions = AsyncMock(side_effect=Exception("API Error"))
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        audio_bytes = b"fake audio data"

        with pytest.raises(RuntimeError, match="Xinference ASR failed"):
            await asr.transcribe(audio_bytes, format="wav")

    @patch(_ASYNC_CLIENT_PATH)
    async def test_get_session_lazy_initialization(
        self, mock_client_class: Mock
    ) -> None:
        """Test that client is lazily initialized."""
        mock_client = MagicMock()
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        assert asr._client is None

        # Access _get_session should create client
        client = await asr._get_session()
        assert asr._client is not None
        assert client is not None

    @patch(_ASYNC_CLIENT_PATH)
    async def test_ensure_model_handle(self, mock_client_class: Mock) -> None:
        """Test that model handle is created and cached."""
        mock_client = MagicMock()
        mock_model = MagicMock()
        mock_client.get_model = AsyncMock(return_value=mock_model)
        mock_client_class.return_value = mock_client

        asr = XinferenceASR()
        assert asr._model_handle is None

        # First call should create model handle
        handle1 = await asr._ensure_model_handle()
        assert handle1 is not None
        assert asr._model_handle is not None

        # Second call should return cached handle
        handle2 = await asr._ensure_model_handle()
        assert handle1 is handle2

        # Should only call get_model once
        assert mock_client.get_model.call_count == 1


class TestASRResult:
    """Test cases for ASRResult dataclass."""

    def test_asr_result_creation(self) -> None:
        """Test ASRResult creation."""
        result = ASRResult(text="test text", segments=None, language="zh")

        assert result.text == "test text"
        assert result.segments is None
        assert result.language == "zh"
        assert result.raw_response is None

    def test_asr_result_str_representation(self) -> None:
        """Test ASRResult __str__ returns text."""
        result = ASRResult(text="test text")
        assert str(result) == "test text"

    def test_asr_result_with_segments(self) -> None:
        """Test ASRResult with segments."""
        segments = [
            ASRSegment(text="hello", start=0.0, end=1.0, speaker="0"),
            ASRSegment(text="world", start=1.0, end=2.0, speaker="1"),
        ]

        result = ASRResult(text="hello world", segments=segments, language="en")

        assert len(result.segments) == 2
        assert result.segments[0].text == "hello"
        assert result.segments[1].speaker == "1"


class TestASRSegment:
    """Test cases for ASRSegment dataclass."""

    def test_segment_creation(self) -> None:
        """Test ASRSegment creation."""
        segment = ASRSegment(
            text="test", start=0.0, end=2.5, speaker="spk0", confidence=0.95
        )

        assert segment.text == "test"
        assert segment.start == 0.0
        assert segment.end == 2.5
        assert segment.speaker == "spk0"
        assert segment.confidence == 0.95

    def test_segment_with_speaker_str(self) -> None:
        """Test ASRSegment __str__ with speaker."""
        segment = ASRSegment(text="hello", start=0.0, end=1.0, speaker="0")

        assert str(segment) == "[0] hello"

    def test_segment_without_speaker_str(self) -> None:
        """Test ASRSegment __str__ without speaker."""
        segment = ASRSegment(text="test", start=0.0, end=1.0)

        assert str(segment) == "test"

    def test_segment_optional_fields(self) -> None:
        """Test ASRSegment with optional fields."""
        segment = ASRSegment(text="test", start=0.0, end=1.0)

        assert segment.speaker is None
        assert segment.confidence is None

    def test_segment_speaker_zero_preserved(self) -> None:
        """Test that speaker ID 0 is preserved in string representation."""
        segment = ASRSegment(text="speech", start=0.0, end=1.0, speaker="0")

        # Should show [0] not [] (preserving speaker 0)
        assert "[0]" in str(segment)