mirror of
https://github.com/jxxghp/MoviePilot.git
synced 2026-11-09 15:19:54 +08:00
449 lines
15 KiB
Python
449 lines
15 KiB
Python
from unittest.mock import patch
|
|
|
|
import pytest
|
|
|
|
from app import schemas
|
|
from app.application.history import TransferHistoryMonthlyStatistics
|
|
from app.modules.ugreen.ugreen import Ugreen
|
|
from app.schemas.types import MediaSource
|
|
|
|
try:
|
|
from app.api.endpoints import dashboard as dashboard_endpoint
|
|
except Exception:
|
|
dashboard_endpoint = None
|
|
|
|
|
|
class _FakeUgreenApi:
|
|
host = "http://127.0.0.1:9999"
|
|
token = "test-token"
|
|
|
|
@staticmethod
|
|
def video_all(classification: int, page: int = 1, page_size: int = 1):
|
|
if classification == -102:
|
|
return {"total_num": 12}
|
|
if classification == -103:
|
|
return {"total_num": 34}
|
|
return {"total_num": 0}
|
|
|
|
|
|
class _FakeReconnectApi:
|
|
token = "test-token"
|
|
|
|
@staticmethod
|
|
def login(_username, _password):
|
|
return "test-token"
|
|
|
|
@staticmethod
|
|
def current_user():
|
|
return {"name": "tester"}
|
|
|
|
@staticmethod
|
|
def close():
|
|
return None
|
|
|
|
@staticmethod
|
|
def export_session_state():
|
|
return {"token": "test-token", "public_key": "public-key"}
|
|
|
|
|
|
class _PagedFolderApi:
|
|
def __init__(self, stop_after: int | None = None):
|
|
self.calls = 0
|
|
self.pages = []
|
|
self.stop_after = stop_after
|
|
|
|
def poster_wall_get_folder(self, page: int, page_size: int = 100):
|
|
self.calls += 1
|
|
self.pages.append(page)
|
|
if self.stop_after is not None and page >= self.stop_after:
|
|
return {
|
|
"folder_arr": [
|
|
{"media_lib_set_id": page, "path": f"/library/{page}"},
|
|
],
|
|
"is_last_page": True,
|
|
}
|
|
return {
|
|
"folder_arr": [
|
|
{"media_lib_set_id": page, "path": f"/library/{page}"},
|
|
],
|
|
"is_last_page": False,
|
|
}
|
|
|
|
|
|
class _FakeMediaApi:
|
|
"""媒体库服务接口的最小伪实现。"""
|
|
|
|
host = "https://nas.example:9443"
|
|
token = "media-token"
|
|
user_id = "user-id"
|
|
server_id = "server-id"
|
|
|
|
def __init__(self) -> None:
|
|
"""初始化可记录请求参数的伪媒体接口。"""
|
|
self.calls: list[tuple[str, dict]] = []
|
|
|
|
@staticmethod
|
|
def _movie() -> dict:
|
|
"""返回电影条目样本。"""
|
|
return {
|
|
"Id": "movie-id",
|
|
"Type": "Movie",
|
|
"Name": "示例电影",
|
|
"OriginalTitle": "Example Movie",
|
|
"ProductionYear": 2024,
|
|
"ProviderIds": {"Tmdb": "100"},
|
|
"ParentId": "movie-library",
|
|
"Path": "/media/movies/example",
|
|
"BackdropImageTags": ["movie-backdrop"],
|
|
}
|
|
|
|
@staticmethod
|
|
def _series() -> dict:
|
|
"""返回电视剧条目样本。"""
|
|
return {
|
|
"Id": "series-id",
|
|
"Type": "Series",
|
|
"Name": "示例剧集",
|
|
"OriginalTitle": "Example Series",
|
|
"ProductionYear": 2023,
|
|
"ProviderIds": {"Tmdb": "200"},
|
|
"ParentId": "tv-library",
|
|
"Path": "/media/tv/example",
|
|
}
|
|
|
|
@staticmethod
|
|
def _episode() -> dict:
|
|
"""返回剧集条目样本。"""
|
|
return {
|
|
"Id": "episode-id",
|
|
"Type": "Episode",
|
|
"Name": "第二集",
|
|
"SeriesName": "示例剧集",
|
|
"SeriesId": "series-id",
|
|
"ParentId": "season-id",
|
|
"ParentIndexNumber": 1,
|
|
"IndexNumber": 2,
|
|
"ProviderIds": {"Tmdb": "200"},
|
|
"UserData": {"PlayedPercentage": 25.0},
|
|
}
|
|
|
|
def current_user(self) -> dict:
|
|
"""返回有效媒体库用户。"""
|
|
return {"Id": self.user_id, "Name": "tester"}
|
|
|
|
def views(self) -> list[dict]:
|
|
"""返回电影和电视剧媒体库视图。"""
|
|
return [
|
|
{
|
|
"Id": "movie-library",
|
|
"Name": "电影",
|
|
"CollectionType": "movies",
|
|
"Path": "/media/movies",
|
|
},
|
|
{
|
|
"Id": "tv-library",
|
|
"Name": "剧集",
|
|
"CollectionType": "tvshows",
|
|
"Path": "/media/tv",
|
|
},
|
|
]
|
|
|
|
def items(self, **kwargs: object) -> dict:
|
|
"""按查询条件返回预置的用户条目。"""
|
|
self.calls.append(("items", dict(kwargs)))
|
|
parent_id = kwargs.get("parent_id")
|
|
ids = kwargs.get("ids")
|
|
include_item_types = kwargs.get("include_item_types")
|
|
if ids == "movie-id":
|
|
return {"Items": [self._movie()], "TotalRecordCount": 1}
|
|
if ids == "series-id":
|
|
return {"Items": [self._series()], "TotalRecordCount": 1}
|
|
if parent_id == "movie-library":
|
|
return {"Items": [self._movie()], "TotalRecordCount": 1}
|
|
if parent_id == "tv-library":
|
|
return {"Items": [self._series()], "TotalRecordCount": 1}
|
|
if include_item_types == "Movie":
|
|
return {"Items": [self._movie()], "TotalRecordCount": 1}
|
|
if include_item_types == "Series":
|
|
return {"Items": [self._series()], "TotalRecordCount": 1}
|
|
if include_item_types == "Movie,Series":
|
|
return {
|
|
"Items": [self._movie(), self._series()],
|
|
"TotalRecordCount": 2,
|
|
}
|
|
if include_item_types == "Movie,Series,MusicAlbum":
|
|
return {
|
|
"Items": [self._movie(), self._series()],
|
|
"TotalRecordCount": 2,
|
|
}
|
|
return {"Items": [], "TotalRecordCount": 0}
|
|
|
|
def item(self, item_id: str) -> dict | None:
|
|
"""返回指定媒体条目详情。"""
|
|
return {
|
|
"movie-id": self._movie(),
|
|
"series-id": self._series(),
|
|
}.get(item_id)
|
|
|
|
def counts(self) -> dict:
|
|
"""返回媒体库数量统计。"""
|
|
return {
|
|
"MovieCount": 11,
|
|
"SeriesCount": 3,
|
|
"EpisodeCount": 27,
|
|
"MusicAlbumCount": 5,
|
|
}
|
|
|
|
def resume(self, limit: int = 20) -> list[dict]:
|
|
"""返回继续观看条目。"""
|
|
_ = limit
|
|
return [self._movie() | {"UserData": {"PlayedPercentage": 50.0}}, self._episode()]
|
|
|
|
def episodes(self, series_id: str, season: int | None = None) -> list[dict]:
|
|
"""返回指定剧集的已入库集数。"""
|
|
assert series_id == "series-id"
|
|
assert season in (None, 1)
|
|
return [self._episode()]
|
|
|
|
def image_url(self, item_id: str, image_type: str = "Primary") -> str:
|
|
"""返回伪造的媒体图片地址。"""
|
|
return f"{self.host}/emby/Items/{item_id}/Images/{image_type}?api_key={self.token}"
|
|
|
|
def close(self) -> None:
|
|
"""关闭伪媒体接口。"""
|
|
return None
|
|
|
|
|
|
def _build_media_service() -> tuple[Ugreen, _FakeMediaApi]:
|
|
"""构造已认证的媒体库服务模式绿联实例。"""
|
|
media_api = _FakeMediaApi()
|
|
ugreen = Ugreen.__new__(Ugreen)
|
|
ugreen._host = media_api.host
|
|
ugreen._username = "tester"
|
|
ugreen._password = "secret"
|
|
ugreen._userinfo = {"Id": media_api.user_id, "Name": "tester"}
|
|
ugreen._verify_ssl = True
|
|
ugreen._connection_mode = Ugreen.MEDIA_SERVICE_CONNECTION_MODE
|
|
ugreen._media_api = media_api
|
|
ugreen._api = None
|
|
ugreen._playhost = "https://play.example"
|
|
ugreen._libraries = {}
|
|
ugreen._library_paths = {}
|
|
ugreen._sync_libraries = []
|
|
return ugreen, media_api
|
|
|
|
|
|
def test_resolve_scan_type():
|
|
resolve = Ugreen._Ugreen__resolve_scan_type
|
|
|
|
assert resolve(scan_mode="new_and_modified") == 1
|
|
assert resolve(scan_mode="supplement_missing") == 2
|
|
assert resolve(scan_mode="full_override") == 3
|
|
assert resolve(scan_mode="1") == 1
|
|
assert resolve(scan_mode="2") == 2
|
|
assert resolve(scan_mode="3") == 3
|
|
assert resolve(scan_type=1) == 1
|
|
assert resolve(scan_type=2) == 2
|
|
assert resolve(scan_type=3) == 3
|
|
assert resolve(scan_mode="unknown") == 2
|
|
assert resolve() == 2
|
|
|
|
|
|
def test_resolve_verify_ssl():
|
|
resolve = Ugreen._Ugreen__resolve_verify_ssl
|
|
assert resolve(True) is True
|
|
assert resolve(False) is False
|
|
assert resolve("true") is True
|
|
assert resolve("1") is True
|
|
assert resolve("false") is False
|
|
assert resolve("0") is False
|
|
assert resolve(None) is True
|
|
|
|
|
|
def test_resolve_connection_mode_uses_media_service_port():
|
|
"""9443 默认使用媒体库服务，显式 internal 可保留旧接口行为。"""
|
|
resolve = Ugreen._Ugreen__resolve_connection_mode
|
|
|
|
assert resolve("https://nas.example:9443") == Ugreen.MEDIA_SERVICE_CONNECTION_MODE
|
|
assert resolve("nas.example:9443") == Ugreen.MEDIA_SERVICE_CONNECTION_MODE
|
|
assert resolve("https://nas.example:9443", "internal") == Ugreen.INTERNAL_CONNECTION_MODE
|
|
assert resolve("https://nas.example:9999", "media_service") == Ugreen.MEDIA_SERVICE_CONNECTION_MODE
|
|
|
|
|
|
def test_media_service_supports_library_query_and_core_media_operations():
|
|
"""媒体库服务模式应覆盖媒体库、搜索、详情、播放和同步查询能力。"""
|
|
ugreen, media_api = _build_media_service()
|
|
|
|
libraries = ugreen.get_librarys()
|
|
assert libraries is not None
|
|
assert [library.id for library in libraries] == ["movie-library", "tv-library"]
|
|
assert libraries[0].type == "电影"
|
|
assert libraries[0].item_count == 1
|
|
|
|
stat = ugreen.get_medias_count()
|
|
assert stat.movie_count == 11
|
|
assert stat.tv_count == 3
|
|
assert stat.episode_count == 27
|
|
assert stat.music_count == 5
|
|
assert ugreen.get_user_count() == 1
|
|
|
|
movies = ugreen.get_movies(
|
|
"示例电影",
|
|
year="2024",
|
|
media_source=MediaSource.TMDB,
|
|
media_id="100",
|
|
)
|
|
assert movies is not None
|
|
assert [movie.item_id for movie in movies] == ["movie-id"]
|
|
assert ugreen.get_iteminfo("movie-id").title == "示例电影"
|
|
|
|
series_id, season_episodes = ugreen.get_tv_episodes(
|
|
item_id="series-id",
|
|
title="示例剧集",
|
|
year="2023",
|
|
media_source=MediaSource.TMDB,
|
|
media_id="200",
|
|
season=1,
|
|
)
|
|
assert series_id == "series-id"
|
|
assert season_episodes == {1: [2]}
|
|
|
|
items = list(ugreen.get_items("movie-library", limit=1))
|
|
assert [item.item_id for item in items] == ["movie-id"]
|
|
assert ugreen.get_items_count("movie-library") == 1
|
|
|
|
play_url = ugreen.get_play_url("movie-id")
|
|
assert play_url == ("https://play.example/web/index.html#!/item?id=movie-id&context=home&serverId=server-id")
|
|
resume = ugreen.get_resume(num=2)
|
|
assert resume is not None
|
|
assert [item.item_id for item in resume] == ["movie-id", "episode-id"]
|
|
assert resume[0].percent == 50.0
|
|
latest = ugreen.get_latest(num=2)
|
|
assert latest is not None
|
|
assert [item.item_id for item in latest] == ["movie-id", "series-id"]
|
|
assert ugreen.get_latest_backdrops(num=1, remote=True) == [
|
|
"https://play.example/emby/Items/movie-id/Images/Backdrop?api_key=media-token"
|
|
]
|
|
assert ugreen.refresh_root_library() is False
|
|
assert any(name == "items" for name, _ in media_api.calls)
|
|
|
|
|
|
def test_get_medias_count_episode_is_none():
|
|
ugreen = Ugreen.__new__(Ugreen)
|
|
ugreen._host = "http://127.0.0.1:9999"
|
|
ugreen._username = "tester"
|
|
ugreen._password = "secret"
|
|
ugreen._userinfo = {"name": "tester"}
|
|
ugreen._api = _FakeUgreenApi()
|
|
|
|
stat = ugreen.get_medias_count()
|
|
assert stat.movie_count == 12
|
|
assert stat.tv_count == 34
|
|
assert stat.episode_count is None
|
|
|
|
|
|
def test_reconnect_does_not_eagerly_load_libraries():
|
|
ugreen = Ugreen.__new__(Ugreen)
|
|
ugreen._host = "http://127.0.0.1:9999"
|
|
ugreen._username = "tester"
|
|
ugreen._password = "secret"
|
|
ugreen._verify_ssl = True
|
|
ugreen._libraries = {"old": {"id": "old"}}
|
|
ugreen._library_paths = {"old": "/old"}
|
|
ugreen._api = None
|
|
ugreen._userinfo = None
|
|
|
|
with patch.object(Ugreen, "_Ugreen__restore_persisted_session", return_value=False), patch(
|
|
"app.modules.ugreen.ugreen.Api", return_value=_FakeReconnectApi()
|
|
), patch.object(Ugreen, "_Ugreen__save_persisted_session", return_value=None), patch.object(
|
|
Ugreen, "disconnect", wraps=ugreen.disconnect
|
|
), patch.object(Ugreen, "get_librarys") as mocked_get_librarys:
|
|
assert ugreen.reconnect() is True
|
|
|
|
mocked_get_librarys.assert_not_called()
|
|
assert ugreen._libraries == {}
|
|
assert ugreen._library_paths == {}
|
|
|
|
|
|
def test_load_library_paths_stops_at_last_page():
|
|
ugreen = Ugreen.__new__(Ugreen)
|
|
ugreen._username = "tester"
|
|
ugreen._api = _PagedFolderApi(stop_after=3)
|
|
|
|
paths = ugreen._Ugreen__load_library_paths()
|
|
|
|
assert ugreen._api.pages == [1, 2, 3]
|
|
assert paths["3"] == "/library/3"
|
|
|
|
|
|
def test_load_library_paths_respects_page_limit():
|
|
ugreen = Ugreen.__new__(Ugreen)
|
|
ugreen._username = "tester"
|
|
ugreen._api = _PagedFolderApi()
|
|
|
|
paths = ugreen._Ugreen__load_library_paths()
|
|
|
|
assert ugreen._api.calls == Ugreen.LIBRARY_PATH_PAGE_LIMIT
|
|
assert len(paths) == Ugreen.LIBRARY_PATH_PAGE_LIMIT
|
|
assert str(Ugreen.LIBRARY_PATH_PAGE_LIMIT) in paths
|
|
|
|
|
|
class _DashboardRepository:
|
|
"""Dashboard 汇总测试使用的零增量历史仓储。"""
|
|
|
|
@staticmethod
|
|
def monthly_media_statistics() -> TransferHistoryMonthlyStatistics:
|
|
"""返回全零月度统计，隔离媒体服务汇总断言。"""
|
|
return TransferHistoryMonthlyStatistics(
|
|
movies=0,
|
|
tv_shows=0,
|
|
episodes=0,
|
|
music=0,
|
|
)
|
|
|
|
|
|
@pytest.mark.skipif(
|
|
dashboard_endpoint is None,
|
|
reason="dashboard endpoint dependencies are missing",
|
|
)
|
|
def test_statistic_all_episode_missing():
|
|
mocked_stats = [
|
|
schemas.Statistic(movie_count=10, tv_count=20, episode_count=None, user_count=2),
|
|
schemas.Statistic(movie_count=1, tv_count=2, episode_count=None, user_count=1),
|
|
]
|
|
from app.application.dashboard import DashboardQueryService
|
|
|
|
service = DashboardQueryService(
|
|
repository=_DashboardRepository(),
|
|
media_statistics=lambda _name: mocked_stats,
|
|
)
|
|
ret = dashboard_endpoint.statistic(name="ugreen", service=service, _=None)
|
|
|
|
assert ret.movie_count == 11
|
|
assert ret.tv_count == 22
|
|
assert ret.user_count == 3
|
|
assert ret.episode_count is None
|
|
|
|
|
|
@pytest.mark.skipif(
|
|
dashboard_endpoint is None,
|
|
reason="dashboard endpoint dependencies are missing",
|
|
)
|
|
def test_statistic_mixed_episode_count():
|
|
mocked_stats = [
|
|
schemas.Statistic(movie_count=10, tv_count=20, episode_count=None, user_count=2),
|
|
schemas.Statistic(movie_count=1, tv_count=2, episode_count=6, user_count=1),
|
|
]
|
|
from app.application.dashboard import DashboardQueryService
|
|
|
|
service = DashboardQueryService(
|
|
repository=_DashboardRepository(),
|
|
media_statistics=lambda _name: mocked_stats,
|
|
)
|
|
ret = dashboard_endpoint.statistic(name="all", service=service, _=None)
|
|
|
|
assert ret.movie_count == 11
|
|
assert ret.tv_count == 22
|
|
assert ret.user_count == 3
|
|
assert ret.episode_count == 6
|