Files
shelfmark/tests/core/test_download_api_guardrails.py
T
splitsec2 d7a4b6b859 fix: keep exception text out of the status, config and release search responses (#1562)
Same idea as #1558, for three more places that hand `str(e)` to whoever
is logged in. These are code scanning alerts 106, 142 and 143.

`/api/status` and `/api/config` returned the raw exception text of an
OSError, RuntimeError and so on with the 500. They now return "Could not
read the download status" and "Could not load the configuration". The
full error is still logged with its trace.

For `/api/releases`, a source failing with an unexpected error put
`source: <exception text>` into the error list that goes back to the
caller. `search_source_releases` takes a new `include_error_detail`
flag. The route passes True for admins (and when auth is off, where
everyone is treated as an admin) and False for everyone else, who get
`source: search failed`. The message of a `SourceUnavailableError` is
written for the user, so it is kept either way, and the background
auto-download caller keeps the default and sees the full text as before.

Left alone on purpose: the `reason` in the release inspect response,
since a test covers that it carries the error text and it looks
intentional.

Tests: two for the routes and two for the helper. All four fail without
the change. Full suite passes (5295), ruff and basedpyright are clean.
2026-10-23 21:06:26 -06:00

1090 lines
42 KiB
Python

"""Baseline guardrail tests for shared release download and queue endpoints."""
from __future__ import annotations
import importlib
import uuid
from unittest.mock import patch
import pytest
from shelfmark.core.models import DownloadTask
@pytest.fixture(scope="module")
def main_module():
"""Import `shelfmark.main` with background startup disabled."""
with patch("shelfmark.download.orchestrator.start"):
import shelfmark.main as main
importlib.reload(main)
return main
@pytest.fixture
def client(main_module):
return main_module.app.test_client()
def _set_authenticated_session(
client,
*,
user_id: str = "alice",
db_user_id: int | None = 7,
is_admin: bool = False,
) -> None:
with client.session_transaction() as sess:
sess["user_id"] = user_id
sess["is_admin"] = is_admin
if db_user_id is not None:
sess["db_user_id"] = db_user_id
def _create_user(main_module, *, prefix: str, role: str = "user") -> dict:
username = f"{prefix}-{uuid.uuid4().hex[:8]}"
return main_module.user_db.create_user(username=username, role=role)
class TestReleaseDownloadEndpointGuardrails:
def test_empty_json_payload_returns_400(self, main_module, client):
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post("/api/releases/download", json={})
assert resp.status_code == 400
assert resp.get_json() == {"error": "No data provided"}
mock_queue_release.assert_not_called()
def test_missing_source_id_returns_400(self, main_module, client):
payload = {
"source": "direct_download",
"title": "Example",
}
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 400
assert resp.get_json() == {"error": "source_id is required"}
mock_queue_release.assert_not_called()
def test_missing_source_returns_400(self, main_module, client):
payload = {
"source_id": "release-xyz",
"title": "Example",
}
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 400
assert resp.get_json() == {"error": "source is required"}
mock_queue_release.assert_not_called()
def test_success_returns_queued_payload_and_forwards_user_context(self, main_module, client):
captured: dict[str, object] = {}
def fake_queue_release(release_data, priority, user_id=None, username=None):
captured.update(
{
"release_data": release_data,
"priority": priority,
"user_id": user_id,
"username": username,
}
)
return True, None
_set_authenticated_session(
client,
user_id="bob",
db_user_id=19,
is_admin=False,
)
payload = {
"source": "direct_download",
"source_id": "release-xyz",
"title": "Release Title",
"priority": 3,
"search_mode": "direct",
}
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend, "queue_release", side_effect=fake_queue_release):
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 200
assert resp.get_json() == {"status": "queued", "priority": 3}
assert captured["release_data"] == {**payload, "content_type": "ebook"}
assert captured["priority"] == 3
assert captured["user_id"] == 19
assert captured["username"] == "bob"
def test_missing_content_type_infers_audiobook_from_format(self, main_module, client):
captured: dict[str, object] = {}
def fake_queue_release(release_data, priority, user_id=None, username=None):
captured.update(
{
"release_data": release_data,
"priority": priority,
"user_id": user_id,
"username": username,
}
)
return True, None
payload = {
"source": "prowlarr",
"source_id": "release-audio",
"title": "Audio Title [m4b]",
"format": "m4b",
"priority": 1,
}
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module.backend, "queue_release", side_effect=fake_queue_release):
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 200
assert resp.get_json() == {"status": "queued", "priority": 1}
assert captured["release_data"] == {**payload, "content_type": "audiobook"}
assert captured["priority"] == 1
def test_non_json_payload_returns_400(self, main_module, client):
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post(
"/api/releases/download",
data="not-json",
content_type="text/plain",
)
body = resp.get_json()
assert resp.status_code == 400
assert body == {"error": "No data provided"}
mock_queue_release.assert_not_called()
def test_admin_can_queue_release_on_behalf_of_another_user(self, main_module, client):
target_user = _create_user(main_module, prefix="target")
admin_user = _create_user(main_module, prefix="admin", role="admin")
captured: dict[str, object] = {}
def fake_queue_release(release_data, priority, user_id=None, username=None):
captured.update(
{
"release_data": release_data,
"priority": priority,
"user_id": user_id,
"username": username,
}
)
return True, None
_set_authenticated_session(
client,
user_id=admin_user["username"],
db_user_id=admin_user["id"],
is_admin=True,
)
payload = {
"source": "direct_download",
"source_id": "release-admin-on-behalf",
"title": "Release Title",
"priority": 2,
"on_behalf_of_user_id": target_user["id"],
}
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend, "queue_release", side_effect=fake_queue_release):
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 200
assert resp.get_json() == {"status": "queued", "priority": 2}
assert captured["priority"] == 2
assert captured["user_id"] == target_user["id"]
assert captured["username"] == target_user["username"]
assert captured["release_data"] == {
**payload,
"content_type": "ebook",
}
def test_non_admin_cannot_queue_release_on_behalf_of_user(self, main_module, client):
target_user = _create_user(main_module, prefix="target")
actor_user = _create_user(main_module, prefix="actor")
_set_authenticated_session(
client,
user_id=actor_user["username"],
db_user_id=actor_user["id"],
is_admin=False,
)
payload = {
"source": "direct_download",
"source_id": "release-forbidden",
"title": "Release Title",
"on_behalf_of_user_id": target_user["id"],
}
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 403
assert resp.get_json() == {"error": "Admin required"}
mock_queue_release.assert_not_called()
@pytest.mark.parametrize("raw_user_id", ["abc", "-1", "0"])
def test_invalid_on_behalf_user_id_returns_400_for_release_download(
self, main_module, client, raw_user_id
):
admin_user = _create_user(main_module, prefix="admin", role="admin")
_set_authenticated_session(
client,
user_id=admin_user["username"],
db_user_id=admin_user["id"],
is_admin=True,
)
payload = {
"source": "direct_download",
"source_id": "release-invalid",
"title": "Release Title",
"on_behalf_of_user_id": raw_user_id,
}
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 400
assert resp.get_json() == {"error": "Invalid on_behalf_of_user_id"}
mock_queue_release.assert_not_called()
def test_unknown_on_behalf_user_returns_404_for_release_download(self, main_module, client):
admin_user = _create_user(main_module, prefix="admin", role="admin")
_set_authenticated_session(
client,
user_id=admin_user["username"],
db_user_id=admin_user["id"],
is_admin=True,
)
payload = {
"source": "direct_download",
"source_id": "release-missing-user",
"title": "Release Title",
"on_behalf_of_user_id": 99999999,
}
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 404
assert resp.get_json() == {"error": "User not found"}
mock_queue_release.assert_not_called()
def test_on_behalf_release_download_returns_503_when_user_db_unavailable(
self, main_module, client
):
admin_user = _create_user(main_module, prefix="admin", role="admin")
_set_authenticated_session(
client,
user_id=admin_user["username"],
db_user_id=admin_user["id"],
is_admin=True,
)
payload = {
"source": "direct_download",
"source_id": "release-user-db-missing",
"title": "Release Title",
"on_behalf_of_user_id": 7,
}
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module, "user_db", None):
with patch.object(main_module.backend, "queue_release") as mock_queue_release:
resp = client.post("/api/releases/download", json=payload)
assert resp.status_code == 503
assert resp.get_json() == {"error": "User database unavailable"}
mock_queue_release.assert_not_called()
class TestCancelDownloadEndpointGuardrails:
def test_owner_can_cancel_direct_download(self, main_module, client):
user = _create_user(main_module, prefix="reader")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
task = DownloadTask(
task_id="direct-task-1",
source="direct_download",
title="Direct Task",
user_id=user["id"],
username=user["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "cancel_download", return_value=True
) as mock_cancel:
resp = client.delete("/api/download/direct-task-1/cancel")
assert resp.status_code == 200
assert resp.get_json() == {"status": "cancelled", "book_id": "direct-task-1"}
mock_cancel.assert_called_once_with("direct-task-1")
def test_non_owner_cannot_cancel_download(self, main_module, client):
owner = _create_user(main_module, prefix="owner")
actor = _create_user(main_module, prefix="actor")
_set_authenticated_session(
client,
user_id=actor["username"],
db_user_id=actor["id"],
is_admin=False,
)
task = DownloadTask(
task_id="owned-task-1",
source="direct_download",
title="Owned Task",
user_id=owner["id"],
username=owner["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "cancel_download", return_value=True
) as mock_cancel:
resp = client.delete("/api/download/owned-task-1/cancel")
assert resp.status_code == 403
assert resp.get_json()["code"] == "download_not_owned"
mock_cancel.assert_not_called()
def test_owner_cannot_cancel_graduated_request_download(self, main_module, client):
user = _create_user(main_module, prefix="requester")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
request_row = main_module.user_db.create_request(
user_id=user["id"],
content_type="ebook",
request_level="release",
policy_mode="request_release",
book_data={
"title": "Requested Book",
"author": "Request Author",
"provider": "openlibrary",
"provider_id": "req-guard-1",
},
release_data={
"source": "prowlarr",
"source_id": "requested-task-1",
"title": "Requested Book.epub",
},
status="fulfilled",
delivery_state="queued",
)
task = DownloadTask(
task_id="requested-task-1",
source="prowlarr",
title="Requested Book",
user_id=user["id"],
username=user["username"],
request_id=request_row["id"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "cancel_download", return_value=True
) as mock_cancel:
resp = client.delete("/api/download/requested-task-1/cancel")
assert resp.status_code == 403
assert resp.get_json()["code"] == "requested_download_cancel_forbidden"
mock_cancel.assert_not_called()
def test_admin_can_cancel_graduated_request_download(self, main_module, client):
admin = _create_user(main_module, prefix="admin", role="admin")
requester = _create_user(main_module, prefix="requester")
_set_authenticated_session(
client,
user_id=admin["username"],
db_user_id=admin["id"],
is_admin=True,
)
main_module.user_db.create_request(
user_id=requester["id"],
content_type="ebook",
request_level="release",
policy_mode="request_release",
book_data={
"title": "Admin Requested Book",
"author": "Admin Request Author",
"provider": "openlibrary",
"provider_id": "req-guard-2",
},
release_data={
"source": "prowlarr",
"source_id": "requested-task-2",
"title": "Admin Requested Book.epub",
},
status="fulfilled",
delivery_state="queued",
)
task = DownloadTask(
task_id="requested-task-2",
source="prowlarr",
title="Admin Requested Book",
user_id=requester["id"],
username=requester["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "cancel_download", return_value=True
) as mock_cancel:
resp = client.delete("/api/download/requested-task-2/cancel")
assert resp.status_code == 200
assert resp.get_json() == {"status": "cancelled", "book_id": "requested-task-2"}
mock_cancel.assert_called_once_with("requested-task-2")
class TestRetryDownloadEndpointGuardrails:
def test_retry_returns_404_when_task_missing(self, main_module, client):
user = _create_user(main_module, prefix="reader")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=None):
with patch.object(main_module.backend, "retry_download") as mock_retry:
resp = client.post("/api/download/missing-task/retry")
assert resp.status_code == 404
assert resp.get_json() == {"error": "Download not found"}
mock_retry.assert_not_called()
def test_owner_can_retry_direct_download(self, main_module, client):
user = _create_user(main_module, prefix="reader")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
task = DownloadTask(
task_id="direct-task-retry-1",
source="direct_download",
title="Direct Task",
user_id=user["id"],
username=user["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "retry_download", return_value=(True, None)
) as mock_retry:
resp = client.post("/api/download/direct-task-retry-1/retry")
assert resp.status_code == 200
assert resp.get_json() == {"status": "queued", "book_id": "direct-task-retry-1"}
mock_retry.assert_called_once_with("direct-task-retry-1")
def test_owner_can_retry_persisted_direct_download_when_live_task_is_missing(
self, main_module, client
):
user = _create_user(main_module, prefix="reader")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
retry_payload = {
"task_id": "persisted-direct-retry-1",
"source": "direct_download",
"title": "Persisted Direct Task",
"user_id": user["id"],
"username": user["username"],
"search_mode": "direct",
}
main_module.download_history_service.record_download(
task_id="persisted-direct-retry-1",
user_id=user["id"],
username=user["username"],
request_id=None,
source="direct_download",
source_display_name="Direct Download",
title="Persisted Direct Task",
author="Direct Author",
file_format="epub",
size="1 MB",
preview=None,
content_type="ebook",
downloads=None,
origin="direct",
retry_payload=retry_payload,
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=None):
with patch.object(
main_module.backend,
"retry_persisted_download",
return_value=(True, None),
) as mock_retry:
resp = client.post("/api/download/persisted-direct-retry-1/retry")
assert resp.status_code == 200
assert resp.get_json() == {"status": "queued", "book_id": "persisted-direct-retry-1"}
assert mock_retry.call_args.args[0] == retry_payload
assert mock_retry.call_args.kwargs["final_status"] == "active"
def test_non_owner_cannot_retry_download(self, main_module, client):
owner = _create_user(main_module, prefix="owner")
actor = _create_user(main_module, prefix="actor")
_set_authenticated_session(
client,
user_id=actor["username"],
db_user_id=actor["id"],
is_admin=False,
)
task = DownloadTask(
task_id="owned-task-retry-1",
source="direct_download",
title="Owned Task",
user_id=owner["id"],
username=owner["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "retry_download", return_value=(True, None)
) as mock_retry:
resp = client.post("/api/download/owned-task-retry-1/retry")
assert resp.status_code == 403
assert resp.get_json()["code"] == "download_not_owned"
mock_retry.assert_not_called()
def test_retry_forbidden_for_request_id_linked_download(self, main_module, client):
user = _create_user(main_module, prefix="requester")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
task = DownloadTask(
task_id="requested-retry-1",
source="prowlarr",
title="Requested Book",
user_id=user["id"],
username=user["username"],
request_id=123,
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "retry_download", return_value=(True, None)
) as mock_retry:
resp = client.post("/api/download/requested-retry-1/retry")
assert resp.status_code == 403
assert resp.get_json()["code"] == "requested_download_retry_forbidden"
mock_retry.assert_not_called()
def test_retry_forbidden_for_graduated_request_download(self, main_module, client):
user = _create_user(main_module, prefix="requester")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
request_row = main_module.user_db.create_request(
user_id=user["id"],
content_type="ebook",
request_level="release",
policy_mode="request_release",
book_data={
"title": "Requested Book",
"author": "Request Author",
"provider": "openlibrary",
"provider_id": "req-retry-1",
},
release_data={
"source": "prowlarr",
"source_id": "requested-retry-2",
"title": "Requested Book.epub",
},
status="fulfilled",
delivery_state="error",
)
task = DownloadTask(
task_id="requested-retry-2",
source="prowlarr",
title="Requested Book",
user_id=user["id"],
username=user["username"],
request_id=request_row["id"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "retry_download", return_value=(True, None)
) as mock_retry:
resp = client.post("/api/download/requested-retry-2/retry")
assert resp.status_code == 403
assert resp.get_json()["code"] == "requested_download_retry_forbidden"
mock_retry.assert_not_called()
def test_retry_allows_request_linked_postprocess_error_with_staged_file(
self, main_module, client, tmp_path
):
user = _create_user(main_module, prefix="requester")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
staged_file = tmp_path / "requested-postprocess.epub"
staged_file.write_text("staged")
task = DownloadTask(
task_id="requested-retry-postprocess-1",
source="prowlarr",
title="Requested Book",
user_id=user["id"],
username=user["username"],
request_id=123,
staged_path=str(staged_file),
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend.book_queue,
"get_task_status",
return_value=main_module.QueueStatus.ERROR,
):
with patch.object(
main_module.backend, "retry_download", return_value=(True, None)
) as mock_retry:
resp = client.post("/api/download/requested-retry-postprocess-1/retry")
assert resp.status_code == 200
assert resp.get_json() == {"status": "queued", "book_id": "requested-retry-postprocess-1"}
mock_retry.assert_called_once_with("requested-retry-postprocess-1")
def test_retry_allows_persisted_request_postprocess_error_with_staged_file(
self, main_module, client, tmp_path
):
user = _create_user(main_module, prefix="requester")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
staged_file = tmp_path / "persisted-request-postprocess.epub"
staged_file.write_text("staged")
retry_payload = {
"task_id": "persisted-request-retry-1",
"source": "prowlarr",
"title": "Persisted Requested Book",
"user_id": user["id"],
"username": user["username"],
"request_id": 123,
"search_mode": "universal",
"staged_path": str(staged_file),
}
main_module.download_history_service.record_download(
task_id="persisted-request-retry-1",
user_id=user["id"],
username=user["username"],
request_id=123,
source="prowlarr",
source_display_name="Prowlarr",
title="Persisted Requested Book",
author="Request Author",
file_format="epub",
size="1 MB",
preview=None,
content_type="ebook",
downloads=None,
origin="requested",
retry_payload=retry_payload,
)
main_module.download_history_service.finalize_download(
task_id="persisted-request-retry-1",
final_status="error",
status_message="Output routing failed",
retry_payload=retry_payload,
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=None):
with patch.object(
main_module.backend,
"retry_persisted_download",
return_value=(True, None),
) as mock_retry:
resp = client.post("/api/download/persisted-request-retry-1/retry")
assert resp.status_code == 200
assert resp.get_json() == {"status": "queued", "book_id": "persisted-request-retry-1"}
assert mock_retry.call_args.args[0] == retry_payload
assert mock_retry.call_args.kwargs["final_status"] == "error"
def test_retry_returns_409_for_non_retryable_state(self, main_module, client):
user = _create_user(main_module, prefix="reader")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
task = DownloadTask(
task_id="direct-task-retry-409",
source="direct_download",
title="Direct Task",
user_id=user["id"],
username=user["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend,
"retry_download",
return_value=(False, "Download is not in an error state"),
) as mock_retry:
resp = client.post("/api/download/direct-task-retry-409/retry")
assert resp.status_code == 409
assert resp.get_json() == {"error": "Download is not in an error state"}
mock_retry.assert_called_once_with("direct-task-retry-409")
class TestStatusEndpointGuardrails:
def test_no_auth_allows_without_session_and_returns_status(self, main_module, client):
observed: dict[str, object] = {}
expected_status = {
"queued": {"book-1": {"title": "One"}},
"downloading": {},
"completed": {},
"failed": {},
"cancelled": {},
}
def fake_queue_status(user_id=None):
observed["user_id"] = user_id
return expected_status
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module.backend, "queue_status", side_effect=fake_queue_status):
resp = client.get("/api/status")
assert resp.status_code == 200
assert resp.get_json() == expected_status
assert observed["user_id"] is None
def test_auth_enabled_without_session_returns_401(self, main_module, client):
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
resp = client.get("/api/status")
assert resp.status_code == 401
assert resp.get_json() == {"error": "Unauthorized"}
def test_non_admin_status_is_scoped_to_db_user(self, main_module, client):
observed: dict[str, object] = {}
def fake_queue_status(user_id=None):
observed["user_id"] = user_id
return {"queued": {}, "downloading": {}, "completed": {}, "failed": {}, "cancelled": {}}
_set_authenticated_session(
client,
user_id="reader",
db_user_id=55,
is_admin=False,
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend, "queue_status", side_effect=fake_queue_status):
resp = client.get("/api/status")
assert resp.status_code == 200
assert observed["user_id"] == 55
def test_admin_status_is_unscoped(self, main_module, client):
observed: dict[str, object] = {}
def fake_queue_status(user_id=None):
observed["user_id"] = user_id
return {"queued": {}, "downloading": {}, "completed": {}, "failed": {}, "cancelled": {}}
_set_authenticated_session(
client,
user_id="admin",
db_user_id=1,
is_admin=True,
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend, "queue_status", side_effect=fake_queue_status):
resp = client.get("/api/status")
assert resp.status_code == 200
assert observed["user_id"] is None
class TestErrorTextStaysOutOfResponses:
"""A failing status or config read must not hand the exception text to the caller."""
def test_status_failure_returns_a_fixed_message(self, main_module, client):
def boom(user_id=None):
msg = "cannot open /srv/shelfmark/queue.db"
raise OSError(msg)
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module.backend, "queue_status", side_effect=boom):
resp = client.get("/api/status")
assert resp.status_code == 500
assert resp.get_json() == {"error": "Could not read the download status"}
def test_config_failure_returns_a_fixed_message(self, main_module, client):
def boom(*_args, **_kwargs):
msg = "cannot read /config/plugins/general.json"
raise OSError(msg)
with patch.object(main_module, "get_auth_mode", return_value="none"):
with patch.object(main_module, "get_session_db_user_id", side_effect=boom):
resp = client.get("/api/config")
assert resp.status_code == 500
assert resp.get_json() == {"error": "Could not load the configuration"}
class TestQueueManagementEndpointGuardrails:
def test_non_owner_cannot_set_priority(self, main_module, client):
owner = _create_user(main_module, prefix="owner")
actor = _create_user(main_module, prefix="actor")
_set_authenticated_session(
client,
user_id=actor["username"],
db_user_id=actor["id"],
is_admin=False,
)
task = DownloadTask(
task_id="owned-priority-1",
source="direct_download",
title="Owned Task",
user_id=owner["id"],
username=owner["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(main_module.backend, "set_book_priority") as mock_set_priority:
resp = client.put("/api/queue/owned-priority-1/priority", json={"priority": 1})
assert resp.status_code == 403
assert resp.get_json()["code"] == "download_not_owned"
mock_set_priority.assert_not_called()
def test_owner_can_set_priority(self, main_module, client):
user = _create_user(main_module, prefix="reader")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
task = DownloadTask(
task_id="reader-priority-1",
source="direct_download",
title="Reader Task",
user_id=user["id"],
username=user["username"],
)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(main_module.backend.book_queue, "get_task", return_value=task):
with patch.object(
main_module.backend, "set_book_priority", return_value=True
) as mock_set_priority:
resp = client.put("/api/queue/reader-priority-1/priority", json={"priority": 2})
assert resp.status_code == 200
assert resp.get_json() == {
"status": "updated",
"book_id": "reader-priority-1",
"priority": 2,
}
mock_set_priority.assert_called_once_with("reader-priority-1", 2)
def test_non_owner_cannot_reorder_other_users_task(self, main_module, client):
owner = _create_user(main_module, prefix="owner")
actor = _create_user(main_module, prefix="actor")
_set_authenticated_session(
client,
user_id=actor["username"],
db_user_id=actor["id"],
is_admin=False,
)
owned_task = DownloadTask(
task_id="actor-reorder-1",
source="direct_download",
title="Actor Task",
user_id=actor["id"],
username=actor["username"],
)
other_task = DownloadTask(
task_id="owner-reorder-1",
source="direct_download",
title="Owner Task",
user_id=owner["id"],
username=owner["username"],
)
def fake_get_task(task_id):
return {
"actor-reorder-1": owned_task,
"owner-reorder-1": other_task,
}.get(task_id)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(
main_module.backend.book_queue, "get_task", side_effect=fake_get_task
):
with patch.object(main_module.backend, "reorder_queue") as mock_reorder:
resp = client.post(
"/api/queue/reorder",
json={
"book_priorities": {
"actor-reorder-1": 1,
"owner-reorder-1": 0,
}
},
)
assert resp.status_code == 403
assert resp.get_json()["code"] == "download_not_owned"
mock_reorder.assert_not_called()
def test_non_admin_queue_order_is_scoped_to_owned_tasks(self, main_module, client):
user = _create_user(main_module, prefix="reader")
other = _create_user(main_module, prefix="other")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
user_task = DownloadTask(
task_id="reader-order-1",
source="direct_download",
title="Reader Task",
user_id=user["id"],
username=user["username"],
)
other_task = DownloadTask(
task_id="other-order-1",
source="direct_download",
title="Other Task",
user_id=other["id"],
username=other["username"],
)
def fake_get_task(task_id):
return {
"reader-order-1": user_task,
"other-order-1": other_task,
}.get(task_id)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(
main_module.backend,
"get_queue_order",
return_value=[
{"id": "reader-order-1", "title": "Reader Task", "priority": 0},
{"id": "other-order-1", "title": "Other Task", "priority": 1},
],
):
with patch.object(
main_module.backend.book_queue, "get_task", side_effect=fake_get_task
):
resp = client.get("/api/queue/order")
assert resp.status_code == 200
assert resp.get_json()["queue"] == [
{"id": "reader-order-1", "title": "Reader Task", "priority": 0}
]
def test_non_admin_active_downloads_are_scoped_to_owned_tasks(self, main_module, client):
user = _create_user(main_module, prefix="reader")
other = _create_user(main_module, prefix="other")
_set_authenticated_session(
client,
user_id=user["username"],
db_user_id=user["id"],
is_admin=False,
)
user_task = DownloadTask(
task_id="reader-active-1",
source="direct_download",
title="Reader Task",
user_id=user["id"],
username=user["username"],
)
other_task = DownloadTask(
task_id="other-active-1",
source="direct_download",
title="Other Task",
user_id=other["id"],
username=other["username"],
)
def fake_get_task(task_id):
return {
"reader-active-1": user_task,
"other-active-1": other_task,
}.get(task_id)
with patch.object(main_module, "get_auth_mode", return_value="builtin"):
with patch.object(
main_module.backend,
"get_active_downloads",
return_value=["reader-active-1", "other-active-1"],
):
with patch.object(
main_module.backend.book_queue, "get_task", side_effect=fake_get_task
):
resp = client.get("/api/downloads/active")
assert resp.status_code == 200
assert resp.get_json() == {"active_downloads": ["reader-active-1"]}