MoviePilot/tests/test_media_recognize_share.py

import asyncio
import sys
import unittest
from types import ModuleType
from unittest.mock import AsyncMock, patch

sys.modules.setdefault("qbittorrentapi", ModuleType("qbittorrentapi"))
setattr(sys.modules["qbittorrentapi"], "TorrentFilesList", list)
sys.modules.setdefault("transmission_rpc", ModuleType("transmission_rpc"))
setattr(sys.modules["transmission_rpc"], "File", object)
sys.modules.setdefault("psutil", ModuleType("psutil"))

from app.chain import ChainBase
from app.core.context import MediaInfo
from app.core.meta import MetaBase
from app.core.metainfo import MetaInfo
from app.chain.media import MediaChain
from app.helper.recognize import MediaRecognizeShareHelper
from app.schemas.types import MediaType


class TestMediaRecognizeShare(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.chain = ChainBase()
        cls.media_chain = MediaChain()

    @staticmethod
    def _build_meta(name: str, media_type: MediaType = MediaType.UNKNOWN) -> MetaBase:
        """
        构造测试用元数据
        """
        meta = MetaBase(name)
        meta.name = name
        meta.type = media_type
        return meta

    def test_report_shared_result_after_local_recognize_success(self):
        """
        本地识别成功后应上报共享识别结果
        """
        meta = self._build_meta("测试电影", MediaType.MOVIE)
        mediainfo = MediaInfo(title="测试电影", year="2024", tmdb_id=100, type=MediaType.MOVIE)

        with patch.object(self.chain, "run_module", return_value=mediainfo) as run_module, patch(
            "app.chain.MediaRecognizeShareHelper.report",
            return_value=True,
        ) as report_mock, patch(
            "app.chain.MediaRecognizeShareHelper.query"
        ) as query_mock:
            result = self.chain.recognize_media(meta=meta, cache=False)

        self.assertIs(result, mediainfo)
        run_module.assert_called_once()
        report_mock.assert_called_once_with(meta=meta, mediainfo=mediainfo)
        query_mock.assert_not_called()

    def test_query_shared_result_when_local_recognize_failed(self):
        """
        本地识别失败后应回查共享识别结果，并按共享ID再次识别
        """
        meta = self._build_meta("测试剧集")
        shared_media = MediaInfo(title="测试剧集", year="2024", tmdb_id=200, type=MediaType.TV)

        with patch.object(
            self.chain,
            "run_module",
            side_effect=[None, shared_media],
        ) as run_module, patch(
            "app.chain.MediaRecognizeShareHelper.query",
            return_value={"type": "tv", "tmdbid": 200, "season": 1},
        ) as query_mock, patch(
            "app.chain.MediaRecognizeShareHelper.to_recognize_params",
            return_value={
                "mtype": MediaType.TV,
                "tmdbid": 200,
                "doubanid": None,
                "bangumiid": None,
                "season": 1,
            },
        ), patch(
            "app.chain.MediaRecognizeShareHelper.report",
            return_value=False,
        ), patch.object(
            self.chain,
            "_update_local_recognize_cache",
        ):
            result = self.chain.recognize_media(meta=meta, cache=False)

        self.assertIs(result, shared_media)
        self.assertEqual(run_module.call_count, 2)
        query_mock.assert_called_once_with(meta=meta, mtype=None)
        second_call = run_module.call_args_list[1]
        self.assertEqual(second_call.kwargs["tmdbid"], 200)
        self.assertEqual(second_call.kwargs["mtype"], MediaType.TV)
        self.assertIsNone(meta.begin_season)

    def test_async_query_shared_result_when_local_recognize_failed(self):
        """
        异步识别失败后也应回查共享识别结果
        """
        meta = self._build_meta("测试异步剧集")
        shared_media = MediaInfo(title="测试异步剧集", year="2025", tmdb_id=300, type=MediaType.TV)
        async_run_module = AsyncMock(side_effect=[None, shared_media])

        async def runner():
            with patch.object(
                self.chain,
                "async_run_module",
                async_run_module,
            ), patch(
                "app.chain.MediaRecognizeShareHelper.async_query",
                AsyncMock(return_value={"type": "tv", "tmdbid": 300, "season": 2}),
            ) as query_mock, patch(
                "app.chain.MediaRecognizeShareHelper.to_recognize_params",
                return_value={
                    "mtype": MediaType.TV,
                    "tmdbid": 300,
                    "doubanid": None,
                    "bangumiid": None,
                    "season": 2,
                },
            ), patch(
                "app.chain.MediaRecognizeShareHelper.async_report",
                AsyncMock(return_value=False),
            ), patch.object(
                self.chain,
                "_async_update_local_recognize_cache",
                AsyncMock(),
            ) as backfill_mock:
                result = await self.chain.async_recognize_media(meta=meta, cache=False)
            return result, query_mock, backfill_mock

        result, query_mock, backfill_mock = asyncio.run(runner())

        self.assertIs(result, shared_media)
        self.assertEqual(async_run_module.await_count, 2)
        query_mock.assert_awaited_once_with(meta=meta, mtype=None)
        backfill_mock.assert_awaited_once()
        self.assertIsNone(meta.begin_season)

    def test_backfill_local_cache_after_shared_recognize_success(self):
        """
        共享识别后二次本地识别成功时，应回填原始名称对应的本地识别缓存。
        """
        meta = self._build_meta("测试缓存回填", MediaType.MOVIE)
        shared_media = MediaInfo(
            title="测试缓存回填",
            year="2024",
            tmdb_id=700,
            type=MediaType.MOVIE,
            source="themoviedb",
            tmdb_info={"id": 700, "media_type": MediaType.MOVIE, "title": "测试缓存回填"},
        )

        with patch.object(
            self.chain,
            "run_module",
            side_effect=[None, shared_media, None],
        ) as run_module_mock, patch(
            "app.chain.MediaRecognizeShareHelper.query",
            return_value={"type": "movie", "tmdbid": 700},
        ), patch(
            "app.chain.MediaRecognizeShareHelper.to_recognize_params",
            return_value={
                "mtype": MediaType.MOVIE,
                "tmdbid": 700,
                "doubanid": None,
                "bangumiid": None,
                "season": None,
            },
        ), patch(
            "app.chain.MediaRecognizeShareHelper.report",
            return_value=False,
        ):
            result = self.chain.recognize_media(meta=meta, cache=False)

        self.assertIs(result, shared_media)
        self.assertEqual(run_module_mock.call_count, 3)
        update_call = run_module_mock.call_args_list[2]
        self.assertEqual(update_call.args[0], "update_recognize_cache")
        self.assertIsNot(update_call.kwargs["meta"], meta)
        self.assertEqual(update_call.kwargs["meta"].name, meta.name)
        self.assertEqual(update_call.kwargs["meta"].type, meta.type)
        self.assertIs(update_call.kwargs["mediainfo"], shared_media)

    def test_query_and_report_prefer_original_name_keyword(self):
        """
        查询和上报共享识别时应优先使用未应用识别词的识别名称
        """
        helper = MediaRecognizeShareHelper()
        meta = self._build_meta("应用识别词后的名称", MediaType.TV)
        meta.original_name = "未应用识别词的名称"
        meta.year = "2024"
        meta.begin_season = 1
        mediainfo = MediaInfo(
            title="测试剧集",
            year="2024",
            tmdb_id=400,
            type=MediaType.TV,
            season=1,
        )

        query_params = helper._build_query_params(meta=meta)
        report_payload = helper._build_report_payload(meta=meta, mediainfo=mediainfo)

        self.assertEqual(query_params["keyword"], "未应用识别词的名称")
        self.assertEqual(report_payload["keyword"], "未应用识别词的名称")

    def test_query_and_report_can_use_distinct_keyword_meta(self):
        """
        共享识别应允许用原始关键字上报，同时保留辅助识别后的年份/季信息。
        """
        helper = MediaRecognizeShareHelper()
        meta = self._build_meta("辅助识别后的名称", MediaType.TV)
        meta.year = "2024"
        meta.begin_season = 2

        keyword_meta = self._build_meta("辅助识别前的名称", MediaType.UNKNOWN)
        keyword_meta.original_name = "辅助识别前的名称"

        mediainfo = MediaInfo(
            title="测试剧集",
            year="2024",
            tmdb_id=401,
            type=MediaType.TV,
            season=2,
        )

        query_params = helper._build_query_params(
            meta=meta,
            mtype=None,
            keyword_meta=keyword_meta,
        )
        report_payload = helper._build_report_payload(
            meta=meta,
            mediainfo=mediainfo,
            keyword_meta=keyword_meta,
        )

        self.assertEqual(query_params["keyword"], "辅助识别前的名称")
        self.assertEqual(query_params["year"], "2024")
        self.assertEqual(query_params["season"], 2)
        self.assertEqual(report_payload["keyword"], "辅助识别前的名称")
        self.assertEqual(report_payload["year"], "2024")
        self.assertEqual(report_payload["season"], 2)

    def test_report_shared_result_with_distinct_keyword_meta(self):
        """
        辅助识别成功后应按辅助前名称上报共享结果。
        """
        meta = self._build_meta("辅助识别后的名称", MediaType.TV)
        meta.year = "2024"
        meta.begin_season = 1
        share_meta = self._build_meta("辅助识别前的名称", MediaType.UNKNOWN)
        share_meta.original_name = "辅助识别前的名称"
        mediainfo = MediaInfo(title="测试剧集", year="2024", tmdb_id=402, type=MediaType.TV)

        with patch.object(self.chain, "run_module", return_value=mediainfo), patch(
            "app.chain.MediaRecognizeShareHelper.report",
            return_value=True,
        ) as report_mock:
            result = self.chain.recognize_media(meta=meta, share_meta=share_meta, cache=False)

        self.assertIs(result, mediainfo)
        report_mock.assert_called_once_with(
            meta=meta,
            mediainfo=mediainfo,
            keyword_meta=share_meta,
        )

    def test_query_shared_result_with_distinct_keyword_meta(self):
        """
        本地识别失败后应按辅助前名称回查共享结果。
        """
        meta = self._build_meta("辅助识别后的名称", MediaType.TV)
        meta.year = "2024"
        share_meta = self._build_meta("辅助识别前的名称", MediaType.UNKNOWN)
        share_meta.original_name = "辅助识别前的名称"
        shared_media = MediaInfo(title="测试剧集", year="2024", tmdb_id=403, type=MediaType.TV)

        with patch.object(
            self.chain,
            "run_module",
            side_effect=[None, shared_media],
        ), patch(
            "app.chain.MediaRecognizeShareHelper.query",
            return_value={"type": "tv", "tmdbid": 403, "season": 1},
        ) as query_mock, patch(
            "app.chain.MediaRecognizeShareHelper.to_recognize_params",
            return_value={
                "mtype": MediaType.TV,
                "tmdbid": 403,
                "doubanid": None,
                "bangumiid": None,
                "season": 1,
            },
        ), patch(
            "app.chain.MediaRecognizeShareHelper.report",
            return_value=False,
        ), patch.object(
            self.chain,
            "_update_local_recognize_cache",
        ):
            result = self.chain.recognize_media(
                meta=meta,
                share_meta=share_meta,
                cache=False,
            )

        self.assertIs(result, shared_media)
        query_mock.assert_called_once_with(
            meta=meta,
            mtype=None,
            keyword_meta=share_meta,
        )

    def test_skip_report_when_local_recognize_hits_cache(self):
        """
        本地识别命中缓存时不应上报共享识别
        """
        meta = self._build_meta("缓存电影", MediaType.MOVIE)
        mediainfo = MediaInfo(title="缓存电影", year="2024", tmdb_id=500, type=MediaType.MOVIE)
        mediainfo.recognize_cache_hit = True

        with patch.object(self.chain, "run_module", return_value=mediainfo) as run_module, patch(
            "app.chain.MediaRecognizeShareHelper.report",
            return_value=True,
        ) as report_mock, patch(
            "app.chain.MediaRecognizeShareHelper.query"
        ) as query_mock:
            result = self.chain.recognize_media(meta=meta)

        self.assertIs(result, mediainfo)
        run_module.assert_called_once()
        report_mock.assert_not_called()
        query_mock.assert_not_called()

    def test_async_skip_report_when_local_recognize_hits_cache(self):
        """
        异步本地识别命中缓存时不应上报共享识别
        """
        meta = self._build_meta("缓存剧集", MediaType.TV)
        mediainfo = MediaInfo(title="缓存剧集", year="2025", tmdb_id=600, type=MediaType.TV)
        mediainfo.recognize_cache_hit = True

        async def runner():
            with patch.object(
                self.chain,
                "async_run_module",
                AsyncMock(return_value=mediainfo),
            ) as async_run_module, patch(
                "app.chain.MediaRecognizeShareHelper.async_report",
                AsyncMock(return_value=True),
            ) as report_mock, patch(
                "app.chain.MediaRecognizeShareHelper.async_query",
                AsyncMock(),
            ) as query_mock:
                result = await self.chain.async_recognize_media(meta=meta)
            return result, async_run_module, report_mock, query_mock

        result, async_run_module, report_mock, query_mock = asyncio.run(runner())

        self.assertIs(result, mediainfo)
        async_run_module.assert_awaited_once()
        report_mock.assert_not_awaited()
        query_mock.assert_not_awaited()

    def test_recognize_by_meta_can_skip_obtain_images(self):
        """
        标题识别可显式关闭图片拉取。
        """
        meta = MetaInfo("测试电影")
        mediainfo = MediaInfo(title="测试电影", year="2024", tmdb_id=404, type=MediaType.MOVIE)

        with patch.object(
            self.media_chain,
            "recognize_media",
            return_value=mediainfo,
        ) as recognize_mock, patch.object(
            self.media_chain,
            "obtain_images",
        ) as obtain_images_mock:
            result = self.media_chain.recognize_by_meta(meta, obtain_images=False)

        self.assertIs(result, mediainfo)
        recognize_mock.assert_called_once()
        obtain_images_mock.assert_not_called()

    def test_recognize_by_meta_reports_with_original_keyword_after_plugin_help(self):
        """
        辅助识别后应继续使用辅助前关键字进行共享上报。
        """
        meta = MetaInfo("辅助前名称")
        plugin_media = MediaInfo(title="辅助后名称", year="2024", tmdb_id=405, type=MediaType.TV)

        with patch.object(
            self.media_chain,
            "select_recognize_source",
            side_effect=lambda **kwargs: kwargs["plugin_fn"](),
        ), patch.object(
            self.media_chain,
            "recognize_help",
            return_value=plugin_media,
        ) as recognize_help_mock, patch.object(
            self.media_chain,
            "obtain_images",
        ):
            result = self.media_chain.recognize_by_meta(meta, obtain_images=False)

        self.assertIs(result, plugin_media)
        self.assertEqual(recognize_help_mock.call_args.kwargs["share_meta"].name, "辅助前名称")

    def test_async_recognize_by_meta_can_skip_obtain_images(self):
        """
        异步标题识别可显式关闭图片拉取。
        """
        meta = MetaInfo("测试异步电影")
        mediainfo = MediaInfo(title="测试异步电影", year="2025", tmdb_id=406, type=MediaType.MOVIE)

        async def runner():
            with patch.object(
                self.media_chain,
                "async_recognize_media",
                AsyncMock(return_value=mediainfo),
            ) as recognize_mock, patch.object(
                self.media_chain,
                "async_obtain_images",
                AsyncMock(),
            ) as obtain_images_mock:
                result = await self.media_chain.async_recognize_by_meta(
                    meta,
                    obtain_images=False,
                )
            return result, recognize_mock, obtain_images_mock

        result, recognize_mock, obtain_images_mock = asyncio.run(runner())

        self.assertIs(result, mediainfo)
        recognize_mock.assert_awaited_once()
        obtain_images_mock.assert_not_awaited()


if __name__ == "__main__":
    unittest.main()