xiaoxia-saas/tests/unit/test_lipsync_gpu_integration.py

"""LipsyncService GPU 路径集成测试."""

from __future__ import annotations

from unittest.mock import MagicMock, patch

import pytest


@pytest.fixture()
def fake_db():
    db = MagicMock()
    return db


@pytest.fixture()
def fake_mediakit():
    client = MagicMock()
    client.submit_lipsync.return_value = {"task_id": "mk-task-1"}
    return client


def _make_job(video_url="videos/video.mp4", audio_url="audios/audio.wav"):
    job = MagicMock()
    job.id = "job-1"
    job.user_id = "u1"
    job.project_id = "p1"
    job.video_url = video_url
    job.audio_url = audio_url
    job.enable_video_loop = True
    job.script_text = ""
    job.sentence_timings = None
    return job


def _make_svc(db, mediakit, use_gpu=False):
    from app.services.lipsync_service import LipsyncService

    svc = LipsyncService(db=db, client=mediakit)
    svc.settings.use_gpu_lipsync = use_gpu
    svc._sign_media_url = lambda u: (u or "") + "?signed"
    return svc


def _patch_storage(public_url="https://own-bucket.oss-cn-beijing.aliyuncs.com", signed_suffix="?signed-7d"):
    """patch get_shared_storage_service，返回自家 OSS storage mock."""
    storage = MagicMock()
    storage.public_url = public_url
    storage.get_download_url.side_effect = lambda key_or_url, expires_seconds=3600: key_or_url + signed_suffix
    return patch("app.services.lipsync_service.get_shared_storage_service", return_value=storage)


