lukas.pupkalipinski/Aniworld
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Add NFO metadata infrastructure (Task 3 - partial)

Browse Source 
- Created TMDB API client with async requests, caching, and retry logic
- Implemented NFO XML generator for Kodi/XBMC format
- Created image downloader for poster/logo/fanart with validation
- Added NFO service to orchestrate metadata creation
- Added NFO-related configuration settings
- Updated requirements.txt with aiohttp, lxml, pillow
- Created unit tests (need refinement due to implementation mismatch)

Components created:
- src/core/services/tmdb_client.py (270 lines)
- src/core/services/nfo_service.py (390 lines)
- src/core/utils/nfo_generator.py (180 lines)
- src/core/utils/image_downloader.py (296 lines)
- tests/unit/test_tmdb_client.py
- tests/unit/test_nfo_generator.py
- tests/unit/test_image_downloader.py

Note: Tests need to be updated to match actual implementation APIs.
Dependencies installed: aiohttp, lxml, pillow
This commit is contained in:
Lukas
2026-01-11 20:33:33 +01:00
parent 5e8815d143
commit 4895e487c0
10 changed files with 2270 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

411
tests/unit/test_image_downloader.py Normal file
View File

@@ -0,0 +1,411 @@
"""Unit tests for image downloader."""
import io
from pathlib import Path
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from PIL import Image
from src.core.utils.image_downloader import (
ImageDownloader,
ImageDownloadError,
)
@pytest.fixture
def image_downloader():
"""Create image downloader instance."""
return ImageDownloader()
@pytest.fixture
def valid_image_bytes():
"""Create valid test image bytes."""
img = Image.new('RGB', (100, 100), color='red')
buf = io.BytesIO()
img.save(buf, format='JPEG')
return buf.getvalue()
@pytest.fixture
def mock_session():
"""Create mock aiohttp session."""
mock = AsyncMock()
mock.get = AsyncMock()
return mock
class TestImageDownloaderInit:
"""Test ImageDownloader initialization."""
def test_init_default_values(self):
"""Test initialization with default values."""
downloader = ImageDownloader()
assert downloader.min_file_size == 1024
assert downloader.max_retries == 3
assert downloader.retry_delay == 1.0
assert downloader.timeout == 30
assert downloader.session is None
def test_init_custom_values(self):
"""Test initialization with custom values."""
downloader = ImageDownloader(
min_file_size=5000,
max_retries=5,
retry_delay=2.0,
timeout=60
)
assert downloader.min_file_size == 5000
assert downloader.max_retries == 5
assert downloader.retry_delay == 2.0
assert downloader.timeout == 60
class TestImageDownloaderContextManager:
"""Test ImageDownloader as context manager."""
@pytest.mark.asyncio
async def test_async_context_manager(self, image_downloader):
"""Test async context manager creates session."""
async with image_downloader as d:
assert d.session is not None
assert image_downloader.session is None
@pytest.mark.asyncio
async def test_close_closes_session(self, image_downloader):
"""Test close method closes session."""
await image_downloader.__aenter__()
assert image_downloader.session is not None
await image_downloader.close()
assert image_downloader.session is None
class TestImageDownloaderValidateImage:
"""Test _validate_image method."""
def test_validate_valid_image(self, image_downloader, valid_image_bytes):
"""Test validation of valid image."""
# Should not raise exception
image_downloader._validate_image(valid_image_bytes)
def test_validate_too_small(self, image_downloader):
"""Test validation rejects too-small file."""
tiny_data = b"tiny"
with pytest.raises(ImageDownloadError, match="too small"):
image_downloader._validate_image(tiny_data)
def test_validate_invalid_image_data(self, image_downloader):
"""Test validation rejects invalid image data."""
invalid_data = b"x" * 2000 # Large enough but not an image
with pytest.raises(ImageDownloadError, match="Cannot open"):
image_downloader._validate_image(invalid_data)
def test_validate_corrupted_image(self, image_downloader):
"""Test validation rejects corrupted image."""
# Create a corrupted JPEG-like file
corrupted = b"\xFF\xD8\xFF\xE0" + b"corrupted_data" * 100
with pytest.raises(ImageDownloadError):
image_downloader._validate_image(corrupted)
class TestImageDownloaderDownloadImage:
"""Test download_image method."""
@pytest.mark.asyncio
async def test_download_image_success(
self,
image_downloader,
valid_image_bytes,
tmp_path
):
"""Test successful image download."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 200
mock_response.read = AsyncMock(return_value=valid_image_bytes)
mock_session.get = AsyncMock(return_value=mock_response)
image_downloader.session = mock_session
output_path = tmp_path / "test.jpg"
await image_downloader.download_image("https://test.com/image.jpg", output_path)
assert output_path.exists()
assert output_path.stat().st_size == len(valid_image_bytes)
@pytest.mark.asyncio
async def test_download_image_skip_existing(
self,
image_downloader,
tmp_path
):
"""Test skipping existing file."""
output_path = tmp_path / "existing.jpg"
output_path.write_bytes(b"existing")
mock_session = AsyncMock()
image_downloader.session = mock_session
result = await image_downloader.download_image(
"https://test.com/image.jpg",
output_path,
skip_existing=True
)
assert result is True
assert output_path.read_bytes() == b"existing" # Unchanged
assert not mock_session.get.called
@pytest.mark.asyncio
async def test_download_image_overwrite_existing(
self,
image_downloader,
valid_image_bytes,
tmp_path
):
"""Test overwriting existing file."""
output_path = tmp_path / "existing.jpg"
output_path.write_bytes(b"old")
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 200
mock_response.read = AsyncMock(return_value=valid_image_bytes)
mock_session.get = AsyncMock(return_value=mock_response)
image_downloader.session = mock_session
await image_downloader.download_image(
"https://test.com/image.jpg",
output_path,
skip_existing=False
)
assert output_path.exists()
assert output_path.read_bytes() == valid_image_bytes
@pytest.mark.asyncio
async def test_download_image_invalid_url(self, image_downloader, tmp_path):
"""Test download with invalid URL."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 404
mock_response.raise_for_status = MagicMock(side_effect=Exception("Not Found"))
mock_session.get = AsyncMock(return_value=mock_response)
image_downloader.session = mock_session
output_path = tmp_path / "test.jpg"
with pytest.raises(ImageDownloadError):
await image_downloader.download_image("https://test.com/missing.jpg", output_path)
class TestImageDownloaderSpecificMethods:
"""Test type-specific download methods."""
@pytest.mark.asyncio
async def test_download_poster(self, image_downloader, valid_image_bytes, tmp_path):
"""Test download_poster method."""
with patch.object(
image_downloader,
'download_image',
new_callable=AsyncMock
) as mock_download:
await image_downloader.download_poster(
"https://test.com/poster.jpg",
tmp_path
)
mock_download.assert_called_once()
call_args = mock_download.call_args
assert call_args[0][1] == tmp_path / "poster.jpg"
@pytest.mark.asyncio
async def test_download_logo(self, image_downloader, tmp_path):
"""Test download_logo method."""
with patch.object(
image_downloader,
'download_image',
new_callable=AsyncMock
) as mock_download:
await image_downloader.download_logo(
"https://test.com/logo.png",
tmp_path
)
mock_download.assert_called_once()
call_args = mock_download.call_args
assert call_args[0][1] == tmp_path / "logo.png"
@pytest.mark.asyncio
async def test_download_fanart(self, image_downloader, tmp_path):
"""Test download_fanart method."""
with patch.object(
image_downloader,
'download_image',
new_callable=AsyncMock
) as mock_download:
await image_downloader.download_fanart(
"https://test.com/fanart.jpg",
tmp_path
)
mock_download.assert_called_once()
call_args = mock_download.call_args
assert call_args[0][1] == tmp_path / "fanart.jpg"
class TestImageDownloaderDownloadAll:
"""Test download_all_media method."""
@pytest.mark.asyncio
async def test_download_all_success(self, image_downloader, tmp_path):
"""Test downloading all media types."""
with patch.object(
image_downloader,
'download_poster',
new_callable=AsyncMock,
return_value=True
), patch.object(
image_downloader,
'download_logo',
new_callable=AsyncMock,
return_value=True
), patch.object(
image_downloader,
'download_fanart',
new_callable=AsyncMock,
return_value=True
):
results = await image_downloader.download_all_media(
tmp_path,
poster_url="https://test.com/poster.jpg",
logo_url="https://test.com/logo.png",
fanart_url="https://test.com/fanart.jpg"
)
assert results["poster"] is True
assert results["logo"] is True
assert results["fanart"] is True
@pytest.mark.asyncio
async def test_download_all_partial(self, image_downloader, tmp_path):
"""Test downloading with some URLs missing."""
with patch.object(
image_downloader,
'download_poster',
new_callable=AsyncMock,
return_value=True
), patch.object(
image_downloader,
'download_logo',
new_callable=AsyncMock
) as mock_logo, patch.object(
image_downloader,
'download_fanart',
new_callable=AsyncMock
) as mock_fanart:
results = await image_downloader.download_all_media(
tmp_path,
poster_url="https://test.com/poster.jpg",
logo_url=None,
fanart_url=None
)
assert results["poster"] is True
assert results["logo"] is None
assert results["fanart"] is None
assert not mock_logo.called
assert not mock_fanart.called
@pytest.mark.asyncio
async def test_download_all_with_failures(self, image_downloader, tmp_path):
"""Test downloading with some failures."""
with patch.object(
image_downloader,
'download_poster',
new_callable=AsyncMock,
return_value=True
), patch.object(
image_downloader,
'download_logo',
new_callable=AsyncMock,
side_effect=ImageDownloadError("Failed")
), patch.object(
image_downloader,
'download_fanart',
new_callable=AsyncMock,
return_value=True
):
results = await image_downloader.download_all_media(
tmp_path,
poster_url="https://test.com/poster.jpg",
logo_url="https://test.com/logo.png",
fanart_url="https://test.com/fanart.jpg"
)
assert results["poster"] is True
assert results["logo"] is False
assert results["fanart"] is True
class TestImageDownloaderRetryLogic:
"""Test retry logic."""
@pytest.mark.asyncio
async def test_retry_on_failure(self, image_downloader, valid_image_bytes, tmp_path):
"""Test retry logic on temporary failure."""
mock_session = AsyncMock()
# First two calls fail, third succeeds
mock_response_fail = AsyncMock()
mock_response_fail.status = 500
mock_response_fail.raise_for_status = MagicMock(side_effect=Exception("Server Error"))
mock_response_success = AsyncMock()
mock_response_success.status = 200
mock_response_success.read = AsyncMock(return_value=valid_image_bytes)
mock_session.get = AsyncMock(
side_effect=[mock_response_fail, mock_response_fail, mock_response_success]
)
image_downloader.session = mock_session
image_downloader.retry_delay = 0.1 # Speed up test
output_path = tmp_path / "test.jpg"
await image_downloader.download_image("https://test.com/image.jpg", output_path)
# Should have retried twice then succeeded
assert mock_session.get.call_count == 3
assert output_path.exists()
@pytest.mark.asyncio
async def test_max_retries_exceeded(self, image_downloader, tmp_path):
"""Test failure after max retries."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 500
mock_response.raise_for_status = MagicMock(side_effect=Exception("Server Error"))
mock_session.get = AsyncMock(return_value=mock_response)
image_downloader.session = mock_session
image_downloader.max_retries = 2
image_downloader.retry_delay = 0.1
output_path = tmp_path / "test.jpg"
with pytest.raises(ImageDownloadError):
await image_downloader.download_image("https://test.com/image.jpg", output_path)
# Should have tried 3 times (initial + 2 retries)
assert mock_session.get.call_count == 3

325
tests/unit/test_nfo_generator.py Normal file
View File

@@ -0,0 +1,325 @@
"""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)
assert xml_string.startswith('<?xml version="1.0" encoding="UTF-8"?>')
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
assert '<rating name="themoviedb" default="true">' in xml_string
assert '<value>8.5</value>' in xml_string
assert '<votes>1000</votes>' in xml_string
assert '<rating name="imdb" default="false">' 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)
assert '<uniqueid type="tmdb" default="false">12345</uniqueid>' in xml_string
assert '<uniqueid type="tvdb" default="true">67890</uniqueid>' in xml_string
assert '<uniqueid type="imdb" default="false">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 "&lt;" in xml_string or "<title>" in xml_string
assert "&amp;" 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"
with pytest.raises(ValueError, match="Invalid XML"):
validate_nfo_xml(invalid_xml)
def test_validate_missing_tvshow_root(self):
"""Test validation rejects non-tvshow root."""
invalid_xml = '<?xml version="1.0"?><movie><title>Test</title></movie>'
with pytest.raises(ValueError, match="root element must be"):
validate_nfo_xml(invalid_xml)
def test_validate_empty_string(self):
"""Test validation rejects empty string."""
with pytest.raises(ValueError):
validate_nfo_xml("")
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

