Skip to content

Speakr is a personal, self-hosted web application designed for transcribing audio recordings

Python
22.1 KB
Raw Blame
"""Tests for the Alibaba Cloud FunASR connector."""
import sys, os
sys.path.insert(0, os.getcwd())

from contextlib import contextmanager
from types import SimpleNamespace
from unittest.mock import patch, MagicMock

import pytest
from flask import Flask

from src.services.transcription.base import TranscriptionRequest
from src.services.transcription.connectors.alibaba_funasr import (
    AlibabaFunASRConnector,
    prepare_funasr_file_url,
)
from src.services.transcription.exceptions import ProviderError, TranscriptionError
import io



def _own_sleeps():
    """Patch time.sleep and record only the calls made by this thread.

    time.sleep is process-wide, and background threads left by other tests
    (Inquire reindex, webhook dispatcher) may sleep while a test runs; counting
    their calls made these tests flaky.
    """
    import threading
    me = threading.get_ident()
    calls = []

    def _sleep(seconds):
        if threading.get_ident() == me:
            calls.append(seconds)
    return patch('time.sleep', side_effect=_sleep), calls


def test_funasr_connector_reads_urls_from_extra_options():
    """AlibabaFunASRConnector reads funasr_file_urls from extra_options."""
    captured = {}

    def _fake_post(url, **kwargs):
        if 'json' in kwargs:
            captured['payload'] = kwargs['json']
        resp = MagicMock()
        resp.status_code = 200
        result = {
            "output": {
                "task_id": "tid",
                "task_status": "SUCCEEDED",
                "results": [{
                    "subtask_status": "SUCCEEDED",
                    "transcription_url": "https://signed.example/result.json",
                }],
            }
        }
        resp.text = '{}'
        resp.json.return_value = result
        resp.raise_for_status.return_value = None
        return resp

    connector = AlibabaFunASRConnector(
        config={'base_url': 'https://dashscope.aliyuncs.com/api/v1', 'api_key': 'sk-test'}
    )
    req = TranscriptionRequest(
        audio_file=io.BytesIO(b'x'),
        filename='x.mp3',
        extra_options={'funasr_file_urls': ['https://signed.example/x.mp3?X-Amz-Sig=abc']},
    )

    with patch('httpx.Client') as client_cls:
        client_instance = MagicMock()
        client_instance.__enter__ = MagicMock(return_value=client_instance)
        client_instance.__exit__ = MagicMock(return_value=False)
        client_instance.post = MagicMock(side_effect=_fake_post)
        client_instance.get = MagicMock(side_effect=_fake_post)
        client_cls.return_value = client_instance

        connector.transcribe(req)

    assert captured['payload']['input']['file_urls'] == ['https://signed.example/x.mp3?X-Amz-Sig=abc']
    print('PASS: test_funasr_connector_reads_urls_from_extra_options')


def test_funasr_connector_raises_when_no_url():
    """If extra_options has no funasr_file_urls, connector raises clearly."""
    connector = AlibabaFunASRConnector(
        config={'base_url': 'https://dashscope.aliyuncs.com/api/v1', 'api_key': 'sk-test'}
    )
    req = TranscriptionRequest(audio_file=io.BytesIO(b'x'), filename='x.mp3')

    raised = False
    try:
        connector.transcribe(req)
    except TranscriptionError as exc:
        raised = True
        msg = str(exc).lower()
        assert 'file url' in msg or 's3' in msg, f'Unexpected error: {exc}'

    assert raised, 'Expected TranscriptionError'
    print('PASS: test_funasr_connector_raises_when_no_url')


def test_transcription_request_has_no_file_urls_field():
    """Bug C guard: TranscriptionRequest must not carry a fork-only file_urls."""
    import dataclasses
    field_names = {f.name for f in dataclasses.fields(TranscriptionRequest)}
    assert 'file_urls' not in field_names, (
        "TranscriptionRequest.file_urls pollutes the upstream interface; "
        "use extra_options['funasr_file_urls'] instead."
    )
    print('PASS: test_transcription_request_has_no_file_urls_field')


def test_transcription_request_extra_options_pass_through():
    """extra_options is the supported passthrough."""
    req = TranscriptionRequest(
        audio_file=io.BytesIO(b'x'),
        filename='x.mp3',
        extra_options={'funasr_file_urls': ['https://signed.example/x.mp3']},
    )
    assert req.extra_options['funasr_file_urls'] == ['https://signed.example/x.mp3']
    print('PASS: test_transcription_request_extra_options_pass_through')


