Refactor code structure for improved readability and maintainability

tests/services/test_favorite.py

@@ -0,0 +1,548 @@
+"""Tests for favorite service."""
+
+from collections.abc import AsyncGenerator
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+import pytest_asyncio
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from app.models.favorite import Favorite
+from app.models.playlist import Playlist
+from app.models.sound import Sound
+from app.models.user import User
+from app.services.favorite import FavoriteService
+
+
+class TestFavoriteService:
+    """Test favorite service operations."""
+
+    @pytest_asyncio.fixture
+    async def mock_session_factory(self) -> AsyncGenerator[MagicMock]:
+        """Create a mock session factory."""
+        mock_session = AsyncMock(spec=AsyncSession)
+        mock_factory = MagicMock(return_value=mock_session)
+        mock_factory.return_value.__aenter__ = AsyncMock(return_value=mock_session)
+        mock_factory.return_value.__aexit__ = AsyncMock(return_value=None)
+        yield mock_factory
+
+    @pytest_asyncio.fixture
+    async def favorite_service(
+        self,
+        mock_session_factory: MagicMock,
+    ) -> AsyncGenerator[FavoriteService]:
+        """Create a favorite service instance with mocked dependencies."""
+        yield FavoriteService(mock_session_factory)
+
+    @pytest_asyncio.fixture
+    async def test_sound(self) -> Sound:
+        """Create a test sound."""
+        return Sound(
+            id=1,
+            filename="test_sound.mp3",
+            name="Test Sound",
+            type="SDB",
+            duration=5000,
+            size=1024000,
+            hash="abcdef123456789",
+        )
+
+    @pytest_asyncio.fixture
+    async def test_playlist(self, test_user: User) -> Playlist:
+        """Create a test playlist."""
+        return Playlist(
+            id=1,
+            user_id=test_user.id,
+            name="Test Playlist",
+            description="A test playlist",
+            genre="test",
+            is_main=False,
+            is_current=False,
+            is_deletable=True,
+        )
+
+    @pytest_asyncio.fixture
+    async def mock_repositories(self) -> dict:
+        """Create mock repositories."""
+        return {
+            "favorite_repo": AsyncMock(),
+            "user_repo": AsyncMock(),
+            "sound_repo": AsyncMock(),
+            "playlist_repo": AsyncMock(),
+        }
+
+    @patch("app.services.favorite.socket_manager")
+    @patch("app.services.favorite.FavoriteRepository")
+    @patch("app.services.favorite.UserRepository")
+    @patch("app.services.favorite.SoundRepository")
+    @pytest.mark.asyncio
+    async def test_add_sound_favorite_success(
+        self,
+        mock_sound_repo_class: AsyncMock,
+        mock_user_repo_class: AsyncMock,
+        mock_favorite_repo_class: AsyncMock,
+        mock_socket_manager: AsyncMock,
+        favorite_service: FavoriteService,
+        test_user: User,
+        test_sound: Sound,
+    ) -> None:
+        """Test successfully adding a sound favorite."""
+        # Setup mocks
+        mock_favorite_repo = AsyncMock()
+        mock_user_repo = AsyncMock()
+        mock_sound_repo = AsyncMock()
+
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+        mock_user_repo_class.return_value = mock_user_repo
+        mock_sound_repo_class.return_value = mock_sound_repo
+
+        mock_user_repo.get_by_id.return_value = test_user
+        mock_sound_repo.get_by_id.return_value = test_sound
+        mock_favorite_repo.get_by_user_and_sound.return_value = None
+
+        expected_favorite = Favorite(
+            id=1,
+            user_id=test_user.id,
+            sound_id=test_sound.id,
+            playlist_id=None,
+        )
+        mock_favorite_repo.create.return_value = expected_favorite
+        mock_favorite_repo.count_sound_favorites.return_value = 1
+
+        # Execute
+        result = await favorite_service.add_sound_favorite(test_user.id, test_sound.id)
+
+        # Verify
+        assert result == expected_favorite
+        mock_user_repo.get_by_id.assert_called_once_with(test_user.id)
+        mock_sound_repo.get_by_id.assert_called_once_with(test_sound.id)
+        mock_favorite_repo.get_by_user_and_sound.assert_called_once_with(test_user.id, test_sound.id)
+        mock_favorite_repo.create.assert_called_once_with({
+            "user_id": test_user.id,
+            "sound_id": test_sound.id,
+            "playlist_id": None,
+        })
+        mock_socket_manager.broadcast_to_all.assert_called_once()
+
+    @patch("app.services.favorite.UserRepository")
+    @pytest.mark.asyncio
+    async def test_add_sound_favorite_user_not_found(
+        self,
+        mock_user_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test adding sound favorite when user not found."""
+        mock_user_repo = AsyncMock()
+        mock_user_repo_class.return_value = mock_user_repo
+        mock_user_repo.get_by_id.return_value = None
+
+        with pytest.raises(ValueError, match="User with ID 1 not found"):
+            await favorite_service.add_sound_favorite(1, 1)
+
+    @patch("app.services.favorite.SoundRepository")
+    @patch("app.services.favorite.UserRepository")
+    @pytest.mark.asyncio
+    async def test_add_sound_favorite_sound_not_found(
+        self,
+        mock_user_repo_class: AsyncMock,
+        mock_sound_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+        test_user: User,
+    ) -> None:
+        """Test adding sound favorite when sound not found."""
+        mock_user_repo = AsyncMock()
+        mock_sound_repo = AsyncMock()
+        mock_user_repo_class.return_value = mock_user_repo
+        mock_sound_repo_class.return_value = mock_sound_repo
+
+        mock_user_repo.get_by_id.return_value = test_user
+        mock_sound_repo.get_by_id.return_value = None
+
+        with pytest.raises(ValueError, match="Sound with ID 1 not found"):
+            await favorite_service.add_sound_favorite(test_user.id, 1)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @patch("app.services.favorite.SoundRepository")
+    @patch("app.services.favorite.UserRepository")
+    @pytest.mark.asyncio
+    async def test_add_sound_favorite_already_exists(
+        self,
+        mock_user_repo_class: AsyncMock,
+        mock_sound_repo_class: AsyncMock,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+        test_user: User,
+        test_sound: Sound,
+    ) -> None:
+        """Test adding sound favorite that already exists."""
+        mock_user_repo = AsyncMock()
+        mock_sound_repo = AsyncMock()
+        mock_favorite_repo = AsyncMock()
+
+        mock_user_repo_class.return_value = mock_user_repo
+        mock_sound_repo_class.return_value = mock_sound_repo
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        mock_user_repo.get_by_id.return_value = test_user
+        mock_sound_repo.get_by_id.return_value = test_sound
+        existing_favorite = Favorite(user_id=test_user.id, sound_id=test_sound.id)
+        mock_favorite_repo.get_by_user_and_sound.return_value = existing_favorite
+
+        with pytest.raises(ValueError, match="already favorited"):
+            await favorite_service.add_sound_favorite(test_user.id, test_sound.id)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @patch("app.services.favorite.PlaylistRepository")
+    @patch("app.services.favorite.UserRepository")
+    @pytest.mark.asyncio
+    async def test_add_playlist_favorite_success(
+        self,
+        mock_user_repo_class: AsyncMock,
+        mock_playlist_repo_class: AsyncMock,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+        test_user: User,
+        test_playlist: Playlist,
+    ) -> None:
+        """Test successfully adding a playlist favorite."""
+        # Setup mocks
+        mock_favorite_repo = AsyncMock()
+        mock_user_repo = AsyncMock()
+        mock_playlist_repo = AsyncMock()
+
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+        mock_user_repo_class.return_value = mock_user_repo
+        mock_playlist_repo_class.return_value = mock_playlist_repo
+
+        mock_user_repo.get_by_id.return_value = test_user
+        mock_playlist_repo.get_by_id.return_value = test_playlist
+        mock_favorite_repo.get_by_user_and_playlist.return_value = None
+
+        expected_favorite = Favorite(
+            id=1,
+            user_id=test_user.id,
+            sound_id=None,
+            playlist_id=test_playlist.id,
+        )
+        mock_favorite_repo.create.return_value = expected_favorite
+
+        # Execute
+        result = await favorite_service.add_playlist_favorite(test_user.id, test_playlist.id)
+
+        # Verify
+        assert result == expected_favorite
+        mock_user_repo.get_by_id.assert_called_once_with(test_user.id)
+        mock_playlist_repo.get_by_id.assert_called_once_with(test_playlist.id)
+        mock_favorite_repo.get_by_user_and_playlist.assert_called_once_with(test_user.id, test_playlist.id)
+        mock_favorite_repo.create.assert_called_once_with({
+            "user_id": test_user.id,
+            "sound_id": None,
+            "playlist_id": test_playlist.id,
+        })
+
+    @patch("app.services.favorite.socket_manager")
+    @patch("app.services.favorite.FavoriteRepository")
+    @patch("app.services.favorite.SoundRepository")
+    @patch("app.services.favorite.UserRepository")
+    @pytest.mark.asyncio
+    async def test_remove_sound_favorite_success(
+        self,
+        mock_user_repo_class: AsyncMock,
+        mock_sound_repo_class: AsyncMock,
+        mock_favorite_repo_class: AsyncMock,
+        mock_socket_manager: AsyncMock,
+        favorite_service: FavoriteService,
+        test_user: User,
+        test_sound: Sound,
+    ) -> None:
+        """Test successfully removing a sound favorite."""
+        mock_favorite_repo = AsyncMock()
+        mock_user_repo = AsyncMock()
+        mock_sound_repo = AsyncMock()
+
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+        mock_user_repo_class.return_value = mock_user_repo
+        mock_sound_repo_class.return_value = mock_sound_repo
+
+        existing_favorite = Favorite(user_id=test_user.id, sound_id=test_sound.id)
+        mock_favorite_repo.get_by_user_and_sound.return_value = existing_favorite
+        mock_user_repo.get_by_id.return_value = test_user
+        mock_sound_repo.get_by_id.return_value = test_sound
+        mock_favorite_repo.count_sound_favorites.return_value = 0
+
+        # Execute
+        await favorite_service.remove_sound_favorite(test_user.id, test_sound.id)
+
+        # Verify
+        mock_favorite_repo.get_by_user_and_sound.assert_called_once_with(test_user.id, test_sound.id)
+        mock_favorite_repo.delete.assert_called_once_with(existing_favorite)
+        mock_socket_manager.broadcast_to_all.assert_called_once()
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_remove_sound_favorite_not_found(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test removing sound favorite that doesn't exist."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+        mock_favorite_repo.get_by_user_and_sound.return_value = None
+
+        with pytest.raises(ValueError, match="is not favorited"):
+            await favorite_service.remove_sound_favorite(1, 1)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_remove_playlist_favorite_success(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+        test_user: User,
+        test_playlist: Playlist,
+    ) -> None:
+        """Test successfully removing a playlist favorite."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        existing_favorite = Favorite(user_id=test_user.id, playlist_id=test_playlist.id)
+        mock_favorite_repo.get_by_user_and_playlist.return_value = existing_favorite
+
+        # Execute
+        await favorite_service.remove_playlist_favorite(test_user.id, test_playlist.id)
+
+        # Verify
+        mock_favorite_repo.get_by_user_and_playlist.assert_called_once_with(test_user.id, test_playlist.id)
+        mock_favorite_repo.delete.assert_called_once_with(existing_favorite)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_remove_playlist_favorite_not_found(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test removing playlist favorite that doesn't exist."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+        mock_favorite_repo.get_by_user_and_playlist.return_value = None
+
+        with pytest.raises(ValueError, match="is not favorited"):
+            await favorite_service.remove_playlist_favorite(1, 1)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_get_user_favorites(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test getting user favorites."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        expected_favorites = [
+            Favorite(id=1, user_id=1, sound_id=1),
+            Favorite(id=2, user_id=1, playlist_id=1),
+        ]
+        mock_favorite_repo.get_user_favorites.return_value = expected_favorites
+
+        # Execute
+        result = await favorite_service.get_user_favorites(1, 10, 0)
+
+        # Verify
+        assert result == expected_favorites
+        mock_favorite_repo.get_user_favorites.assert_called_once_with(1, 10, 0)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_get_user_sound_favorites(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test getting user sound favorites."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        expected_favorites = [Favorite(id=1, user_id=1, sound_id=1)]
+        mock_favorite_repo.get_user_sound_favorites.return_value = expected_favorites
+
+        # Execute
+        result = await favorite_service.get_user_sound_favorites(1, 10, 0)
+
+        # Verify
+        assert result == expected_favorites
+        mock_favorite_repo.get_user_sound_favorites.assert_called_once_with(1, 10, 0)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_get_user_playlist_favorites(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test getting user playlist favorites."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        expected_favorites = [Favorite(id=1, user_id=1, playlist_id=1)]
+        mock_favorite_repo.get_user_playlist_favorites.return_value = expected_favorites
+
+        # Execute
+        result = await favorite_service.get_user_playlist_favorites(1, 10, 0)
+
+        # Verify
+        assert result == expected_favorites
+        mock_favorite_repo.get_user_playlist_favorites.assert_called_once_with(1, 10, 0)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_is_sound_favorited(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test checking if sound is favorited."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        mock_favorite_repo.is_sound_favorited.return_value = True
+
+        # Execute
+        result = await favorite_service.is_sound_favorited(1, 1)
+
+        # Verify
+        assert result is True
+        mock_favorite_repo.is_sound_favorited.assert_called_once_with(1, 1)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_is_playlist_favorited(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test checking if playlist is favorited."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        mock_favorite_repo.is_playlist_favorited.return_value = False
+
+        # Execute
+        result = await favorite_service.is_playlist_favorited(1, 1)
+
+        # Verify
+        assert result is False
+        mock_favorite_repo.is_playlist_favorited.assert_called_once_with(1, 1)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_get_favorite_counts(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test getting favorite counts."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        mock_favorite_repo.count_user_favorites.return_value = 3
+        mock_favorite_repo.get_user_sound_favorites.return_value = [1, 2]  # 2 sounds
+        mock_favorite_repo.get_user_playlist_favorites.return_value = [1]  # 1 playlist
+
+        # Execute
+        result = await favorite_service.get_favorite_counts(1)
+
+        # Verify
+        expected = {
+            "total": 3,
+            "sounds": 2,
+            "playlists": 1,
+        }
+        assert result == expected
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_get_sound_favorite_count(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test getting sound favorite count."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        mock_favorite_repo.count_sound_favorites.return_value = 5
+
+        # Execute
+        result = await favorite_service.get_sound_favorite_count(1)
+
+        # Verify
+        assert result == 5
+        mock_favorite_repo.count_sound_favorites.assert_called_once_with(1)
+
+    @patch("app.services.favorite.FavoriteRepository")
+    @pytest.mark.asyncio
+    async def test_get_playlist_favorite_count(
+        self,
+        mock_favorite_repo_class: AsyncMock,
+        favorite_service: FavoriteService,
+    ) -> None:
+        """Test getting playlist favorite count."""
+        mock_favorite_repo = AsyncMock()
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+
+        mock_favorite_repo.count_playlist_favorites.return_value = 3
+
+        # Execute
+        result = await favorite_service.get_playlist_favorite_count(1)
+
+        # Verify
+        assert result == 3
+        mock_favorite_repo.count_playlist_favorites.assert_called_once_with(1)
+
+    @patch("app.services.favorite.socket_manager")
+    @patch("app.services.favorite.FavoriteRepository")
+    @patch("app.services.favorite.SoundRepository")
+    @patch("app.services.favorite.UserRepository")
+    @pytest.mark.asyncio
+    async def test_socket_broadcast_error_handling(
+        self,
+        mock_user_repo_class: AsyncMock,
+        mock_sound_repo_class: AsyncMock,
+        mock_favorite_repo_class: AsyncMock,
+        mock_socket_manager: AsyncMock,
+        favorite_service: FavoriteService,
+        test_user: User,
+        test_sound: Sound,
+    ) -> None:
+        """Test that socket broadcast errors don't affect the operation."""
+        # Setup mocks
+        mock_favorite_repo = AsyncMock()
+        mock_user_repo = AsyncMock()
+        mock_sound_repo = AsyncMock()
+
+        mock_favorite_repo_class.return_value = mock_favorite_repo
+        mock_user_repo_class.return_value = mock_user_repo
+        mock_sound_repo_class.return_value = mock_sound_repo
+
+        mock_user_repo.get_by_id.return_value = test_user
+        mock_sound_repo.get_by_id.return_value = test_sound
+        mock_favorite_repo.get_by_user_and_sound.return_value = None
+
+        expected_favorite = Favorite(id=1, user_id=test_user.id, sound_id=test_sound.id)
+        mock_favorite_repo.create.return_value = expected_favorite
+        mock_favorite_repo.count_sound_favorites.return_value = 1
+
+        # Make socket broadcast raise an exception
+        mock_socket_manager.broadcast_to_all.side_effect = Exception("Socket error")
+
+        # Execute - should not raise exception despite socket error
+        result = await favorite_service.add_sound_favorite(test_user.id, test_sound.id)
+
+        # Verify operation still succeeded
+        assert result == expected_favorite
+        mock_favorite_repo.create.assert_called_once()
+