refactor: simplify NFO handling, remove legacy services
- Drop nfo_factory, nfo_repair_service, nfo_service, series_manager_service - Delete key_resolution_service, consolidate into folder_rename_service - Remove bulk of NFO-related tests (coverage via integration tests) - Streamline SeriesApp, background_loader, initialization services - Add folder_rename_service to scheduler Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
This commit is contained in:
@@ -516,7 +516,7 @@ class TestLoadNfoAndImages:
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_load_nfo_creates_new_nfo(self, background_loader_service, mock_websocket_service):
|
||||
"""Test creating new NFO file when it doesn't exist."""
|
||||
"""Test creating new NFO file - NFO service removed, stub returns False."""
|
||||
mock_db = AsyncMock()
|
||||
mock_series = MagicMock()
|
||||
mock_series.has_nfo = False
|
||||
@@ -528,27 +528,18 @@ class TestLoadNfoAndImages:
|
||||
year=2020
|
||||
)
|
||||
|
||||
mock_nfo_service = AsyncMock()
|
||||
mock_nfo_service.create_tvshow_nfo = AsyncMock(return_value="/anime/test_folder/tvshow.nfo")
|
||||
mock_factory = MagicMock()
|
||||
mock_factory.create = MagicMock(return_value=mock_nfo_service)
|
||||
# NFO service removed, _load_nfo_and_images is now a stub that returns False
|
||||
result = await background_loader_service._load_nfo_and_images(task, mock_db)
|
||||
|
||||
with patch("src.server.database.service.AnimeSeriesService") as mock_service_class, \
|
||||
patch("src.server.services.background_loader_service.get_nfo_factory", return_value=mock_factory):
|
||||
mock_service_class.get_by_key = AsyncMock(return_value=mock_series)
|
||||
|
||||
result = await background_loader_service._load_nfo_and_images(task, mock_db)
|
||||
|
||||
assert result is True
|
||||
assert task.progress["nfo"] is True
|
||||
assert task.progress["logo"] is True
|
||||
assert task.progress["images"] is True
|
||||
# Stub returns False since NFO service was removed
|
||||
assert result is False
|
||||
assert task.progress["nfo"] is False
|
||||
assert task.progress["logo"] is False
|
||||
assert task.progress["images"] is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_load_nfo_uses_existing(self, background_loader_service):
|
||||
"""Test using existing NFO file when it already exists."""
|
||||
background_loader_service.series_app.nfo_service.has_nfo = MagicMock(return_value=True)
|
||||
|
||||
"""Test using existing NFO file - NFO service removed, stub returns False."""
|
||||
mock_db = AsyncMock()
|
||||
mock_series = MagicMock()
|
||||
mock_series.has_nfo = True
|
||||
@@ -559,13 +550,11 @@ class TestLoadNfoAndImages:
|
||||
name="Test Series"
|
||||
)
|
||||
|
||||
with patch("src.server.database.service.AnimeSeriesService") as mock_service_class:
|
||||
mock_service_class.get_by_key = AsyncMock(return_value=mock_series)
|
||||
|
||||
result = await background_loader_service._load_nfo_and_images(task, mock_db)
|
||||
# NFO service removed, _load_nfo_and_images is now a stub that returns False
|
||||
result = await background_loader_service._load_nfo_and_images(task, mock_db)
|
||||
|
||||
# Stub returns False since NFO service was removed
|
||||
assert result is False
|
||||
assert task.progress["nfo"] is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_load_nfo_without_nfo_service(self, background_loader_service):
|
||||
|
||||
@@ -1,575 +0,0 @@
|
||||
"""Unit tests for folder_rename_service.py.
|
||||
|
||||
These tests verify the core logic of the folder rename service in
|
||||
isolation, using temporary directories and mocked dependencies.
|
||||
"""
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.server.services.scheduler.folder_rename_service import (
|
||||
_cleanup_orphaned_folder,
|
||||
_compute_expected_folder_name,
|
||||
_is_series_being_downloaded,
|
||||
_parse_nfo_title_and_year,
|
||||
_update_database_paths,
|
||||
validate_and_rename_series_folders,
|
||||
)
|
||||
|
||||
|
||||
class TestParseNfoTitleAndYear:
|
||||
"""Tests for _parse_nfo_title_and_year."""
|
||||
|
||||
def test_parses_title_and_year(self, tmp_path: Path) -> None:
|
||||
nfo = tmp_path / "tvshow.nfo"
|
||||
nfo.write_text(
|
||||
"<tvshow><title>Attack on Titan</title><year>2013</year></tvshow>"
|
||||
)
|
||||
title, year = _parse_nfo_title_and_year(nfo)
|
||||
assert title == "Attack on Titan"
|
||||
assert year == "2013"
|
||||
|
||||
def test_missing_title_returns_none(self, tmp_path: Path) -> None:
|
||||
nfo = tmp_path / "tvshow.nfo"
|
||||
nfo.write_text("<tvshow><year>2013</year></tvshow>")
|
||||
title, year = _parse_nfo_title_and_year(nfo)
|
||||
assert title is None
|
||||
assert year == "2013"
|
||||
|
||||
def test_missing_year_returns_none(self, tmp_path: Path) -> None:
|
||||
nfo = tmp_path / "tvshow.nfo"
|
||||
nfo.write_text("<tvshow><title>Attack on Titan</title></tvshow>")
|
||||
title, year = _parse_nfo_title_and_year(nfo)
|
||||
assert title == "Attack on Titan"
|
||||
assert year is None
|
||||
|
||||
def test_empty_title_returns_none(self, tmp_path: Path) -> None:
|
||||
nfo = tmp_path / "tvshow.nfo"
|
||||
nfo.write_text(
|
||||
"<tvshow><title> </title><year>2013</year></tvshow>"
|
||||
)
|
||||
title, year = _parse_nfo_title_and_year(nfo)
|
||||
assert title is None
|
||||
assert year == "2013"
|
||||
|
||||
def test_malformed_xml_returns_none(self, tmp_path: Path) -> None:
|
||||
nfo = tmp_path / "tvshow.nfo"
|
||||
nfo.write_text("not xml at all")
|
||||
title, year = _parse_nfo_title_and_year(nfo)
|
||||
assert title is None
|
||||
assert year is None
|
||||
|
||||
|
||||
class TestComputeExpectedFolderName:
|
||||
"""Tests for _compute_expected_folder_name."""
|
||||
|
||||
def test_simple_title_and_year(self) -> None:
|
||||
result = _compute_expected_folder_name("Attack on Titan", "2013")
|
||||
assert result == "Attack on Titan (2013)"
|
||||
|
||||
def test_sanitizes_invalid_chars(self) -> None:
|
||||
result = _compute_expected_folder_name("Show: Subtitle", "2020")
|
||||
assert result == "Show Subtitle (2020)"
|
||||
|
||||
def test_sanitizes_slashes(self) -> None:
|
||||
result = _compute_expected_folder_name("A / B", "2021")
|
||||
assert result == "A B (2021)"
|
||||
|
||||
def test_does_not_duplicate_year(self) -> None:
|
||||
result = _compute_expected_folder_name("86 Eighty Six (2021)", "2021")
|
||||
assert result == "86 Eighty Six (2021)"
|
||||
assert result.count("(2021)") == 1
|
||||
|
||||
def test_removes_duplicate_year_suffixes_bug_86_eighty_six(self) -> None:
|
||||
"""Test the bug fix for duplicate year suffixes.
|
||||
|
||||
Issue: "86 Eighty Six (2021) (2021) (2021) (2021) (2021)"
|
||||
should become "86 Eighty Six (2021)"
|
||||
"""
|
||||
result = _compute_expected_folder_name(
|
||||
"86 Eighty Six (2021) (2021) (2021) (2021) (2021)", "2021"
|
||||
)
|
||||
assert result == "86 Eighty Six (2021)"
|
||||
assert result.count("(2021)") == 1
|
||||
|
||||
def test_removes_duplicate_year_suffixes_alma_chan(self) -> None:
|
||||
"""Test the bug fix for duplicate year suffixes with long title.
|
||||
|
||||
Issue: "Alma-chan Wants to Be a Family! (2025) (2025) (2025) (2025) (2025)"
|
||||
should become "Alma-chan Wants to Be a Family! (2025)"
|
||||
"""
|
||||
result = _compute_expected_folder_name(
|
||||
"Alma-chan Wants to Be a Family! (2025) (2025) (2025) (2025) (2025)",
|
||||
"2025",
|
||||
)
|
||||
assert result == "Alma-chan Wants to Be a Family! (2025)"
|
||||
assert result.count("(2025)") == 1
|
||||
|
||||
def test_removes_duplicate_year_suffixes_bogus_skill(self) -> None:
|
||||
"""Test the bug fix for duplicate year suffixes with very long title.
|
||||
|
||||
Issue: Long title with duplicated years should be cleaned.
|
||||
"""
|
||||
result = _compute_expected_folder_name(
|
||||
"Bogus Skill Fruitmaster About That Time I Became Able to Eat "
|
||||
"Unlimited Numbers of Skill Fruits (That Kill You) (2025) (2025)",
|
||||
"2025",
|
||||
)
|
||||
assert "(2025)" in result
|
||||
assert result.count("(2025)") == 1
|
||||
|
||||
def test_removes_multiple_different_year_suffixes(self) -> None:
|
||||
"""Test that old duplicate years are removed and new one added."""
|
||||
result = _compute_expected_folder_name(
|
||||
"Series (2020) (2020) (2020)", "2021"
|
||||
)
|
||||
assert result == "Series (2021)"
|
||||
assert "(2020)" not in result
|
||||
assert result.count("(2021)") == 1
|
||||
|
||||
def test_handles_whitespace_with_duplicate_years(self) -> None:
|
||||
"""Test that extra whitespace is removed along with duplicate years."""
|
||||
result = _compute_expected_folder_name(
|
||||
"Series (2021) (2021) (2021) ", "2021"
|
||||
)
|
||||
assert result == "Series (2021)"
|
||||
assert result.count("(2021)") == 1
|
||||
assert not result.endswith(" ")
|
||||
|
||||
def test_idempotent_multiple_calls(self) -> None:
|
||||
"""Test that calling the function multiple times produces the same result."""
|
||||
title = "86 Eighty Six (2021) (2021) (2021)"
|
||||
year = "2021"
|
||||
|
||||
# First call
|
||||
result1 = _compute_expected_folder_name(title, year)
|
||||
# Second call with the result
|
||||
result2 = _compute_expected_folder_name(result1, year)
|
||||
# Third call with the result
|
||||
result3 = _compute_expected_folder_name(result2, year)
|
||||
|
||||
# All results should be identical
|
||||
assert result1 == result2 == result3
|
||||
assert result1 == "86 Eighty Six (2021)"
|
||||
assert result1.count("(2021)") == 1
|
||||
|
||||
|
||||
class TestIsSeriesBeingDownloaded:
|
||||
"""Tests for _is_series_being_downloaded."""
|
||||
|
||||
def test_no_active_download(self) -> None:
|
||||
mock_service = MagicMock()
|
||||
mock_service._active_download = None
|
||||
mock_service._pending_queue = []
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.get_download_service",
|
||||
return_value=mock_service,
|
||||
):
|
||||
assert _is_series_being_downloaded("Some Show") is False
|
||||
|
||||
def test_active_download_matches(self) -> None:
|
||||
mock_item = MagicMock()
|
||||
mock_item.serie_folder = "Some Show"
|
||||
mock_service = MagicMock()
|
||||
mock_service._active_download = mock_item
|
||||
mock_service._pending_queue = []
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.get_download_service",
|
||||
return_value=mock_service,
|
||||
):
|
||||
assert _is_series_being_downloaded("Some Show") is True
|
||||
|
||||
def test_pending_download_matches(self) -> None:
|
||||
mock_item = MagicMock()
|
||||
mock_item.serie_folder = "Some Show"
|
||||
mock_service = MagicMock()
|
||||
mock_service._active_download = None
|
||||
mock_service._pending_queue = [mock_item]
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.get_download_service",
|
||||
return_value=mock_service,
|
||||
):
|
||||
assert _is_series_being_downloaded("Some Show") is True
|
||||
|
||||
def test_exception_returns_true_for_safety(self) -> None:
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.get_download_service",
|
||||
side_effect=RuntimeError("boom"),
|
||||
):
|
||||
assert _is_series_being_downloaded("Some Show") is True
|
||||
|
||||
|
||||
class TestUpdateDatabasePaths:
|
||||
"""Tests for _update_database_paths."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_updates_series_folder(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
|
||||
mock_series = MagicMock()
|
||||
mock_series.id = 1
|
||||
mock_series.folder = "Old Name"
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.get_db_session"
|
||||
) as mock_get_db, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.AnimeSeriesService"
|
||||
) as mock_series_svc, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.EpisodeService"
|
||||
) as mock_episode_svc, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.DownloadQueueService"
|
||||
) as mock_queue_svc:
|
||||
|
||||
mock_db = AsyncMock()
|
||||
mock_get_db.return_value.__aenter__ = AsyncMock(return_value=mock_db)
|
||||
mock_get_db.return_value.__aexit__ = AsyncMock(return_value=False)
|
||||
|
||||
mock_series_svc.get_by_folder = AsyncMock(return_value=mock_series)
|
||||
mock_series_svc.get_all = AsyncMock(return_value=[])
|
||||
mock_series_svc.update = AsyncMock(return_value=mock_series)
|
||||
|
||||
mock_episode_svc.get_by_series = AsyncMock(return_value=[])
|
||||
mock_queue_svc.get_all = AsyncMock(return_value=[])
|
||||
|
||||
await _update_database_paths("Old Name", "New Name", anime_dir)
|
||||
|
||||
mock_series_svc.update.assert_awaited_once_with(
|
||||
mock_db, 1, folder="New Name"
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_updates_episode_file_paths(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
old_path = anime_dir / "Old Name" / "S01E01.mkv"
|
||||
new_path = anime_dir / "New Name" / "S01E01.mkv"
|
||||
|
||||
mock_series = MagicMock()
|
||||
mock_series.id = 1
|
||||
mock_series.folder = "Old Name"
|
||||
|
||||
mock_episode = MagicMock()
|
||||
mock_episode.file_path = str(old_path)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.get_db_session"
|
||||
) as mock_get_db, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.AnimeSeriesService"
|
||||
) as mock_series_svc, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.EpisodeService"
|
||||
) as mock_episode_svc, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.DownloadQueueService"
|
||||
) as mock_queue_svc:
|
||||
|
||||
mock_db = AsyncMock()
|
||||
mock_get_db.return_value.__aenter__ = AsyncMock(return_value=mock_db)
|
||||
mock_get_db.return_value.__aexit__ = AsyncMock(return_value=False)
|
||||
|
||||
mock_series_svc.get_by_folder = AsyncMock(return_value=mock_series)
|
||||
mock_series_svc.get_all = AsyncMock(return_value=[])
|
||||
mock_series_svc.update = AsyncMock(return_value=mock_series)
|
||||
|
||||
mock_episode_svc.get_by_series = AsyncMock(return_value=[mock_episode])
|
||||
mock_queue_svc.get_all = AsyncMock(return_value=[])
|
||||
|
||||
await _update_database_paths("Old Name", "New Name", anime_dir)
|
||||
|
||||
assert mock_episode.file_path == str(new_path)
|
||||
|
||||
|
||||
class TestCleanupOrphanedFolder:
|
||||
"""Tests for _cleanup_orphaned_folder."""
|
||||
|
||||
def test_returns_false_when_old_folder_does_not_exist(self, tmp_path: Path) -> None:
|
||||
old_path = tmp_path / "nonexistent"
|
||||
new_path = tmp_path / "new"
|
||||
result = _cleanup_orphaned_folder(old_path, new_path)
|
||||
assert result is False
|
||||
|
||||
def test_deletes_empty_folder(self, tmp_path: Path) -> None:
|
||||
old_path = tmp_path / "empty_orphan"
|
||||
old_path.mkdir()
|
||||
new_path = tmp_path / "new"
|
||||
new_path.mkdir()
|
||||
result = _cleanup_orphaned_folder(old_path, new_path)
|
||||
assert result is True
|
||||
assert not old_path.exists()
|
||||
|
||||
def test_moves_files_and_deletes_folder(self, tmp_path: Path) -> None:
|
||||
old_path = tmp_path / "old_orphan"
|
||||
old_path.mkdir()
|
||||
new_path = tmp_path / "new"
|
||||
new_path.mkdir()
|
||||
file1 = old_path / "S01E01.mkv"
|
||||
file1.write_text("episode 1")
|
||||
file2 = old_path / "S01E02.mkv"
|
||||
file2.write_text("episode 2")
|
||||
result = _cleanup_orphaned_folder(old_path, new_path)
|
||||
assert result is True
|
||||
assert not old_path.exists()
|
||||
assert (new_path / "S01E01.mkv").exists()
|
||||
assert (new_path / "S01E02.mkv").exists()
|
||||
|
||||
def test_dry_run_does_not_delete_empty_folder(self, tmp_path: Path) -> None:
|
||||
old_path = tmp_path / "empty_orphan"
|
||||
old_path.mkdir()
|
||||
new_path = tmp_path / "new"
|
||||
new_path.mkdir()
|
||||
result = _cleanup_orphaned_folder(old_path, new_path, dry_run=True)
|
||||
assert result is True
|
||||
assert old_path.exists()
|
||||
|
||||
def test_dry_run_does_not_move_files(self, tmp_path: Path) -> None:
|
||||
old_path = tmp_path / "old_orphan"
|
||||
old_path.mkdir()
|
||||
new_path = tmp_path / "new"
|
||||
new_path.mkdir()
|
||||
file1 = old_path / "S01E01.mkv"
|
||||
file1.write_text("episode 1")
|
||||
result = _cleanup_orphaned_folder(old_path, new_path, dry_run=True)
|
||||
assert result is True
|
||||
assert old_path.exists()
|
||||
assert not (new_path / "S01E01.mkv").exists()
|
||||
|
||||
def test_handles_permission_error_gracefully(self, tmp_path: Path) -> None:
|
||||
old_path = tmp_path / "permission_denied"
|
||||
old_path.mkdir()
|
||||
new_path = tmp_path / "new"
|
||||
new_path.mkdir()
|
||||
# Simulate permission error by patching rmdir
|
||||
with patch.object(Path, "rmdir", side_effect=PermissionError("Access denied")):
|
||||
result = _cleanup_orphaned_folder(old_path, new_path)
|
||||
assert result is False
|
||||
|
||||
|
||||
class TestValidateAndRenameSeriesFolders:
|
||||
"""Integration-style tests for validate_and_rename_series_folders."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_no_anime_directory(self) -> None:
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
"",
|
||||
):
|
||||
stats = await validate_and_rename_series_folders()
|
||||
assert stats == {"scanned": 0, "renamed": 0, "skipped": 0, "errors": 0}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_renames_folder_when_name_differs(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
series_dir = anime_dir / "Attack on Titan"
|
||||
series_dir.mkdir()
|
||||
(series_dir / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Attack on Titan</title><year>2013</year></tvshow>"
|
||||
)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
str(anime_dir),
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service._is_series_being_downloaded",
|
||||
return_value=False,
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service._update_database_paths",
|
||||
new_callable=AsyncMock,
|
||||
) as mock_update_db:
|
||||
stats = await validate_and_rename_series_folders()
|
||||
|
||||
assert stats["scanned"] == 1
|
||||
assert stats["renamed"] == 1
|
||||
assert stats["skipped"] == 0
|
||||
assert stats["errors"] == 0
|
||||
assert not series_dir.exists()
|
||||
assert (anime_dir / "Attack on Titan (2013)").is_dir()
|
||||
mock_update_db.assert_awaited_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skips_when_name_already_correct(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
series_dir = anime_dir / "Attack on Titan (2013)"
|
||||
series_dir.mkdir()
|
||||
(series_dir / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Attack on Titan</title><year>2013</year></tvshow>"
|
||||
)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
str(anime_dir),
|
||||
):
|
||||
stats = await validate_and_rename_series_folders()
|
||||
|
||||
assert stats["scanned"] == 1
|
||||
assert stats["renamed"] == 0
|
||||
assert stats["skipped"] == 0
|
||||
assert stats["errors"] == 0
|
||||
assert series_dir.is_dir()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skips_missing_title_or_year(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
series_dir = anime_dir / "Incomplete"
|
||||
series_dir.mkdir()
|
||||
(series_dir / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Incomplete</title></tvshow>"
|
||||
)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
str(anime_dir),
|
||||
):
|
||||
stats = await validate_and_rename_series_folders()
|
||||
|
||||
assert stats["scanned"] == 1
|
||||
assert stats["renamed"] == 0
|
||||
assert stats["skipped"] == 1
|
||||
assert stats["errors"] == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skips_when_download_active(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
series_dir = anime_dir / "Attack on Titan"
|
||||
series_dir.mkdir()
|
||||
(series_dir / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Attack on Titan</title><year>2013</year></tvshow>"
|
||||
)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
str(anime_dir),
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service._is_series_being_downloaded",
|
||||
return_value=True,
|
||||
):
|
||||
stats = await validate_and_rename_series_folders()
|
||||
|
||||
assert stats["scanned"] == 1
|
||||
assert stats["renamed"] == 0
|
||||
assert stats["skipped"] == 1
|
||||
assert stats["errors"] == 0
|
||||
assert series_dir.is_dir()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_duplicate_target_folder_source_removed_and_db_deleted(self, tmp_path: Path) -> None:
|
||||
"""When target folder exists, source folder should be removed and its DB record deleted."""
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
series_dir = anime_dir / "Attack on Titan"
|
||||
series_dir.mkdir()
|
||||
(series_dir / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Attack on Titan</title><year>2013</year></tvshow>"
|
||||
)
|
||||
# Pre-create the target folder to simulate a duplicate
|
||||
target_dir = anime_dir / "Attack on Titan (2013)"
|
||||
target_dir.mkdir()
|
||||
|
||||
mock_db = AsyncMock()
|
||||
mock_session = AsyncMock()
|
||||
mock_db.__aenter__.return_value = mock_session
|
||||
mock_db.__aexit__.return_value = None
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
str(anime_dir),
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service._is_series_being_downloaded",
|
||||
return_value=False,
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service.get_db_session",
|
||||
return_value=mock_db,
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service.AnimeSeriesService.get_by_key",
|
||||
new_callable=AsyncMock,
|
||||
return_value=None,
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service.AnimeSeriesService.get_all",
|
||||
new_callable=AsyncMock,
|
||||
return_value=[],
|
||||
):
|
||||
stats = await validate_and_rename_series_folders()
|
||||
|
||||
# Source folder removed, target survives
|
||||
assert not series_dir.exists()
|
||||
assert target_dir.is_dir()
|
||||
# Duplicate resolved: counts as renamed (source removed, target kept)
|
||||
assert stats["scanned"] == 1
|
||||
assert stats["renamed"] == 1
|
||||
assert stats["skipped"] == 0
|
||||
assert stats["errors"] == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_counts_multiple_folders(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
|
||||
# Folder 1: needs rename
|
||||
d1 = anime_dir / "Show A"
|
||||
d1.mkdir()
|
||||
(d1 / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Show A</title><year>2020</year></tvshow>"
|
||||
)
|
||||
|
||||
# Folder 2: already correct
|
||||
d2 = anime_dir / "Show B (2021)"
|
||||
d2.mkdir()
|
||||
(d2 / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Show B</title><year>2021</year></tvshow>"
|
||||
)
|
||||
|
||||
# Folder 3: missing year
|
||||
d3 = anime_dir / "Show C"
|
||||
d3.mkdir()
|
||||
(d3 / "tvshow.nfo").write_text("<tvshow><title>Show C</title></tvshow>")
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
str(anime_dir),
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service._is_series_being_downloaded",
|
||||
return_value=False,
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service._update_database_paths",
|
||||
new_callable=AsyncMock,
|
||||
):
|
||||
stats = await validate_and_rename_series_folders()
|
||||
|
||||
assert stats["scanned"] == 3
|
||||
assert stats["renamed"] == 1
|
||||
assert stats["skipped"] == 1
|
||||
assert stats["errors"] == 0
|
||||
assert not d1.exists()
|
||||
assert (anime_dir / "Show A (2020)").is_dir()
|
||||
assert d2.is_dir()
|
||||
assert d3.is_dir()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_dry_run_does_not_rename_folders(self, tmp_path: Path) -> None:
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
series_dir = anime_dir / "Attack on Titan"
|
||||
series_dir.mkdir()
|
||||
(series_dir / "tvshow.nfo").write_text(
|
||||
"<tvshow><title>Attack on Titan</title><year>2013</year></tvshow>"
|
||||
)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_rename_service.settings.anime_directory",
|
||||
str(anime_dir),
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service._is_series_being_downloaded",
|
||||
return_value=False,
|
||||
):
|
||||
stats = await validate_and_rename_series_folders(dry_run=True)
|
||||
|
||||
assert stats["scanned"] == 1
|
||||
assert stats["renamed"] == 1
|
||||
assert stats["skipped"] == 0
|
||||
assert stats["errors"] == 0
|
||||
# Original folder should still exist (not renamed in dry-run)
|
||||
assert series_dir.is_dir()
|
||||
assert not (anime_dir / "Attack on Titan (2013)").exists()
|
||||
@@ -140,17 +140,14 @@ class TestRunFolderScanPrerequisites:
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestNfoRepairIntegration:
|
||||
"""Test perform_nfo_repair_scan is called inside run_folder_scan."""
|
||||
"""Test NFO repair scan behavior - NFO service removed, now stub."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_calls_perform_nfo_repair_scan(self, folder_scan_service, tmp_path):
|
||||
"""run_folder_scan must call perform_nfo_repair_scan."""
|
||||
async def test_nfo_repair_skipped(self, folder_scan_service, tmp_path):
|
||||
"""NFO repair scan is skipped since NFO service removed."""
|
||||
with patch.object(
|
||||
folder_scan_service, "_prerequisites_met", return_value=True
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_scan_service.perform_nfo_repair_scan",
|
||||
new_callable=AsyncMock,
|
||||
) as mock_repair, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.validate_and_rename_series_folders",
|
||||
new_callable=AsyncMock,
|
||||
return_value={"scanned": 0, "renamed": 0, "skipped": 0, "errors": 0},
|
||||
@@ -161,34 +158,8 @@ class TestNfoRepairIntegration:
|
||||
return_value={"scanned": 0, "downloaded": 0, "skipped": 0, "errors": 0},
|
||||
):
|
||||
await folder_scan_service.run_folder_scan()
|
||||
mock_repair.assert_awaited_once_with(background_loader=None)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_nfo_repair_failure_does_not_crash_scan(
|
||||
self, folder_scan_service, tmp_path
|
||||
):
|
||||
"""If perform_nfo_repair_scan raises, the broad except catches it
|
||||
and the scan stops — remaining steps are NOT invoked."""
|
||||
with patch.object(
|
||||
folder_scan_service, "_prerequisites_met", return_value=True
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_scan_service.perform_nfo_repair_scan",
|
||||
new_callable=AsyncMock,
|
||||
side_effect=RuntimeError("repair failed"),
|
||||
) as mock_repair, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.validate_and_rename_series_folders",
|
||||
new_callable=AsyncMock,
|
||||
return_value={"scanned": 0, "renamed": 0, "skipped": 0, "errors": 0},
|
||||
) as mock_rename, patch.object(
|
||||
folder_scan_service,
|
||||
"check_and_download_missing_posters",
|
||||
new_callable=AsyncMock,
|
||||
return_value={"scanned": 0, "downloaded": 0, "skipped": 0, "errors": 0},
|
||||
):
|
||||
await folder_scan_service.run_folder_scan()
|
||||
mock_repair.assert_awaited_once()
|
||||
# Broad except stops the scan; rename/poster are skipped
|
||||
mock_rename.assert_not_called()
|
||||
# NFO repair is skipped - verify scan continues to folder rename
|
||||
# No exception means the stub worked correctly
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
@@ -565,13 +536,10 @@ class TestRunFolderScanFull:
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_full_scan_happy_path(self, folder_scan_service, tmp_path):
|
||||
"""All sub-tasks succeed."""
|
||||
"""All sub-tasks succeed. NFO repair is now a stub."""
|
||||
with patch.object(
|
||||
folder_scan_service, "_prerequisites_met", return_value=True
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_scan_service.perform_nfo_repair_scan",
|
||||
new_callable=AsyncMock,
|
||||
) as mock_repair, patch(
|
||||
"src.server.services.scheduler.folder_rename_service.validate_and_rename_series_folders",
|
||||
new_callable=AsyncMock,
|
||||
return_value={"scanned": 3, "renamed": 1, "skipped": 1, "errors": 1},
|
||||
@@ -583,7 +551,7 @@ class TestRunFolderScanFull:
|
||||
) as mock_poster:
|
||||
await folder_scan_service.run_folder_scan()
|
||||
|
||||
mock_repair.assert_awaited_once_with(background_loader=None)
|
||||
# NFO repair is now a stub - not awaited in code
|
||||
mock_rename.assert_awaited_once()
|
||||
mock_poster.assert_awaited_once()
|
||||
|
||||
@@ -592,9 +560,6 @@ class TestRunFolderScanFull:
|
||||
"""Empty library → all stats zero."""
|
||||
with patch.object(
|
||||
folder_scan_service, "_prerequisites_met", return_value=True
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_scan_service.perform_nfo_repair_scan",
|
||||
new_callable=AsyncMock,
|
||||
), patch(
|
||||
"src.server.services.scheduler.folder_rename_service.validate_and_rename_series_folders",
|
||||
new_callable=AsyncMock,
|
||||
|
||||
@@ -458,40 +458,21 @@ class TestNFOScanFunctions:
|
||||
|
||||
|
||||
class TestExecuteNFOScan:
|
||||
"""Test NFO scan execution."""
|
||||
"""Test NFO scan execution - NFO service removed."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_execute_nfo_scan_without_progress(self):
|
||||
"""Test executing NFO scan without progress service."""
|
||||
mock_manager = MagicMock()
|
||||
mock_manager.scan_and_process_nfo = AsyncMock()
|
||||
mock_manager.close = AsyncMock()
|
||||
|
||||
with patch('src.core.services.series_manager_service.SeriesManagerService') as mock_sms:
|
||||
mock_sms.from_settings.return_value = mock_manager
|
||||
|
||||
await _execute_nfo_scan()
|
||||
|
||||
mock_manager.scan_and_process_nfo.assert_called_once()
|
||||
mock_manager.close.assert_called_once()
|
||||
"""Test executing NFO scan without progress service - now no-op."""
|
||||
# NFO service removed, so _execute_nfo_scan should be a no-op
|
||||
await _execute_nfo_scan()
|
||||
# If we got here without exception, the no-op worked
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_execute_nfo_scan_with_progress(self):
|
||||
"""Test executing NFO scan with progress updates."""
|
||||
mock_manager = MagicMock()
|
||||
mock_manager.scan_and_process_nfo = AsyncMock()
|
||||
mock_manager.close = AsyncMock()
|
||||
"""Test executing NFO scan with progress updates - now no-op."""
|
||||
mock_progress = AsyncMock()
|
||||
|
||||
with patch('src.core.services.series_manager_service.SeriesManagerService') as mock_sms:
|
||||
mock_sms.from_settings.return_value = mock_manager
|
||||
|
||||
await _execute_nfo_scan(progress_service=mock_progress)
|
||||
|
||||
mock_manager.scan_and_process_nfo.assert_called_once()
|
||||
mock_manager.close.assert_called_once()
|
||||
assert mock_progress.update_progress.call_count == 2
|
||||
mock_progress.complete_progress.assert_called_once()
|
||||
await _execute_nfo_scan(progress_service=mock_progress)
|
||||
# If we got here without exception, the no-op worked
|
||||
|
||||
|
||||
class TestPerformNFOScan:
|
||||
@@ -761,7 +742,10 @@ class TestInitializationIntegration:
|
||||
|
||||
|
||||
class TestPerformNfoRepairScan:
|
||||
"""Tests for the perform_nfo_repair_scan startup hook."""
|
||||
"""Tests for the perform_nfo_repair_scan startup hook.
|
||||
|
||||
Note: NFO service removed, so these tests verify no-op behavior.
|
||||
"""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skips_without_tmdb_api_key(self, tmp_path):
|
||||
@@ -790,100 +774,20 @@ class TestPerformNfoRepairScan:
|
||||
await perform_nfo_repair_scan()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_queues_deficient_series_as_asyncio_task(self, tmp_path):
|
||||
"""Series with incomplete NFO should be scheduled via asyncio.create_task."""
|
||||
async def test_is_no_op(self, tmp_path):
|
||||
"""perform_nfo_repair_scan is now a no-op - just verify it returns without error."""
|
||||
mock_settings = MagicMock()
|
||||
mock_settings.tmdb_api_key = "test-key"
|
||||
mock_settings.anime_directory = str(tmp_path)
|
||||
|
||||
series_dir = tmp_path / "MyAnime"
|
||||
series_dir.mkdir()
|
||||
nfo_file = series_dir / "tvshow.nfo"
|
||||
nfo_file.write_text("<tvshow><title>MyAnime</title></tvshow>")
|
||||
|
||||
mock_settings = MagicMock()
|
||||
mock_settings.tmdb_api_key = "test-key"
|
||||
mock_settings.anime_directory = str(tmp_path)
|
||||
|
||||
mock_repair_service = AsyncMock()
|
||||
mock_repair_service.repair_series = AsyncMock(return_value=True)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_scan_service._settings", mock_settings
|
||||
), patch(
|
||||
"src.core.services.nfo_repair_service.nfo_needs_repair",
|
||||
return_value=True,
|
||||
), patch(
|
||||
"src.core.services.nfo_factory.NFOServiceFactory"
|
||||
) as mock_factory_cls, patch(
|
||||
"src.core.services.nfo_repair_service.NfoRepairService",
|
||||
return_value=mock_repair_service,
|
||||
), patch(
|
||||
"asyncio.create_task"
|
||||
) as mock_create_task, patch(
|
||||
"asyncio.gather", new_callable=AsyncMock
|
||||
) as mock_gather:
|
||||
mock_factory_cls.return_value.create.return_value = MagicMock()
|
||||
):
|
||||
await perform_nfo_repair_scan(background_loader=AsyncMock())
|
||||
|
||||
mock_create_task.assert_called_once()
|
||||
mock_gather.assert_called_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skips_complete_series(self, tmp_path):
|
||||
"""Series with complete NFO should not be scheduled for repair."""
|
||||
series_dir = tmp_path / "CompleteAnime"
|
||||
series_dir.mkdir()
|
||||
nfo_file = series_dir / "tvshow.nfo"
|
||||
nfo_file.write_text("<tvshow><title>CompleteAnime</title></tvshow>")
|
||||
|
||||
mock_settings = MagicMock()
|
||||
mock_settings.tmdb_api_key = "test-key"
|
||||
mock_settings.anime_directory = str(tmp_path)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_scan_service._settings", mock_settings
|
||||
), patch(
|
||||
"src.core.services.nfo_repair_service.nfo_needs_repair",
|
||||
return_value=False,
|
||||
), patch(
|
||||
"src.core.services.nfo_factory.NFOServiceFactory"
|
||||
) as mock_factory_cls, patch(
|
||||
"asyncio.create_task"
|
||||
) as mock_create_task:
|
||||
mock_factory_cls.return_value.create.return_value = MagicMock()
|
||||
await perform_nfo_repair_scan(background_loader=AsyncMock())
|
||||
|
||||
mock_create_task.assert_not_called()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_repairs_via_asyncio_task_without_background_loader(self, tmp_path):
|
||||
"""When no background_loader provided, repair is still scheduled via asyncio.create_task."""
|
||||
series_dir = tmp_path / "NeedsRepair"
|
||||
series_dir.mkdir()
|
||||
nfo_file = series_dir / "tvshow.nfo"
|
||||
nfo_file.write_text("<tvshow><title>NeedsRepair</title></tvshow>")
|
||||
|
||||
mock_settings = MagicMock()
|
||||
mock_settings.tmdb_api_key = "test-key"
|
||||
mock_settings.anime_directory = str(tmp_path)
|
||||
|
||||
mock_repair_service = AsyncMock()
|
||||
mock_repair_service.repair_series = AsyncMock(return_value=True)
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.folder_scan_service._settings", mock_settings
|
||||
), patch(
|
||||
"src.core.services.nfo_repair_service.nfo_needs_repair",
|
||||
return_value=True,
|
||||
), patch(
|
||||
"src.core.services.nfo_factory.NFOServiceFactory"
|
||||
) as mock_factory_cls, patch(
|
||||
"src.core.services.nfo_repair_service.NfoRepairService",
|
||||
return_value=mock_repair_service,
|
||||
), patch(
|
||||
"asyncio.create_task"
|
||||
) as mock_create_task, patch(
|
||||
"asyncio.gather", new_callable=AsyncMock
|
||||
) as mock_gather:
|
||||
mock_factory_cls.return_value.create.return_value = MagicMock()
|
||||
await perform_nfo_repair_scan(background_loader=None)
|
||||
|
||||
mock_create_task.assert_called_once()
|
||||
mock_gather.assert_called_once()
|
||||
# If we got here, the no-op worked correctly
|
||||
|
||||
@@ -1,218 +0,0 @@
|
||||
"""Unit tests for key_resolution_service."""
|
||||
from __future__ import annotations
|
||||
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.server.services.scheduler.key_resolution_service import (
|
||||
_extract_key_from_link,
|
||||
_extract_year_from_folder,
|
||||
_normalize_for_comparison,
|
||||
_strip_year_from_folder,
|
||||
resolve_key_for_folder,
|
||||
)
|
||||
|
||||
|
||||
class TestStripYearFromFolder:
|
||||
"""Tests for _strip_year_from_folder."""
|
||||
|
||||
def test_removes_year_suffix(self):
|
||||
assert _strip_year_from_folder("Rent-A-Girlfriend (2020)") == "Rent-A-Girlfriend"
|
||||
|
||||
def test_removes_year_suffix_with_spaces(self):
|
||||
assert _strip_year_from_folder("Attack on Titan (2013)") == "Attack on Titan"
|
||||
|
||||
def test_no_year_returns_original(self):
|
||||
assert _strip_year_from_folder("Naruto") == "Naruto"
|
||||
|
||||
def test_year_in_middle_not_stripped(self):
|
||||
assert _strip_year_from_folder("2024 Anime (2024)") == "2024 Anime"
|
||||
|
||||
def test_empty_string(self):
|
||||
assert _strip_year_from_folder("") == ""
|
||||
|
||||
def test_only_year(self):
|
||||
assert _strip_year_from_folder("(2020)") == ""
|
||||
|
||||
|
||||
class TestExtractYearFromFolder:
|
||||
"""Tests for _extract_year_from_folder."""
|
||||
|
||||
def test_extracts_year(self):
|
||||
assert _extract_year_from_folder("Rent-A-Girlfriend (2020)") == 2020
|
||||
|
||||
def test_no_year_returns_none(self):
|
||||
assert _extract_year_from_folder("Naruto") is None
|
||||
|
||||
def test_year_in_middle_not_extracted(self):
|
||||
# Only trailing year is extracted
|
||||
assert _extract_year_from_folder("2024 Anime") is None
|
||||
|
||||
|
||||
class TestExtractKeyFromLink:
|
||||
"""Tests for _extract_key_from_link."""
|
||||
|
||||
def test_relative_link(self):
|
||||
assert _extract_key_from_link("/anime/stream/rent-a-girlfriend") == "rent-a-girlfriend"
|
||||
|
||||
def test_full_url(self):
|
||||
assert (
|
||||
_extract_key_from_link("https://aniworld.to/anime/stream/attack-on-titan")
|
||||
== "attack-on-titan"
|
||||
)
|
||||
|
||||
def test_link_with_trailing_slash(self):
|
||||
assert _extract_key_from_link("/anime/stream/naruto/") == "naruto"
|
||||
|
||||
def test_empty_link(self):
|
||||
assert _extract_key_from_link("") is None
|
||||
|
||||
def test_none_link(self):
|
||||
assert _extract_key_from_link(None) is None
|
||||
|
||||
def test_slug_only(self):
|
||||
assert _extract_key_from_link("one-piece") == "one-piece"
|
||||
|
||||
|
||||
class TestNormalizeForComparison:
|
||||
"""Tests for _normalize_for_comparison."""
|
||||
|
||||
def test_case_insensitive(self):
|
||||
assert _normalize_for_comparison("Rent-A-Girlfriend") == _normalize_for_comparison(
|
||||
"rent-a-girlfriend"
|
||||
)
|
||||
|
||||
def test_strips_whitespace(self):
|
||||
assert _normalize_for_comparison(" Naruto ") == "naruto"
|
||||
|
||||
def test_normalizes_dashes(self):
|
||||
assert _normalize_for_comparison("Rent-A-Girlfriend") == "rent a girlfriend"
|
||||
|
||||
def test_collapses_spaces(self):
|
||||
assert _normalize_for_comparison("Attack on Titan") == "attack on titan"
|
||||
|
||||
|
||||
class TestResolveKeyForFolder:
|
||||
"""Tests for resolve_key_for_folder."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_single_exact_match_returns_key(self):
|
||||
"""When provider returns exactly one exact-name match, key is resolved."""
|
||||
search_results = [
|
||||
{"link": "/anime/stream/rent-a-girlfriend", "title": "Rent-A-Girlfriend"},
|
||||
]
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=search_results,
|
||||
):
|
||||
key = await resolve_key_for_folder("Rent-A-Girlfriend (2020)")
|
||||
assert key == "rent-a-girlfriend"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_no_results_returns_none(self):
|
||||
"""When provider returns no results, returns None."""
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=[],
|
||||
):
|
||||
key = await resolve_key_for_folder("Unknown Anime (2020)")
|
||||
assert key is None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_multiple_exact_matches_returns_none(self):
|
||||
"""When multiple results match the same name exactly, returns None."""
|
||||
search_results = [
|
||||
{"link": "/anime/stream/my-anime", "title": "My Anime"},
|
||||
{"link": "/anime/stream/my-anime-2", "title": "My Anime"},
|
||||
]
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=search_results,
|
||||
):
|
||||
key = await resolve_key_for_folder("My Anime (2022)")
|
||||
assert key is None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_no_exact_match_returns_none(self):
|
||||
"""When results exist but none match the folder name, returns None."""
|
||||
search_results = [
|
||||
{"link": "/anime/stream/rent-a-girlfriend-2", "title": "Rent-A-Girlfriend 2nd Season"},
|
||||
{"link": "/anime/stream/rent-a-girlfriend-3", "title": "Rent-A-Girlfriend 3rd Season"},
|
||||
]
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=search_results,
|
||||
):
|
||||
key = await resolve_key_for_folder("Rent-A-Girlfriend (2020)")
|
||||
assert key is None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_case_insensitive_match(self):
|
||||
"""Matching is case-insensitive."""
|
||||
search_results = [
|
||||
{"link": "/anime/stream/naruto", "title": "NARUTO"},
|
||||
]
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=search_results,
|
||||
):
|
||||
key = await resolve_key_for_folder("Naruto (2002)")
|
||||
assert key == "naruto"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_provider_error_returns_none(self):
|
||||
"""When provider search raises an exception, returns None gracefully."""
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
side_effect=RuntimeError("Network error"),
|
||||
):
|
||||
key = await resolve_key_for_folder("Some Anime (2020)")
|
||||
assert key is None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_result_with_name_field_instead_of_title(self):
|
||||
"""Search results using 'name' field instead of 'title' work."""
|
||||
search_results = [
|
||||
{"link": "/anime/stream/one-piece", "name": "One Piece"},
|
||||
]
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=search_results,
|
||||
):
|
||||
key = await resolve_key_for_folder("One Piece (1999)")
|
||||
assert key == "one-piece"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_folder_without_year(self):
|
||||
"""Folders without year suffix still work."""
|
||||
search_results = [
|
||||
{"link": "/anime/stream/naruto", "title": "Naruto"},
|
||||
]
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=search_results,
|
||||
):
|
||||
key = await resolve_key_for_folder("Naruto")
|
||||
assert key == "naruto"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_exact_match_among_partial_matches(self):
|
||||
"""Only exact matches count, partial matches are ignored."""
|
||||
search_results = [
|
||||
{"link": "/anime/stream/dororo", "title": "Dororo"},
|
||||
{"link": "/anime/stream/dororo-to-hyakkimaru", "title": "Dororo to Hyakkimaru"},
|
||||
]
|
||||
|
||||
with patch(
|
||||
"src.server.services.scheduler.key_resolution_service._search_provider",
|
||||
return_value=search_results,
|
||||
):
|
||||
key = await resolve_key_for_folder("Dororo (2019)")
|
||||
assert key == "dororo"
|
||||
@@ -1,384 +0,0 @@
|
||||
"""Unit tests for NFO auto-create logic.
|
||||
|
||||
Tests the NFO service's auto-creation logic, file path resolution,
|
||||
existence checks, and configuration-based behavior.
|
||||
"""
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock, Mock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.services.nfo_service import NFOService
|
||||
|
||||
|
||||
class TestNFOFileExistenceCheck:
|
||||
"""Test NFO file existence checking logic."""
|
||||
|
||||
def test_has_nfo_returns_true_when_file_exists(self, tmp_path):
|
||||
"""Test has_nfo returns True when tvshow.nfo exists."""
|
||||
# Setup
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
serie_folder = anime_dir / "Test Series"
|
||||
serie_folder.mkdir()
|
||||
nfo_file = serie_folder / "tvshow.nfo"
|
||||
nfo_file.write_text("<tvshow></tvshow>")
|
||||
|
||||
# Create service
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Test
|
||||
assert service.has_nfo("Test Series") is True
|
||||
|
||||
def test_has_nfo_returns_false_when_file_missing(self, tmp_path):
|
||||
"""Test has_nfo returns False when tvshow.nfo is missing."""
|
||||
# Setup
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
serie_folder = anime_dir / "Test Series"
|
||||
serie_folder.mkdir()
|
||||
|
||||
# Create service
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Test
|
||||
assert service.has_nfo("Test Series") is False
|
||||
|
||||
def test_has_nfo_returns_false_when_folder_missing(self, tmp_path):
|
||||
"""Test has_nfo returns False when series folder doesn't exist."""
|
||||
# Setup
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
|
||||
# Create service
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Test - folder doesn't exist
|
||||
assert service.has_nfo("Nonexistent Series") is False
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_check_nfo_exists_returns_true_when_file_exists(self, tmp_path):
|
||||
"""Test async check_nfo_exists returns True when file exists."""
|
||||
# Setup
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
serie_folder = anime_dir / "Test Series"
|
||||
serie_folder.mkdir()
|
||||
nfo_file = serie_folder / "tvshow.nfo"
|
||||
nfo_file.write_text("<tvshow></tvshow>")
|
||||
|
||||
# Create service
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Test
|
||||
result = await service.check_nfo_exists("Test Series")
|
||||
assert result is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_check_nfo_exists_returns_false_when_file_missing(self, tmp_path):
|
||||
"""Test async check_nfo_exists returns False when file missing."""
|
||||
# Setup
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
serie_folder = anime_dir / "Test Series"
|
||||
serie_folder.mkdir()
|
||||
|
||||
# Create service
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Test
|
||||
result = await service.check_nfo_exists("Test Series")
|
||||
assert result is False
|
||||
|
||||
|
||||
class TestNFOFilePathResolution:
|
||||
"""Test NFO file path resolution logic."""
|
||||
|
||||
def test_nfo_path_constructed_correctly(self, tmp_path):
|
||||
"""Test NFO path is constructed correctly from anime dir and series folder."""
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Check internal path construction
|
||||
expected_path = anime_dir / "My Series" / "tvshow.nfo"
|
||||
actual_path = service.anime_directory / "My Series" / "tvshow.nfo"
|
||||
|
||||
assert actual_path == expected_path
|
||||
|
||||
def test_nfo_path_handles_special_characters(self, tmp_path):
|
||||
"""Test NFO path handles special characters in folder name."""
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Test with special characters
|
||||
folder_name = "Series: The (2024) [HD]"
|
||||
expected_path = anime_dir / folder_name / "tvshow.nfo"
|
||||
actual_path = service.anime_directory / folder_name / "tvshow.nfo"
|
||||
|
||||
assert actual_path == expected_path
|
||||
|
||||
def test_nfo_path_uses_pathlib(self, tmp_path):
|
||||
"""Test that NFO path uses pathlib.Path internally."""
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Service should use Path internally
|
||||
assert isinstance(service.anime_directory, Path)
|
||||
|
||||
|
||||
class TestYearExtractionLogic:
|
||||
"""Test year extraction from series names."""
|
||||
|
||||
def test_extract_year_from_name_with_year(self):
|
||||
"""Test extracting year from series name with (YYYY) format."""
|
||||
clean_name, year = NFOService._extract_year_from_name("Attack on Titan (2013)")
|
||||
|
||||
assert clean_name == "Attack on Titan"
|
||||
assert year == 2013
|
||||
|
||||
def test_extract_year_from_name_without_year(self):
|
||||
"""Test extracting year when no year present."""
|
||||
clean_name, year = NFOService._extract_year_from_name("Attack on Titan")
|
||||
|
||||
assert clean_name == "Attack on Titan"
|
||||
assert year is None
|
||||
|
||||
def test_extract_year_handles_trailing_spaces(self):
|
||||
"""Test year extraction handles trailing spaces."""
|
||||
clean_name, year = NFOService._extract_year_from_name("Cowboy Bebop (1998) ")
|
||||
|
||||
assert clean_name == "Cowboy Bebop"
|
||||
assert year == 1998
|
||||
|
||||
def test_extract_year_handles_spaces_before_year(self):
|
||||
"""Test year extraction handles spaces before parentheses."""
|
||||
clean_name, year = NFOService._extract_year_from_name("One Piece (1999)")
|
||||
|
||||
assert clean_name == "One Piece"
|
||||
assert year == 1999
|
||||
|
||||
def test_extract_year_ignores_mid_name_years(self):
|
||||
"""Test year extraction ignores years not at the end."""
|
||||
clean_name, year = NFOService._extract_year_from_name("Series (2020) Episode")
|
||||
|
||||
# Should not extract since year is not at the end
|
||||
assert clean_name == "Series (2020) Episode"
|
||||
assert year is None
|
||||
|
||||
def test_extract_year_with_various_formats(self):
|
||||
"""Test year extraction with various common formats."""
|
||||
# Standard format
|
||||
name1, year1 = NFOService._extract_year_from_name("Series Name (2024)")
|
||||
assert name1 == "Series Name"
|
||||
assert year1 == 2024
|
||||
|
||||
# With extra info before year
|
||||
name2, year2 = NFOService._extract_year_from_name("Long Series Name (2024)")
|
||||
assert name2 == "Long Series Name"
|
||||
assert year2 == 2024
|
||||
|
||||
# Old year
|
||||
name3, year3 = NFOService._extract_year_from_name("Classic Show (1985)")
|
||||
assert name3 == "Classic Show"
|
||||
assert year3 == 1985
|
||||
|
||||
|
||||
class TestConfigurationBasedBehavior:
|
||||
"""Test configuration-based NFO creation behavior."""
|
||||
|
||||
def test_auto_create_enabled_by_default(self):
|
||||
"""Test auto_create is enabled by default."""
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory="/anime"
|
||||
)
|
||||
|
||||
assert service.auto_create is True
|
||||
|
||||
def test_auto_create_can_be_disabled(self):
|
||||
"""Test auto_create can be explicitly disabled."""
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory="/anime",
|
||||
auto_create=False
|
||||
)
|
||||
|
||||
assert service.auto_create is False
|
||||
|
||||
def test_service_initializes_with_all_config_options(self):
|
||||
"""Test service initializes with all configuration options."""
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key_123",
|
||||
anime_directory="/my/anime",
|
||||
image_size="w500",
|
||||
auto_create=True
|
||||
)
|
||||
|
||||
assert service.tmdb_client is not None
|
||||
assert service.anime_directory == Path("/my/anime")
|
||||
assert service.image_size == "w500"
|
||||
assert service.auto_create is True
|
||||
|
||||
def test_image_size_defaults_to_original(self):
|
||||
"""Test image_size defaults to 'original'."""
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory="/anime"
|
||||
)
|
||||
|
||||
assert service.image_size == "original"
|
||||
|
||||
def test_image_size_can_be_customized(self):
|
||||
"""Test image_size can be customized."""
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory="/anime",
|
||||
image_size="w780"
|
||||
)
|
||||
|
||||
assert service.image_size == "w780"
|
||||
|
||||
|
||||
class TestNFOCreationWithYearHandling:
|
||||
"""Test NFO creation year handling logic."""
|
||||
|
||||
def test_year_extraction_used_in_clean_name(self):
|
||||
"""Test that year extraction produces clean name for search."""
|
||||
# This tests the _extract_year_from_name static method which is already tested above
|
||||
# Here we document that the clean name (without year) is used for searches
|
||||
clean_name, year = NFOService._extract_year_from_name("Attack on Titan (2013)")
|
||||
|
||||
assert clean_name == "Attack on Titan"
|
||||
assert year == 2013
|
||||
|
||||
def test_explicit_year_parameter_takes_precedence(self):
|
||||
"""Test that explicit year parameter takes precedence over extracted year."""
|
||||
# When both explicit year and year in name are provided,
|
||||
# the explicit year parameter should be used
|
||||
# This is documented behavior, tested in integration tests
|
||||
clean_name, extracted_year = NFOService._extract_year_from_name("Test Series (2020)")
|
||||
|
||||
# Extracted year is 2020
|
||||
assert extracted_year == 2020
|
||||
|
||||
# But if explicit year=2019 is passed to create_tvshow_nfo,
|
||||
# it should use 2019 (tested in integration tests)
|
||||
assert clean_name == "Test Series"
|
||||
|
||||
|
||||
class TestMediaFileDownloadConfiguration:
|
||||
"""Test media file download configuration."""
|
||||
|
||||
def test_download_flags_control_behavior(self):
|
||||
"""Test that download flags (poster/logo/fanart) control download behavior."""
|
||||
# This tests the configuration options passed to create_tvshow_nfo
|
||||
# The actual download behavior is tested in integration tests
|
||||
|
||||
# Document expected behavior:
|
||||
# - download_poster=True should download poster.jpg
|
||||
# - download_logo=True should download logo.png
|
||||
# - download_fanart=True should download fanart.jpg
|
||||
# - Setting any to False should skip that download
|
||||
|
||||
# This behavior is enforced in NFOService.create_tvshow_nfo
|
||||
# and verified in integration tests
|
||||
pass
|
||||
|
||||
def test_default_download_settings(self):
|
||||
"""Test default media download settings."""
|
||||
# By default, create_tvshow_nfo has:
|
||||
# - download_poster=True
|
||||
# - download_logo=True
|
||||
# - download_fanart=True
|
||||
|
||||
# This means all media is downloaded by default
|
||||
# Verified in integration tests
|
||||
pass
|
||||
|
||||
|
||||
class TestNFOServiceEdgeCases:
|
||||
"""Test edge cases in NFO service."""
|
||||
|
||||
def test_service_requires_api_key(self):
|
||||
"""Test service requires valid API key."""
|
||||
# TMDBClient validates API key on initialization
|
||||
with pytest.raises(ValueError, match="TMDB API key is required"):
|
||||
NFOService(
|
||||
tmdb_api_key="",
|
||||
anime_directory="/anime"
|
||||
)
|
||||
|
||||
def test_has_nfo_handles_empty_folder_name(self, tmp_path):
|
||||
"""Test has_nfo handles empty folder name."""
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Should return False for empty folder
|
||||
assert service.has_nfo("") is False
|
||||
|
||||
def test_extract_year_handles_invalid_year_format(self):
|
||||
"""Test year extraction handles invalid year formats."""
|
||||
# Invalid year (not 4 digits)
|
||||
name1, year1 = NFOService._extract_year_from_name("Series (202)")
|
||||
assert name1 == "Series (202)"
|
||||
assert year1 is None
|
||||
|
||||
# Year with letters
|
||||
name2, year2 = NFOService._extract_year_from_name("Series (202a)")
|
||||
assert name2 == "Series (202a)"
|
||||
assert year2 is None
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_check_nfo_exists_handles_permission_error(self, tmp_path):
|
||||
"""Test check_nfo_exists handles permission errors gracefully."""
|
||||
anime_dir = tmp_path / "anime"
|
||||
anime_dir.mkdir()
|
||||
serie_folder = anime_dir / "Test Series"
|
||||
serie_folder.mkdir()
|
||||
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=str(anime_dir)
|
||||
)
|
||||
|
||||
# Mock path.exists to raise PermissionError
|
||||
with patch.object(Path, 'exists', side_effect=PermissionError("No access")):
|
||||
# Should handle error and return False
|
||||
# (In reality, exists() doesn't raise, but this tests robustness)
|
||||
with pytest.raises(PermissionError):
|
||||
await service.check_nfo_exists("Test Series")
|
||||
@@ -1,704 +0,0 @@
|
||||
"""Unit tests for NFO batch operations.
|
||||
|
||||
This module tests NFO batch operation logic including:
|
||||
- Concurrent NFO creation with max_concurrent limits
|
||||
- Batch operation error handling (partial failures)
|
||||
- Batch operation progress tracking
|
||||
- Batch operation cancellation
|
||||
"""
|
||||
import asyncio
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock, Mock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.entities.series import Serie
|
||||
from src.core.services.nfo_service import NFOService
|
||||
from src.server.api.nfo import batch_create_nfo
|
||||
from src.server.models.nfo import NFOBatchCreateRequest
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_series_app():
|
||||
"""Create a mock SeriesApp with test series."""
|
||||
app = Mock()
|
||||
|
||||
# Create test series
|
||||
series = []
|
||||
for i in range(5):
|
||||
serie = Mock(spec=Serie)
|
||||
serie.key = f"serie{i}"
|
||||
serie.folder = f"Serie {i}"
|
||||
serie.name = f"Serie {i}"
|
||||
serie.year = 2020 + i
|
||||
serie.ensure_folder_with_year = Mock(return_value=f"Serie {i} (202{i})")
|
||||
series.append(serie)
|
||||
|
||||
app.list = Mock()
|
||||
app.list.GetList = Mock(return_value=series)
|
||||
|
||||
return app
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_nfo_service():
|
||||
"""Create a mock NFO service."""
|
||||
service = Mock(spec=NFOService)
|
||||
service.check_nfo_exists = AsyncMock(return_value=False)
|
||||
service.create_tvshow_nfo = AsyncMock(return_value=Path("/fake/path/tvshow.nfo"))
|
||||
return service
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def mock_settings():
|
||||
"""Create mock settings."""
|
||||
with patch("src.server.api.nfo.settings") as mock:
|
||||
mock.anime_directory = "/fake/anime/dir"
|
||||
yield mock
|
||||
|
||||
|
||||
class TestBatchOperationConcurrency:
|
||||
"""Tests for concurrent NFO creation with limits."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_respects_max_concurrent_limit(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that batch operations respect max_concurrent limit."""
|
||||
# Track concurrent executions
|
||||
concurrent_count = {"current": 0, "max": 0}
|
||||
|
||||
async def track_concurrent(*args, **kwargs):
|
||||
concurrent_count["current"] += 1
|
||||
concurrent_count["max"] = max(
|
||||
concurrent_count["max"],
|
||||
concurrent_count["current"]
|
||||
)
|
||||
await asyncio.sleep(0.1) # Simulate work
|
||||
concurrent_count["current"] -= 1
|
||||
return Path("/fake/path/tvshow.nfo")
|
||||
|
||||
mock_nfo_service.create_tvshow_nfo.side_effect = track_concurrent
|
||||
|
||||
# Create request with max_concurrent=2
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=[f"serie{i}" for i in range(5)],
|
||||
max_concurrent=2,
|
||||
download_media=False,
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
# Execute batch operation
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify max concurrent operations didn't exceed limit
|
||||
assert concurrent_count["max"] <= 2
|
||||
assert result.total == 5
|
||||
assert result.successful == 5
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_max_concurrent_default_value(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that default max_concurrent value is applied."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1"],
|
||||
# max_concurrent not specified, should default to 3
|
||||
)
|
||||
|
||||
assert request.max_concurrent == 3
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_max_concurrent_validation(self):
|
||||
"""Test that max_concurrent is validated within range."""
|
||||
# Test minimum
|
||||
with pytest.raises(ValueError):
|
||||
NFOBatchCreateRequest(
|
||||
serie_ids=["serie0"],
|
||||
max_concurrent=0 # Below minimum
|
||||
)
|
||||
|
||||
# Test maximum
|
||||
with pytest.raises(ValueError):
|
||||
NFOBatchCreateRequest(
|
||||
serie_ids=["serie0"],
|
||||
max_concurrent=11 # Above maximum
|
||||
)
|
||||
|
||||
# Test valid values
|
||||
for value in [1, 3, 5, 10]:
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0"],
|
||||
max_concurrent=value
|
||||
)
|
||||
assert request.max_concurrent == value
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_concurrent_operations_complete_correctly(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test all concurrent operations complete successfully."""
|
||||
call_order = []
|
||||
|
||||
async def track_order(serie_name, serie_folder, **kwargs):
|
||||
call_order.append(serie_name)
|
||||
await asyncio.sleep(0.05) # Simulate work
|
||||
return Path(f"/fake/{serie_folder}/tvshow.nfo")
|
||||
|
||||
mock_nfo_service.create_tvshow_nfo.side_effect = track_order
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1", "serie2", "serie3"],
|
||||
max_concurrent=2
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# All operations should complete
|
||||
assert len(call_order) == 4
|
||||
assert result.successful == 4
|
||||
assert result.failed == 0
|
||||
|
||||
|
||||
class TestBatchOperationErrorHandling:
|
||||
"""Tests for batch operation error handling."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_partial_failure_continues_processing(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that partial failures don't stop batch processing."""
|
||||
# Make serie1 and serie3 fail
|
||||
async def selective_failure(serie_name, **kwargs):
|
||||
if serie_name in ["Serie 1", "Serie 3"]:
|
||||
raise Exception("TMDB API error")
|
||||
return Path(f"/fake/{serie_name}/tvshow.nfo")
|
||||
|
||||
mock_nfo_service.create_tvshow_nfo.side_effect = selective_failure
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1", "serie2", "serie3", "serie4"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify partial success
|
||||
assert result.total == 5
|
||||
assert result.successful == 3 # serie0, serie2, serie4
|
||||
assert result.failed == 2 # serie1, serie3
|
||||
|
||||
# Check failed results have error messages
|
||||
failed_results = [r for r in result.results if not r.success]
|
||||
assert len(failed_results) == 2
|
||||
for failed in failed_results:
|
||||
assert "Error:" in failed.message
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_series_not_found_error(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test handling of non-existent series."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "nonexistent", "serie1"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify error handling
|
||||
assert result.total == 3
|
||||
assert result.successful == 2
|
||||
assert result.failed == 1
|
||||
|
||||
# Find the failed result
|
||||
failed = next(r for r in result.results if r.serie_id == "nonexistent")
|
||||
assert not failed.success
|
||||
assert "not found" in failed.message.lower()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_all_operations_fail(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test batch operation when all operations fail."""
|
||||
mock_nfo_service.create_tvshow_nfo.side_effect = Exception("Network error")
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1", "serie2"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
assert result.total == 3
|
||||
assert result.successful == 0
|
||||
assert result.failed == 3
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_error_messages_are_informative(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that error messages contain useful information."""
|
||||
async def specific_errors(serie_name, **kwargs):
|
||||
errors = {
|
||||
"Serie 0": "TMDB API rate limit exceeded",
|
||||
"Serie 1": "File permission denied",
|
||||
"Serie 2": "Network timeout",
|
||||
}
|
||||
if serie_name in errors:
|
||||
raise Exception(errors[serie_name])
|
||||
return Path("/fake/path/tvshow.nfo")
|
||||
|
||||
mock_nfo_service.create_tvshow_nfo.side_effect = specific_errors
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1", "serie2"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify error messages are preserved
|
||||
for res in result.results:
|
||||
assert not res.success
|
||||
assert "Error:" in res.message
|
||||
# Verify specific error is mentioned
|
||||
if res.serie_id == "serie0":
|
||||
assert "rate limit" in res.message.lower()
|
||||
elif res.serie_id == "serie1":
|
||||
assert "permission" in res.message.lower()
|
||||
elif res.serie_id == "serie2":
|
||||
assert "timeout" in res.message.lower()
|
||||
|
||||
|
||||
class TestBatchOperationSkipping:
|
||||
"""Tests for skip_existing functionality."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skip_existing_nfo_files(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that existing NFO files are skipped when requested."""
|
||||
# Serie 1 and 3 have existing NFOs
|
||||
async def check_exists(serie_folder):
|
||||
return serie_folder in ["Serie 1 (2021)", "Serie 3 (2023)"]
|
||||
|
||||
mock_nfo_service.check_nfo_exists.side_effect = check_exists
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1", "serie2", "serie3", "serie4"],
|
||||
skip_existing=True
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify skipped series
|
||||
assert result.total == 5
|
||||
assert result.successful == 3 # serie0, serie2, serie4
|
||||
assert result.skipped == 2 # serie1, serie3
|
||||
|
||||
# Verify create was only called for non-existing
|
||||
assert mock_nfo_service.create_tvshow_nfo.call_count == 3
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skip_existing_false_overwrites(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that existing NFO files are overwritten when skip_existing=False."""
|
||||
mock_nfo_service.check_nfo_exists.return_value = True
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# All should be created despite existing
|
||||
assert result.successful == 2
|
||||
assert result.skipped == 0
|
||||
assert mock_nfo_service.create_tvshow_nfo.call_count == 2
|
||||
|
||||
|
||||
class TestBatchOperationMediaDownloads:
|
||||
"""Tests for media download functionality in batch operations."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_download_media_enabled(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that media downloads are requested when enabled."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1"],
|
||||
download_media=True,
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify media downloads were requested
|
||||
for call in mock_nfo_service.create_tvshow_nfo.call_args_list:
|
||||
kwargs = call[1]
|
||||
assert kwargs["download_poster"] is True
|
||||
assert kwargs["download_logo"] is True
|
||||
assert kwargs["download_fanart"] is True
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_download_media_disabled(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that media downloads are skipped when disabled."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1"],
|
||||
download_media=False,
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify media downloads were not requested
|
||||
for call in mock_nfo_service.create_tvshow_nfo.call_args_list:
|
||||
kwargs = call[1]
|
||||
assert kwargs["download_poster"] is False
|
||||
assert kwargs["download_logo"] is False
|
||||
assert kwargs["download_fanart"] is False
|
||||
|
||||
|
||||
class TestBatchOperationResults:
|
||||
"""Tests for batch operation result structure."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_result_includes_all_series(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that result includes entry for every series."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1", "serie2"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify all series in results
|
||||
assert len(result.results) == 3
|
||||
result_ids = {r.serie_id for r in result.results}
|
||||
assert result_ids == {"serie0", "serie1", "serie2"}
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_result_includes_nfo_paths(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that successful results include NFO file paths."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify NFO paths are included
|
||||
for res in result.results:
|
||||
if res.success:
|
||||
assert res.nfo_path is not None
|
||||
assert "tvshow.nfo" in res.nfo_path
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_result_counts_are_accurate(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test that result counts match actual outcomes."""
|
||||
# Setup: 2 success, 1 skip, 1 fail, 1 not found
|
||||
async def mixed_results(serie_name, **kwargs):
|
||||
if serie_name == "Serie 2":
|
||||
raise Exception("TMDB error")
|
||||
return Path(f"/fake/{serie_name}/tvshow.nfo")
|
||||
|
||||
mock_nfo_service.create_tvshow_nfo.side_effect = mixed_results
|
||||
mock_nfo_service.check_nfo_exists.side_effect = lambda f: f == "Serie 1 (2021)"
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie1", "serie2", "nonexistent"],
|
||||
skip_existing=True
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Verify counts
|
||||
assert result.total == 4
|
||||
assert result.successful == 1 # serie0
|
||||
assert result.skipped == 1 # serie1
|
||||
assert result.failed == 2 # serie2 (error), nonexistent (not found)
|
||||
|
||||
# Verify sum adds up
|
||||
assert result.successful + result.skipped + result.failed == result.total
|
||||
|
||||
|
||||
class TestBatchOperationEdgeCases:
|
||||
"""Tests for edge cases in batch operations."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_empty_series_list(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test batch operation with empty series list."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=[],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
assert result.total == 0
|
||||
assert result.successful == 0
|
||||
assert result.failed == 0
|
||||
assert len(result.results) == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_single_series(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test batch operation with single series."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
assert result.total == 1
|
||||
assert result.successful == 1
|
||||
assert len(result.results) == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_large_batch_operation(
|
||||
self,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test batch operation with many series."""
|
||||
# Create app with 20 series
|
||||
app = Mock()
|
||||
series = []
|
||||
for i in range(20):
|
||||
serie = Mock(spec=Serie)
|
||||
serie.key = f"serie{i}"
|
||||
serie.folder = f"Serie {i}"
|
||||
serie.name = f"Serie {i}"
|
||||
serie.ensure_folder_with_year = Mock(return_value=f"Serie {i} (2020)")
|
||||
series.append(serie)
|
||||
app.list = Mock()
|
||||
app.list.GetList = Mock(return_value=series)
|
||||
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=[f"serie{i}" for i in range(20)],
|
||||
max_concurrent=5,
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
assert result.total == 20
|
||||
assert result.successful == 20
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_duplicate_serie_ids(
|
||||
self,
|
||||
mock_series_app,
|
||||
mock_nfo_service,
|
||||
mock_settings
|
||||
):
|
||||
"""Test batch operation handles duplicate serie IDs."""
|
||||
request = NFOBatchCreateRequest(
|
||||
serie_ids=["serie0", "serie0", "serie1", "serie1"],
|
||||
skip_existing=False
|
||||
)
|
||||
|
||||
with patch("src.server.api.nfo.get_series_app", return_value=mock_series_app), \
|
||||
patch("src.server.api.nfo.get_nfo_service", return_value=mock_nfo_service):
|
||||
|
||||
result = await batch_create_nfo(
|
||||
request=request,
|
||||
_auth={"username": "test"},
|
||||
series_app=mock_series_app,
|
||||
nfo_service=mock_nfo_service
|
||||
)
|
||||
|
||||
# Should process all (including duplicates)
|
||||
assert result.total == 4
|
||||
assert result.successful == 4
|
||||
@@ -1,356 +0,0 @@
|
||||
"""Unit tests for the NFO CLI module.
|
||||
|
||||
Tests the CLI entry point, command dispatch, and individual command functions
|
||||
from src/cli/nfo_cli.py.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from io import StringIO
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.cli.nfo_cli import (
|
||||
check_nfo_status,
|
||||
main,
|
||||
scan_and_create_nfo,
|
||||
update_nfo_files,
|
||||
)
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# main() dispatcher tests
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestMainDispatcher:
|
||||
"""Tests for the main() CLI entry point."""
|
||||
|
||||
@patch("src.cli.nfo_cli.sys")
|
||||
def test_no_args_shows_usage(self, mock_sys, capsys):
|
||||
"""No arguments prints usage text and returns 1."""
|
||||
mock_sys.argv = ["nfo_cli"]
|
||||
result = main()
|
||||
assert result == 1
|
||||
|
||||
@patch("src.cli.nfo_cli.asyncio")
|
||||
@patch("src.cli.nfo_cli.sys")
|
||||
def test_scan_command_dispatches(self, mock_sys, mock_asyncio):
|
||||
"""'scan' command runs scan_and_create_nfo."""
|
||||
mock_sys.argv = ["nfo_cli", "scan"]
|
||||
mock_asyncio.run.return_value = 0
|
||||
result = main()
|
||||
mock_asyncio.run.assert_called_once()
|
||||
|
||||
@patch("src.cli.nfo_cli.asyncio")
|
||||
@patch("src.cli.nfo_cli.sys")
|
||||
def test_status_command_dispatches(self, mock_sys, mock_asyncio):
|
||||
"""'status' command runs check_nfo_status."""
|
||||
mock_sys.argv = ["nfo_cli", "status"]
|
||||
mock_asyncio.run.return_value = 0
|
||||
result = main()
|
||||
mock_asyncio.run.assert_called_once()
|
||||
|
||||
@patch("src.cli.nfo_cli.asyncio")
|
||||
@patch("src.cli.nfo_cli.sys")
|
||||
def test_update_command_dispatches(self, mock_sys, mock_asyncio):
|
||||
"""'update' command runs update_nfo_files."""
|
||||
mock_sys.argv = ["nfo_cli", "update"]
|
||||
mock_asyncio.run.return_value = 0
|
||||
result = main()
|
||||
mock_asyncio.run.assert_called_once()
|
||||
|
||||
@patch("src.cli.nfo_cli.sys")
|
||||
def test_unknown_command_returns_1(self, mock_sys):
|
||||
"""Unknown command returns exit code 1."""
|
||||
mock_sys.argv = ["nfo_cli", "bogus"]
|
||||
result = main()
|
||||
assert result == 1
|
||||
|
||||
@patch("src.cli.nfo_cli.asyncio")
|
||||
@patch("src.cli.nfo_cli.sys")
|
||||
def test_command_is_case_insensitive(self, mock_sys, mock_asyncio):
|
||||
"""Command matching is case-insensitive."""
|
||||
mock_sys.argv = ["nfo_cli", "SCAN"]
|
||||
mock_asyncio.run.return_value = 0
|
||||
main()
|
||||
mock_asyncio.run.assert_called_once()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# scan_and_create_nfo tests
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestScanAndCreateNfo:
|
||||
"""Tests for scan_and_create_nfo command."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_1_without_tmdb_key(self, mock_settings):
|
||||
"""Returns 1 when TMDB_API_KEY is missing."""
|
||||
mock_settings.tmdb_api_key = None
|
||||
result = await scan_and_create_nfo()
|
||||
assert result == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_1_without_anime_directory(self, mock_settings):
|
||||
"""Returns 1 when ANIME_DIRECTORY is missing."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = None
|
||||
result = await scan_and_create_nfo()
|
||||
assert result == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.SeriesManagerService")
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_0_when_no_series_found(self, mock_settings, mock_sms):
|
||||
"""Returns 0 when directory has no series."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_auto_create = True
|
||||
mock_settings.nfo_update_on_scan = False
|
||||
mock_settings.nfo_download_poster = False
|
||||
mock_settings.nfo_download_logo = False
|
||||
mock_settings.nfo_download_fanart = False
|
||||
|
||||
mock_manager = MagicMock()
|
||||
mock_serie_list = MagicMock()
|
||||
mock_serie_list.get_all.return_value = []
|
||||
mock_manager.get_serie_list.return_value = mock_serie_list
|
||||
mock_sms.from_settings.return_value = mock_manager
|
||||
|
||||
result = await scan_and_create_nfo()
|
||||
assert result == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.SeriesManagerService")
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_calls_scan_and_process_nfo(self, mock_settings, mock_sms):
|
||||
"""Processing is invoked for found series."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_auto_create = True
|
||||
mock_settings.nfo_update_on_scan = False
|
||||
mock_settings.nfo_download_poster = False
|
||||
mock_settings.nfo_download_logo = False
|
||||
mock_settings.nfo_download_fanart = False
|
||||
|
||||
mock_serie = MagicMock()
|
||||
mock_serie.has_nfo.return_value = False
|
||||
mock_serie.name = "Naruto"
|
||||
mock_serie.folder = "Naruto"
|
||||
mock_serie.has_poster.return_value = False
|
||||
mock_serie.has_logo.return_value = False
|
||||
mock_serie.has_fanart.return_value = False
|
||||
|
||||
mock_serie_list = MagicMock()
|
||||
mock_serie_list.get_all.return_value = [mock_serie]
|
||||
mock_serie_list.load_series = MagicMock()
|
||||
|
||||
mock_manager = MagicMock()
|
||||
mock_manager.get_serie_list.return_value = mock_serie_list
|
||||
mock_manager.scan_and_process_nfo = AsyncMock()
|
||||
mock_manager.close = AsyncMock()
|
||||
mock_sms.from_settings.return_value = mock_manager
|
||||
|
||||
result = await scan_and_create_nfo()
|
||||
assert result == 0
|
||||
mock_manager.scan_and_process_nfo.assert_awaited_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.SeriesManagerService")
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_1_on_exception(self, mock_settings, mock_sms):
|
||||
"""Returns 1 when processing raises."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_auto_create = True
|
||||
mock_settings.nfo_update_on_scan = False
|
||||
mock_settings.nfo_download_poster = False
|
||||
mock_settings.nfo_download_logo = False
|
||||
mock_settings.nfo_download_fanart = False
|
||||
|
||||
mock_serie = MagicMock()
|
||||
mock_serie.has_nfo.return_value = False
|
||||
mock_serie.name = "Test"
|
||||
mock_serie.folder = "Test"
|
||||
mock_serie_list = MagicMock()
|
||||
mock_serie_list.get_all.return_value = [mock_serie]
|
||||
|
||||
mock_manager = MagicMock()
|
||||
mock_manager.get_serie_list.return_value = mock_serie_list
|
||||
mock_manager.scan_and_process_nfo = AsyncMock(
|
||||
side_effect=RuntimeError("fail")
|
||||
)
|
||||
mock_manager.close = AsyncMock()
|
||||
mock_sms.from_settings.return_value = mock_manager
|
||||
|
||||
result = await scan_and_create_nfo()
|
||||
assert result == 1
|
||||
# close is called even on error (finally block)
|
||||
mock_manager.close.assert_awaited_once()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# check_nfo_status tests
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestCheckNfoStatus:
|
||||
"""Tests for check_nfo_status command."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_1_without_anime_directory(self, mock_settings):
|
||||
"""Returns 1 when ANIME_DIRECTORY is missing."""
|
||||
mock_settings.anime_directory = None
|
||||
result = await check_nfo_status()
|
||||
assert result == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_0_when_no_series(self, mock_settings):
|
||||
"""Returns 0 when no series found."""
|
||||
mock_settings.anime_directory = "/anime"
|
||||
with patch("src.core.entities.SerieList.SerieList") as mock_sl:
|
||||
mock_list = MagicMock()
|
||||
mock_list.get_all.return_value = []
|
||||
mock_sl.return_value = mock_list
|
||||
result = await check_nfo_status()
|
||||
assert result == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_reports_series_with_and_without_nfo(self, mock_settings, capsys):
|
||||
"""Status report categorises series correctly."""
|
||||
mock_settings.anime_directory = "/anime"
|
||||
|
||||
serie_a = MagicMock()
|
||||
serie_a.has_nfo.return_value = True
|
||||
serie_a.has_poster.return_value = True
|
||||
serie_a.has_logo.return_value = False
|
||||
serie_a.has_fanart.return_value = False
|
||||
serie_a.name = "A"
|
||||
serie_a.folder = "A"
|
||||
|
||||
serie_b = MagicMock()
|
||||
serie_b.has_nfo.return_value = False
|
||||
serie_b.has_poster.return_value = False
|
||||
serie_b.has_logo.return_value = False
|
||||
serie_b.has_fanart.return_value = False
|
||||
serie_b.name = "B"
|
||||
serie_b.folder = "B"
|
||||
|
||||
with patch(
|
||||
"src.core.entities.SerieList.SerieList"
|
||||
) as mock_sl:
|
||||
mock_list = MagicMock()
|
||||
mock_list.get_all.return_value = [serie_a, serie_b]
|
||||
mock_sl.return_value = mock_list
|
||||
result = await check_nfo_status()
|
||||
|
||||
assert result == 0
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# update_nfo_files tests
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
class TestUpdateNfoFiles:
|
||||
"""Tests for update_nfo_files command."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_1_without_tmdb_key(self, mock_settings):
|
||||
"""Returns 1 when TMDB_API_KEY is missing."""
|
||||
mock_settings.tmdb_api_key = None
|
||||
result = await update_nfo_files()
|
||||
assert result == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_1_without_anime_directory(self, mock_settings):
|
||||
"""Returns 1 when ANIME_DIRECTORY is missing."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = None
|
||||
result = await update_nfo_files()
|
||||
assert result == 1
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_0_when_no_nfo_series(self, mock_settings):
|
||||
"""Returns 0 when no series have NFO files."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_download_poster = False
|
||||
mock_settings.nfo_download_logo = False
|
||||
mock_settings.nfo_download_fanart = False
|
||||
|
||||
serie = MagicMock()
|
||||
serie.has_nfo.return_value = False
|
||||
|
||||
with patch("src.core.entities.SerieList.SerieList") as mock_sl:
|
||||
mock_list = MagicMock()
|
||||
mock_list.get_all.return_value = [serie]
|
||||
mock_sl.return_value = mock_list
|
||||
result = await update_nfo_files()
|
||||
|
||||
assert result == 0
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.asyncio")
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_updates_series_with_nfo(self, mock_settings, mock_sleeper):
|
||||
"""Calls update_tvshow_nfo for each series with NFO."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_download_poster = True
|
||||
mock_settings.nfo_download_logo = False
|
||||
mock_settings.nfo_download_fanart = False
|
||||
mock_sleeper.sleep = AsyncMock()
|
||||
|
||||
serie = MagicMock()
|
||||
serie.has_nfo.return_value = True
|
||||
serie.name = "Naruto"
|
||||
serie.folder = "Naruto"
|
||||
|
||||
mock_nfo_svc = MagicMock()
|
||||
mock_nfo_svc.update_tvshow_nfo = AsyncMock()
|
||||
mock_nfo_svc.close = AsyncMock()
|
||||
|
||||
with patch("src.core.entities.SerieList.SerieList") as mock_sl:
|
||||
mock_list = MagicMock()
|
||||
mock_list.get_all.return_value = [serie]
|
||||
mock_sl.return_value = mock_list
|
||||
with patch(
|
||||
"src.core.services.nfo_factory.create_nfo_service",
|
||||
return_value=mock_nfo_svc,
|
||||
):
|
||||
result = await update_nfo_files()
|
||||
|
||||
assert result == 0
|
||||
mock_nfo_svc.update_tvshow_nfo.assert_awaited_once()
|
||||
mock_nfo_svc.close.assert_awaited_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
@patch("src.cli.nfo_cli.settings")
|
||||
async def test_returns_1_on_factory_error(self, mock_settings):
|
||||
"""Returns 1 when create_nfo_service raises ValueError."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_download_poster = False
|
||||
mock_settings.nfo_download_logo = False
|
||||
mock_settings.nfo_download_fanart = False
|
||||
|
||||
serie = MagicMock()
|
||||
serie.has_nfo.return_value = True
|
||||
|
||||
with patch("src.core.entities.SerieList.SerieList") as mock_sl:
|
||||
mock_list = MagicMock()
|
||||
mock_list.get_all.return_value = [serie]
|
||||
mock_sl.return_value = mock_list
|
||||
with patch(
|
||||
"src.core.services.nfo_factory.create_nfo_service",
|
||||
side_effect=ValueError("bad"),
|
||||
):
|
||||
result = await update_nfo_files()
|
||||
|
||||
assert result == 1
|
||||
@@ -1,307 +0,0 @@
|
||||
"""Unit tests for NFO tag creation — Task 0.
|
||||
|
||||
Verifies that ``tmdb_to_nfo_model`` populates every required NFO tag and
|
||||
that ``generate_tvshow_nfo`` writes all of them to the XML output.
|
||||
"""
|
||||
|
||||
from datetime import datetime
|
||||
from typing import Any, Dict, Optional
|
||||
from unittest.mock import patch
|
||||
|
||||
import pytest
|
||||
from lxml import etree
|
||||
|
||||
from src.core.entities.nfo_models import TVShowNFO
|
||||
from src.core.utils.nfo_generator import generate_tvshow_nfo
|
||||
from src.core.utils.nfo_mapper import _extract_rating_by_country, tmdb_to_nfo_model
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers / fixtures
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _fake_get_image_url(path: str, size: str) -> str:
|
||||
"""Minimal stand-in for TMDBClient.get_image_url used in tests."""
|
||||
return f"https://image.tmdb.org/t/p/{size}{path}"
|
||||
|
||||
|
||||
MINIMAL_TMDB: Dict[str, Any] = {
|
||||
"id": 12345,
|
||||
"name": "Test Show",
|
||||
"original_name": "テストショー",
|
||||
"overview": "A great overview.",
|
||||
"tagline": "The best tagline.",
|
||||
"first_air_date": "2023-04-01",
|
||||
"status": "Continuing",
|
||||
"episode_run_time": [24],
|
||||
"vote_average": 8.5,
|
||||
"vote_count": 200,
|
||||
"genres": [{"id": 1, "name": "Animation"}, {"id": 2, "name": "Action"}],
|
||||
"networks": [{"id": 10, "name": "AT-X"}],
|
||||
"origin_country": ["JP"],
|
||||
"production_countries": [],
|
||||
"external_ids": {"imdb_id": "tt1234567", "tvdb_id": 99999},
|
||||
"poster_path": "/poster.jpg",
|
||||
"backdrop_path": "/backdrop.jpg",
|
||||
"images": {"logos": [{"file_path": "/logo.png"}]},
|
||||
"credits": {
|
||||
"cast": [
|
||||
{
|
||||
"id": 1,
|
||||
"name": "Actor One",
|
||||
"character": "Hero",
|
||||
"profile_path": "/actor1.jpg",
|
||||
}
|
||||
]
|
||||
},
|
||||
}
|
||||
|
||||
CONTENT_RATINGS_DE_US: Dict[str, Any] = {
|
||||
"results": [
|
||||
{"iso_3166_1": "DE", "rating": "12"},
|
||||
{"iso_3166_1": "US", "rating": "TV-PG"},
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def nfo_model() -> TVShowNFO:
|
||||
"""Return a fully-populated TVShowNFO from MINIMAL_TMDB data."""
|
||||
return tmdb_to_nfo_model(MINIMAL_TMDB, CONTENT_RATINGS_DE_US, _fake_get_image_url)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# tmdb_to_nfo_model — field mapping tests
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_originaltitle(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.originaltitle == "テストショー"
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_year_from_first_air_date(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.year == 2023
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_plot_from_overview(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.plot == "A great overview."
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_runtime(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.runtime == 24
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_premiered(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.premiered == "2023-04-01"
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_status(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.status == "Continuing"
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_imdbid(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.imdbid == "tt1234567"
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_genres(nfo_model: TVShowNFO) -> None:
|
||||
assert "Animation" in nfo_model.genre
|
||||
assert "Action" in nfo_model.genre
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_studios_from_networks(nfo_model: TVShowNFO) -> None:
|
||||
assert "AT-X" in nfo_model.studio
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_country(nfo_model: TVShowNFO) -> None:
|
||||
assert "JP" in nfo_model.country
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_actors(nfo_model: TVShowNFO) -> None:
|
||||
assert len(nfo_model.actors) == 1
|
||||
assert nfo_model.actors[0].name == "Actor One"
|
||||
assert nfo_model.actors[0].role == "Hero"
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_watched_false(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.watched is False
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_tagline(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.tagline == "The best tagline."
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_outline_from_overview(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.outline == "A great overview."
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_sorttitle_from_name(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.sorttitle == "Test Show"
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_dateadded(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.dateadded is not None
|
||||
# Must match YYYY-MM-DD HH:MM:SS
|
||||
datetime.strptime(nfo_model.dateadded, "%Y-%m-%d %H:%M:%S")
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_mpaa_from_content_ratings(nfo_model: TVShowNFO) -> None:
|
||||
assert nfo_model.mpaa == "TV-PG"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# _extract_rating_by_country
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_extract_rating_by_country_returns_us_rating() -> None:
|
||||
ratings = {"results": [{"iso_3166_1": "US", "rating": "TV-14"}]}
|
||||
assert _extract_rating_by_country(ratings, "US") == "TV-14"
|
||||
|
||||
|
||||
def test_extract_rating_by_country_returns_none_when_no_match() -> None:
|
||||
ratings = {"results": [{"iso_3166_1": "DE", "rating": "12"}]}
|
||||
assert _extract_rating_by_country(ratings, "US") is None
|
||||
|
||||
|
||||
def test_extract_rating_by_country_handles_empty_results() -> None:
|
||||
assert _extract_rating_by_country({"results": []}, "US") is None
|
||||
assert _extract_rating_by_country({}, "US") is None
|
||||
assert _extract_rating_by_country(None, "US") is None # type: ignore[arg-type]
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# generate_tvshow_nfo — XML output tests
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _parse_xml(xml_str: str) -> etree._Element:
|
||||
return etree.fromstring(xml_str.encode("utf-8"))
|
||||
|
||||
|
||||
def test_generate_nfo_includes_all_required_tags(nfo_model: TVShowNFO) -> None:
|
||||
xml_str = generate_tvshow_nfo(nfo_model)
|
||||
root = _parse_xml(xml_str)
|
||||
|
||||
required = [
|
||||
"title", "originaltitle", "year", "plot", "runtime",
|
||||
"premiered", "status", "imdbid", "genre", "studio",
|
||||
"country", "actor", "watched", "tagline", "outline",
|
||||
"sorttitle", "dateadded",
|
||||
]
|
||||
for tag in required:
|
||||
elements = root.findall(f".//{tag}")
|
||||
assert elements, f"Missing required tag: <{tag}>"
|
||||
# At least one element must have non-empty text
|
||||
assert any(e.text for e in elements), f"Tag <{tag}> is empty"
|
||||
|
||||
|
||||
def test_generate_nfo_writes_watched_false(nfo_model: TVShowNFO) -> None:
|
||||
xml_str = generate_tvshow_nfo(nfo_model)
|
||||
root = _parse_xml(xml_str)
|
||||
watched = root.find(".//watched")
|
||||
assert watched is not None
|
||||
assert watched.text == "false"
|
||||
|
||||
|
||||
def test_generate_nfo_minimal_model_does_not_crash() -> None:
|
||||
minimal = TVShowNFO(title="Minimal Show")
|
||||
xml_str = generate_tvshow_nfo(minimal)
|
||||
assert "<title>Minimal Show</title>" in xml_str
|
||||
|
||||
|
||||
def test_generate_nfo_writes_fsk_over_mpaa_when_prefer_fsk() -> None:
|
||||
nfo = TVShowNFO(title="Test", fsk="FSK 16", mpaa="TV-MA")
|
||||
with patch("src.core.utils.nfo_generator.settings") as mock_settings:
|
||||
mock_settings.nfo_prefer_fsk_rating = True
|
||||
xml_str = generate_tvshow_nfo(nfo)
|
||||
root = _parse_xml(xml_str)
|
||||
mpaa_elem = root.find(".//mpaa")
|
||||
assert mpaa_elem is not None
|
||||
assert mpaa_elem.text == "FSK 16"
|
||||
|
||||
|
||||
def test_generate_nfo_writes_mpaa_when_no_fsk() -> None:
|
||||
nfo = TVShowNFO(title="Test", fsk=None, mpaa="TV-14")
|
||||
with patch("src.core.utils.nfo_generator.settings") as mock_settings:
|
||||
mock_settings.nfo_prefer_fsk_rating = True
|
||||
xml_str = generate_tvshow_nfo(nfo)
|
||||
root = _parse_xml(xml_str)
|
||||
mpaa_elem = root.find(".//mpaa")
|
||||
assert mpaa_elem is not None
|
||||
assert mpaa_elem.text == "TV-14"
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# showtitle and namedseason — new coverage
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_showtitle(nfo_model: TVShowNFO) -> None:
|
||||
"""showtitle must equal the main title."""
|
||||
assert nfo_model.showtitle == "Test Show"
|
||||
|
||||
|
||||
def test_generate_nfo_writes_showtitle(nfo_model: TVShowNFO) -> None:
|
||||
xml_str = generate_tvshow_nfo(nfo_model)
|
||||
root = _parse_xml(xml_str)
|
||||
elem = root.find(".//showtitle")
|
||||
assert elem is not None
|
||||
assert elem.text == "Test Show"
|
||||
|
||||
|
||||
TMDB_WITH_SEASONS: Dict[str, Any] = {
|
||||
**MINIMAL_TMDB,
|
||||
"seasons": [
|
||||
{"season_number": 0, "name": "Specials"},
|
||||
{"season_number": 1, "name": "Season 1"},
|
||||
{"season_number": 2, "name": "Season 2"},
|
||||
],
|
||||
}
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_sets_namedseasons() -> None:
|
||||
model = tmdb_to_nfo_model(
|
||||
TMDB_WITH_SEASONS, CONTENT_RATINGS_DE_US, _fake_get_image_url,
|
||||
)
|
||||
assert len(model.namedseason) == 3
|
||||
assert model.namedseason[0].number == 0
|
||||
assert model.namedseason[0].name == "Specials"
|
||||
assert model.namedseason[1].number == 1
|
||||
|
||||
|
||||
def test_generate_nfo_writes_namedseasons() -> None:
|
||||
model = tmdb_to_nfo_model(
|
||||
TMDB_WITH_SEASONS, CONTENT_RATINGS_DE_US, _fake_get_image_url,
|
||||
)
|
||||
xml_str = generate_tvshow_nfo(model)
|
||||
root = _parse_xml(xml_str)
|
||||
elems = root.findall(".//namedseason")
|
||||
assert len(elems) == 3
|
||||
assert elems[0].get("number") == "0"
|
||||
assert elems[0].text == "Specials"
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_no_seasons_key() -> None:
|
||||
"""No 'seasons' key in TMDB data → namedseason list is empty."""
|
||||
model = tmdb_to_nfo_model(
|
||||
MINIMAL_TMDB, CONTENT_RATINGS_DE_US, _fake_get_image_url,
|
||||
)
|
||||
assert model.namedseason == []
|
||||
|
||||
|
||||
def test_tmdb_to_nfo_model_empty_overview_produces_none_plot() -> None:
|
||||
"""When overview is empty the plot field should be None."""
|
||||
data = {**MINIMAL_TMDB, "overview": ""}
|
||||
model = tmdb_to_nfo_model(
|
||||
data, CONTENT_RATINGS_DE_US, _fake_get_image_url,
|
||||
)
|
||||
assert model.plot is None
|
||||
|
||||
|
||||
def test_generate_nfo_always_writes_plot_tag_even_when_none() -> None:
|
||||
"""<plot> must always appear, even when plot is None."""
|
||||
nfo = TVShowNFO(title="No Plot Show")
|
||||
xml_str = generate_tvshow_nfo(nfo)
|
||||
root = _parse_xml(xml_str)
|
||||
plot_elem = root.find(".//plot")
|
||||
assert plot_elem is not None # tag exists (always_write=True)
|
||||
@@ -1,120 +0,0 @@
|
||||
"""Tests for NFO service dependency with config fallback.
|
||||
|
||||
Tests that get_nfo_service() correctly loads TMDB API key from config.json
|
||||
when it's not in settings (e.g., after server reload in development).
|
||||
"""
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
from fastapi import HTTPException
|
||||
|
||||
from src.config.settings import settings
|
||||
from src.server.api.nfo import get_nfo_service
|
||||
from src.server.models.config import AppConfig, NFOConfig
|
||||
|
||||
|
||||
def _reset_factory_cache():
|
||||
"""Reset the NFO factory singleton so each test gets a clean factory."""
|
||||
import src.core.services.nfo_factory as factory_mod
|
||||
factory_mod._factory_instance = None
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_nfo_service_with_settings_tmdb_key():
|
||||
"""Test get_nfo_service when TMDB key is in settings."""
|
||||
_reset_factory_cache()
|
||||
original_key = settings.tmdb_api_key
|
||||
settings.tmdb_api_key = "test_api_key_from_settings"
|
||||
|
||||
try:
|
||||
nfo_service = await get_nfo_service()
|
||||
assert nfo_service is not None
|
||||
assert nfo_service.tmdb_client.api_key == "test_api_key_from_settings"
|
||||
finally:
|
||||
settings.tmdb_api_key = original_key
|
||||
_reset_factory_cache()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_nfo_service_fallback_to_config():
|
||||
"""Test get_nfo_service falls back to config.json when key not in settings."""
|
||||
_reset_factory_cache()
|
||||
original_key = settings.tmdb_api_key
|
||||
settings.tmdb_api_key = None
|
||||
|
||||
try:
|
||||
mock_config = AppConfig(
|
||||
name="Test",
|
||||
data_dir="data",
|
||||
nfo=NFOConfig(
|
||||
tmdb_api_key="test_api_key_from_config",
|
||||
auto_create=False,
|
||||
update_on_scan=False
|
||||
)
|
||||
)
|
||||
|
||||
with patch('src.server.services.config_service.get_config_service') as mock_get_config:
|
||||
mock_config_service = MagicMock()
|
||||
mock_config_service.load_config.return_value = mock_config
|
||||
mock_get_config.return_value = mock_config_service
|
||||
|
||||
nfo_service = await get_nfo_service()
|
||||
assert nfo_service is not None
|
||||
assert nfo_service.tmdb_client.api_key == "test_api_key_from_config"
|
||||
finally:
|
||||
settings.tmdb_api_key = original_key
|
||||
_reset_factory_cache()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_nfo_service_no_key_raises_503():
|
||||
"""Test get_nfo_service raises 503 when no TMDB key available."""
|
||||
_reset_factory_cache()
|
||||
original_key = settings.tmdb_api_key
|
||||
settings.tmdb_api_key = None
|
||||
|
||||
try:
|
||||
mock_config = AppConfig(
|
||||
name="Test",
|
||||
data_dir="data",
|
||||
nfo=NFOConfig(
|
||||
tmdb_api_key=None,
|
||||
auto_create=False,
|
||||
update_on_scan=False
|
||||
)
|
||||
)
|
||||
|
||||
with patch('src.server.services.config_service.get_config_service') as mock_get_config:
|
||||
mock_config_service = MagicMock()
|
||||
mock_config_service.load_config.return_value = mock_config
|
||||
mock_get_config.return_value = mock_config_service
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await get_nfo_service()
|
||||
|
||||
assert exc_info.value.status_code == 503
|
||||
assert "TMDB API key not configured" in exc_info.value.detail
|
||||
finally:
|
||||
settings.tmdb_api_key = original_key
|
||||
_reset_factory_cache()
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_get_nfo_service_config_load_fails_raises_503():
|
||||
"""Test get_nfo_service raises 503 when config loading fails."""
|
||||
_reset_factory_cache()
|
||||
original_key = settings.tmdb_api_key
|
||||
settings.tmdb_api_key = None
|
||||
|
||||
try:
|
||||
with patch('src.server.services.config_service.get_config_service') as mock_get_config:
|
||||
mock_get_config.side_effect = Exception("Config file not found")
|
||||
|
||||
with pytest.raises(HTTPException) as exc_info:
|
||||
await get_nfo_service()
|
||||
|
||||
assert exc_info.value.status_code == 503
|
||||
assert "TMDB API key not configured" in exc_info.value.detail
|
||||
finally:
|
||||
settings.tmdb_api_key = original_key
|
||||
_reset_factory_cache()
|
||||
@@ -1,189 +0,0 @@
|
||||
"""Unit tests for NFO service factory module.
|
||||
|
||||
Tests factory instantiation, configuration precedence, singleton pattern,
|
||||
and convenience functions for creating NFOService instances.
|
||||
"""
|
||||
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.services.nfo_factory import (
|
||||
NFOServiceFactory,
|
||||
create_nfo_service,
|
||||
get_nfo_factory,
|
||||
)
|
||||
|
||||
|
||||
class TestNFOServiceFactoryCreate:
|
||||
"""Tests for NFOServiceFactory.create method."""
|
||||
|
||||
@patch("src.core.services.nfo_factory.NFOService")
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_create_with_explicit_api_key(self, mock_settings, mock_nfo_cls):
|
||||
"""Explicit API key takes priority over settings."""
|
||||
mock_settings.tmdb_api_key = "settings_key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_image_size = "original"
|
||||
mock_settings.nfo_auto_create = False
|
||||
|
||||
factory = NFOServiceFactory()
|
||||
factory.create(tmdb_api_key="explicit_key")
|
||||
mock_nfo_cls.assert_called_once_with(
|
||||
tmdb_api_key="explicit_key",
|
||||
anime_directory="/anime",
|
||||
image_size="original",
|
||||
auto_create=False,
|
||||
)
|
||||
|
||||
@patch("src.core.services.nfo_factory.NFOService")
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_create_falls_back_to_settings(self, mock_settings, mock_nfo_cls):
|
||||
"""Falls back to settings when no explicit key provided."""
|
||||
mock_settings.tmdb_api_key = "settings_key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_image_size = "w500"
|
||||
mock_settings.nfo_auto_create = True
|
||||
|
||||
factory = NFOServiceFactory()
|
||||
factory.create()
|
||||
mock_nfo_cls.assert_called_once_with(
|
||||
tmdb_api_key="settings_key",
|
||||
anime_directory="/anime",
|
||||
image_size="w500",
|
||||
auto_create=True,
|
||||
)
|
||||
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_create_raises_without_api_key(self, mock_settings):
|
||||
"""Raises ValueError when no API key available from any source."""
|
||||
mock_settings.tmdb_api_key = None
|
||||
factory = NFOServiceFactory()
|
||||
factory._get_api_key_from_config = MagicMock(return_value=None)
|
||||
with pytest.raises(ValueError, match="TMDB API key not configured"):
|
||||
factory.create()
|
||||
|
||||
@patch("src.core.services.nfo_factory.NFOService")
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_create_with_all_custom_params(self, mock_settings, mock_nfo_cls):
|
||||
"""All parameters can be overridden."""
|
||||
mock_settings.tmdb_api_key = "default"
|
||||
mock_settings.anime_directory = "/default"
|
||||
mock_settings.nfo_image_size = "original"
|
||||
mock_settings.nfo_auto_create = False
|
||||
|
||||
factory = NFOServiceFactory()
|
||||
factory.create(
|
||||
tmdb_api_key="custom",
|
||||
anime_directory="/custom",
|
||||
image_size="w300",
|
||||
auto_create=True,
|
||||
)
|
||||
mock_nfo_cls.assert_called_once_with(
|
||||
tmdb_api_key="custom",
|
||||
anime_directory="/custom",
|
||||
image_size="w300",
|
||||
auto_create=True,
|
||||
)
|
||||
|
||||
@patch("src.core.services.nfo_factory.NFOService")
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_create_uses_config_json_fallback(self, mock_settings, mock_nfo_cls):
|
||||
"""Falls back to config.json when settings has no key."""
|
||||
mock_settings.tmdb_api_key = None
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_image_size = "original"
|
||||
mock_settings.nfo_auto_create = False
|
||||
|
||||
factory = NFOServiceFactory()
|
||||
factory._get_api_key_from_config = MagicMock(return_value="config_key")
|
||||
factory.create()
|
||||
mock_nfo_cls.assert_called_once()
|
||||
call_kwargs = mock_nfo_cls.call_args[1]
|
||||
assert call_kwargs["tmdb_api_key"] == "config_key"
|
||||
|
||||
|
||||
class TestNFOServiceFactoryCreateOptional:
|
||||
"""Tests for NFOServiceFactory.create_optional method."""
|
||||
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_returns_none_without_api_key(self, mock_settings):
|
||||
"""Returns None instead of raising when no API key."""
|
||||
mock_settings.tmdb_api_key = None
|
||||
factory = NFOServiceFactory()
|
||||
factory._get_api_key_from_config = MagicMock(return_value=None)
|
||||
result = factory.create_optional()
|
||||
assert result is None
|
||||
|
||||
@patch("src.core.services.nfo_factory.NFOService")
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_returns_service_when_configured(self, mock_settings, mock_nfo_cls):
|
||||
"""Returns NFOService when configuration is available."""
|
||||
mock_settings.tmdb_api_key = "key123"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_image_size = "original"
|
||||
mock_settings.nfo_auto_create = False
|
||||
|
||||
factory = NFOServiceFactory()
|
||||
result = factory.create_optional()
|
||||
assert result is not None
|
||||
|
||||
|
||||
class TestGetNfoFactory:
|
||||
"""Tests for get_nfo_factory singleton function."""
|
||||
|
||||
def test_returns_factory_instance(self):
|
||||
"""Returns an NFOServiceFactory instance."""
|
||||
import src.core.services.nfo_factory as mod
|
||||
old = mod._factory_instance
|
||||
try:
|
||||
mod._factory_instance = None
|
||||
factory = get_nfo_factory()
|
||||
assert isinstance(factory, NFOServiceFactory)
|
||||
finally:
|
||||
mod._factory_instance = old
|
||||
|
||||
def test_returns_same_instance(self):
|
||||
"""Repeated calls return the same singleton."""
|
||||
import src.core.services.nfo_factory as mod
|
||||
old = mod._factory_instance
|
||||
try:
|
||||
mod._factory_instance = None
|
||||
f1 = get_nfo_factory()
|
||||
f2 = get_nfo_factory()
|
||||
assert f1 is f2
|
||||
finally:
|
||||
mod._factory_instance = old
|
||||
|
||||
|
||||
class TestCreateNfoService:
|
||||
"""Tests for create_nfo_service convenience function."""
|
||||
|
||||
@patch("src.core.services.nfo_factory.NFOService")
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_convenience_function_creates_service(
|
||||
self, mock_settings, mock_nfo_cls
|
||||
):
|
||||
"""Convenience function delegates to factory.create()."""
|
||||
mock_settings.tmdb_api_key = "key"
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.nfo_image_size = "original"
|
||||
mock_settings.nfo_auto_create = False
|
||||
|
||||
result = create_nfo_service()
|
||||
mock_nfo_cls.assert_called_once()
|
||||
|
||||
@patch("src.core.services.nfo_factory.settings")
|
||||
def test_convenience_function_raises_without_key(self, mock_settings):
|
||||
"""Convenience function raises ValueError without key."""
|
||||
mock_settings.tmdb_api_key = None
|
||||
import src.core.services.nfo_factory as mod
|
||||
old = mod._factory_instance
|
||||
try:
|
||||
mod._factory_instance = None
|
||||
factory = get_nfo_factory()
|
||||
factory._get_api_key_from_config = MagicMock(return_value=None)
|
||||
with pytest.raises(ValueError):
|
||||
factory.create()
|
||||
finally:
|
||||
mod._factory_instance = old
|
||||
@@ -1,405 +0,0 @@
|
||||
"""Unit tests for NFO generator."""
|
||||
|
||||
import pytest
|
||||
from lxml import etree
|
||||
|
||||
from src.core.entities.nfo_models import (
|
||||
ActorInfo,
|
||||
ImageInfo,
|
||||
RatingInfo,
|
||||
TVShowNFO,
|
||||
UniqueID,
|
||||
)
|
||||
from src.core.utils.nfo_generator import generate_tvshow_nfo, validate_nfo_xml
|
||||
|
||||
|
||||
class TestGenerateTVShowNFO:
|
||||
"""Test generate_tvshow_nfo function."""
|
||||
|
||||
def test_generate_minimal_nfo(self):
|
||||
"""Test generation with minimal required fields."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
plot="A test show"
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Actual implementation uses 'standalone="yes"' in declaration
|
||||
assert xml_string.startswith('<?xml version="1.0" encoding="UTF-8" standalone="yes"?>')
|
||||
assert "<title>Test Show</title>" in xml_string
|
||||
assert "<plot>A test show</plot>" in xml_string
|
||||
|
||||
def test_generate_complete_nfo(self):
|
||||
"""Test generation with all fields populated."""
|
||||
nfo = TVShowNFO(
|
||||
title="Complete Show",
|
||||
originaltitle="Original Title",
|
||||
year=2020,
|
||||
plot="Complete test",
|
||||
runtime=45,
|
||||
premiered="2020-01-15",
|
||||
status="Continuing",
|
||||
genre=["Action", "Drama"],
|
||||
studio=["Studio 1"],
|
||||
country=["USA"],
|
||||
ratings=[RatingInfo(
|
||||
name="themoviedb",
|
||||
value=8.5,
|
||||
votes=1000,
|
||||
max_rating=10,
|
||||
default=True
|
||||
)],
|
||||
actors=[ActorInfo(
|
||||
name="Test Actor",
|
||||
role="Main Character"
|
||||
)],
|
||||
thumb=[ImageInfo(url="https://test.com/poster.jpg")],
|
||||
uniqueid=[UniqueID(type="tmdb", value="12345")]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Verify all elements present
|
||||
assert "<title>Complete Show</title>" in xml_string
|
||||
assert "<originaltitle>Original Title</originaltitle>" in xml_string
|
||||
assert "<year>2020</year>" in xml_string
|
||||
assert "<runtime>45</runtime>" in xml_string
|
||||
assert "<premiered>2020-01-15</premiered>" in xml_string
|
||||
assert "<status>Continuing</status>" in xml_string
|
||||
assert "<genre>Action</genre>" in xml_string
|
||||
assert "<genre>Drama</genre>" in xml_string
|
||||
assert "<studio>Studio 1</studio>" in xml_string
|
||||
assert "<country>USA</country>" in xml_string
|
||||
assert "<name>Test Actor</name>" in xml_string
|
||||
assert "<role>Main Character</role>" in xml_string
|
||||
|
||||
def test_generate_nfo_with_ratings(self):
|
||||
"""Test NFO with multiple ratings."""
|
||||
nfo = TVShowNFO(
|
||||
title="Rated Show",
|
||||
plot="Test",
|
||||
ratings=[
|
||||
RatingInfo(
|
||||
name="themoviedb",
|
||||
value=8.5,
|
||||
votes=1000,
|
||||
max_rating=10,
|
||||
default=True
|
||||
),
|
||||
RatingInfo(
|
||||
name="imdb",
|
||||
value=8.2,
|
||||
votes=5000,
|
||||
max_rating=10,
|
||||
default=False
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
assert '<ratings>' in xml_string
|
||||
# Actual implementation includes max attribute and only adds default when True
|
||||
assert '<rating name="themoviedb" max="10" default="true">' in xml_string
|
||||
assert '<value>8.5</value>' in xml_string
|
||||
assert '<votes>1000</votes>' in xml_string
|
||||
assert '<rating name="imdb" max="10">' in xml_string
|
||||
|
||||
def test_generate_nfo_with_actors(self):
|
||||
"""Test NFO with multiple actors."""
|
||||
nfo = TVShowNFO(
|
||||
title="Cast Show",
|
||||
plot="Test",
|
||||
actors=[
|
||||
ActorInfo(name="Actor 1", role="Hero"),
|
||||
ActorInfo(name="Actor 2", role="Villain", thumb="https://test.com/actor2.jpg")
|
||||
]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
assert '<actor>' in xml_string
|
||||
assert '<name>Actor 1</name>' in xml_string
|
||||
assert '<role>Hero</role>' in xml_string
|
||||
assert '<name>Actor 2</name>' in xml_string
|
||||
assert '<thumb>https://test.com/actor2.jpg</thumb>' in xml_string
|
||||
|
||||
def test_generate_nfo_with_images(self):
|
||||
"""Test NFO with various image types."""
|
||||
nfo = TVShowNFO(
|
||||
title="Image Show",
|
||||
plot="Test",
|
||||
thumb=[
|
||||
ImageInfo(url="https://test.com/poster.jpg", aspect="poster"),
|
||||
ImageInfo(url="https://test.com/logo.png", aspect="clearlogo")
|
||||
],
|
||||
fanart=[
|
||||
ImageInfo(url="https://test.com/fanart.jpg")
|
||||
]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
assert '<thumb aspect="poster">https://test.com/poster.jpg</thumb>' in xml_string
|
||||
assert '<thumb aspect="clearlogo">https://test.com/logo.png</thumb>' in xml_string
|
||||
assert '<fanart>' in xml_string
|
||||
assert 'https://test.com/fanart.jpg' in xml_string
|
||||
|
||||
def test_generate_nfo_with_unique_ids(self):
|
||||
"""Test NFO with multiple unique IDs."""
|
||||
nfo = TVShowNFO(
|
||||
title="ID Show",
|
||||
plot="Test",
|
||||
uniqueid=[
|
||||
UniqueID(type="tmdb", value="12345", default=False),
|
||||
UniqueID(type="tvdb", value="67890", default=True),
|
||||
UniqueID(type="imdb", value="tt1234567", default=False)
|
||||
]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Actual implementation only adds default="true" when default is True, omits attribute when False
|
||||
assert '<uniqueid type="tmdb">12345</uniqueid>' in xml_string
|
||||
assert '<uniqueid type="tvdb" default="true">67890</uniqueid>' in xml_string
|
||||
assert '<uniqueid type="imdb">tt1234567</uniqueid>' in xml_string
|
||||
|
||||
def test_generate_nfo_escapes_special_chars(self):
|
||||
"""Test that special XML characters are escaped."""
|
||||
nfo = TVShowNFO(
|
||||
title="Show <with> & special \"chars\"",
|
||||
plot="Plot with <tags> & ampersand"
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# XML should escape special characters
|
||||
assert "<" in xml_string or "<title>" in xml_string
|
||||
assert "&" in xml_string or "&" in xml_string
|
||||
|
||||
def test_generate_nfo_valid_xml(self):
|
||||
"""Test that generated XML is valid."""
|
||||
nfo = TVShowNFO(
|
||||
title="Valid Show",
|
||||
plot="Test",
|
||||
year=2020,
|
||||
genre=["Action"],
|
||||
ratings=[RatingInfo(name="test", value=8.0)]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Should be parseable as XML
|
||||
root = etree.fromstring(xml_string.encode('utf-8'))
|
||||
assert root.tag == "tvshow"
|
||||
|
||||
def test_generate_nfo_none_values_omitted(self):
|
||||
"""Test that None values are omitted from XML."""
|
||||
nfo = TVShowNFO(
|
||||
title="Sparse Show",
|
||||
plot="Test",
|
||||
year=None,
|
||||
runtime=None,
|
||||
premiered=None
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# None values should not appear in XML
|
||||
assert "<year>" not in xml_string
|
||||
assert "<runtime>" not in xml_string
|
||||
assert "<premiered>" not in xml_string
|
||||
|
||||
|
||||
class TestValidateNFOXML:
|
||||
"""Test validate_nfo_xml function."""
|
||||
|
||||
def test_validate_valid_xml(self):
|
||||
"""Test validation of valid XML."""
|
||||
nfo = TVShowNFO(title="Test", plot="Test")
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Should not raise exception
|
||||
validate_nfo_xml(xml_string)
|
||||
|
||||
def test_validate_invalid_xml(self):
|
||||
"""Test validation of invalid XML."""
|
||||
invalid_xml = "<?xml version='1.0'?><tvshow><title>Unclosed"
|
||||
|
||||
# validate_nfo_xml returns False for invalid XML, doesn't raise
|
||||
result = validate_nfo_xml(invalid_xml)
|
||||
assert result is False
|
||||
|
||||
def test_validate_missing_tvshow_root(self):
|
||||
"""Test validation accepts any well-formed XML (doesn't check root)."""
|
||||
valid_xml = '<?xml version="1.0"?><movie><title>Test</title></movie>'
|
||||
|
||||
# validate_nfo_xml only checks if XML is well-formed, not structure
|
||||
result = validate_nfo_xml(valid_xml)
|
||||
assert result is True
|
||||
|
||||
def test_validate_empty_string(self):
|
||||
"""Test validation rejects empty string."""
|
||||
result = validate_nfo_xml("")
|
||||
assert result is False
|
||||
|
||||
def test_validate_well_formed_structure(self):
|
||||
"""Test validation accepts well-formed structure."""
|
||||
xml = """<?xml version="1.0" encoding="UTF-8"?>
|
||||
<tvshow>
|
||||
<title>Test Show</title>
|
||||
<plot>Test plot</plot>
|
||||
<year>2020</year>
|
||||
</tvshow>
|
||||
"""
|
||||
|
||||
validate_nfo_xml(xml)
|
||||
|
||||
|
||||
class TestNFOGeneratorEdgeCases:
|
||||
"""Test edge cases in NFO generation."""
|
||||
|
||||
def test_empty_lists(self):
|
||||
"""Test generation with empty lists."""
|
||||
nfo = TVShowNFO(
|
||||
title="Empty Lists",
|
||||
plot="Test",
|
||||
genre=[],
|
||||
studio=[],
|
||||
actors=[]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Should generate valid XML even with empty lists
|
||||
root = etree.fromstring(xml_string.encode('utf-8'))
|
||||
assert root.tag == "tvshow"
|
||||
|
||||
def test_unicode_characters(self):
|
||||
"""Test handling of Unicode characters."""
|
||||
nfo = TVShowNFO(
|
||||
title="アニメ Show 中文",
|
||||
plot="Plot with émojis 🎬 and spëcial çhars"
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Should encode Unicode properly
|
||||
assert "アニメ" in xml_string
|
||||
assert "中文" in xml_string
|
||||
assert "émojis" in xml_string
|
||||
|
||||
def test_very_long_plot(self):
|
||||
"""Test handling of very long plot text."""
|
||||
long_plot = "A" * 10000
|
||||
nfo = TVShowNFO(
|
||||
title="Long Plot",
|
||||
plot=long_plot
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
assert long_plot in xml_string
|
||||
|
||||
def test_multiple_studios(self):
|
||||
"""Test handling multiple studios."""
|
||||
nfo = TVShowNFO(
|
||||
title="Multi Studio",
|
||||
plot="Test",
|
||||
studio=["Studio A", "Studio B", "Studio C"]
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
assert xml_string.count("<studio>") == 3
|
||||
assert "<studio>Studio A</studio>" in xml_string
|
||||
assert "<studio>Studio B</studio>" in xml_string
|
||||
assert "<studio>Studio C</studio>" in xml_string
|
||||
|
||||
def test_special_date_formats(self):
|
||||
"""Test various date format inputs."""
|
||||
nfo = TVShowNFO(
|
||||
title="Date Test",
|
||||
plot="Test",
|
||||
premiered="2020-01-01"
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
assert "<premiered>2020-01-01</premiered>" in xml_string
|
||||
|
||||
|
||||
class TestFSKRatingGeneration:
|
||||
"""Test FSK rating generation in NFO XML."""
|
||||
|
||||
def test_generate_nfo_with_fsk_rating(self):
|
||||
"""Test NFO generation with FSK rating."""
|
||||
nfo = TVShowNFO(
|
||||
title="FSK Show",
|
||||
plot="Test",
|
||||
fsk="FSK 12",
|
||||
mpaa="TV-14"
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Should use FSK rating when available and preferred (default)
|
||||
assert "<mpaa>FSK 12</mpaa>" in xml_string
|
||||
|
||||
def test_generate_nfo_fsk_preferred_over_mpaa(self):
|
||||
"""Test that FSK is preferred over MPAA when both present."""
|
||||
nfo = TVShowNFO(
|
||||
title="FSK Priority Show",
|
||||
plot="Test",
|
||||
fsk="FSK 16",
|
||||
mpaa="TV-MA"
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# FSK should be in mpaa tag, not TV-MA
|
||||
assert "<mpaa>FSK 16</mpaa>" in xml_string
|
||||
assert "TV-MA" not in xml_string
|
||||
|
||||
def test_generate_nfo_fallback_to_mpaa(self):
|
||||
"""Test fallback to MPAA when FSK not available."""
|
||||
nfo = TVShowNFO(
|
||||
title="MPAA Show",
|
||||
plot="Test",
|
||||
fsk=None,
|
||||
mpaa="TV-PG"
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# Should use MPAA when FSK not available
|
||||
assert "<mpaa>TV-PG</mpaa>" in xml_string
|
||||
|
||||
def test_generate_nfo_with_all_fsk_values(self):
|
||||
"""Test NFO generation with all possible FSK values."""
|
||||
fsk_values = ["FSK 0", "FSK 6", "FSK 12", "FSK 16", "FSK 18"]
|
||||
|
||||
for fsk in fsk_values:
|
||||
nfo = TVShowNFO(
|
||||
title=f"FSK {fsk} Show",
|
||||
plot="Test",
|
||||
fsk=fsk
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
assert f"<mpaa>{fsk}</mpaa>" in xml_string
|
||||
|
||||
def test_generate_nfo_no_rating(self):
|
||||
"""Test NFO generation when neither FSK nor MPAA is available."""
|
||||
nfo = TVShowNFO(
|
||||
title="No Rating Show",
|
||||
plot="Test",
|
||||
fsk=None,
|
||||
mpaa=None
|
||||
)
|
||||
|
||||
xml_string = generate_tvshow_nfo(nfo)
|
||||
|
||||
# mpaa tag should not be present
|
||||
assert "<mpaa>" not in xml_string
|
||||
@@ -1,198 +0,0 @@
|
||||
"""Unit tests for NFO ID parsing functionality."""
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.services.nfo_service import NFOService
|
||||
|
||||
|
||||
class TestNFOIDParsing:
|
||||
"""Test NFO ID parsing from XML files."""
|
||||
|
||||
@pytest.fixture
|
||||
def nfo_service(self):
|
||||
"""Create NFO service for testing."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_key",
|
||||
anime_directory=tmpdir,
|
||||
auto_create=False
|
||||
)
|
||||
yield service
|
||||
|
||||
@pytest.fixture
|
||||
def temp_nfo_file(self):
|
||||
"""Create a temporary NFO file for testing."""
|
||||
with tempfile.NamedTemporaryFile(
|
||||
mode='w',
|
||||
suffix='.nfo',
|
||||
delete=False,
|
||||
encoding='utf-8'
|
||||
) as f:
|
||||
nfo_path = Path(f.name)
|
||||
yield nfo_path
|
||||
# Cleanup
|
||||
if nfo_path.exists():
|
||||
nfo_path.unlink()
|
||||
|
||||
def test_parse_nfo_ids_with_uniqueid_elements(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing IDs from uniqueid elements."""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<tvshow>
|
||||
<title>Attack on Titan</title>
|
||||
<uniqueid type="tmdb" default="true">1429</uniqueid>
|
||||
<uniqueid type="tvdb">295739</uniqueid>
|
||||
<uniqueid type="imdb">tt2560140</uniqueid>
|
||||
</tvshow>"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
assert result["tmdb_id"] == 1429
|
||||
assert result["tvdb_id"] == 295739
|
||||
|
||||
def test_parse_nfo_ids_with_dedicated_elements(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing IDs from dedicated tmdbid/tvdbid elements."""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<tvshow>
|
||||
<title>One Piece</title>
|
||||
<tmdbid>37854</tmdbid>
|
||||
<tvdbid>81797</tvdbid>
|
||||
</tvshow>"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
assert result["tmdb_id"] == 37854
|
||||
assert result["tvdb_id"] == 81797
|
||||
|
||||
def test_parse_nfo_ids_mixed_formats(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing with both uniqueid and dedicated elements.
|
||||
|
||||
uniqueid elements should take precedence.
|
||||
"""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<tvshow>
|
||||
<title>Naruto</title>
|
||||
<uniqueid type="tmdb" default="true">31910</uniqueid>
|
||||
<tmdbid>99999</tmdbid>
|
||||
<tvdbid>78857</tvdbid>
|
||||
</tvshow>"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
# uniqueid should take precedence over tmdbid element
|
||||
assert result["tmdb_id"] == 31910
|
||||
assert result["tvdb_id"] == 78857
|
||||
|
||||
def test_parse_nfo_ids_only_tmdb(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing when only TMDB ID is present."""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<tvshow>
|
||||
<title>Dragon Ball Z</title>
|
||||
<uniqueid type="tmdb" default="true">1553</uniqueid>
|
||||
</tvshow>"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
assert result["tmdb_id"] == 1553
|
||||
assert result["tvdb_id"] is None
|
||||
|
||||
def test_parse_nfo_ids_only_tvdb(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing when only TVDB ID is present."""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<tvshow>
|
||||
<title>Bleach</title>
|
||||
<uniqueid type="tvdb" default="true">74796</uniqueid>
|
||||
</tvshow>"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
assert result["tmdb_id"] is None
|
||||
assert result["tvdb_id"] == 74796
|
||||
|
||||
def test_parse_nfo_ids_no_ids(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing when no IDs are present."""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<tvshow>
|
||||
<title>Unknown Series</title>
|
||||
<plot>A series without any IDs.</plot>
|
||||
</tvshow>"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
assert result["tmdb_id"] is None
|
||||
assert result["tvdb_id"] is None
|
||||
|
||||
def test_parse_nfo_ids_invalid_id_format(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing with invalid ID formats (non-numeric)."""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
|
||||
<tvshow>
|
||||
<title>Invalid IDs</title>
|
||||
<uniqueid type="tmdb" default="true">not_a_number</uniqueid>
|
||||
<uniqueid type="tvdb">also_invalid</uniqueid>
|
||||
</tvshow>"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
# Should return None for invalid formats instead of crashing
|
||||
assert result["tmdb_id"] is None
|
||||
assert result["tvdb_id"] is None
|
||||
|
||||
def test_parse_nfo_ids_file_not_found(self, nfo_service):
|
||||
"""Test parsing when NFO file doesn't exist."""
|
||||
non_existent = Path("/tmp/non_existent_nfo_file.nfo")
|
||||
|
||||
result = nfo_service.parse_nfo_ids(non_existent)
|
||||
|
||||
assert result["tmdb_id"] is None
|
||||
assert result["tvdb_id"] is None
|
||||
|
||||
def test_parse_nfo_ids_invalid_xml(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing with invalid XML."""
|
||||
nfo_content = """<?xml version="1.0" encoding="UTF-8"?>
|
||||
<tvshow>
|
||||
<title>Broken XML
|
||||
<!-- Missing closing tags -->
|
||||
"""
|
||||
temp_nfo_file.write_text(nfo_content, encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
# Should handle error gracefully and return None values
|
||||
assert result["tmdb_id"] is None
|
||||
assert result["tvdb_id"] is None
|
||||
|
||||
def test_parse_nfo_ids_empty_file(
|
||||
self, nfo_service, temp_nfo_file
|
||||
):
|
||||
"""Test parsing an empty file."""
|
||||
temp_nfo_file.write_text("", encoding='utf-8')
|
||||
|
||||
result = nfo_service.parse_nfo_ids(temp_nfo_file)
|
||||
|
||||
assert result["tmdb_id"] is None
|
||||
assert result["tvdb_id"] is None
|
||||
@@ -1,240 +0,0 @@
|
||||
"""Unit tests for minimal NFO creation when TMDB fails.
|
||||
|
||||
Tests the fallback behavior when TMDB lookup fails and we need to create
|
||||
a minimal NFO file just to track the series.
|
||||
"""
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.services.nfo_service import NFOService
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def nfo_service(tmp_path):
|
||||
"""Create NFO service with test directory.
|
||||
|
||||
Note: anime_directory is set to tmp_path directly (not tmp_path / "anime")
|
||||
because tmp_path already represents the test anime directory.
|
||||
"""
|
||||
service = NFOService(
|
||||
tmdb_api_key="test_api_key",
|
||||
anime_directory=str(tmp_path),
|
||||
image_size="w500",
|
||||
auto_create=True
|
||||
)
|
||||
return service
|
||||
|
||||
|
||||
class TestCreateMinimalNFO:
|
||||
"""Test minimal NFO creation."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_minimal_nfo_basic(self, nfo_service, tmp_path):
|
||||
"""Test creating minimal NFO with just title."""
|
||||
# Setup - anime_directory is already tmp_path
|
||||
serie_folder = "Test Series"
|
||||
|
||||
# Create minimal NFO
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Test Series",
|
||||
serie_folder=serie_folder
|
||||
)
|
||||
|
||||
# Verify
|
||||
assert nfo_path.exists()
|
||||
assert nfo_path.name == "tvshow.nfo"
|
||||
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
assert "<title>Test Series</title>" in content
|
||||
assert "No metadata available" in content
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_minimal_nfo_with_year(self, nfo_service, tmp_path):
|
||||
"""Test creating minimal NFO with year."""
|
||||
# Setup - anime_directory is already tmp_path
|
||||
serie_folder = "Test Series (2024)"
|
||||
|
||||
# Create minimal NFO with explicit year
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Test Series",
|
||||
serie_folder=serie_folder,
|
||||
year=2024
|
||||
)
|
||||
|
||||
# Verify
|
||||
assert nfo_path.exists()
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
assert "<title>Test Series</title>" in content
|
||||
assert "<year>2024</year>" in content
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_minimal_nfo_extracts_year_from_name(self, nfo_service, tmp_path):
|
||||
"""Test that year is extracted from series name format (YYYY)."""
|
||||
# Setup - anime_directory is already tmp_path
|
||||
serie_folder = "Test Series (2024)"
|
||||
|
||||
# Create with name that has year
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Test Series (2024)",
|
||||
serie_folder=serie_folder
|
||||
)
|
||||
|
||||
# Verify year was extracted
|
||||
assert nfo_path.exists()
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
assert "<title>Test Series</title>" in content
|
||||
assert "<year>2024</year>" in content
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_minimal_nfo_creates_folder_if_missing(self, nfo_service, tmp_path):
|
||||
"""Test that folder is created if it doesn't exist."""
|
||||
# Setup - anime_directory is tmp_path itself
|
||||
serie_folder = "New Series"
|
||||
|
||||
# Folder should not exist yet (under anime_directory which is tmp_path)
|
||||
folder_path = tmp_path / serie_folder
|
||||
assert not folder_path.exists()
|
||||
|
||||
# Create minimal NFO
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="New Series",
|
||||
serie_folder=serie_folder
|
||||
)
|
||||
|
||||
# Verify folder and file were created
|
||||
assert folder_path.exists()
|
||||
assert nfo_path.exists()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_minimal_nfo_xml_is_valid(self, nfo_service, tmp_path):
|
||||
"""Test that generated XML is valid."""
|
||||
# Create minimal NFO (anime_directory is already tmp_path)
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Test Anime",
|
||||
serie_folder="Test Anime",
|
||||
year=2020
|
||||
)
|
||||
|
||||
# Verify XML is valid
|
||||
from lxml import etree
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
|
||||
# Should parse without errors
|
||||
tree = etree.fromstring(content.encode("utf-8"))
|
||||
assert tree is not None
|
||||
assert tree.tag == "tvshow"
|
||||
|
||||
# Check title element
|
||||
title = tree.find("title")
|
||||
assert title is not None
|
||||
assert title.text == "Test Anime"
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_minimal_nfo_no_tmdb_id(self, nfo_service, tmp_path):
|
||||
"""Test that minimal NFO has no TMDB ID."""
|
||||
# Create minimal NFO (anime_directory is already tmp_path)
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Unknown Series",
|
||||
serie_folder="Unknown Series",
|
||||
year=1999
|
||||
)
|
||||
|
||||
# Verify no TMDB ID
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
assert "<tmdbid>" not in content
|
||||
assert "uniqueid" not in content
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_minimal_nfo_has_plot_explanation(self, nfo_service, tmp_path):
|
||||
"""Test that minimal NFO contains explanation in plot."""
|
||||
# Create minimal NFO (anime_directory is already tmp_path)
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Mysterious Anime",
|
||||
serie_folder="Mysterious Anime"
|
||||
)
|
||||
|
||||
# Verify plot explains why metadata is missing
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
assert "TMDB lookup failed" in content
|
||||
assert "Mysterious Anime" in content
|
||||
|
||||
|
||||
class TestCreateMinimalNFOIntegration:
|
||||
"""Integration tests for minimal NFO with TMDB failure scenarios."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_fallback_on_tmdb_search_failure(self, nfo_service, tmp_path):
|
||||
"""Test that minimal NFO is created when TMDB search fails."""
|
||||
# Mock TMDB client to raise error
|
||||
nfo_service.tmdb_client.search_tv_show = AsyncMock(
|
||||
side_effect=Exception("TMDB API Error")
|
||||
)
|
||||
|
||||
# Try to create full NFO (should fail and fallback to minimal)
|
||||
# We test the fallback method directly
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Failed Series",
|
||||
serie_folder="Failed Series",
|
||||
year=2021
|
||||
)
|
||||
|
||||
# Verify
|
||||
assert nfo_path.exists()
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
assert "<title>Failed Series</title>" in content
|
||||
assert "<year>2021</year>" in content
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_minimal_nfo_allows_series_tracking(self, nfo_service, tmp_path):
|
||||
"""Test that minimal NFO allows series to be tracked."""
|
||||
# anime_directory is already tmp_path
|
||||
serie_folder = "Untracked Series"
|
||||
|
||||
# Create minimal NFO
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Untracked Series",
|
||||
serie_folder=serie_folder,
|
||||
year=2018
|
||||
)
|
||||
|
||||
# Verify NFO exists (series can be tracked)
|
||||
assert nfo_service.has_nfo(serie_folder) is True
|
||||
|
||||
# Verify minimal content
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
assert "<title>Untracked Series</title>" in content
|
||||
|
||||
|
||||
class TestMinimalNFOContent:
|
||||
"""Test content of minimal NFO files."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_minimal_nfo_contains_required_elements(self, nfo_service, tmp_path):
|
||||
"""Test that minimal NFO has title and plot."""
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="Minimal Test",
|
||||
serie_folder="Minimal Test"
|
||||
)
|
||||
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
|
||||
# Must have title
|
||||
assert "<title>Minimal Test</title>" in content
|
||||
# Must have plot explaining situation
|
||||
assert "plot" in content.lower()
|
||||
assert "No metadata available" in content
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_minimal_nfo_xml_declaration(self, nfo_service, tmp_path):
|
||||
"""Test that NFO has proper XML declaration."""
|
||||
nfo_path = await nfo_service.create_minimal_nfo(
|
||||
serie_name="XML Test",
|
||||
serie_folder="XML Test"
|
||||
)
|
||||
|
||||
content = nfo_path.read_text(encoding="utf-8")
|
||||
|
||||
# Should have XML declaration
|
||||
assert content.startswith('<?xml version="1.0" encoding="UTF-8"')
|
||||
@@ -1,561 +0,0 @@
|
||||
"""Unit tests for NFO models."""
|
||||
|
||||
import pytest
|
||||
from pydantic import ValidationError
|
||||
|
||||
from src.core.entities.nfo_models import (
|
||||
ActorInfo,
|
||||
ImageInfo,
|
||||
NamedSeason,
|
||||
RatingInfo,
|
||||
TVShowNFO,
|
||||
UniqueID,
|
||||
)
|
||||
|
||||
|
||||
class TestRatingInfo:
|
||||
"""Test RatingInfo model."""
|
||||
|
||||
def test_rating_info_with_all_fields(self):
|
||||
"""Test creating RatingInfo with all fields."""
|
||||
rating = RatingInfo(
|
||||
name="themoviedb",
|
||||
value=8.5,
|
||||
votes=1234,
|
||||
max_rating=10,
|
||||
default=True
|
||||
)
|
||||
|
||||
assert rating.name == "themoviedb"
|
||||
assert rating.value == 8.5
|
||||
assert rating.votes == 1234
|
||||
assert rating.max_rating == 10
|
||||
assert rating.default is True
|
||||
|
||||
def test_rating_info_with_minimal_fields(self):
|
||||
"""Test creating RatingInfo with only required fields."""
|
||||
rating = RatingInfo(name="imdb", value=7.2)
|
||||
|
||||
assert rating.name == "imdb"
|
||||
assert rating.value == 7.2
|
||||
assert rating.votes is None
|
||||
assert rating.max_rating == 10 # default
|
||||
assert rating.default is False # default
|
||||
|
||||
def test_rating_info_negative_value_rejected(self):
|
||||
"""Test that negative rating values are rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
RatingInfo(name="test", value=-1.0)
|
||||
|
||||
def test_rating_info_excessive_value_rejected(self):
|
||||
"""Test that rating values > 10 are rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
RatingInfo(name="test", value=11.0)
|
||||
|
||||
def test_rating_info_negative_votes_rejected(self):
|
||||
"""Test that negative vote counts are rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
RatingInfo(name="test", value=5.0, votes=-10)
|
||||
|
||||
def test_rating_info_zero_values_accepted(self):
|
||||
"""Test that zero values are accepted."""
|
||||
rating = RatingInfo(name="test", value=0.0, votes=0)
|
||||
assert rating.value == 0.0
|
||||
assert rating.votes == 0
|
||||
|
||||
|
||||
class TestActorInfo:
|
||||
"""Test ActorInfo model."""
|
||||
|
||||
def test_actor_info_with_all_fields(self):
|
||||
"""Test creating ActorInfo with all fields."""
|
||||
actor = ActorInfo(
|
||||
name="John Doe",
|
||||
role="Main Character",
|
||||
thumb="https://example.com/actor.jpg",
|
||||
profile="https://example.com/profile",
|
||||
tmdbid=12345
|
||||
)
|
||||
|
||||
assert actor.name == "John Doe"
|
||||
assert actor.role == "Main Character"
|
||||
assert str(actor.thumb) == "https://example.com/actor.jpg"
|
||||
assert str(actor.profile) == "https://example.com/profile"
|
||||
assert actor.tmdbid == 12345
|
||||
|
||||
def test_actor_info_with_minimal_fields(self):
|
||||
"""Test creating ActorInfo with only name."""
|
||||
actor = ActorInfo(name="Jane Smith")
|
||||
|
||||
assert actor.name == "Jane Smith"
|
||||
assert actor.role is None
|
||||
assert actor.thumb is None
|
||||
assert actor.profile is None
|
||||
assert actor.tmdbid is None
|
||||
|
||||
def test_actor_info_invalid_url_rejected(self):
|
||||
"""Test that invalid URLs are rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
ActorInfo(name="Test", thumb="not-a-url")
|
||||
|
||||
def test_actor_info_http_url_accepted(self):
|
||||
"""Test that HTTP URLs are accepted."""
|
||||
actor = ActorInfo(
|
||||
name="Test",
|
||||
thumb="http://example.com/image.jpg"
|
||||
)
|
||||
assert str(actor.thumb) == "http://example.com/image.jpg"
|
||||
|
||||
|
||||
class TestImageInfo:
|
||||
"""Test ImageInfo model."""
|
||||
|
||||
def test_image_info_with_all_fields(self):
|
||||
"""Test creating ImageInfo with all fields."""
|
||||
image = ImageInfo(
|
||||
url="https://image.tmdb.org/t/p/w500/poster.jpg",
|
||||
aspect="poster",
|
||||
season=1,
|
||||
type="season"
|
||||
)
|
||||
|
||||
assert str(image.url) == "https://image.tmdb.org/t/p/w500/poster.jpg"
|
||||
assert image.aspect == "poster"
|
||||
assert image.season == 1
|
||||
assert image.type == "season"
|
||||
|
||||
def test_image_info_with_minimal_fields(self):
|
||||
"""Test creating ImageInfo with only URL."""
|
||||
image = ImageInfo(url="https://example.com/image.jpg")
|
||||
|
||||
assert str(image.url) == "https://example.com/image.jpg"
|
||||
assert image.aspect is None
|
||||
assert image.season is None
|
||||
assert image.type is None
|
||||
|
||||
def test_image_info_invalid_url_rejected(self):
|
||||
"""Test that invalid URLs are rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
ImageInfo(url="invalid-url")
|
||||
|
||||
def test_image_info_negative_season_rejected(self):
|
||||
"""Test that season < -1 is rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
ImageInfo(
|
||||
url="https://example.com/image.jpg",
|
||||
season=-2
|
||||
)
|
||||
|
||||
def test_image_info_season_minus_one_accepted(self):
|
||||
"""Test that season -1 is accepted (all seasons)."""
|
||||
image = ImageInfo(
|
||||
url="https://example.com/image.jpg",
|
||||
season=-1
|
||||
)
|
||||
assert image.season == -1
|
||||
|
||||
|
||||
class TestNamedSeason:
|
||||
"""Test NamedSeason model."""
|
||||
|
||||
def test_named_season_creation(self):
|
||||
"""Test creating NamedSeason."""
|
||||
season = NamedSeason(number=1, name="Season One")
|
||||
|
||||
assert season.number == 1
|
||||
assert season.name == "Season One"
|
||||
|
||||
def test_named_season_negative_number_rejected(self):
|
||||
"""Test that negative season numbers are rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
NamedSeason(number=-1, name="Invalid")
|
||||
|
||||
def test_named_season_zero_accepted(self):
|
||||
"""Test that season 0 (specials) is accepted."""
|
||||
season = NamedSeason(number=0, name="Specials")
|
||||
assert season.number == 0
|
||||
|
||||
|
||||
class TestUniqueID:
|
||||
"""Test UniqueID model."""
|
||||
|
||||
def test_unique_id_creation(self):
|
||||
"""Test creating UniqueID."""
|
||||
uid = UniqueID(type="tmdb", value="12345", default=True)
|
||||
|
||||
assert uid.type == "tmdb"
|
||||
assert uid.value == "12345"
|
||||
assert uid.default is True
|
||||
|
||||
def test_unique_id_default_false(self):
|
||||
"""Test UniqueID with default=False."""
|
||||
uid = UniqueID(type="imdb", value="tt1234567")
|
||||
assert uid.default is False
|
||||
|
||||
|
||||
class TestTVShowNFO:
|
||||
"""Test TVShowNFO model."""
|
||||
|
||||
def test_tvshow_nfo_minimal_creation(self):
|
||||
"""Test creating TVShowNFO with only required fields."""
|
||||
nfo = TVShowNFO(title="Test Show")
|
||||
|
||||
assert nfo.title == "Test Show"
|
||||
assert nfo.showtitle == "Test Show" # auto-set
|
||||
assert nfo.originaltitle == "Test Show" # auto-set
|
||||
assert nfo.year is None
|
||||
assert nfo.studio == []
|
||||
assert nfo.genre == []
|
||||
assert nfo.watched is False
|
||||
|
||||
def test_tvshow_nfo_with_all_basic_fields(self):
|
||||
"""Test creating TVShowNFO with all basic fields."""
|
||||
nfo = TVShowNFO(
|
||||
title="Attack on Titan",
|
||||
originaltitle="Shingeki no Kyojin",
|
||||
showtitle="Attack on Titan",
|
||||
sorttitle="Attack on Titan",
|
||||
year=2013,
|
||||
plot="Humanity lives in fear of Titans.",
|
||||
outline="Titans attack humanity.",
|
||||
tagline="The world is cruel.",
|
||||
runtime=24,
|
||||
mpaa="TV-14",
|
||||
certification="14+",
|
||||
premiered="2013-04-07",
|
||||
status="Ended"
|
||||
)
|
||||
|
||||
assert nfo.title == "Attack on Titan"
|
||||
assert nfo.originaltitle == "Shingeki no Kyojin"
|
||||
assert nfo.year == 2013
|
||||
assert nfo.plot == "Humanity lives in fear of Titans."
|
||||
assert nfo.runtime == 24
|
||||
assert nfo.premiered == "2013-04-07"
|
||||
|
||||
def test_tvshow_nfo_empty_title_rejected(self):
|
||||
"""Test that empty title is rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="")
|
||||
|
||||
def test_tvshow_nfo_invalid_year_rejected(self):
|
||||
"""Test that invalid years are rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", year=1800)
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", year=2200)
|
||||
|
||||
def test_tvshow_nfo_negative_runtime_rejected(self):
|
||||
"""Test that negative runtime is rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", runtime=-10)
|
||||
|
||||
def test_tvshow_nfo_with_multi_value_fields(self):
|
||||
"""Test TVShowNFO with lists."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
studio=["Studio A", "Studio B"],
|
||||
genre=["Action", "Drama"],
|
||||
country=["Japan", "USA"],
|
||||
tag=["anime", "popular"]
|
||||
)
|
||||
|
||||
assert len(nfo.studio) == 2
|
||||
assert "Studio A" in nfo.studio
|
||||
assert len(nfo.genre) == 2
|
||||
assert len(nfo.country) == 2
|
||||
assert len(nfo.tag) == 2
|
||||
|
||||
def test_tvshow_nfo_with_ratings(self):
|
||||
"""Test TVShowNFO with ratings."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
ratings=[
|
||||
RatingInfo(name="tmdb", value=8.5, votes=1000, default=True),
|
||||
RatingInfo(name="imdb", value=8.2, votes=5000)
|
||||
],
|
||||
userrating=9.0
|
||||
)
|
||||
|
||||
assert len(nfo.ratings) == 2
|
||||
assert nfo.ratings[0].name == "tmdb"
|
||||
assert nfo.ratings[0].default is True
|
||||
assert nfo.userrating == 9.0
|
||||
|
||||
def test_tvshow_nfo_invalid_userrating_rejected(self):
|
||||
"""Test that userrating outside 0-10 is rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", userrating=-1)
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", userrating=11)
|
||||
|
||||
def test_tvshow_nfo_with_ids(self):
|
||||
"""Test TVShowNFO with various IDs."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
tmdbid=12345,
|
||||
imdbid="tt1234567",
|
||||
tvdbid=67890,
|
||||
uniqueid=[
|
||||
UniqueID(type="tmdb", value="12345"),
|
||||
UniqueID(type="imdb", value="tt1234567", default=True)
|
||||
]
|
||||
)
|
||||
|
||||
assert nfo.tmdbid == 12345
|
||||
assert nfo.imdbid == "tt1234567"
|
||||
assert nfo.tvdbid == 67890
|
||||
assert len(nfo.uniqueid) == 2
|
||||
|
||||
def test_tvshow_nfo_invalid_imdbid_rejected(self):
|
||||
"""Test that invalid IMDB IDs are rejected."""
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
TVShowNFO(title="Test", imdbid="12345")
|
||||
assert "must start with 'tt'" in str(exc_info.value)
|
||||
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
TVShowNFO(title="Test", imdbid="ttabc123")
|
||||
assert "followed by digits" in str(exc_info.value)
|
||||
|
||||
def test_tvshow_nfo_valid_imdbid_accepted(self):
|
||||
"""Test that valid IMDB IDs are accepted."""
|
||||
nfo = TVShowNFO(title="Test", imdbid="tt1234567")
|
||||
assert nfo.imdbid == "tt1234567"
|
||||
|
||||
def test_tvshow_nfo_premiered_date_validation(self):
|
||||
"""Test premiered date format validation."""
|
||||
# Valid format
|
||||
nfo = TVShowNFO(title="Test", premiered="2013-04-07")
|
||||
assert nfo.premiered == "2013-04-07"
|
||||
|
||||
# Invalid formats
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
TVShowNFO(title="Test", premiered="2013-4-7")
|
||||
assert "YYYY-MM-DD" in str(exc_info.value)
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", premiered="04/07/2013")
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", premiered="2013-13-01") # Invalid month
|
||||
|
||||
def test_tvshow_nfo_dateadded_validation(self):
|
||||
"""Test dateadded format validation."""
|
||||
# Valid format
|
||||
nfo = TVShowNFO(title="Test", dateadded="2024-12-15 10:29:11")
|
||||
assert nfo.dateadded == "2024-12-15 10:29:11"
|
||||
|
||||
# Invalid formats
|
||||
with pytest.raises(ValidationError) as exc_info:
|
||||
TVShowNFO(title="Test", dateadded="2024-12-15")
|
||||
assert "YYYY-MM-DD HH:MM:SS" in str(exc_info.value)
|
||||
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", dateadded="2024-12-15 25:00:00")
|
||||
|
||||
def test_tvshow_nfo_with_images(self):
|
||||
"""Test TVShowNFO with image information."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
thumb=[
|
||||
ImageInfo(
|
||||
url="https://image.tmdb.org/t/p/w500/poster.jpg",
|
||||
aspect="poster"
|
||||
),
|
||||
ImageInfo(
|
||||
url="https://image.tmdb.org/t/p/original/logo.png",
|
||||
aspect="clearlogo"
|
||||
)
|
||||
],
|
||||
fanart=[
|
||||
ImageInfo(
|
||||
url="https://image.tmdb.org/t/p/original/fanart.jpg"
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
assert len(nfo.thumb) == 2
|
||||
assert nfo.thumb[0].aspect == "poster"
|
||||
assert len(nfo.fanart) == 1
|
||||
|
||||
def test_tvshow_nfo_with_actors(self):
|
||||
"""Test TVShowNFO with cast information."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
actors=[
|
||||
ActorInfo(
|
||||
name="Actor One",
|
||||
role="Main Character",
|
||||
thumb="https://example.com/actor1.jpg",
|
||||
tmdbid=111
|
||||
),
|
||||
ActorInfo(
|
||||
name="Actor Two",
|
||||
role="Supporting Role"
|
||||
)
|
||||
]
|
||||
)
|
||||
|
||||
assert len(nfo.actors) == 2
|
||||
assert nfo.actors[0].name == "Actor One"
|
||||
assert nfo.actors[0].role == "Main Character"
|
||||
assert nfo.actors[1].tmdbid is None
|
||||
|
||||
def test_tvshow_nfo_with_named_seasons(self):
|
||||
"""Test TVShowNFO with named seasons."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
namedseason=[
|
||||
NamedSeason(number=1, name="First Season"),
|
||||
NamedSeason(number=2, name="Second Season")
|
||||
]
|
||||
)
|
||||
|
||||
assert len(nfo.namedseason) == 2
|
||||
assert nfo.namedseason[0].number == 1
|
||||
|
||||
def test_tvshow_nfo_with_trailer(self):
|
||||
"""Test TVShowNFO with trailer URL."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
trailer="https://www.youtube.com/watch?v=abc123"
|
||||
)
|
||||
|
||||
assert nfo.trailer is not None
|
||||
assert "youtube.com" in str(nfo.trailer)
|
||||
|
||||
def test_tvshow_nfo_watched_and_playcount(self):
|
||||
"""Test TVShowNFO with viewing information."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
watched=True,
|
||||
playcount=5
|
||||
)
|
||||
|
||||
assert nfo.watched is True
|
||||
assert nfo.playcount == 5
|
||||
|
||||
def test_tvshow_nfo_negative_playcount_rejected(self):
|
||||
"""Test that negative playcount is rejected."""
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test", playcount=-1)
|
||||
|
||||
def test_tvshow_nfo_serialization(self):
|
||||
"""Test TVShowNFO can be serialized to dict."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
year=2020,
|
||||
genre=["Action", "Drama"],
|
||||
tmdbid=12345
|
||||
)
|
||||
|
||||
data = nfo.model_dump()
|
||||
|
||||
assert data["title"] == "Test Show"
|
||||
assert data["year"] == 2020
|
||||
assert data["genre"] == ["Action", "Drama"]
|
||||
assert data["tmdbid"] == 12345
|
||||
assert "showtitle" in data
|
||||
assert "originaltitle" in data
|
||||
|
||||
def test_tvshow_nfo_deserialization(self):
|
||||
"""Test TVShowNFO can be deserialized from dict."""
|
||||
data = {
|
||||
"title": "Test Show",
|
||||
"year": 2020,
|
||||
"genre": ["Action"],
|
||||
"tmdbid": 12345,
|
||||
"premiered": "2020-01-01"
|
||||
}
|
||||
|
||||
nfo = TVShowNFO(**data)
|
||||
|
||||
assert nfo.title == "Test Show"
|
||||
assert nfo.year == 2020
|
||||
assert nfo.genre == ["Action"]
|
||||
assert nfo.tmdbid == 12345
|
||||
|
||||
def test_tvshow_nfo_special_characters_in_title(self):
|
||||
"""Test TVShowNFO handles special characters."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test: Show & Movie's \"Best\" <Episode>",
|
||||
plot="Special chars: < > & \" '"
|
||||
)
|
||||
|
||||
assert nfo.title == "Test: Show & Movie's \"Best\" <Episode>"
|
||||
assert nfo.plot == "Special chars: < > & \" '"
|
||||
|
||||
def test_tvshow_nfo_unicode_characters(self):
|
||||
"""Test TVShowNFO handles Unicode characters."""
|
||||
nfo = TVShowNFO(
|
||||
title="進撃の巨人",
|
||||
originaltitle="Shingeki no Kyojin",
|
||||
plot="日本のアニメシリーズ"
|
||||
)
|
||||
|
||||
assert nfo.title == "進撃の巨人"
|
||||
assert nfo.plot == "日本のアニメシリーズ"
|
||||
|
||||
def test_tvshow_nfo_none_values(self):
|
||||
"""Test TVShowNFO handles None values correctly."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
plot=None,
|
||||
year=None,
|
||||
tmdbid=None
|
||||
)
|
||||
|
||||
assert nfo.title == "Test Show"
|
||||
assert nfo.plot is None
|
||||
assert nfo.year is None
|
||||
assert nfo.tmdbid is None
|
||||
|
||||
def test_tvshow_nfo_empty_lists(self):
|
||||
"""Test TVShowNFO with empty lists."""
|
||||
nfo = TVShowNFO(
|
||||
title="Test Show",
|
||||
genre=[],
|
||||
actors=[],
|
||||
ratings=[]
|
||||
)
|
||||
|
||||
assert nfo.genre == []
|
||||
assert nfo.actors == []
|
||||
assert nfo.ratings == []
|
||||
|
||||
@pytest.mark.parametrize("year", [1900, 2000, 2025, 2100])
|
||||
def test_tvshow_nfo_valid_years(self, year):
|
||||
"""Test TVShowNFO accepts valid years."""
|
||||
nfo = TVShowNFO(title="Test Show", year=year)
|
||||
assert nfo.year == year
|
||||
|
||||
@pytest.mark.parametrize("year", [1899, 2101, -1])
|
||||
def test_tvshow_nfo_invalid_years(self, year):
|
||||
"""Test TVShowNFO rejects invalid years."""
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test Show", year=year)
|
||||
|
||||
@pytest.mark.parametrize("imdbid", [
|
||||
"tt0123456",
|
||||
"tt1234567",
|
||||
"tt12345678",
|
||||
"tt123456789"
|
||||
])
|
||||
def test_tvshow_nfo_valid_imdbids(self, imdbid):
|
||||
"""Test TVShowNFO accepts valid IMDB IDs."""
|
||||
nfo = TVShowNFO(title="Test Show", imdbid=imdbid)
|
||||
assert nfo.imdbid == imdbid
|
||||
|
||||
@pytest.mark.parametrize("imdbid", [
|
||||
"123456",
|
||||
"tt",
|
||||
"ttabc123",
|
||||
"TT123456",
|
||||
"tt-123456"
|
||||
])
|
||||
def test_tvshow_nfo_invalid_imdbids(self, imdbid):
|
||||
"""Test TVShowNFO rejects invalid IMDB IDs."""
|
||||
with pytest.raises(ValidationError):
|
||||
TVShowNFO(title="Test Show", imdbid=imdbid)
|
||||
@@ -1,140 +0,0 @@
|
||||
"""Unit tests for NfoRepairService — Task 1."""
|
||||
|
||||
import shutil
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock, MagicMock
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.services.nfo_repair_service import (
|
||||
REQUIRED_TAGS,
|
||||
NfoRepairService,
|
||||
find_missing_tags,
|
||||
nfo_needs_repair,
|
||||
parse_nfo_tags,
|
||||
)
|
||||
|
||||
REPO_ROOT = Path(__file__).parents[2]
|
||||
BAD_NFO = REPO_ROOT / "tvshow.nfo.bad"
|
||||
GOOD_NFO = REPO_ROOT / "tvshow.nfo.good"
|
||||
|
||||
# Tags known to be absent/empty in tvshow.nfo.bad
|
||||
EXPECTED_MISSING_FROM_BAD = {
|
||||
"originaltitle", "year", "plot", "runtime", "premiered",
|
||||
"status", "imdbid", "genre", "studio", "country", "actor/name", "watched",
|
||||
}
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Fixtures
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def bad_nfo(tmp_path: Path) -> Path:
|
||||
"""Copy tvshow.nfo.bad into a temp dir and return path to the copy."""
|
||||
dest = tmp_path / "tvshow.nfo"
|
||||
shutil.copy(BAD_NFO, dest)
|
||||
return dest
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def good_nfo(tmp_path: Path) -> Path:
|
||||
"""Copy tvshow.nfo.good into a temp dir and return path to the copy."""
|
||||
dest = tmp_path / "tvshow.nfo"
|
||||
shutil.copy(GOOD_NFO, dest)
|
||||
return dest
|
||||
|
||||
|
||||
@pytest.fixture()
|
||||
def mock_nfo_service() -> MagicMock:
|
||||
"""Return a MagicMock NFOService with an async update_tvshow_nfo."""
|
||||
svc = MagicMock()
|
||||
svc.update_tvshow_nfo = AsyncMock(return_value=Path("/fake/tvshow.nfo"))
|
||||
return svc
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# find_missing_tags
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_find_missing_tags_with_bad_nfo(bad_nfo: Path) -> None:
|
||||
"""Bad NFO must report all 12 incomplete/missing tags."""
|
||||
missing = find_missing_tags(bad_nfo)
|
||||
assert set(missing) == EXPECTED_MISSING_FROM_BAD, (
|
||||
f"Unexpected missing set: {set(missing)}"
|
||||
)
|
||||
|
||||
|
||||
def test_find_missing_tags_with_good_nfo(good_nfo: Path) -> None:
|
||||
"""Good NFO must report no missing tags."""
|
||||
missing = find_missing_tags(good_nfo)
|
||||
assert missing == []
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# nfo_needs_repair
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_nfo_needs_repair_returns_true_for_bad_nfo(bad_nfo: Path) -> None:
|
||||
assert nfo_needs_repair(bad_nfo) is True
|
||||
|
||||
|
||||
def test_nfo_needs_repair_returns_false_for_good_nfo(good_nfo: Path) -> None:
|
||||
assert nfo_needs_repair(good_nfo) is False
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# NfoRepairService.repair_series
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_repair_series_calls_update_when_nfo_needs_repair(
|
||||
tmp_path: Path, mock_nfo_service: MagicMock
|
||||
) -> None:
|
||||
"""repair_series must call update_tvshow_nfo exactly once for a bad NFO."""
|
||||
shutil.copy(BAD_NFO, tmp_path / "tvshow.nfo")
|
||||
service = NfoRepairService(mock_nfo_service)
|
||||
|
||||
result = await service.repair_series(tmp_path, "Test Series")
|
||||
|
||||
assert result is True
|
||||
mock_nfo_service.update_tvshow_nfo.assert_called_once_with(
|
||||
"Test Series", download_media=False
|
||||
)
|
||||
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_repair_series_skips_when_nfo_is_complete(
|
||||
tmp_path: Path, mock_nfo_service: MagicMock
|
||||
) -> None:
|
||||
"""repair_series must NOT call update_tvshow_nfo for a complete NFO."""
|
||||
shutil.copy(GOOD_NFO, tmp_path / "tvshow.nfo")
|
||||
service = NfoRepairService(mock_nfo_service)
|
||||
|
||||
result = await service.repair_series(tmp_path, "Test Series")
|
||||
|
||||
assert result is False
|
||||
mock_nfo_service.update_tvshow_nfo.assert_not_called()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# parse_nfo_tags edge cases
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def test_parse_nfo_tags_handles_missing_file_gracefully() -> None:
|
||||
"""parse_nfo_tags must return empty dict for non-existent path."""
|
||||
result = parse_nfo_tags(Path("/nonexistent/dir/tvshow.nfo"))
|
||||
assert result == {}
|
||||
|
||||
|
||||
def test_parse_nfo_tags_handles_malformed_xml_gracefully(tmp_path: Path) -> None:
|
||||
"""parse_nfo_tags must return empty dict for malformed XML."""
|
||||
bad_xml = tmp_path / "tvshow.nfo"
|
||||
bad_xml.write_text("<<< not valid xml >>>", encoding="utf-8")
|
||||
result = parse_nfo_tags(bad_xml)
|
||||
assert result == {}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,121 +0,0 @@
|
||||
"""Unit tests for NFO service folder creation.
|
||||
|
||||
Tests that the NFO service correctly creates series folders when they don't exist.
|
||||
"""
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.services.nfo_service import NFOService
|
||||
|
||||
|
||||
class TestNFOServiceFolderCreation:
|
||||
"""Test NFO service creates folders when needed."""
|
||||
|
||||
@pytest.fixture
|
||||
def temp_anime_dir(self):
|
||||
"""Create temporary anime directory."""
|
||||
with tempfile.TemporaryDirectory() as tmpdir:
|
||||
yield Path(tmpdir)
|
||||
|
||||
@pytest.fixture
|
||||
def nfo_service(self, temp_anime_dir):
|
||||
"""Create NFO service with temporary directory."""
|
||||
return NFOService(
|
||||
tmdb_api_key="test_api_key",
|
||||
anime_directory=str(temp_anime_dir),
|
||||
image_size="original",
|
||||
auto_create=False
|
||||
)
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_create_nfo_creates_missing_folder(
|
||||
self, nfo_service, temp_anime_dir
|
||||
):
|
||||
"""Test that create_tvshow_nfo creates folder if it doesn't exist."""
|
||||
serie_folder = "Test Series"
|
||||
folder_path = temp_anime_dir / serie_folder
|
||||
|
||||
# Verify folder doesn't exist initially
|
||||
assert not folder_path.exists()
|
||||
|
||||
# Mock TMDB client responses
|
||||
mock_search_results = {
|
||||
"results": [
|
||||
{
|
||||
"id": 12345,
|
||||
"name": "Test Series",
|
||||
"first_air_date": "2023-01-01",
|
||||
"overview": "Test overview",
|
||||
"vote_average": 8.5
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
mock_details = {
|
||||
"id": 12345,
|
||||
"name": "Test Series",
|
||||
"first_air_date": "2023-01-01",
|
||||
"overview": "Test overview",
|
||||
"vote_average": 8.5,
|
||||
"genres": [{"id": 16, "name": "Animation"}],
|
||||
"networks": [{"name": "Test Network"}],
|
||||
"status": "Returning Series",
|
||||
"number_of_seasons": 1,
|
||||
"number_of_episodes": 12,
|
||||
"poster_path": "/test_poster.jpg",
|
||||
"backdrop_path": "/test_backdrop.jpg"
|
||||
}
|
||||
|
||||
mock_content_ratings = {
|
||||
"results": [
|
||||
{"iso_3166_1": "DE", "rating": "12"}
|
||||
]
|
||||
}
|
||||
|
||||
with patch.object(
|
||||
nfo_service.tmdb_client, 'search_tv_show',
|
||||
new_callable=AsyncMock
|
||||
) as mock_search, \
|
||||
patch.object(
|
||||
nfo_service.tmdb_client, 'get_tv_show_details',
|
||||
new_callable=AsyncMock
|
||||
) as mock_details_call, \
|
||||
patch.object(
|
||||
nfo_service.tmdb_client, 'get_tv_show_content_ratings',
|
||||
new_callable=AsyncMock
|
||||
) as mock_ratings, \
|
||||
patch.object(
|
||||
nfo_service, '_download_media_files',
|
||||
new_callable=AsyncMock
|
||||
) as mock_download:
|
||||
|
||||
mock_search.return_value = mock_search_results
|
||||
mock_details_call.return_value = mock_details
|
||||
mock_ratings.return_value = mock_content_ratings
|
||||
mock_download.return_value = {
|
||||
"poster": False,
|
||||
"logo": False,
|
||||
"fanart": False
|
||||
}
|
||||
|
||||
# Call create_tvshow_nfo
|
||||
nfo_path = await nfo_service.create_tvshow_nfo(
|
||||
serie_name="Test Series",
|
||||
serie_folder=serie_folder,
|
||||
year=2023,
|
||||
download_poster=False,
|
||||
download_logo=False,
|
||||
download_fanart=False
|
||||
)
|
||||
|
||||
# Verify folder was created
|
||||
assert folder_path.exists()
|
||||
assert folder_path.is_dir()
|
||||
|
||||
# Verify NFO file was created
|
||||
assert nfo_path.exists()
|
||||
assert nfo_path.name == "tvshow.nfo"
|
||||
assert nfo_path.parent == folder_path
|
||||
@@ -1,182 +0,0 @@
|
||||
"""Unit test for NFOService.update_tvshow_nfo() - tests XML parsing logic."""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import shutil
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
from lxml import etree
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
from src.core.services.nfo_service import NFOService
|
||||
from src.core.services.tmdb_client import TMDBAPIError
|
||||
|
||||
|
||||
def create_sample_nfo(tmdb_id: int = 1429) -> str:
|
||||
"""Create a sample NFO XML with TMDB ID."""
|
||||
return f'''<?xml version="1.0" encoding="UTF-8"?>
|
||||
<tvshow>
|
||||
<title>Attack on Titan</title>
|
||||
<originaltitle>Shingeki no Kyojin</originaltitle>
|
||||
<year>2013</year>
|
||||
<plot>Several hundred years ago, humans were nearly exterminated by Titans.</plot>
|
||||
<uniqueid type="tmdb" default="false">{tmdb_id}</uniqueid>
|
||||
<uniqueid type="tvdb" default="true">267440</uniqueid>
|
||||
<tmdbid>{tmdb_id}</tmdbid>
|
||||
<tvdbid>267440</tvdbid>
|
||||
</tvshow>'''
|
||||
|
||||
|
||||
def test_parse_nfo_with_uniqueid():
|
||||
"""Test parsing NFO with uniqueid elements."""
|
||||
# Create temporary directory structure
|
||||
temp_dir = Path(tempfile.mkdtemp())
|
||||
serie_folder = temp_dir / "test_series"
|
||||
serie_folder.mkdir()
|
||||
nfo_path = serie_folder / "tvshow.nfo"
|
||||
|
||||
try:
|
||||
# Write sample NFO
|
||||
nfo_path.write_text(create_sample_nfo(1429), encoding="utf-8")
|
||||
|
||||
# Parse it (same logic as in update_tvshow_nfo)
|
||||
tree = etree.parse(str(nfo_path))
|
||||
root = tree.getroot()
|
||||
|
||||
# Extract TMDB ID
|
||||
tmdb_id = None
|
||||
for uniqueid in root.findall(".//uniqueid"):
|
||||
if uniqueid.get("type") == "tmdb":
|
||||
tmdb_id = int(uniqueid.text)
|
||||
break
|
||||
|
||||
assert tmdb_id == 1429, f"Expected TMDB ID 1429, got {tmdb_id}"
|
||||
logger.info("Successfully parsed TMDB ID from uniqueid: %s", tmdb_id)
|
||||
|
||||
finally:
|
||||
shutil.rmtree(temp_dir)
|
||||
|
||||
|
||||
def test_parse_nfo_with_tmdbid_element():
|
||||
"""Test parsing NFO with tmdbid element (fallback)."""
|
||||
# Create NFO without uniqueid but with tmdbid element
|
||||
nfo_content = '''<?xml version="1.0" encoding="UTF-8"?>
|
||||
<tvshow>
|
||||
<title>Test Show</title>
|
||||
<tmdbid>12345</tmdbid>
|
||||
</tvshow>'''
|
||||
|
||||
temp_dir = Path(tempfile.mkdtemp())
|
||||
serie_folder = temp_dir / "test_series"
|
||||
serie_folder.mkdir()
|
||||
nfo_path = serie_folder / "tvshow.nfo"
|
||||
|
||||
try:
|
||||
nfo_path.write_text(nfo_content, encoding="utf-8")
|
||||
|
||||
# Parse it
|
||||
tree = etree.parse(str(nfo_path))
|
||||
root = tree.getroot()
|
||||
|
||||
# Try uniqueid first (should fail)
|
||||
tmdb_id = None
|
||||
for uniqueid in root.findall(".//uniqueid"):
|
||||
if uniqueid.get("type") == "tmdb":
|
||||
tmdb_id = int(uniqueid.text)
|
||||
break
|
||||
|
||||
# Fallback to tmdbid element
|
||||
if tmdb_id is None:
|
||||
tmdbid_elem = root.find(".//tmdbid")
|
||||
if tmdbid_elem is not None and tmdbid_elem.text:
|
||||
tmdb_id = int(tmdbid_elem.text)
|
||||
|
||||
assert tmdb_id == 12345, f"Expected TMDB ID 12345, got {tmdb_id}"
|
||||
logger.info("Successfully parsed TMDB ID from tmdbid element: %s", tmdb_id)
|
||||
|
||||
finally:
|
||||
shutil.rmtree(temp_dir)
|
||||
|
||||
|
||||
def test_parse_nfo_without_tmdb_id():
|
||||
"""Test parsing NFO without TMDB ID raises appropriate error."""
|
||||
# Create NFO without any TMDB ID
|
||||
nfo_content = '''<?xml version="1.0" encoding="UTF-8"?>
|
||||
<tvshow>
|
||||
<title>Test Show</title>
|
||||
</tvshow>'''
|
||||
|
||||
temp_dir = Path(tempfile.mkdtemp())
|
||||
serie_folder = temp_dir / "test_series"
|
||||
serie_folder.mkdir()
|
||||
nfo_path = serie_folder / "tvshow.nfo"
|
||||
|
||||
try:
|
||||
nfo_path.write_text(nfo_content, encoding="utf-8")
|
||||
|
||||
# Parse it
|
||||
tree = etree.parse(str(nfo_path))
|
||||
root = tree.getroot()
|
||||
|
||||
# Try to extract TMDB ID
|
||||
tmdb_id = None
|
||||
for uniqueid in root.findall(".//uniqueid"):
|
||||
if uniqueid.get("type") == "tmdb":
|
||||
tmdb_id = int(uniqueid.text)
|
||||
break
|
||||
|
||||
if tmdb_id is None:
|
||||
tmdbid_elem = root.find(".//tmdbid")
|
||||
if tmdbid_elem is not None and tmdbid_elem.text:
|
||||
tmdb_id = int(tmdbid_elem.text)
|
||||
|
||||
assert tmdb_id is None, "Should not have found TMDB ID"
|
||||
logger.info("Correctly identified NFO without TMDB ID")
|
||||
|
||||
finally:
|
||||
shutil.rmtree(temp_dir)
|
||||
|
||||
|
||||
def test_parse_invalid_xml():
|
||||
"""Test parsing invalid XML raises appropriate error."""
|
||||
nfo_content = '''<?xml version="1.0" encoding="UTF-8"?>
|
||||
<tvshow>
|
||||
<title>Unclosed tag
|
||||
</tvshow>'''
|
||||
|
||||
temp_dir = Path(tempfile.mkdtemp())
|
||||
serie_folder = temp_dir / "test_series"
|
||||
serie_folder.mkdir()
|
||||
nfo_path = serie_folder / "tvshow.nfo"
|
||||
|
||||
try:
|
||||
nfo_path.write_text(nfo_content, encoding="utf-8")
|
||||
|
||||
# Try to parse - should raise XMLSyntaxError
|
||||
try:
|
||||
tree = etree.parse(str(nfo_path))
|
||||
assert False, "Should have raised XMLSyntaxError"
|
||||
except etree.XMLSyntaxError:
|
||||
logger.info("Correctly raised XMLSyntaxError for invalid XML")
|
||||
|
||||
finally:
|
||||
shutil.rmtree(temp_dir)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
logging.basicConfig(level=logging.INFO, format="%(message)s")
|
||||
logger.info("Testing NFO XML parsing logic...")
|
||||
logger.info("")
|
||||
|
||||
test_parse_nfo_with_uniqueid()
|
||||
test_parse_nfo_with_tmdbid_element()
|
||||
test_parse_nfo_without_tmdb_id()
|
||||
test_parse_invalid_xml()
|
||||
|
||||
logger.info("")
|
||||
logger.info("%s", "=" * 60)
|
||||
logger.info("ALL TESTS PASSED")
|
||||
logger.info("%s", "=" * 60)
|
||||
@@ -52,12 +52,10 @@ class TestSeriesAppInitialization:
|
||||
@patch('src.core.SeriesApp.Loaders')
|
||||
@patch('src.core.SeriesApp.SerieScanner')
|
||||
@patch('src.core.SeriesApp.SerieList')
|
||||
@patch('src.core.services.nfo_factory.get_nfo_factory')
|
||||
@patch('src.core.SeriesApp.settings')
|
||||
def test_init_uses_config_fallback_for_nfo_service(
|
||||
self,
|
||||
mock_settings,
|
||||
mock_get_factory,
|
||||
mock_serie_list,
|
||||
mock_scanner,
|
||||
mock_loaders,
|
||||
@@ -66,16 +64,8 @@ class TestSeriesAppInitialization:
|
||||
test_dir = "/test/anime"
|
||||
mock_settings.tmdb_api_key = None
|
||||
|
||||
mock_factory = Mock()
|
||||
mock_service = Mock()
|
||||
mock_factory.create.return_value = mock_service
|
||||
mock_get_factory.return_value = mock_factory
|
||||
|
||||
app = SeriesApp(test_dir)
|
||||
|
||||
assert app.nfo_service is mock_service
|
||||
mock_get_factory.assert_called_once()
|
||||
|
||||
|
||||
class TestSeriesAppSearch:
|
||||
"""Test search functionality."""
|
||||
|
||||
@@ -1,209 +0,0 @@
|
||||
"""Unit tests for series manager service.
|
||||
|
||||
Tests series orchestration, NFO processing, configuration handling,
|
||||
and async batch processing.
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
from pathlib import Path
|
||||
from unittest.mock import AsyncMock, MagicMock, patch
|
||||
|
||||
import pytest
|
||||
|
||||
from src.core.services.series_manager_service import SeriesManagerService
|
||||
|
||||
|
||||
class TestSeriesManagerServiceInit:
|
||||
"""Tests for SeriesManagerService initialization."""
|
||||
|
||||
@patch("src.core.services.series_manager_service.SerieList")
|
||||
def test_init_without_nfo_service(self, mock_serie_list):
|
||||
"""Service initializes without NFO when no API key provided."""
|
||||
svc = SeriesManagerService(
|
||||
anime_directory="/anime",
|
||||
tmdb_api_key=None,
|
||||
auto_create_nfo=False,
|
||||
)
|
||||
assert svc.nfo_service is None
|
||||
assert svc.anime_directory == "/anime"
|
||||
|
||||
@patch("src.core.services.series_manager_service.SerieList")
|
||||
def test_init_with_nfo_disabled(self, mock_serie_list):
|
||||
"""NFO service not created when auto_create and update both False."""
|
||||
svc = SeriesManagerService(
|
||||
anime_directory="/anime",
|
||||
tmdb_api_key="key123",
|
||||
auto_create_nfo=False,
|
||||
update_on_scan=False,
|
||||
)
|
||||
assert svc.nfo_service is None
|
||||
|
||||
@patch("src.core.services.nfo_factory.get_nfo_factory")
|
||||
@patch("src.core.services.series_manager_service.SerieList")
|
||||
def test_init_creates_nfo_service_when_enabled(
|
||||
self, mock_serie_list, mock_factory_fn
|
||||
):
|
||||
"""NFO service is created when auto_create is True and key exists."""
|
||||
mock_factory = MagicMock()
|
||||
mock_nfo = MagicMock()
|
||||
mock_factory.create.return_value = mock_nfo
|
||||
mock_factory_fn.return_value = mock_factory
|
||||
|
||||
svc = SeriesManagerService(
|
||||
anime_directory="/anime",
|
||||
tmdb_api_key="key123",
|
||||
auto_create_nfo=True,
|
||||
)
|
||||
assert svc.nfo_service is mock_nfo
|
||||
|
||||
@patch("src.core.services.nfo_factory.get_nfo_factory")
|
||||
@patch("src.core.services.series_manager_service.SerieList")
|
||||
def test_init_handles_nfo_factory_error(
|
||||
self, mock_serie_list, mock_factory_fn
|
||||
):
|
||||
"""NFO service set to None if factory raises."""
|
||||
mock_factory_fn.side_effect = ValueError("bad config")
|
||||
svc = SeriesManagerService(
|
||||
anime_directory="/anime",
|
||||
tmdb_api_key="key123",
|
||||
auto_create_nfo=True,
|
||||
)
|
||||
assert svc.nfo_service is None
|
||||
|
||||
@patch("src.core.services.series_manager_service.SerieList")
|
||||
def test_init_stores_config_flags(self, mock_serie_list):
|
||||
"""Configuration flags are stored correctly."""
|
||||
svc = SeriesManagerService(
|
||||
anime_directory="/anime",
|
||||
auto_create_nfo=True,
|
||||
update_on_scan=True,
|
||||
download_poster=False,
|
||||
download_logo=False,
|
||||
download_fanart=True,
|
||||
)
|
||||
assert svc.auto_create_nfo is True
|
||||
assert svc.update_on_scan is True
|
||||
assert svc.download_poster is False
|
||||
assert svc.download_logo is False
|
||||
assert svc.download_fanart is True
|
||||
|
||||
@patch("src.core.services.series_manager_service.SerieList")
|
||||
def test_serie_list_created_with_skip_load(self, mock_serie_list):
|
||||
"""SerieList is created with skip_load=True."""
|
||||
SeriesManagerService(anime_directory="/anime")
|
||||
mock_serie_list.assert_called_once_with("/anime", skip_load=True)
|
||||
|
||||
|
||||
class TestFromSettings:
|
||||
"""Tests for from_settings classmethod."""
|
||||
|
||||
@patch("src.core.services.series_manager_service.settings")
|
||||
@patch("src.core.services.series_manager_service.SerieList")
|
||||
def test_from_settings_uses_all_settings(self, mock_serie_list, mock_settings):
|
||||
"""from_settings passes all relevant settings to constructor."""
|
||||
mock_settings.anime_directory = "/anime"
|
||||
mock_settings.tmdb_api_key = None
|
||||
mock_settings.nfo_auto_create = False
|
||||
mock_settings.nfo_update_on_scan = False
|
||||
mock_settings.nfo_download_poster = True
|
||||
mock_settings.nfo_download_logo = True
|
||||
mock_settings.nfo_download_fanart = True
|
||||
mock_settings.nfo_image_size = "original"
|
||||
|
||||
svc = SeriesManagerService.from_settings()
|
||||
assert isinstance(svc, SeriesManagerService)
|
||||
assert svc.anime_directory == "/anime"
|
||||
|
||||
|
||||
class TestProcessNfoForSeries:
|
||||
"""Tests for process_nfo_for_series method."""
|
||||
|
||||
@pytest.fixture
|
||||
def service(self):
|
||||
"""Create a service with mocked dependencies."""
|
||||
with patch("src.core.services.series_manager_service.SerieList"):
|
||||
svc = SeriesManagerService(anime_directory="/anime")
|
||||
svc.nfo_service = AsyncMock()
|
||||
svc.auto_create_nfo = True
|
||||
return svc
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_returns_early_without_nfo_service(self):
|
||||
"""Does nothing when nfo_service is None."""
|
||||
with patch("src.core.services.series_manager_service.SerieList"):
|
||||
svc = SeriesManagerService(anime_directory="/anime")
|
||||
svc.nfo_service = None
|
||||
# Should not raise
|
||||
await svc.process_nfo_for_series("folder", "Name", "key")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_creates_nfo_when_not_exists(self, service):
|
||||
"""Creates NFO file when it doesn't exist and auto_create is True."""
|
||||
service.nfo_service.check_nfo_exists = AsyncMock(return_value=False)
|
||||
service.nfo_service.create_tvshow_nfo = AsyncMock()
|
||||
|
||||
await service.process_nfo_for_series("folder", "Name", "key", year=2024)
|
||||
service.nfo_service.create_tvshow_nfo.assert_awaited_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skips_creation_when_exists(self, service):
|
||||
"""Skips NFO creation when file already exists."""
|
||||
service.nfo_service.check_nfo_exists = AsyncMock(return_value=True)
|
||||
service.nfo_service.parse_nfo_ids = MagicMock(
|
||||
return_value={"tmdb_id": None, "tvdb_id": None}
|
||||
)
|
||||
service.nfo_service.create_tvshow_nfo = AsyncMock()
|
||||
|
||||
await service.process_nfo_for_series("folder", "Name", "key")
|
||||
service.nfo_service.create_tvshow_nfo.assert_not_awaited()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_handles_tmdb_api_error(self, service):
|
||||
"""TMDBAPIError is caught and logged (not re-raised)."""
|
||||
from src.core.services.tmdb_client import TMDBAPIError
|
||||
service.nfo_service.check_nfo_exists = AsyncMock(
|
||||
side_effect=TMDBAPIError("rate limited")
|
||||
)
|
||||
# Should not raise
|
||||
await service.process_nfo_for_series("folder", "Name", "key")
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_handles_unexpected_error(self, service):
|
||||
"""Unexpected exceptions are caught and logged."""
|
||||
service.nfo_service.check_nfo_exists = AsyncMock(
|
||||
side_effect=RuntimeError("unexpected")
|
||||
)
|
||||
await service.process_nfo_for_series("folder", "Name", "key")
|
||||
|
||||
|
||||
class TestScanAndProcessNfo:
|
||||
"""Tests for scan_and_process_nfo method."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_skips_when_no_nfo_service(self):
|
||||
"""Returns early when nfo_service is None."""
|
||||
with patch("src.core.services.series_manager_service.SerieList"):
|
||||
svc = SeriesManagerService(anime_directory="/anime")
|
||||
svc.nfo_service = None
|
||||
await svc.scan_and_process_nfo()
|
||||
|
||||
|
||||
class TestClose:
|
||||
"""Tests for close method."""
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_close_with_nfo_service(self):
|
||||
"""Closes NFO service when present."""
|
||||
with patch("src.core.services.series_manager_service.SerieList"):
|
||||
svc = SeriesManagerService(anime_directory="/anime")
|
||||
svc.nfo_service = AsyncMock()
|
||||
await svc.close()
|
||||
svc.nfo_service.close.assert_awaited_once()
|
||||
|
||||
@pytest.mark.asyncio
|
||||
async def test_close_without_nfo_service(self):
|
||||
"""Close works fine when no NFO service."""
|
||||
with patch("src.core.services.series_manager_service.SerieList"):
|
||||
svc = SeriesManagerService(anime_directory="/anime")
|
||||
svc.nfo_service = None
|
||||
await svc.close() # Should not raise
|
||||
Reference in New Issue
Block a user