def test_terminal_provider_failure_is_not_retried():
    """A terminal task failure must return immediately instead of polling again."""
    response = MagicMock(status_code=200)
    response.raise_for_status.return_value = None
    response.json.return_value = {
        'output': {
            'task_status': 'FAILED',
            'code': 'INVALID_PARAMETER',
            'message': 'bad request',
        }
    }
    client = MagicMock()
    client.__enter__.return_value = client
    client.__exit__.return_value = False
    client.get.return_value = response
    connector = AlibabaFunASRConnector({
        'base_url': 'https://dashscope.aliyuncs.com/api/v1',
        'api_key': 'sk-test',
        'timeout': 20,
        'poll_interval': 10,
    })

    sleep_patch, sleeps = _own_sleeps()
    with patch('httpx.Client', return_value=client), sleep_patch:
        with pytest.raises(ProviderError, match='INVALID_PARAMETER'):
            connector._poll_task_result('task-1', {'Authorization': 'Bearer sk-test'})

    assert client.get.call_count == 1
    assert sleeps == []


def test_transcribe_preserves_provider_error_type():
    """Provider metadata must survive the connector's public error boundary."""
    response = MagicMock(status_code=200, text='{}')
    response.raise_for_status.return_value = None
    response.json.return_value = {'output': {'task_id': 'task-1'}}
    client = MagicMock()
    client.__enter__.return_value = client
    client.__exit__.return_value = False
    client.post.return_value = response
    connector = AlibabaFunASRConnector({
        'base_url': 'https://dashscope.aliyuncs.com/api/v1',
        'api_key': 'sk-test',
    })
    request = TranscriptionRequest(
        audio_file=io.BytesIO(b'x'),
        filename='x.wav',
        extra_options={'funasr_file_urls': ['https://signed.example/x.wav']},
    )
    provider_error = ProviderError(
        'task rejected', provider='funasr', status_code=400
    )

    with patch('httpx.Client', return_value=client), patch.object(
        connector, '_poll_task_result', side_effect=provider_error
    ):
        with pytest.raises(ProviderError) as exc_info:
            connector.transcribe(request)

    assert exc_info.value.provider == 'funasr'
    assert exc_info.value.status_code == 400


def test_presigned_urls_are_not_written_to_logs(caplog):
    """Signed query credentials must not be included in informational logs."""
    signed_audio_url = (
        'https://signed.example/x.wav?X-Amz-Signature=audio-secret'
    )
    signed_result_url = (
        'https://signed.example/result.json?X-Amz-Signature=result-secret'
    )
    response = MagicMock(status_code=200, text='{}')
    response.raise_for_status.return_value = None
    response.json.return_value = {'output': {'task_id': 'task-1'}}
    client = MagicMock()
    client.__enter__.return_value = client
    client.__exit__.return_value = False
    client.post.return_value = response
    connector = AlibabaFunASRConnector({
        'base_url': 'https://dashscope.aliyuncs.com/api/v1',
        'api_key': 'sk-test',
    })
    request = TranscriptionRequest(
        audio_file=io.BytesIO(b'x'),
        filename='x.wav',
        extra_options={'funasr_file_urls': [signed_audio_url]},
    )
    result = {'output': {'results': [{
        'subtask_status': 'SUCCEEDED',
        'transcription_url': signed_result_url,
    }]}}
    parsed = {'transcripts': [{'sentences': [{
        'text': 'hello', 'begin_time': 0, 'end_time': 1000,
    }]}]}

    with caplog.at_level('INFO'), patch('httpx.Client', return_value=client), patch.object(
        connector, '_poll_task_result', return_value=result
    ), patch.object(
        connector, '_download_transcription_result', return_value=parsed
    ):
        connector.transcribe(request)

    assert 'audio-secret' not in caplog.text
    assert 'result-secret' not in caplog.text


def _fake_storage(audio_locator='local://recordings/source.wav'):
    s3 = MagicMock()
    s3.build_locator.return_value = 's3://bucket/funasr/1/source.wav'
    s3.exists.return_value = False
    s3.presign_get_url.return_value = (
        'https://signed.example/source.wav?X-Amz-Signature=secret'
    )
    storage = MagicMock(s3=s3)
    storage.maybe_normalize_local_legacy_locator.return_value = audio_locator
    storage.exists.return_value = True

    @contextmanager
    def materialize(_locator):
        yield SimpleNamespace(local_path='/tmp/source.wav')

    storage.materialize.side_effect = materialize
    return storage


