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

fixed some tests

Browse Source
This commit is contained in:
Lukas
2025-11-15 16:56:12 +01:00
parent f49598d82b
commit fac0cecf90
13 changed files with 10434 additions and 3301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

309
tests/unit/test_download_progress_websocket.py
View File

@@ -10,11 +10,7 @@ from unittest.mock import Mock, patch
import pytest
from src.server.models.download import (
DownloadPriority,
DownloadProgress,
EpisodeIdentifier,
)
from src.server.models.download import DownloadPriority, EpisodeIdentifier
from src.server.services.anime_service import AnimeService
from src.server.services.download_service import DownloadService
from src.server.services.progress_service import ProgressService
@@ -23,45 +19,60 @@ from src.server.services.progress_service import ProgressService
@pytest.fixture
def mock_series_app():
"""Mock SeriesApp for testing."""
app = Mock()
from unittest.mock import MagicMock
app = MagicMock()
app.series_list = []
app.search = Mock(return_value=[])
app.ReScan = Mock()
# Mock download with progress callback
def mock_download(
serie_folder, season, episode, key, callback=None, **kwargs
# Create mock event handlers that can be assigned
app.download_status = None
app.scan_status = None
# Mock download with event triggering
async def mock_download(
serie_folder, season, episode, key, **kwargs
):
"""Simulate download with progress updates."""
if callback:
# Simulate progress updates
callback({
'percent': 25.0,
'downloaded_mb': 25.0,
'total_mb': 100.0,
'speed_mbps': 2.5,
'eta_seconds': 30,
})
callback({
'percent': 50.0,
'downloaded_mb': 50.0,
'total_mb': 100.0,
'speed_mbps': 2.5,
'eta_seconds': 20,
})
callback({
'percent': 100.0,
'downloaded_mb': 100.0,
'total_mb': 100.0,
'speed_mbps': 2.5,
'eta_seconds': 0,
})
"""Simulate download with events."""
# Create event args that mimic SeriesApp's DownloadStatusEventArgs
class MockDownloadArgs:
def __init__(
self, status, serie_folder, season, episode,
progress=None, message=None, error=None
):
self.status = status
self.serie_folder = serie_folder
self.season = season
self.episode = episode
self.progress = progress
self.message = message
self.error = error
# Return success result
result = Mock()
result.success = True
result.message = "Download completed"
return result
# Trigger started event
if app.download_status:
app.download_status(MockDownloadArgs(
"started", serie_folder, season, episode
))
# Simulate progress updates
progress_values = [25.0, 50.0, 75.0, 100.0]
for progress in progress_values:
if app.download_status:
await asyncio.sleep(0.01) # Small delay
app.download_status(MockDownloadArgs(
"progress", serie_folder, season, episode,
progress=progress,
message=f"Downloading... {progress}%"
))
# Trigger completed event
if app.download_status:
app.download_status(MockDownloadArgs(
"completed", serie_folder, season, episode
))
return True
app.download = Mock(side_effect=mock_download)
return app
@@ -86,13 +97,26 @@ async def anime_service(mock_series_app, progress_service):
@pytest.fixture
async def download_service(anime_service, progress_service):
"""Create a DownloadService with dependencies."""
import os
persistence_path = "/tmp/test_download_progress_queue.json"
# Remove any existing queue file
if os.path.exists(persistence_path):
os.remove(persistence_path)
service = DownloadService(
anime_service=anime_service,
progress_service=progress_service,
persistence_path="/tmp/test_download_progress_queue.json",
persistence_path=persistence_path,
)
yield service
yield service, progress_service
await service.stop()
# Clean up after test
if os.path.exists(persistence_path):
os.remove(persistence_path)
class TestDownloadProgressWebSocket:
@@ -102,17 +126,22 @@ class TestDownloadProgressWebSocket:
async def test_progress_callback_broadcasts_updates(
self, download_service
):
"""Test that progress callback broadcasts updates via WebSocket."""
"""Test that progress updates are emitted via events."""
download_svc, progress_svc = download_service
broadcasts: List[Dict[str, Any]] = []
async def mock_broadcast(update_type: str, data: dict):
"""Capture broadcast calls."""
broadcasts.append({"type": update_type, "data": data})
async def mock_event_handler(event):
"""Capture progress events."""
broadcasts.append({
"type": event.event_type,
"data": event.progress.to_dict()
})
download_service.set_broadcast_callback(mock_broadcast)
# Subscribe to progress_updated events
progress_svc.subscribe("progress_updated", mock_event_handler)
# Add item to queue
item_ids = await download_service.add_to_queue(
item_ids = await download_svc.add_to_queue(
serie_id="test_serie_1",
serie_folder="test_serie_1",
serie_name="Test Anime",
@@ -123,13 +152,13 @@ class TestDownloadProgressWebSocket:
assert len(item_ids) == 1
# Start processing - this should trigger download with progress
result = await download_service.start_queue_processing()
result = await download_svc.start_queue_processing()
assert result is not None
# Wait for download to process
await asyncio.sleep(0.5)
# Filter progress broadcasts
# Filter download progress broadcasts
progress_broadcasts = [
b for b in broadcasts if b["type"] == "download_progress"
]
@@ -137,32 +166,32 @@ class TestDownloadProgressWebSocket:
# Should have received multiple progress updates
assert len(progress_broadcasts) >= 2
# Verify progress data structure
# Verify progress data structure (Progress model format)
for broadcast in progress_broadcasts:
data = broadcast["data"]
assert "download_id" in data or "item_id" in data
assert "progress" in data
progress = data["progress"]
assert "percent" in progress
assert "downloaded_mb" in progress
assert "total_mb" in progress
assert 0 <= progress["percent"] <= 100
assert "id" in data # Progress ID
assert "type" in data # Progress type
# Progress events use 'current' and 'total'
assert "current" in data or "message" in data
@pytest.mark.asyncio
async def test_progress_updates_include_episode_info(
self, download_service
):
"""Test that progress updates include episode information."""
download_svc, progress_svc = download_service
broadcasts: List[Dict[str, Any]] = []
async def mock_broadcast(update_type: str, data: dict):
broadcasts.append({"type": update_type, "data": data})
async def mock_event_handler(event):
broadcasts.append({
"type": event.event_type,
"data": event.progress.to_dict()
})
download_service.set_broadcast_callback(mock_broadcast)
progress_svc.subscribe("progress_updated", mock_event_handler)
# Add item with specific episode info
await download_service.add_to_queue(
await download_svc.add_to_queue(
serie_id="test_serie_2",
serie_folder="test_serie_2",
serie_name="My Test Anime",
@@ -171,7 +200,7 @@ class TestDownloadProgressWebSocket:
)
# Start processing
await download_service.start_queue_processing()
await download_svc.start_queue_processing()
await asyncio.sleep(0.5)
# Find progress broadcasts
@@ -181,30 +210,34 @@ class TestDownloadProgressWebSocket:
assert len(progress_broadcasts) > 0
# Verify episode info is included
# Verify progress info is included
data = progress_broadcasts[0]["data"]
assert data["serie_name"] == "My Test Anime"
assert data["season"] == 2
assert data["episode"] == 5
assert "id" in data
# ID should contain folder name: download_test_serie_2_2_5
assert "test_serie_2" in data["id"]
@pytest.mark.asyncio
async def test_progress_percent_increases(self, download_service):
"""Test that progress percentage increases over time."""
download_svc, progress_svc = download_service
broadcasts: List[Dict[str, Any]] = []
async def mock_broadcast(update_type: str, data: dict):
broadcasts.append({"type": update_type, "data": data})
async def mock_event_handler(event):
broadcasts.append({
"type": event.event_type,
"data": event.progress.to_dict()
})
download_service.set_broadcast_callback(mock_broadcast)
progress_svc.subscribe("progress_updated", mock_event_handler)
await download_service.add_to_queue(
await download_svc.add_to_queue(
serie_id="test_serie_3",
serie_folder="test_serie_3",
serie_name="Progress Test",
episodes=[EpisodeIdentifier(season=1, episode=1)],
)
await download_service.start_queue_processing()
await download_svc.start_queue_processing()
await asyncio.sleep(0.5)
# Get progress broadcasts in order
@@ -215,33 +248,37 @@ class TestDownloadProgressWebSocket:
# Verify we have multiple updates
assert len(progress_broadcasts) >= 2
# Verify progress increases
percentages = [
b["data"]["progress"]["percent"] for b in progress_broadcasts
# Verify progress increases (using current value)
current_values = [
b["data"].get("current", 0) for b in progress_broadcasts
]
# Each percentage should be >= the previous one
for i in range(1, len(percentages)):
assert percentages[i] >= percentages[i - 1]
# Each current value should be >= the previous one
for i in range(1, len(current_values)):
assert current_values[i] >= current_values[i - 1]
@pytest.mark.asyncio
async def test_progress_includes_speed_and_eta(self, download_service):
"""Test that progress updates include speed and ETA."""
download_svc, progress_svc = download_service
broadcasts: List[Dict[str, Any]] = []
async def mock_broadcast(update_type: str, data: dict):
broadcasts.append({"type": update_type, "data": data})
async def mock_event_handler(event):
broadcasts.append({
"type": event.event_type,
"data": event.progress.to_dict()
})
download_service.set_broadcast_callback(mock_broadcast)
progress_svc.subscribe("progress_updated", mock_event_handler)
await download_service.add_to_queue(
await download_svc.add_to_queue(
serie_id="test_serie_4",
serie_folder="test_serie_4",
serie_name="Speed Test",
episodes=[EpisodeIdentifier(season=1, episode=1)],
)
await download_service.start_queue_processing()
await download_svc.start_queue_processing()
await asyncio.sleep(0.5)
progress_broadcasts = [
@@ -250,23 +287,19 @@ class TestDownloadProgressWebSocket:
assert len(progress_broadcasts) > 0
# Check that speed and ETA are present
progress = progress_broadcasts[0]["data"]["progress"]
assert "speed_mbps" in progress
assert "eta_seconds" in progress
# Speed and ETA should be numeric (or None)
if progress["speed_mbps"] is not None:
assert isinstance(progress["speed_mbps"], (int, float))
if progress["eta_seconds"] is not None:
assert isinstance(progress["eta_seconds"], (int, float))
# Check that progress data is present
progress_data = progress_broadcasts[0]["data"]
assert "id" in progress_data
assert "type" in progress_data
assert progress_data["type"] == "download"
@pytest.mark.asyncio
async def test_no_broadcast_without_callback(self, download_service):
"""Test that no errors occur when broadcast callback is not set."""
# Don't set broadcast callback
"""Test that no errors occur when no event handlers subscribed."""
download_svc, progress_svc = download_service
# Don't subscribe to any events
await download_service.add_to_queue(
await download_svc.add_to_queue(
serie_id="test_serie_5",
serie_folder="test_serie_5",
serie_name="No Broadcast Test",
@@ -274,58 +307,63 @@ class TestDownloadProgressWebSocket:
)
# Should complete without errors
await download_service.start_queue_processing()
await download_svc.start_queue_processing()
await asyncio.sleep(0.5)
# Verify download completed successfully
status = await download_service.get_queue_status()
status = await download_svc.get_queue_status()
assert len(status.completed_downloads) == 1
@pytest.mark.asyncio
async def test_broadcast_error_handling(self, download_service):
"""Test that broadcast errors don't break download process."""
"""Test that event handler errors don't break download process."""
download_svc, progress_svc = download_service
error_count = 0
async def failing_broadcast(update_type: str, data: dict):
"""Broadcast that always fails."""
async def failing_handler(event):
"""Event handler that always fails."""
nonlocal error_count
error_count += 1
raise RuntimeError("Broadcast failed")
raise RuntimeError("Event handler failed")
download_service.set_broadcast_callback(failing_broadcast)
progress_svc.subscribe("progress_updated", failing_handler)
await download_service.add_to_queue(
await download_svc.add_to_queue(
serie_id="test_serie_6",
serie_folder="test_serie_6",
serie_name="Error Handling Test",
episodes=[EpisodeIdentifier(season=1, episode=1)],
)
# Should complete despite broadcast errors
await download_service.start_queue_processing()
# Should complete despite handler errors
await download_svc.start_queue_processing()
await asyncio.sleep(0.5)
# Verify download still completed
status = await download_service.get_queue_status()
status = await download_svc.get_queue_status()
assert len(status.completed_downloads) == 1
# Verify broadcast was attempted
# Verify handler was attempted
assert error_count > 0
@pytest.mark.asyncio
async def test_multiple_downloads_broadcast_separately(
self, download_service
):
"""Test that multiple downloads broadcast their progress separately."""
"""Test that multiple downloads emit progress separately."""
download_svc, progress_svc = download_service
broadcasts: List[Dict[str, Any]] = []
async def mock_broadcast(update_type: str, data: dict):
broadcasts.append({"type": update_type, "data": data})
async def mock_event_handler(event):
broadcasts.append({
"type": event.event_type,
"data": event.progress.to_dict()
})
download_service.set_broadcast_callback(mock_broadcast)
progress_svc.subscribe("progress_updated", mock_event_handler)
# Add multiple episodes
item_ids = await download_service.add_to_queue(
item_ids = await download_svc.add_to_queue(
serie_id="test_serie_7",
serie_folder="test_serie_7",
serie_name="Multi Episode Test",
@@ -338,8 +376,9 @@ class TestDownloadProgressWebSocket:
assert len(item_ids) == 2
# Start processing
await download_service.start_queue_processing()
await asyncio.sleep(1.0) # Give time for both downloads
# Give time for both downloads
await download_svc.start_queue_processing()
await asyncio.sleep(2.0)
# Get progress broadcasts
progress_broadcasts = [
@@ -347,39 +386,40 @@ class TestDownloadProgressWebSocket:
]
# Should have progress for both episodes
assert len(progress_broadcasts) >= 4 # At least 2 updates per episode
assert len(progress_broadcasts) >= 4 # At least 2 updates per ep
# Verify different download IDs
download_ids = set()
for broadcast in progress_broadcasts:
download_id = (
broadcast["data"].get("download_id")
or broadcast["data"].get("item_id")
)
if download_id:
download_id = broadcast["data"].get("id", "")
if "download_" in download_id:
download_ids.add(download_id)
# Should have at least 2 unique download IDs
# Should have at least 2 unique download progress IDs
assert len(download_ids) >= 2
@pytest.mark.asyncio
async def test_progress_data_format_matches_model(self, download_service):
"""Test that broadcast data matches DownloadProgress model."""
"""Test that event data matches Progress model."""
download_svc, progress_svc = download_service
broadcasts: List[Dict[str, Any]] = []
async def mock_broadcast(update_type: str, data: dict):
broadcasts.append({"type": update_type, "data": data})
async def mock_event_handler(event):
broadcasts.append({
"type": event.event_type,
"data": event.progress.to_dict()
})
download_service.set_broadcast_callback(mock_broadcast)
progress_svc.subscribe("progress_updated", mock_event_handler)
await download_service.add_to_queue(
await download_svc.add_to_queue(
serie_id="test_serie_8",
serie_folder="test_serie_8",
serie_name="Model Test",
episodes=[EpisodeIdentifier(season=1, episode=1)],
)
await download_service.start_queue_processing()
await download_svc.start_queue_processing()
await asyncio.sleep(0.5)
progress_broadcasts = [
@@ -388,12 +428,11 @@ class TestDownloadProgressWebSocket:
assert len(progress_broadcasts) > 0
# Verify progress can be parsed as DownloadProgress
progress_data = progress_broadcasts[0]["data"]["progress"]
progress = DownloadProgress(**progress_data)
# Verify progress follows Progress model structure
progress_data = progress_broadcasts[0]["data"]
# Verify required fields
assert isinstance(progress.percent, float)
assert isinstance(progress.downloaded_mb, float)
assert 0 <= progress.percent <= 100
assert progress.downloaded_mb >= 0
# Verify required fields from Progress model
assert "id" in progress_data
assert "type" in progress_data
assert "status" in progress_data
assert progress_data["type"] == "download"