class TestGpuFallback:
    def test_switch_off_uses_mediakit(self, fake_db, fake_mediakit):
        """开关关闭时直接走 MediaKit，不调用 _submit_to_gpu."""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=False)
        job = _make_job()
        with patch.object(svc, "_submit_to_gpu") as m_sub:
            svc._submit_audio_direct(job=job)
            m_sub.assert_not_called()
        fake_mediakit.submit_lipsync.assert_called_once()
        assert job.status == "submitted"

    def test_switch_on_no_worker_falls_back(self, fake_db, fake_mediakit):
        """开关打开但 has_available_worker=False → 回退 MediaKit."""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = False
        with patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc):
            job = _make_job()
            svc._submit_audio_direct(job=job)
        fake_gpu_svc.create_task.assert_not_called()
        fake_mediakit.submit_lipsync.assert_called_once()
        assert job.status == "submitted"

    def test_gpu_success_marks_completed(self, fake_db, fake_mediakit):
        """GPU 路径成功：job 直接 completed，不调 MediaKit；结果 key 由 storage 签 7 天 URL."""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        gpu_done = MagicMock(
            id="gpu-task-1",
            status="done",
            result_url="gpu-lipsync/results/gpu-task-1.mp4",
            result_duration=12.5,
        )
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = True
        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-1")
        fake_gpu_svc.wait_for_result.return_value = gpu_done
        with (
            _patch_storage() as storage_p,
            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
        ):
            storage = storage_p()
            job = _make_job()
            svc._submit_audio_direct(job=job)
        fake_gpu_svc.create_task.assert_called_once()
        fake_mediakit.submit_lipsync.assert_not_called()
        assert job.status == "completed"
        assert job.output_duration == 12.5
        # Bug1 回归：裸 result key 必须经 storage.get_download_url 签 7 天，前端才可播放
        storage.get_download_url.assert_called_once_with(
            "gpu-lipsync/results/gpu-task-1.mp4", expires_seconds=7 * 24 * 3600
        )
        assert job.output_video_url == "gpu-lipsync/results/gpu-task-1.mp4?signed-7d"
        fake_db.commit.assert_called()

    def test_gpu_timeout_falls_back(self, fake_db, fake_mediakit):
        """wait_for_result 返回 None（超时）→ 回退 MediaKit."""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = True
        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-t")
        fake_gpu_svc.wait_for_result.return_value = None
        with patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc):
            job = _make_job()
            svc._submit_audio_direct(job=job)
        fake_mediakit.submit_lipsync.assert_called_once()
        assert job.status == "submitted"

    def test_gpu_failed_status_falls_back(self, fake_db, fake_mediakit):
        """GPU 终态 failed → 回退 MediaKit."""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = True
        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-t")
        fake_gpu_svc.wait_for_result.return_value = MagicMock(status="failed", error_msg="musetalk crash")
        with patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc):
            job = _make_job()
            svc._submit_audio_direct(job=job)
        fake_mediakit.submit_lipsync.assert_called_once()
        assert job.status == "submitted"

    def test_gpu_exception_falls_back(self, fake_db, fake_mediakit):
        """GPU 路径抛异常 → 回退 MediaKit."""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = True
        fake_gpu_svc.create_task.side_effect = RuntimeError("DB down")
        with _patch_storage(), patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc):
            job = _make_job()
            svc._submit_audio_direct(job=job)
        fake_mediakit.submit_lipsync.assert_called_once()
        assert job.status == "submitted"

    def test_gpu_external_audio_persisted_to_own_oss(self, fake_db, fake_mediakit):
        """Bug2 回归：dashscope 临时音频 URL 在创建 GPU 任务前转存自家 OSS。"""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        dashscope_url = "https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/tmp/abc.mp3"
        job = _make_job(audio_url=dashscope_url)
        gpu_done = MagicMock(id="gpu-task-2", status="done", result_url="gpu-lipsync/results/gpu-task-2.mp4")
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = True
        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-2")
        fake_gpu_svc.wait_for_result.return_value = gpu_done
        with (
            _patch_storage() as storage_p,
            patch("app.services.lipsync_service.safe_download_bytes", return_value=b"FAKE-MP3") as m_dl,
            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
        ):
            storage = storage_p()
            storage.upload_file.return_value = "https://own-bucket.oss-cn-beijing.aliyuncs.com/lipsync-tts/u1/job-1.mp3"
            svc._submit_audio_direct(job=job)
        # 外部音频在 GPU 分支被额外下载（purpose 区分于前置 ffprobe 下载）并转存到约定 key
        gpu_dl_calls = [c for c in m_dl.call_args_list if c.kwargs.get("purpose") == "lipsync_gpu_tts_audio"]
        assert len(gpu_dl_calls) == 1
        assert gpu_dl_calls[0].args[0] == dashscope_url
        storage.upload_file.assert_called_once()
        args, kwargs = storage.upload_file.call_args
        assert args[1] == "lipsync-tts/u1/job-1.mp3"
        assert kwargs.get("content_type") == "audio/mpeg"
        # 创建 GPU 任务时用的是自家 OSS URL，Worker 可经预签名下载
        kwargs_create = fake_gpu_svc.create_task.call_args.kwargs
        assert kwargs_create["audio_url"] == ("https://own-bucket.oss-cn-beijing.aliyuncs.com/lipsync-tts/u1/job-1.mp3")
        assert kwargs_create["audio_url"] != dashscope_url

    def test_gpu_own_audio_not_repersisted(self, fake_db, fake_mediakit):
        """Bug2：已是自家 OSS 的音频（含裸 key）不重复下载转存。"""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        job = _make_job(audio_url="lipsync-tts/u1/job-1.mp3")
        gpu_done = MagicMock(id="gpu-task-3", status="done", result_url="gpu-lipsync/results/gpu-task-3.mp4")
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = True
        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-3")
        fake_gpu_svc.wait_for_result.return_value = gpu_done
        with (
            _patch_storage() as storage_p,
            patch("app.services.lipsync_service.safe_download_bytes") as m_dl,
            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
        ):
            storage = storage_p()
            svc._submit_audio_direct(job=job)
        # 前置 ffprobe 下载允许发生，但 GPU 转存分支不应再下载/上传
        gpu_dl_calls = [c for c in m_dl.call_args_list if c.kwargs.get("purpose") == "lipsync_gpu_tts_audio"]
        assert gpu_dl_calls == []
        storage.upload_file.assert_not_called()
        assert fake_gpu_svc.create_task.call_args.kwargs["audio_url"] == "lipsync-tts/u1/job-1.mp3"

    def test_gpu_external_audio_persist_fail_falls_back_original_url(self, fake_db, fake_mediakit):
        """Bug2：外部音频转存失败不阻断，用原始 URL 建任务（失败后服务端重试/回退 MediaKit）。"""
        svc = _make_svc(fake_db, fake_mediakit, use_gpu=True)
        dashscope_url = "https://dashscope-result-bj.oss-cn-beijing.aliyuncs.com/tmp/abc.mp3"
        job = _make_job(audio_url=dashscope_url)
        gpu_done = MagicMock(id="gpu-task-4", status="done", result_url="gpu-lipsync/results/gpu-task-4.mp4")
        fake_gpu_svc = MagicMock()
        fake_gpu_svc.has_available_worker.return_value = True
        fake_gpu_svc.create_task.return_value = MagicMock(id="gpu-task-4")
        fake_gpu_svc.wait_for_result.return_value = gpu_done
        with (
            _patch_storage() as storage_p,
            patch("app.services.lipsync_service.safe_download_bytes", side_effect=RuntimeError("network blocked")),
            patch("app.services.gpu_lipsync_service.GpuLipsyncService", return_value=fake_gpu_svc),
        ):
            storage = storage_p()
            svc._submit_audio_direct(job=job)
        storage.upload_file.assert_not_called()
        assert fake_gpu_svc.create_task.call_args.kwargs["audio_url"] == dashscope_url


class TestGpuServiceHelpers:
    """GpuLipsyncService.has_available_worker 测试."""

    def test_no_workers(self, fake_db):
        from app.services.gpu_lipsync_service import GpuLipsyncService

        svc = GpuLipsyncService(db=fake_db)
        fake_db.query.return_value.filter.return_value.first.return_value = None
        assert svc.has_available_worker() is False

    def test_fresh_worker_available(self, fake_db):
        from app.services.gpu_lipsync_service import GpuLipsyncService

        svc = GpuLipsyncService(db=fake_db)
        svc.settings.gpu_worker_stale_seconds = 300
        # 模拟SQL filter条件成立 → first() 返回非None
        fake_db.query.return_value.filter.return_value.first.return_value = MagicMock()
        assert svc.has_available_worker() is True

    def test_stale_worker_unavailable(self, fake_db):
        from app.services.gpu_lipsync_service import GpuLipsyncService

        svc = GpuLipsyncService(db=fake_db)
        # filter条件不成立（stale）→ first() 返回None
        fake_db.query.return_value.filter.return_value.first.return_value = None
        assert svc.has_available_worker() is False