def test_prepare_local_audio_does_not_persist_signed_url():
    """Ephemeral object-store credentials stay inside the active task."""
    storage = _fake_storage()
    recording = SimpleNamespace(
        id=1,
        audio_path='local://recordings/source.wav',
        original_filename='source.wav',
        mime_type='audio/wav',
    )

    with Flask(__name__).app_context(), patch(
        'src.services.storage.get_storage_service', return_value=storage
    ):
        success, urls = prepare_funasr_file_url(recording)

    assert success is True
    assert urls == [storage.s3.presign_get_url.return_value]
    assert not hasattr(recording, 'bucket_urls')


def test_prepare_existing_s3_audio_without_duplicate_upload():
    """An existing S3 locator is signed directly instead of copied again."""
    original_locator = 's3://bucket/recordings/source.wav'
    storage = _fake_storage(audio_locator=original_locator)
    recording = SimpleNamespace(
        id=1,
        audio_path=original_locator,
        original_filename='source.wav',
        mime_type='audio/wav',
    )

    with Flask(__name__).app_context(), patch(
        'src.services.storage.get_storage_service', return_value=storage
    ):
        success, urls = prepare_funasr_file_url(recording)

    assert success is True
    assert urls == [storage.s3.presign_get_url.return_value]
    storage.s3.upload_local_file.assert_not_called()
    signed_locator = storage.s3.presign_get_url.call_args.args[0]
    assert signed_locator.raw == original_locator


def test_prepare_audio_signs_directly_for_configured_intranet_endpoint():
    original_locator = 's3://bucket/recordings/source.wav'
    storage = _fake_storage(audio_locator=original_locator)
    recording = SimpleNamespace(
        id=1,
        audio_path=original_locator,
        original_filename='source.wav',
        mime_type='audio/wav',
    )

    with Flask(__name__).app_context(), patch(
        'src.services.storage.get_storage_service', return_value=storage
    ), patch(
        'src.config.app_config.S3_INTRANET_ENDPOINT_URL',
        'https://oss-cn-shanghai-internal.aliyuncs.com',
    ):
        success, urls = prepare_funasr_file_url(recording)

    assert success is True
    assert urls == [storage.s3.presign_get_url.return_value]
    assert storage.s3.presign_get_url.call_args.kwargs['endpoint_url'] == (
        'https://oss-cn-shanghai-internal.aliyuncs.com'
    )


def test_poll_4xx_is_terminal_and_not_retried():
    """A 4xx response during polling (e.g. revoked key) must raise immediately."""
    from httpx import HTTPStatusError, Request, Response

    client = MagicMock()
    client.__enter__.return_value = client
    client.__exit__.return_value = False

    def _raise_for_status():
        resp = Response(401, request=Request('GET', 'https://dashscope.aliyuncs.com/tasks/x'))
        raise HTTPStatusError('401 Unauthorized', request=resp.request, response=resp)

    resp = MagicMock(status_code=401)
    resp.raise_for_status.side_effect = _raise_for_status
    client.get.return_value = resp

    connector = AlibabaFunASRConnector({
        'base_url': 'https://dashscope.aliyuncs.com/api/v1',
        'api_key': 'sk-test',
        'timeout': 30,
        'poll_interval': 10,
    })

    sleep_patch, sleeps = _own_sleeps()
    with patch('httpx.Client', return_value=client), sleep_patch:
        with pytest.raises(ProviderError) as exc_info:
            connector._poll_task_result('task-1', {'Authorization': 'Bearer sk-test'})

    assert exc_info.value.status_code == 401
    assert client.get.call_count == 1
    assert sleeps == []


def test_poll_5xx_is_retried():
    """A 5xx response during polling is transient and must be retried."""
    from httpx import HTTPStatusError, Request, Response

    client = MagicMock()
    client.__enter__.return_value = client
    client.__exit__.return_value = False

    def _raise_for_status():
        resp = Response(503, request=Request('GET', 'https://dashscope.aliyuncs.com/tasks/x'))
        raise HTTPStatusError('503 Service Unavailable', request=resp.request, response=resp)

    resp = MagicMock(status_code=503)
    resp.raise_for_status.side_effect = _raise_for_status
    client.get.return_value = resp

    connector = AlibabaFunASRConnector({
        'base_url': 'https://dashscope.aliyuncs.com/api/v1',
        'api_key': 'sk-test',
        'timeout': 30,
        'poll_interval': 10,
    })

    sleep_patch, sleeps = _own_sleeps()
    with patch('httpx.Client', return_value=client), sleep_patch:
        with pytest.raises(HTTPStatusError):
            connector._poll_task_result('task-1', {'Authorization': 'Bearer sk-test'})

    assert client.get.call_count > 1
    assert sleeps
    # 503 (non-429) retries with the normal poll interval, not doubled.
    assert sleeps[-1] == 10