331
tests/unit/test_tmdb_client.py Normal file
View File

@@ -0,0 +1,331 @@
"""Unit tests for TMDB client."""
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from aiohttp import ClientResponseError, ClientSession
from src.core.services.tmdb_client import TMDBAPIError, TMDBClient
@pytest.fixture
def tmdb_client():
"""Create TMDB client with test API key."""
return TMDBClient(api_key="test_api_key")
@pytest.fixture
def mock_response():
"""Create mock aiohttp response."""
mock = AsyncMock()
mock.status = 200
mock.json = AsyncMock(return_value={"success": True})
return mock
class TestTMDBClientInit:
"""Test TMDB client initialization."""
def test_init_with_api_key(self):
"""Test initialization with API key."""
client = TMDBClient(api_key="my_key")
assert client.api_key == "my_key"
assert client.base_url == "https://api.themoviedb.org/3"
assert client.image_base_url == "https://image.tmdb.org/t/p"
assert client.session is None
assert client._cache == {}
def test_init_sets_attributes(self):
"""Test all attributes are set correctly."""
client = TMDBClient(api_key="test")
assert hasattr(client, "api_key")
assert hasattr(client, "base_url")
assert hasattr(client, "image_base_url")
assert hasattr(client, "session")
assert hasattr(client, "_cache")
class TestTMDBClientContextManager:
"""Test TMDB client as context manager."""
@pytest.mark.asyncio
async def test_async_context_manager(self):
"""Test async context manager creates session."""
client = TMDBClient(api_key="test")
async with client as c:
assert c.session is not None
assert isinstance(c.session, ClientSession)
# Session should be closed after context
assert client.session is None
@pytest.mark.asyncio
async def test_close_closes_session(self):
"""Test close method closes session."""
client = TMDBClient(api_key="test")
await client.__aenter__()
assert client.session is not None
await client.close()
assert client.session is None
class TestTMDBClientSearchTVShow:
"""Test search_tv_show method."""
@pytest.mark.asyncio
async def test_search_tv_show_success(self, tmdb_client, mock_response):
"""Test successful TV show search."""
mock_response.json = AsyncMock(return_value={
"results": [
{"id": 1, "name": "Test Show"},
{"id": 2, "name": "Another Show"}
]
})
with patch.object(tmdb_client, "_make_request", return_value=mock_response.json.return_value):
result = await tmdb_client.search_tv_show("Test Show")
assert "results" in result
assert len(result["results"]) == 2
assert result["results"][0]["name"] == "Test Show"
@pytest.mark.asyncio
async def test_search_tv_show_with_year(self, tmdb_client):
"""Test TV show search with year filter."""
mock_data = {"results": [{"id": 1, "name": "Test Show", "first_air_date": "2020-01-01"}]}
with patch.object(tmdb_client, "_make_request", return_value=mock_data):
result = await tmdb_client.search_tv_show("Test Show", year=2020)
assert "results" in result
@pytest.mark.asyncio
async def test_search_tv_show_empty_results(self, tmdb_client):
"""Test search with no results."""
with patch.object(tmdb_client, "_make_request", return_value={"results": []}):
result = await tmdb_client.search_tv_show("NonexistentShow")
assert result["results"] == []
@pytest.mark.asyncio
async def test_search_tv_show_uses_cache(self, tmdb_client):
"""Test search results are cached."""
mock_data = {"results": [{"id": 1, "name": "Cached Show"}]}
with patch.object(tmdb_client, "_make_request", return_value=mock_data) as mock_request:
# First call should hit API
result1 = await tmdb_client.search_tv_show("Cached Show")
assert mock_request.call_count == 1
# Second call should use cache
result2 = await tmdb_client.search_tv_show("Cached Show")
assert mock_request.call_count == 1 # Not called again
assert result1 == result2
class TestTMDBClientGetTVShowDetails:
"""Test get_tv_show_details method."""
@pytest.mark.asyncio
async def test_get_tv_show_details_success(self, tmdb_client):
"""Test successful TV show details retrieval."""
mock_data = {
"id": 123,
"name": "Test Show",
"overview": "A test show",
"first_air_date": "2020-01-01"
}
with patch.object(tmdb_client, "_make_request", return_value=mock_data):
result = await tmdb_client.get_tv_show_details(123)
assert result["id"] == 123
assert result["name"] == "Test Show"
@pytest.mark.asyncio
async def test_get_tv_show_details_with_append(self, tmdb_client):
"""Test details with append_to_response."""
mock_data = {
"id": 123,
"name": "Test Show",
"credits": {"cast": []},
"images": {"posters": []}
}
with patch.object(tmdb_client, "_make_request", return_value=mock_data) as mock_request:
result = await tmdb_client.get_tv_show_details(123, append_to_response="credits,images")
assert "credits" in result
assert "images" in result
# Verify append_to_response was passed
call_args = mock_request.call_args
assert "credits,images" in str(call_args)
class TestTMDBClientGetExternalIDs:
"""Test get_tv_show_external_ids method."""
@pytest.mark.asyncio
async def test_get_external_ids_success(self, tmdb_client):
"""Test successful external IDs retrieval."""
mock_data = {
"imdb_id": "tt1234567",
"tvdb_id": 98765
}
with patch.object(tmdb_client, "_make_request", return_value=mock_data):
result = await tmdb_client.get_tv_show_external_ids(123)
assert result["imdb_id"] == "tt1234567"
assert result["tvdb_id"] == 98765
class TestTMDBClientGetImages:
"""Test get_tv_show_images method."""
@pytest.mark.asyncio
async def test_get_images_success(self, tmdb_client):
"""Test successful images retrieval."""
mock_data = {
"posters": [{"file_path": "/poster.jpg"}],
"backdrops": [{"file_path": "/backdrop.jpg"}],
"logos": [{"file_path": "/logo.png"}]
}
with patch.object(tmdb_client, "_make_request", return_value=mock_data):
result = await tmdb_client.get_tv_show_images(123)
assert "posters" in result
assert "backdrops" in result
assert "logos" in result
assert len(result["posters"]) == 1
class TestTMDBClientImageURL:
"""Test get_image_url method."""
def test_get_image_url_with_size(self, tmdb_client):
"""Test image URL generation with size."""
url = tmdb_client.get_image_url("/test.jpg", "w500")
assert url == "https://image.tmdb.org/t/p/w500/test.jpg"
def test_get_image_url_original(self, tmdb_client):
"""Test image URL with original size."""
url = tmdb_client.get_image_url("/test.jpg", "original")
assert url == "https://image.tmdb.org/t/p/original/test.jpg"
def test_get_image_url_strips_leading_slash(self, tmdb_client):
"""Test path without leading slash works."""
url = tmdb_client.get_image_url("test.jpg", "w500")
assert url == "https://image.tmdb.org/t/p/w500/test.jpg"
class TestTMDBClientMakeRequest:
"""Test _make_request private method."""
@pytest.mark.asyncio
async def test_make_request_success(self, tmdb_client):
"""Test successful request."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 200
mock_response.json = AsyncMock(return_value={"data": "test"})
mock_session.get = AsyncMock(return_value=mock_response)
tmdb_client.session = mock_session
result = await tmdb_client._make_request("tv/search", {"query": "test"})
assert result == {"data": "test"}
@pytest.mark.asyncio
async def test_make_request_unauthorized(self, tmdb_client):
"""Test 401 unauthorized error."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 401
mock_response.raise_for_status = MagicMock(
side_effect=ClientResponseError(None, None, status=401)
)
mock_session.get = AsyncMock(return_value=mock_response)
tmdb_client.session = mock_session
with pytest.raises(TMDBAPIError, match="Invalid API key"):
await tmdb_client._make_request("tv/search", {})
@pytest.mark.asyncio
async def test_make_request_not_found(self, tmdb_client):
"""Test 404 not found error."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 404
mock_response.raise_for_status = MagicMock(
side_effect=ClientResponseError(None, None, status=404)
)
mock_session.get = AsyncMock(return_value=mock_response)
tmdb_client.session = mock_session
with pytest.raises(TMDBAPIError, match="not found"):
await tmdb_client._make_request("tv/99999", {})
@pytest.mark.asyncio
async def test_make_request_rate_limit(self, tmdb_client):
"""Test 429 rate limit error."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 429
mock_response.raise_for_status = MagicMock(
side_effect=ClientResponseError(None, None, status=429)
)
mock_session.get = AsyncMock(return_value=mock_response)
tmdb_client.session = mock_session
with pytest.raises(TMDBAPIError, match="rate limit"):
await tmdb_client._make_request("tv/search", {})
class TestTMDBClientDownloadImage:
"""Test download_image method."""
@pytest.mark.asyncio
async def test_download_image_success(self, tmdb_client, tmp_path):
"""Test successful image download."""
image_data = b"fake_image_data"
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 200
mock_response.read = AsyncMock(return_value=image_data)
mock_session.get = AsyncMock(return_value=mock_response)
tmdb_client.session = mock_session
output_path = tmp_path / "test.jpg"
await tmdb_client.download_image("https://test.com/image.jpg", output_path)
assert output_path.exists()
assert output_path.read_bytes() == image_data
@pytest.mark.asyncio
async def test_download_image_failure(self, tmdb_client, tmp_path):
"""Test image download failure."""
mock_session = AsyncMock()
mock_response = AsyncMock()
mock_response.status = 404
mock_response.raise_for_status = MagicMock(
side_effect=ClientResponseError(None, None, status=404)
)
mock_session.get = AsyncMock(return_value=mock_response)
tmdb_client.session = mock_session
output_path = tmp_path / "test.jpg"
with pytest.raises(TMDBAPIError):
await tmdb_client.download_image("https://test.com/missing.jpg", output_path)