Aniworld/tests/integration/test_data_file_db_sync.py

"""Integration tests for data file to database synchronization.

This module verifies that the data file to database sync functionality
works correctly, including:
- Loading series from data files
- Adding series to the database
- Preventing duplicate entries
- Handling corrupt or missing files gracefully
- End-to-end startup sync behavior

The sync functionality allows existing series metadata stored in
data files to be automatically imported into the database during
application startup.
"""
import json
import os
import tempfile
from unittest.mock import AsyncMock, Mock, patch

import pytest

from src.server.database.models import AnimeSeries
from src.server.SeriesApp import SeriesApp


class TestGetAllSeriesFromDataFiles:
    """Test SeriesApp.get_all_series_from_data_files() method."""

    def test_returns_empty_list_for_empty_directory(self):
        """Test that empty directory returns empty list."""
        with tempfile.TemporaryDirectory() as tmp_dir:
            with patch('src.server.SeriesApp.Loaders'), \
                 patch('src.server.SeriesApp.SerieScanner'):
                app = SeriesApp(tmp_dir)
                result = app.get_all_series_from_data_files()

                assert isinstance(result, list)
                assert len(result) == 0

    def test_returns_series_from_data_files(self):
        """Test that valid data files are loaded correctly."""
        with tempfile.TemporaryDirectory() as tmp_dir:
            # Create test data files
            _create_test_data_file(
                tmp_dir,
                folder="Anime Test 1",
                key="anime-test-1",
                name="Anime Test 1",
                episodes={1: [1, 2, 3]}
            )
            _create_test_data_file(
                tmp_dir,
                folder="Anime Test 2",
                key="anime-test-2",
                name="Anime Test 2",
                episodes={1: [1]}
            )

            with patch('src.server.SeriesApp.Loaders'), \
                 patch('src.server.SeriesApp.SerieScanner'):
                app = SeriesApp(tmp_dir)
                result = app.get_all_series_from_data_files()

                assert isinstance(result, list)
                assert len(result) == 2
                keys = {s.key for s in result}
                assert "anime-test-1" in keys
                assert "anime-test-2" in keys

    def test_handles_corrupt_data_files_gracefully(self):
        """Test that corrupt data files don't crash the sync."""
        with tempfile.TemporaryDirectory() as tmp_dir:
            # Create a valid data file
            _create_test_data_file(
                tmp_dir,
                folder="Valid Anime",
                key="valid-anime",
                name="Valid Anime",
                episodes={1: [1]}
            )

            # Create a corrupt data file (invalid JSON)
            corrupt_dir = os.path.join(tmp_dir, "Corrupt Anime")
            os.makedirs(corrupt_dir, exist_ok=True)
            with open(os.path.join(corrupt_dir, "data"), "w") as f:
                f.write("this is not valid json {{{")

            with patch('src.server.SeriesApp.Loaders'), \
                 patch('src.server.SeriesApp.SerieScanner'):
                app = SeriesApp(tmp_dir)
                result = app.get_all_series_from_data_files()

                # Should still return the valid series
                assert isinstance(result, list)
                assert len(result) >= 1
                # The valid anime should be loaded
                keys = {s.key for s in result}
                assert "valid-anime" in keys

    def test_handles_missing_directory_gracefully(self):
        """Test that non-existent directory returns empty list."""
        non_existent_dir = "/non/existent/directory/path"

        with patch('src.server.SeriesApp.Loaders'), \
             patch('src.server.SeriesApp.SerieScanner'):
            app = SeriesApp(non_existent_dir)
            result = app.get_all_series_from_data_files()

            assert isinstance(result, list)
            assert len(result) == 0


class TestEndToEndSync:
    """End-to-end tests for the sync functionality."""

    @pytest.mark.asyncio
    async def test_startup_sync_integration(self):
        """Test end-to-end startup sync behavior."""
        # This test verifies the integration of all components
        with tempfile.TemporaryDirectory() as tmp_dir:
            # Create test data
            _create_test_data_file(
                tmp_dir,
                folder="E2E Test Anime 1",
                key="e2e-test-anime-1",
                name="E2E Test Anime 1",
                episodes={1: [1, 2, 3]}
            )
            _create_test_data_file(
                tmp_dir,
                folder="E2E Test Anime 2",
                key="e2e-test-anime-2",
                name="E2E Test Anime 2",
                episodes={1: [1], 2: [1, 2]}
            )

            # Use SeriesApp to load series from files
            with patch('src.server.SeriesApp.Loaders'), \
                 patch('src.server.SeriesApp.SerieScanner'):
                app = SeriesApp(tmp_dir)
                all_series = app.get_all_series_from_data_files()

                # Verify all series were loaded
                assert len(all_series) == 2

                # Verify series data is correct
                series_by_key = {s.key: s for s in all_series}
                assert "e2e-test-anime-1" in series_by_key
                assert "e2e-test-anime-2" in series_by_key

                # Verify episode data
                anime1 = series_by_key["e2e-test-anime-1"]
                assert anime1.episodeDict == {1: [1, 2, 3]}

                anime2 = series_by_key["e2e-test-anime-2"]
                assert anime2.episodeDict == {1: [1], 2: [1, 2]}


def _create_test_data_file(
    base_dir: str,
    folder: str,
    key: str,
    name: str,
    episodes: dict
) -> None:
    """
    Create a test data file in the anime directory.

    Args:
        base_dir: Base directory for anime folders
        folder: Folder name for the anime
        key: Unique key for the series
        name: Display name of the series
        episodes: Dictionary mapping season to list of episode numbers
    """
    anime_dir = os.path.join(base_dir, folder)
    os.makedirs(anime_dir, exist_ok=True)

    data = {
        "key": key,
        "name": name,
        "site": "https://aniworld.to",
        "folder": folder,
        "episodeDict": {str(k): v for k, v in episodes.items()}
    }

    data_file = os.path.join(anime_dir, "data")
    with open(data_file, "w", encoding="utf-8") as f:
        json.dump(data, f, indent=2)