def test_poll_429_is_retried_with_doubled_backoff():
    """429 is transient and must be retried with a doubled backoff."""
    from httpx import HTTPStatusError, Request, Response

    client = MagicMock()
    client.__enter__.return_value = client
    client.__exit__.return_value = False

    def _raise_for_status():
        resp = Response(429, request=Request('GET', 'https://dashscope.aliyuncs.com/tasks/x'))
        raise HTTPStatusError('429 Too Many Requests', request=resp.request, response=resp)

    resp = MagicMock(status_code=429)
    resp.raise_for_status.side_effect = _raise_for_status
    client.get.return_value = resp

    connector = AlibabaFunASRConnector({
        'base_url': 'https://dashscope.aliyuncs.com/api/v1',
        'api_key': 'sk-test',
        'timeout': 30,
        'poll_interval': 10,
    })

    sleep_patch, sleeps = _own_sleeps()
    with patch('httpx.Client', return_value=client), sleep_patch:
        with pytest.raises(HTTPStatusError):
            connector._poll_task_result('task-1', {'Authorization': 'Bearer sk-test'})

    assert client.get.call_count > 1
    assert sleeps
    # 429 retries with a doubled backoff.
    assert sleeps[-1] == 20


def test_transcribe_diarize_false_overrides_config_default():
    """An explicit off toggle must beat the connector's default_diarize."""
    captured = {}

    def _fake_post(url, **kwargs):
        if 'json' in kwargs:
            captured['payload'] = kwargs['json']
        resp = MagicMock()
        resp.status_code = 200
        resp.text = '{}'
        resp.json.return_value = {
            'output': {
                'task_id': 'tid',
                'task_status': 'SUCCEEDED',
                'results': [{
                    'subtask_status': 'SUCCEEDED',
                    'transcription_url': 'https://signed.example/result.json',
                }],
            }
        }
        resp.raise_for_status.return_value = None
        return resp

    connector = AlibabaFunASRConnector(
        config={
            'base_url': 'https://dashscope.aliyuncs.com/api/v1',
            'api_key': 'sk-test',
            'diarize': True,
        }
    )
    req = TranscriptionRequest(
        audio_file=io.BytesIO(b'x'),
        filename='x.mp3',
        diarize=False,
        extra_options={'funasr_file_urls': ['https://signed.example/x.mp3']},
    )

    with patch('httpx.Client') as client_cls:
        client_instance = MagicMock()
        client_instance.__enter__.return_value = client_instance
        client_instance.__exit__.return_value = False
        client_instance.post = MagicMock(side_effect=_fake_post)
        client_instance.get = MagicMock(side_effect=_fake_post)
        client_cls.return_value = client_instance

        connector.transcribe(req)

    params = captured['payload'].get('parameters', {})
    assert 'diarization_enabled' not in params


def test_transcribe_honors_request_diarize_and_speaker_count():
    """Per-request diarize / speaker bounds must reach the FunASR payload."""
    captured = {}

    def _fake_post(url, **kwargs):
        if 'json' in kwargs:
            captured['payload'] = kwargs['json']
        resp = MagicMock()
        resp.status_code = 200
        resp.text = '{}'
        resp.json.return_value = {
            'output': {
                'task_id': 'tid',
                'task_status': 'SUCCEEDED',
                'results': [{
                    'subtask_status': 'SUCCEEDED',
                    'transcription_url': 'https://signed.example/result.json',
                }],
            }
        }
        resp.raise_for_status.return_value = None
        return resp

    connector = AlibabaFunASRConnector(
        config={'base_url': 'https://dashscope.aliyuncs.com/api/v1', 'api_key': 'sk-test'}
    )
    req = TranscriptionRequest(
        audio_file=io.BytesIO(b'x'),
        filename='x.mp3',
        diarize=True,
        min_speakers=2,
        max_speakers=4,
        extra_options={'funasr_file_urls': ['https://signed.example/x.mp3']},
    )

    with patch('httpx.Client') as client_cls:
        client_instance = MagicMock()
        client_instance.__enter__.return_value = client_instance
        client_instance.__exit__.return_value = False
        client_instance.post = MagicMock(side_effect=_fake_post)
        client_instance.get = MagicMock(side_effect=_fake_post)
        client_cls.return_value = client_instance

        connector.transcribe(req)

    params = captured['payload'].get('parameters', {})
    assert params.get('diarization_enabled') is True
    assert params.get('speaker_count') == 4


