"""Unit tests for the Jackett release source, client and handler."""
from unittest.mock import MagicMock, patch
import pytest
import requests
from shelfmark.core.config import config
from shelfmark.core.models import DownloadTask
from shelfmark.core.search_plan import ReleaseSearchPlan, ReleaseSearchVariant
from shelfmark.metadata_providers import BookMetadata
from shelfmark.release_sources import ReleaseProtocol, SourceUnavailableError
from shelfmark.release_sources.jackett.api import JackettClient, JackettSearchError
from shelfmark.release_sources.jackett.handler import JackettHandler
from shelfmark.release_sources.jackett.source import JackettSource
from shelfmark.release_sources.prowlarr.cache import cache_release, remove_release
TORZNAB_XML = """
-
Frank Herbert - Dune.epub
https://tracker.example/details/42
My Tracker
http://jackett:9117/dl/mytracker/?jackett_apikey=k&path=abc
1048576
7020
"""
INDEXERS_XML = """
A
B
"""
ERROR_XML = ''
def _response(text: str = "", status: int = 200, json_data=None) -> MagicMock:
resp = MagicMock()
resp.text = text
resp.ok = status < 400
resp.status_code = status
resp.json.return_value = json_data
if status >= 400:
resp.raise_for_status.side_effect = requests.exceptions.HTTPError(response=resp)
return resp
def _client() -> JackettClient:
return JackettClient("http://jackett:9117", "key", indexer_timeout=30)
def _book() -> BookMetadata:
return BookMetadata(
provider="hardcover", provider_id="1", title="Dune", authors=["Frank Herbert"]
)
def _plan(**kwargs) -> ReleaseSearchPlan:
variants = [ReleaseSearchVariant(title="Dune", author="Frank Herbert")]
return ReleaseSearchPlan(
languages=None,
isbn_candidates=[],
author="Frank Herbert",
title_variants=variants,
grouped_title_variants=variants,
**kwargs,
)
@pytest.fixture
def jackett_config(monkeypatch):
values = {
"JACKETT_ENABLED": True,
"JACKETT_URL": "http://jackett:9117",
"JACKETT_API_KEY": "key",
}
monkeypatch.setattr(config, "get", lambda key, default=None: values.get(key, default))
return values
class TestClient:
def test_search_parses_jackett_items(self):
client = _client()
with patch.object(client._session, "get", return_value=_response(TORZNAB_XML)) as get:
results = client.torznab_search(query="Dune", categories=[7000])
url = get.call_args.args[0]
assert url == "http://jackett:9117/api/v2.0/indexers/all/results/torznab/api"
params = get.call_args.kwargs["params"]
assert params["apikey"] == "key"
assert params["cat"] == "7000"
assert results[0]["indexer"] == "My Tracker"
assert results[0]["indexerKey"] == "mytracker"
assert results[0]["protocol"] == "torrent"
def test_error_document_raises(self):
client = _client()
with (
patch.object(client._session, "get", return_value=_response(ERROR_XML)),
pytest.raises(JackettSearchError, match="Invalid API Key"),
):
client.torznab_search(query="Dune")
def test_timeout_raises_search_error(self):
client = _client()
with (
patch.object(client._session, "get", side_effect=requests.exceptions.Timeout()),
pytest.raises(JackettSearchError, match="did not respond"),
):
client.torznab_search(query="Dune")
def test_connection_reports_invalid_key(self):
client = _client()
with patch.object(client._session, "get", return_value=_response(ERROR_XML)):
assert client.test_connection() == (False, "Invalid API key")
def test_connection_success_counts_indexers(self):
client = _client()
responses = [
_response(""),
_response(INDEXERS_XML),
]
with patch.object(client._session, "get", side_effect=responses):
ok, message = client.test_connection()
assert ok
assert "1 indexers" in message
def test_get_indexers_uses_torznab_listing_and_skips_unconfigured(self):
client = _client()
with patch.object(client._session, "get", return_value=_response(INDEXERS_XML)) as get:
indexers = client.get_indexers()
assert get.call_args.kwargs["params"]["t"] == "indexers"
assert "/api/v2.0/indexers/all/results/torznab/api" in get.call_args.args[0]
assert indexers == [{"id": "a", "name": "A"}]
def test_get_indexers_raises_on_non_xml_when_requested(self):
client = _client()
with (
patch.object(client._session, "get", return_value=_response("login")),
pytest.raises(ValueError, match="Unexpected"),
):
client.get_indexers(raise_on_error=True)
class TestSource:
def test_search_builds_namespaced_torrent_release(self, jackett_config):
client = MagicMock()
client.indexer_timeout = 30
client.torznab_search.return_value = _parsed_results()
with patch.object(JackettSource, "_get_client", return_value=client):
releases = JackettSource().search(_book(), _plan())
assert len(releases) == 1
release = releases[0]
assert release.source == "jackett"
assert release.source_id == "jackett:mytracker:https://tracker.example/details/42"
assert release.protocol == ReleaseProtocol.TORRENT
assert release.indexer == "My Tracker"
assert release.peers == "12 / 3"
# Searches the aggregate when no indexers are selected.
assert client.torznab_search.call_args.kwargs["indexer_id"] == "all"
remove_release(release.source_id)
def test_selected_indexers_are_searched_individually(self, jackett_config):
jackett_config["JACKETT_INDEXERS"] = ["a", "b"]
client = MagicMock()
client.indexer_timeout = 30
client.torznab_search.return_value = []
with patch.object(JackettSource, "_get_client", return_value=client):
JackettSource().search(_book(), _plan())
searched = [c.kwargs["indexer_id"] for c in client.torznab_search.call_args_list]
assert searched == ["a", "b"]
def test_filter_names_resolve_to_ids(self, jackett_config):
client = MagicMock()
client.indexer_timeout = 30
client.get_indexers.return_value = [{"id": "a", "name": "Alpha"}]
client.torznab_search.return_value = []
with patch.object(JackettSource, "_get_client", return_value=client):
JackettSource().search(_book(), _plan(indexers=["Alpha"]))
assert client.torznab_search.call_args.kwargs["indexer_id"] == "a"
def test_filter_matching_no_indexers_searches_nothing(self, jackett_config):
client = MagicMock()
client.indexer_timeout = 30
client.get_indexers.return_value = [{"id": "a", "name": "Alpha"}]
with patch.object(JackettSource, "_get_client", return_value=client):
results = JackettSource().search(_book(), _plan(indexers=["Gone"]))
assert results == []
client.torznab_search.assert_not_called()
def test_all_failures_raise_instead_of_returning_empty(self, jackett_config):
client = MagicMock()
client.indexer_timeout = 30
client.torznab_search.side_effect = JackettSearchError("boom")
with (
patch.object(JackettSource, "_get_client", return_value=client),
pytest.raises(SourceUnavailableError),
):
JackettSource().search(_book(), _plan())
def test_an_unreachable_jackett_does_not_put_its_api_key_in_the_error(self, jackett_config):
# requests puts the request URL, apikey included, in a connection error's text.
client = JackettClient("http://jackett:9117", "SECRETKEY123")
error = requests.exceptions.ConnectionError(
"HTTPConnectionPool(host='jackett', port=9117): Max retries exceeded with url: "
"/api/v2.0/indexers/all/results/torznab/api?apikey=SECRETKEY123&t=book&q=dune"
)
with (
patch.object(JackettSource, "_get_client", return_value=client),
patch.object(client._session, "get", side_effect=error),
pytest.raises(SourceUnavailableError) as raised,
):
JackettSource().search(_book(), _plan())
assert "SECRETKEY123" not in str(raised.value)
assert "Max retries exceeded" in str(raised.value)
def test_the_indexer_lookup_error_does_not_put_the_api_key_in_the_message(self, jackett_config):
client = JackettClient("http://jackett:9117", "SECRETKEY123")
error = requests.exceptions.ConnectionError(
"HTTPConnectionPool(host='jackett', port=9117): Max retries exceeded with url: "
"/api/v2.0/indexers/all/results/torznab/api?t=indexers&configured=true"
"&apikey=SECRETKEY123"
)
with (
patch.object(JackettSource, "_get_client", return_value=client),
patch.object(client._session, "get", side_effect=error),
pytest.raises(SourceUnavailableError) as raised,
):
JackettSource().search(_book(), _plan(indexers=["Alpha"]))
assert "SECRETKEY123" not in str(raised.value)
assert str(raised.value).startswith("could not reach Jackett")
def test_auto_expand_retries_without_categories(self, jackett_config):
jackett_config["JACKETT_AUTO_EXPAND"] = True
client = MagicMock()
client.indexer_timeout = 30
client.torznab_search.return_value = []
with patch.object(JackettSource, "_get_client", return_value=client):
JackettSource().search(_book(), _plan())
cats = [c.kwargs["categories"] for c in client.torznab_search.call_args_list]
assert cats == [[7000], None]
def test_is_available_requires_enabled_url_and_key(self, jackett_config):
assert JackettSource().is_available()
jackett_config["JACKETT_API_KEY"] = ""
assert not JackettSource().is_available()
def _parsed_results() -> list[dict]:
from shelfmark.release_sources.prowlarr.torznab import parse_torznab_xml
return parse_torznab_xml(TORZNAB_XML)
class TestHandler:
def _task(self) -> DownloadTask:
return DownloadTask(task_id="jackett:mytracker:1", source="jackett", title="Dune")
def test_resolves_magnet_for_torrent(self):
result = {**_parsed_results()[0], "magnetUrl": "magnet:?xt=urn:btih:abc"}
cache_release("jackett:mytracker:1", result)
status = MagicMock()
with patch(
"shelfmark.release_sources.jackett.handler.client_prefers_torrent_file",
return_value=False,
):
request = JackettHandler()._resolve_download(self._task(), status)
remove_release("jackett:mytracker:1")
assert request is not None
assert request.protocol == "torrent"
assert request.url.startswith("magnet:")
assert request.expected_hash == "abc"
def test_cache_miss_reports_error(self):
status = MagicMock()
assert JackettHandler()._resolve_download(self._task(), status) is None
status.assert_called_once()
assert status.call_args.args[0] == "error"
def test_cache_miss_restores_from_retry_fields(self):
task = self._task()
task.retry_download_url = "http://jackett:9117/dl/mytracker/?path=abc"
task.retry_download_protocol = "torrent"
request = JackettHandler()._resolve_download(task, MagicMock())
assert request is not None
assert request.url == task.retry_download_url