273 lines
11 KiB
Python
273 lines
11 KiB
Python
from unittest.mock import MagicMock, Mock, patch
|
|
|
|
from app.library.Utils import REMOVE_KEYS
|
|
from app.library.ytdlp import YTDLP, _ArchiveProxy, ytdlp_options
|
|
|
|
|
|
class TestArchiveProxy:
|
|
def test_bool_and_falsey_cases(self) -> None:
|
|
# No file path means proxy is falsey and operations return False
|
|
p = _ArchiveProxy(file=None)
|
|
assert bool(p) is False
|
|
assert ("id" in p) is False
|
|
assert p.add("id") is False
|
|
|
|
# Empty item also returns False
|
|
p2 = _ArchiveProxy(file="/tmp/archive.txt")
|
|
assert bool(p2) is True
|
|
assert ("" in p2) is False
|
|
assert p2.add("") is False
|
|
|
|
@patch("app.library.Archiver.Archiver.get_instance")
|
|
def test_contains_and_add_delegate_to_archiver(self, mock_get_instance) -> None:
|
|
arch = MagicMock()
|
|
mock_get_instance.return_value = arch
|
|
|
|
p = _ArchiveProxy(file="/tmp/archive.txt")
|
|
|
|
# contains -> read(file, [item]) and check membership
|
|
arch.read.return_value = ["abc"]
|
|
assert ("abc" in p) is True
|
|
arch.read.assert_called_with("/tmp/archive.txt", ["abc"])
|
|
|
|
arch.read.return_value = []
|
|
assert ("xyz" in p) is False
|
|
|
|
# add -> add(file, [item]) returns boolean
|
|
arch.add.return_value = True
|
|
assert p.add("abc") is True
|
|
arch.add.assert_called_with("/tmp/archive.txt", ["abc"])
|
|
|
|
arch.add.return_value = False
|
|
assert p.add("xyz") is False
|
|
|
|
|
|
class TestYtDlpOptions:
|
|
def test_options_structure_and_no_suppresshelp(self) -> None:
|
|
opts = ytdlp_options()
|
|
|
|
assert isinstance(opts, list)
|
|
assert len(opts) > 0
|
|
|
|
# Every entry should have required keys
|
|
for o in opts:
|
|
assert {"flags", "description", "group", "ignored"} <= set(o.keys())
|
|
assert isinstance(o["flags"], list)
|
|
assert len(o["flags"]) > 0
|
|
# Ensure SUPPRESSHELP has been normalized away
|
|
if isinstance(o.get("description"), str):
|
|
assert "SUPPRESSHELP" not in o["description"]
|
|
|
|
def test_ignored_flags_match_remove_keys(self) -> None:
|
|
# Collect the flags that should be ignored from REMOVE_KEYS
|
|
ignored_flags: set[str] = {
|
|
f.strip() for group in REMOVE_KEYS for v in group.values() for f in v.split(",") if f.strip()
|
|
}
|
|
|
|
opts = ytdlp_options()
|
|
|
|
# Map flag -> ignored value as reported by our function (first match wins)
|
|
flag_to_ignored: dict[str, bool] = {}
|
|
for o in opts:
|
|
for f in o["flags"]:
|
|
if f not in flag_to_ignored:
|
|
flag_to_ignored[f] = bool(o["ignored"]) # normalize to bool
|
|
|
|
# For any ignored flag that actually exists in yt-dlp parser, ensure it is marked ignored
|
|
present_ignored_flags = [f for f in ignored_flags if f in flag_to_ignored]
|
|
assert len(present_ignored_flags) > 0, "We expect at least one to be present (e.g., -P / --paths, etc.)"
|
|
assert all(flag_to_ignored[f] is True for f in present_ignored_flags)
|
|
|
|
|
|
class TestYTDLP:
|
|
"""Test the YTDLP class overridden methods."""
|
|
|
|
def _create_ytdlp(self, params=None):
|
|
"""Helper to create a YTDLP instance with mocked parent __init__."""
|
|
with patch("app.library.ytdlp.yt_dlp.YoutubeDL.__init__", return_value=None):
|
|
ytdlp = YTDLP(params=params)
|
|
ytdlp.params = params or {}
|
|
return ytdlp
|
|
|
|
@patch("app.library.ytdlp.yt_dlp.YoutubeDL.__init__")
|
|
def test_init_patches_download_archive_param(self, mock_super_init) -> None:
|
|
"""Test that __init__ removes download_archive before calling super, then restores it."""
|
|
mock_super_init.return_value = None
|
|
|
|
params = {"download_archive": "/tmp/archive.txt", "quiet": True}
|
|
|
|
ytdlp = YTDLP(params=params, auto_init=True)
|
|
# Set params as it would be after super().__init__
|
|
ytdlp.params = {}
|
|
|
|
# Verify super().__init__ was called without download_archive
|
|
mock_super_init.assert_called_once()
|
|
call_kwargs = mock_super_init.call_args[1]
|
|
assert "download_archive" not in call_kwargs["params"]
|
|
assert call_kwargs["params"]["quiet"] is True
|
|
assert call_kwargs["auto_init"] is True
|
|
|
|
# Our __init__ code manually sets these after super()
|
|
ytdlp.params["download_archive"] = "/tmp/archive.txt"
|
|
|
|
assert ytdlp.params["download_archive"] == "/tmp/archive.txt", "Verify download_archive was restored to params"
|
|
|
|
# Verify archive proxy was set up
|
|
assert isinstance(ytdlp.archive, _ArchiveProxy)
|
|
assert ytdlp.archive._file == "/tmp/archive.txt"
|
|
|
|
@patch("app.library.ytdlp.yt_dlp.YoutubeDL.__init__")
|
|
def test_init_handles_no_download_archive(self, mock_super_init) -> None:
|
|
"""Test __init__ works correctly when download_archive is not in params."""
|
|
mock_super_init.return_value = None
|
|
|
|
params = {"quiet": True}
|
|
|
|
ytdlp = YTDLP(params=params, auto_init=False)
|
|
|
|
# Verify super().__init__ was called with original params
|
|
mock_super_init.assert_called_once()
|
|
call_kwargs = mock_super_init.call_args[1]
|
|
assert call_kwargs["params"]["quiet"] is True
|
|
assert call_kwargs["auto_init"] is False
|
|
|
|
assert isinstance(ytdlp.archive, _ArchiveProxy), "Verify archive proxy is falsey"
|
|
assert not ytdlp.archive
|
|
|
|
@patch("app.library.ytdlp.yt_dlp.YoutubeDL.__init__")
|
|
def test_init_handles_none_params(self, mock_super_init) -> None:
|
|
"""Test __init__ handles None params gracefully."""
|
|
mock_super_init.return_value = None
|
|
|
|
ytdlp = YTDLP(params=None)
|
|
|
|
mock_super_init.assert_called_once_with(params=None, auto_init=True)
|
|
assert isinstance(ytdlp.archive, _ArchiveProxy)
|
|
assert not ytdlp.archive
|
|
|
|
@patch("app.library.ytdlp.yt_dlp.YoutubeDL._delete_downloaded_files")
|
|
def test_delete_downloaded_files_skips_when_interrupted(self, mock_super_delete) -> None:
|
|
"""Test _delete_downloaded_files skips cleanup when _interrupted is True."""
|
|
with patch("app.library.ytdlp.yt_dlp.YoutubeDL.__init__", return_value=None):
|
|
ytdlp = YTDLP(params={})
|
|
ytdlp.to_screen = Mock()
|
|
|
|
# Set interrupted flag
|
|
ytdlp._interrupted = True
|
|
|
|
result = ytdlp._delete_downloaded_files("arg1", "arg2", kwarg1="value1")
|
|
|
|
# Should not call super method
|
|
mock_super_delete.assert_not_called()
|
|
# Should show message
|
|
ytdlp.to_screen.assert_called_once_with("[info] Cancelled — skipping temp cleanup.")
|
|
# Should return None
|
|
assert result is None
|
|
|
|
@patch("app.library.ytdlp.yt_dlp.YoutubeDL._delete_downloaded_files")
|
|
def test_delete_downloaded_files_calls_super_when_not_interrupted(self, mock_super_delete) -> None:
|
|
"""Test _delete_downloaded_files calls super when not interrupted."""
|
|
mock_super_delete.return_value = "cleanup_result"
|
|
|
|
with patch("app.library.ytdlp.yt_dlp.YoutubeDL.__init__", return_value=None):
|
|
ytdlp = YTDLP(params={})
|
|
ytdlp._interrupted = False
|
|
|
|
result = ytdlp._delete_downloaded_files("arg1", kwarg1="value1")
|
|
|
|
# Should call super method with same args
|
|
mock_super_delete.assert_called_once_with("arg1", kwarg1="value1")
|
|
# Should return super's result
|
|
assert result == "cleanup_result"
|
|
|
|
def test_record_download_archive_does_nothing_without_download_archive_param(self) -> None:
|
|
"""Test record_download_archive returns early when download_archive is not set."""
|
|
ytdlp = self._create_ytdlp(params={})
|
|
ytdlp.archive = Mock()
|
|
|
|
ytdlp.record_download_archive({"id": "test123"})
|
|
|
|
# Should not interact with archive
|
|
ytdlp.archive.add.assert_not_called()
|
|
|
|
def test_record_download_archive_adds_archive_id(self) -> None:
|
|
"""Test record_download_archive adds the archive ID."""
|
|
ytdlp = self._create_ytdlp(params={"download_archive": "/tmp/archive.txt"})
|
|
ytdlp.write_debug = Mock()
|
|
ytdlp.archive = Mock()
|
|
ytdlp._make_archive_id = Mock(return_value="youtube test123")
|
|
|
|
info_dict = {"id": "test123", "ie_key": "Youtube"}
|
|
|
|
ytdlp.record_download_archive(info_dict)
|
|
|
|
# Verify _make_archive_id was called
|
|
ytdlp._make_archive_id.assert_called_once_with(info_dict)
|
|
|
|
# Verify archive.add was called with the archive_id
|
|
ytdlp.archive.add.assert_called_once_with("youtube test123")
|
|
ytdlp.write_debug.assert_called_with("Adding to archive: youtube test123")
|
|
|
|
def test_record_download_archive_handles_old_archive_ids(self) -> None:
|
|
"""Test record_download_archive adds _old_archive_ids when present."""
|
|
ytdlp = self._create_ytdlp(params={"download_archive": "/tmp/archive.txt"})
|
|
ytdlp.write_debug = Mock()
|
|
ytdlp.archive = Mock()
|
|
ytdlp._make_archive_id = Mock(return_value="youtube new123")
|
|
|
|
info_dict = {
|
|
"id": "new123",
|
|
"ie_key": "Youtube",
|
|
"_old_archive_ids": ["youtube old123", "youtube old456", "youtube new123"],
|
|
}
|
|
|
|
ytdlp.record_download_archive(info_dict)
|
|
|
|
# Should add main archive_id
|
|
assert ytdlp.archive.add.call_count == 3
|
|
calls = [call[0][0] for call in ytdlp.archive.add.call_args_list]
|
|
|
|
assert calls[0] == "youtube new123", "First call is main archive_id"
|
|
|
|
# Should add old IDs except the duplicate
|
|
assert "youtube old123" in calls
|
|
assert "youtube old456" in calls
|
|
# Should not add duplicate (youtube new123 appears only once)
|
|
assert calls.count("youtube new123") == 1
|
|
|
|
def test_record_download_archive_skips_empty_old_archive_ids(self) -> None:
|
|
"""Test record_download_archive handles empty or invalid _old_archive_ids."""
|
|
ytdlp = self._create_ytdlp(params={"download_archive": "/tmp/archive.txt"})
|
|
ytdlp.write_debug = Mock()
|
|
ytdlp.archive = Mock()
|
|
ytdlp._make_archive_id = Mock(return_value="youtube test123")
|
|
|
|
# Test with empty list
|
|
info_dict = {"id": "test123", "ie_key": "Youtube", "_old_archive_ids": []}
|
|
ytdlp.record_download_archive(info_dict)
|
|
assert ytdlp.archive.add.call_count == 1 # Only main ID
|
|
|
|
ytdlp.archive.reset_mock()
|
|
|
|
# Test with None
|
|
info_dict = {"id": "test123", "ie_key": "Youtube", "_old_archive_ids": None}
|
|
ytdlp.record_download_archive(info_dict)
|
|
assert ytdlp.archive.add.call_count == 1 # Only main ID
|
|
|
|
ytdlp.archive.reset_mock()
|
|
|
|
# Test with non-list value
|
|
info_dict = {"id": "test123", "ie_key": "Youtube", "_old_archive_ids": "not a list"}
|
|
ytdlp.record_download_archive(info_dict)
|
|
assert ytdlp.archive.add.call_count == 1 # Only main ID
|
|
|
|
def test_record_download_archive_returns_early_on_empty_archive_id(self) -> None:
|
|
"""Test record_download_archive returns early when _make_archive_id returns empty."""
|
|
ytdlp = self._create_ytdlp(params={"download_archive": "/tmp/archive.txt"})
|
|
ytdlp.archive = Mock()
|
|
ytdlp._make_archive_id = Mock(return_value=None)
|
|
|
|
ytdlp.record_download_archive({"id": "test123"})
|
|
|
|
# Should not add anything
|
|
ytdlp.archive.add.assert_not_called()
|