def test_transcribe_speaker_count_falls_back_to_config_default():
    """When the request carries no speaker bounds, config default is used."""
    captured = {}

    def _fake_post(url, **kwargs):
        if 'json' in kwargs:
            captured['payload'] = kwargs['json']
        resp = MagicMock()
        resp.status_code = 200
        resp.text = '{}'
        resp.json.return_value = {
            'output': {
                'task_id': 'tid',
                'task_status': 'SUCCEEDED',
                'results': [{
                    'subtask_status': 'SUCCEEDED',
                    'transcription_url': 'https://signed.example/result.json',
                }],
            }
        }
        resp.raise_for_status.return_value = None
        return resp

    connector = AlibabaFunASRConnector(
        config={
            'base_url': 'https://dashscope.aliyuncs.com/api/v1',
            'api_key': 'sk-test',
            'diarize': True,
            'speaker_count': 3,
        }
    )
    req = TranscriptionRequest(
        audio_file=io.BytesIO(b'x'),
        filename='x.mp3',
        extra_options={'funasr_file_urls': ['https://signed.example/x.mp3']},
    )

    with patch('httpx.Client') as client_cls:
        client_instance = MagicMock()
        client_instance.__enter__.return_value = client_instance
        client_instance.__exit__.return_value = False
        client_instance.post = MagicMock(side_effect=_fake_post)
        client_instance.get = MagicMock(side_effect=_fake_post)
        client_cls.return_value = client_instance

        connector.transcribe(req)

    params = captured['payload'].get('parameters', {})
    # diarize is a plain bool (default False), so it never falls back to the
    # connector default here; processing.py resolves the default before
    # building the request. Only speaker_count falls back to config.
    assert 'diarization_enabled' not in params
    assert params.get('speaker_count') == 3


def test_cleanup_funasr_staging_deletes_staged_keys():
    """Staging keys recorded during prepare are deleted by cleanup."""
    from src.services.transcription.connectors.alibaba_funasr import cleanup_funasr_staging

    s3 = MagicMock()
    s3.build_locator.return_value = 's3://bucket/funasr/1/source.wav'
    storage = MagicMock(s3=s3)
    recording = SimpleNamespace(
        id=1,
        _funasr_staging_keys=['funasr/1/source.wav'],
    )

    with Flask(__name__).app_context(), patch(
        'src.services.storage.get_storage_service', return_value=storage
    ):
        cleanup_funasr_staging(recording)

    s3.delete.assert_called_once()
    assert s3.delete.call_args.args[0].raw == 's3://bucket/funasr/1/source.wav'


def test_cleanup_funasr_staging_noop_without_keys():
    """Cleanup with no recorded staging keys must not touch storage."""
    from src.services.transcription.connectors.alibaba_funasr import cleanup_funasr_staging

    s3 = MagicMock()
    storage = MagicMock(s3=s3)
    recording = SimpleNamespace(id=1)

    with Flask(__name__).app_context(), patch(
        'src.services.storage.get_storage_service', return_value=storage
    ):
        cleanup_funasr_staging(recording)

    s3.delete.assert_not_called()


def test_prepare_local_audio_always_reuploads_staging():
    """A replaced audio file must never re-sign a stale staging object."""
    storage = _fake_storage()
    recording = SimpleNamespace(
        id=1,
        audio_path='local://recordings/source.wav',
        original_filename='source.wav',
        mime_type='audio/wav',
    )

    with Flask(__name__).app_context(), patch(
        'src.services.storage.get_storage_service', return_value=storage
    ):
        success, urls = prepare_funasr_file_url(recording)

    assert success is True
    storage.s3.upload_local_file.assert_called_once()
    assert recording._funasr_staging_keys == ['funasr/1/source.wav']


if __name__ == '__main__':
    test_transcription_request_has_no_file_urls_field()
    test_transcription_request_extra_options_pass_through()
    test_funasr_connector_reads_urls_from_extra_options()
    test_funasr_connector_raises_when_no_url()
    print('\nAll 4 standalone FunASR tests passed.')