alfred/tests/application/test_list_folder_move_media.py

"""Tests for ListFolderUseCase and MoveMediaUseCase."""

import pytest
from unittest.mock import MagicMock

from alfred.application.filesystem.list_folder import ListFolderUseCase
from alfred.application.filesystem.move_media import MoveMediaUseCase


# ---------------------------------------------------------------------------
# ListFolderUseCase
# ---------------------------------------------------------------------------

class TestListFolderUseCase:

    def _use_case(self, fm_result):
        fm = MagicMock()
        fm.list_folder.return_value = fm_result
        return ListFolderUseCase(fm)

    def test_success_returns_response(self):
        uc = self._use_case({
            "status": "ok",
            "folder_type": "download",
            "path": ".",
            "entries": ["movie.mkv", "show/"],
            "count": 2,
        })
        resp = uc.execute("download")
        assert resp.status == "ok"
        assert resp.folder_type == "download"
        assert resp.path == "."
        assert resp.entries == ["movie.mkv", "show/"]
        assert resp.count == 2

    def test_error_propagates(self):
        uc = self._use_case({
            "status": "error",
            "error": "folder_not_set",
            "message": "Download folder not configured.",
        })
        resp = uc.execute("download")
        assert resp.status == "error"
        assert resp.error == "folder_not_set"
        assert resp.message == "Download folder not configured."

    def test_delegates_folder_type_and_path(self):
        fm = MagicMock()
        fm.list_folder.return_value = {
            "status": "ok",
            "folder_type": "tv_show",
            "path": "Breaking Bad",
            "entries": [],
            "count": 0,
        }
        uc = ListFolderUseCase(fm)
        uc.execute("tv_show", "Breaking Bad")
        fm.list_folder.assert_called_once_with("tv_show", "Breaking Bad")

    def test_default_path_is_dot(self):
        fm = MagicMock()
        fm.list_folder.return_value = {
            "status": "ok", "folder_type": "download",
            "path": ".", "entries": [], "count": 0,
        }
        uc = ListFolderUseCase(fm)
        uc.execute("download")
        fm.list_folder.assert_called_once_with("download", ".")

    def test_success_response_has_no_error(self):
        uc = self._use_case({
            "status": "ok",
            "folder_type": "movie",
            "path": ".",
            "entries": [],
            "count": 0,
        })
        resp = uc.execute("movie")
        assert resp.error is None

    def test_error_response_has_no_entries(self):
        uc = self._use_case({
            "status": "error",
            "error": "not_found",
            "message": "Path does not exist",
        })
        resp = uc.execute("download", "some/path")
        assert resp.entries is None
        assert resp.count is None


# ---------------------------------------------------------------------------
# MoveMediaUseCase
# ---------------------------------------------------------------------------

class TestMoveMediaUseCase:

    def _use_case(self, fm_result):
        fm = MagicMock()
        fm.move_file.return_value = fm_result
        return MoveMediaUseCase(fm)

    def test_success_returns_response(self, tmp_path):
        src = str(tmp_path / "src.mkv")
        dst = str(tmp_path / "dst.mkv")
        uc = self._use_case({
            "status": "ok",
            "source": src,
            "destination": dst,
            "filename": "dst.mkv",
            "size": 1024,
        })
        resp = uc.execute(src, dst)
        assert resp.status == "ok"
        assert resp.source == src
        assert resp.destination == dst
        assert resp.filename == "dst.mkv"
        assert resp.size == 1024

    def test_error_propagates(self, tmp_path):
        uc = self._use_case({
            "status": "error",
            "error": "source_not_found",
            "message": "Source does not exist: /ghost.mkv",
        })
        resp = uc.execute("/ghost.mkv", str(tmp_path / "dst.mkv"))
        assert resp.status == "error"
        assert resp.error == "source_not_found"

    def test_delegates_to_file_manager(self, tmp_path):
        src = "/downloads/movie.mkv"
        dst = "/movies/Movie.2024/movie.mkv"
        fm = MagicMock()
        fm.move_file.return_value = {
            "status": "ok", "source": src, "destination": dst,
            "filename": "movie.mkv", "size": 1,
        }
        uc = MoveMediaUseCase(fm)
        uc.execute(src, dst)
        fm.move_file.assert_called_once_with(src, dst)

    def test_error_response_has_no_paths(self):
        uc = self._use_case({
            "status": "error",
            "error": "destination_exists",
            "message": "File already exists",
        })
        resp = uc.execute("/src.mkv", "/dst.mkv")
        assert resp.source is None
        assert resp.destination is None
        assert resp.filename is None

    def test_to_dict_success(self, tmp_path):
        src = "/downloads/movie.mkv"
        dst = "/movies/movie.mkv"
        uc = self._use_case({
            "status": "ok",
            "source": src,
            "destination": dst,
            "filename": "movie.mkv",
            "size": 2048,
        })
        resp = uc.execute(src, dst)
        d = resp.to_dict()
        assert d["status"] == "ok"
        assert d["filename"] == "movie.mkv"
        assert d["size"] == 2048

    def test_to_dict_error(self):
        uc = self._use_case({
            "status": "error",
            "error": "link_failed",
            "message": "Cross-device link not permitted",
        })
        resp = uc.execute("/src.mkv", "/dst.mkv")
        d = resp.to_dict()
        assert d["status"] == "error"
        assert "error" in d
        assert "message" in d