aboutsummaryrefslogtreecommitdiff
path: root/tests/views/test_received.py
diff options
context:
space:
mode:
Diffstat (limited to 'tests/views/test_received.py')
-rw-r--r--tests/views/test_received.py1063
1 files changed, 1063 insertions, 0 deletions
diff --git a/tests/views/test_received.py b/tests/views/test_received.py
new file mode 100644
index 0000000..ec00e05
--- /dev/null
+++ b/tests/views/test_received.py
@@ -0,0 +1,1063 @@
+# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
+#
+# SPDX-License-Identifier: BSD-3-Clause
+
+import re
+import uuid
+from datetime import UTC, datetime, timedelta
+from html import unescape
+from http import HTTPStatus
+from types import ModuleType
+from unittest.mock import Mock
+from urllib.parse import parse_qs, urlsplit
+
+import pytest
+from bs4 import BeautifulSoup
+from flask import Flask
+from flask.testing import FlaskClient
+
+from webmentions_ssg import db
+from webmentions_ssg.models.received import ReceivedWebmention
+
+from .helpers import (
+ SOURCE_URL,
+ TARGET_URL,
+ create_received_webmention,
+ log_in,
+ mock_admin_action_form,
+)
+
+
+@pytest.fixture
+def views_module(app: Flask) -> ModuleType:
+ _ = app
+ from webmentions_ssg.views import received as module
+
+ return module
+
+
+def test_received_requires_login(client: FlaskClient) -> None:
+ response = client.get("/received")
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert "/login" in response.headers["Location"]
+
+
+def test_received_lists_webmentions(app: Flask, client: FlaskClient) -> None:
+ log_in(app, client)
+ create_received_webmention(app)
+
+ response = client.get("/received")
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert SOURCE_URL in html
+ assert TARGET_URL in html
+
+
+@pytest.mark.parametrize(
+ ("filter_status", "expected_statuses"),
+ [
+ ("pending", {"received"}),
+ ("verifying", {"verifying"}),
+ ("verified", {"verified"}),
+ ("declined", {"failed", "source_removed"}),
+ ],
+)
+def test_received_filters_by_display_status(
+ app: Flask, client: FlaskClient, filter_status: str, expected_statuses: set[str]
+) -> None:
+ log_in(app, client)
+ statuses = ("received", "verifying", "verified", "failed", "source_removed")
+ for status in statuses:
+ create_received_webmention(
+ app, source=f"https://{status}.example/post", status=status
+ )
+
+ response = client.get("/received", query_string={"status": filter_status})
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ for status in statuses:
+ assert (f"https://{status}.example/post" in html) == (
+ status in expected_statuses
+ )
+ assert re.search(
+ rf'<option\b(?=[^>]*\bvalue="{filter_status}")(?=[^>]*\bselected\b)[^>]*>', html
+ )
+
+
+def test_received_filter_args_uses_typed_dict_fields(
+ app: Flask, views_module: ModuleType
+) -> None:
+ with app.test_request_context(
+ "/received",
+ query_string={
+ "status": "declined",
+ "q": " example.org ",
+ "date_from": "2026-11-08",
+ "date_to": "2026-11-14",
+ "sort": "updated",
+ "order": "asc",
+ "per_page": "37",
+ },
+ ):
+ form = views_module.received_filter_form()
+ assert set(views_module.ReceivedFilterArgs.__annotations__) == set(form._fields)
+ assert views_module.received_filter_args(form) == {
+ "status": "declined",
+ "q": "example.org",
+ "date_from": "2026-11-08",
+ "date_to": "2026-11-14",
+ "sort": "updated",
+ "order": "asc",
+ "per_page": "37",
+ }
+
+
+@pytest.mark.parametrize("max_page_size", [10, 100])
+def test_received_filter_args_omits_defaults_for_configured_page_size(
+ app: Flask, views_module: ModuleType, max_page_size: int
+) -> None:
+ app.config["RECEIVED_MAX_PAGE_SIZE"] = max_page_size
+ with app.test_request_context("/received"):
+ form = views_module.received_filter_form()
+ assert form.per_page.data == min(25, max_page_size)
+ assert views_module.received_filter_args(form) == {}
+
+
+@pytest.mark.parametrize(
+ ("sort", "order", "expected"),
+ [
+ ("received", "desc", ("removed", "failed", "verified", "pending")),
+ ("received", "asc", ("pending", "verified", "failed", "removed")),
+ ("updated", "desc", ("verified", "failed", "pending", "removed")),
+ ("updated", "asc", ("removed", "pending", "failed", "verified")),
+ ("status", "asc", ("pending", "verified", "removed", "failed")),
+ ("status", "desc", ("removed", "failed", "verified", "pending")),
+ ],
+)
+def test_received_sorting(
+ app: Flask, client: FlaskClient, sort: str, order: str, expected: tuple[str, ...]
+) -> None:
+ log_in(app, client)
+ for label, status, day in (
+ ("pending", "received", 12),
+ ("verified", "verified", 14),
+ ("failed", "failed", 13),
+ ("removed", "source_removed", 11),
+ ):
+ create_received_webmention(
+ app,
+ source=f"https://{label}.example/post",
+ status=status,
+ updated_at=datetime(2026, 11, day, tzinfo=UTC),
+ )
+
+ response = client.get("/received", query_string={"sort": sort, "order": order})
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ indices = [html.index(f"https://{label}.example/post") for label in expected]
+ assert indices == sorted(indices)
+ assert f'aria-sort="{"ascending" if order == "asc" else "descending"}"' in html
+
+
+@pytest.mark.parametrize("column", ["source", "target"])
+@pytest.mark.parametrize("order", ["asc", "desc"])
+def test_received_sorts_by_source_or_target(
+ app: Flask, client: FlaskClient, column: str, order: str
+) -> None:
+ log_in(app, client)
+ # Deliberately create rows out of lexical order for both URL columns.
+ for source_name, target_name in (
+ ("beta", "alpha"),
+ ("alpha", "gamma"),
+ ("gamma", "beta"),
+ ):
+ create_received_webmention(
+ app,
+ source=f"https://source.example/{source_name}",
+ target=f"https://target.example/{target_name}",
+ )
+
+ response = client.get("/received", query_string={"sort": column, "order": order})
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ rows = re.findall(r"<tr[^>]*>.*?</tr>", html, flags=re.DOTALL)
+ urls = re.findall(rf'<a href="(https://{column}\.example/[^"]+)">', "".join(rows))
+ assert urls == sorted(urls, reverse=(order == "desc"))
+ assert len(urls) == 3
+ assert f'aria-sort="{"ascending" if order == "asc" else "descending"}"' in html
+
+
+def test_received_sort_links_preserve_filters_and_page_size(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ create_received_webmention(app, source="https://some.example/post", status="failed")
+ response = client.get(
+ "/received",
+ query_string={
+ "status": "declined",
+ "q": "some.example",
+ "sort": "updated",
+ "order": "desc",
+ "per_page": "37",
+ },
+ )
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ links = [
+ parse_qs(urlsplit(unescape(link)).query)
+ for link in re.findall(r'href="([^"]+)"', html)
+ if urlsplit(unescape(link)).path == "/received"
+ ]
+ for sort, order in (
+ ("received", "desc"),
+ ("updated", "asc"),
+ ("status", "asc"),
+ ("source", "asc"),
+ ("target", "asc"),
+ ):
+ assert {
+ "status": ["declined"],
+ "q": ["some.example"],
+ "sort": [sort],
+ "order": [order],
+ "per_page": ["37"],
+ } in links
+ assert 'name="sort"' in html
+ assert 'name="order"' in html
+ assert 'name="per_page"' in html
+ assert 'value="37"' in html
+
+
+def test_received_page_size_is_free_form_and_controls_pagination(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ for index in range(52):
+ create_received_webmention(app, source=f"https://source.example/{index}")
+
+ for page_size, expected_rows in ((25, 25), (37, 37), (50, 50), (100, 52)):
+ response = client.get("/received", query_string={"per_page": page_size})
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert "52 total" in html
+ assert html.count('data-title="Reverify webmention?"') == expected_rows
+ assert ("page=2" in html) == (page_size < 52)
+
+ response = client.get("/received", query_string={"per_page": 37, "page": 2})
+ assert response.status_code == HTTPStatus.OK
+ assert (
+ response.get_data(as_text=True).count('data-title="Reverify webmention?"') == 15
+ )
+
+
+def test_received_default_page_size_is_capped_when_max_is_below_25(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ app.config["RECEIVED_MAX_PAGE_SIZE"] = 10
+ for index in range(11):
+ create_received_webmention(app, source=f"https://source.example/{index}")
+
+ response = client.get("/received")
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert html.count('data-title="Reverify webmention?"') == 10
+ assert 'name="per_page"' in html
+ assert 'value="10"' in html
+ assert "page=2" in html
+
+
+def test_received_page_size_respects_configured_maximum(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ app.config["RECEIVED_MAX_PAGE_SIZE"] = 50
+ response = client.get("/received", query_string={"per_page": 50})
+ assert response.status_code == HTTPStatus.OK
+ assert re.search(
+ r'<input\b(?=[^>]*name="per_page")(?=[^>]*max="50")',
+ response.get_data(as_text=True),
+ )
+ assert client.get("/received?per_page=51").status_code == HTTPStatus.BAD_REQUEST
+
+
+def test_received_get_filter_controls_render_serialized_values(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ response = client.get(
+ "/received",
+ query_string={
+ "status": "pending",
+ "q": "example.org",
+ "date_from": "2026-11-08",
+ "date_to": "2026-11-14",
+ "sort": "updated",
+ "order": "asc",
+ "per_page": "37",
+ },
+ )
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ for field in ("status", "q", "date_from", "date_to", "sort", "order", "per_page"):
+ assert f'name="{field}"' in html
+ assert 'type="search"' in html
+ assert html.count('type="date"') == 2
+ assert 'value="example.org"' in html
+ assert 'value="2026-11-08"' in html
+ assert 'value="2026-11-14"' in html
+ assert 'name="sort" type="hidden" value="updated"' in html
+ assert 'name="order" type="hidden" value="asc"' in html
+ assert 'value="37"' in html
+ assert re.search(r'<form[^>]*method="get"[^>]*role="search"', html)
+
+
+def test_received_get_filter_controls_render_defaults(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ response = client.get("/received")
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert 'name="sort" type="hidden" value="received"' in html
+ assert 'name="order" type="hidden" value="desc"' in html
+ assert 'value="25"' in html
+ status_option = BeautifulSoup(html, "html.parser").select_one(
+ 'select[name="status"] option[value=""][selected]'
+ )
+ assert status_option is not None
+ assert status_option.get_text(strip=True) == "All statuses"
+
+
+def test_received_filters_source_or_target_as_literal_substring(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ create_received_webmention(
+ app, source="https://site.example/Alpha_10%", target="https://other.example/a"
+ )
+ create_received_webmention(
+ app, source="https://other.example/b", target="https://site.example/alpha_10%"
+ )
+ create_received_webmention(
+ app, source="https://site.example/alphaX100", target="https://other.example/c"
+ )
+
+ response = client.get("/received", query_string={"q": "ALPHA_10%"})
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert "https://other.example/a" in html
+ assert "https://other.example/b" in html
+ assert "https://other.example/c" not in html
+
+
+def test_received_filters_by_inclusive_updated_date_range(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ dates = {
+ "before": datetime(2026, 11, 7, 23, 59, 59, tzinfo=UTC),
+ "first": datetime(2026, 11, 8, tzinfo=UTC),
+ "last": datetime(2026, 11, 14, 23, 59, 59, 999999, tzinfo=UTC),
+ "after": datetime(2026, 11, 15, tzinfo=UTC),
+ }
+ for label, updated_at in dates.items():
+ create_received_webmention(
+ app,
+ source=f"https://{label}.example/post",
+ status="failed",
+ updated_at=updated_at,
+ )
+
+ response = client.get(
+ "/received",
+ query_string={
+ "status": "declined",
+ "date_from": "2026-11-08",
+ "date_to": "2026-11-14",
+ },
+ )
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ for label in ("first", "last"):
+ assert f"https://{label}.example/post" in html
+ for label in ("before", "after"):
+ assert f"https://{label}.example/post" not in html
+
+
+def test_received_filters_are_combined(app: Flask, client: FlaskClient) -> None:
+ log_in(app, client)
+ for status, source, day in (
+ ("failed", "https://match.example/a", 12),
+ ("verified", "https://match.example/b", 12),
+ ("failed", "https://other.example/c", 12),
+ ("failed", "https://match.example/d", 1),
+ ):
+ create_received_webmention(
+ app,
+ source=source,
+ status=status,
+ updated_at=datetime(2026, 11, day, tzinfo=UTC),
+ )
+
+ response = client.get(
+ "/received",
+ query_string={
+ "status": "declined",
+ "q": "match.example",
+ "date_from": "2026-11-08",
+ "date_to": "2026-11-14",
+ },
+ )
+
+ html = response.get_data(as_text=True)
+ assert "https://match.example/a" in html
+ for suffix in ("b", "c", "d"):
+ assert f"/{suffix}</a>" not in html
+ assert "1 total" in html
+
+
+@pytest.mark.parametrize(
+ "query_string",
+ [
+ "status=unknown",
+ "date_from=not-a-date",
+ "date_from=2026-11-8",
+ "date_to=2026-02-30",
+ "date_from=2026-11-15&date_to=2026-11-08",
+ "sort=unknown",
+ "order=sideways",
+ "per_page=0",
+ "per_page=-1",
+ "per_page=101",
+ "per_page=abc",
+ "per_page=1.5",
+ ],
+)
+def test_received_rejects_invalid_filters(
+ app: Flask, client: FlaskClient, query_string: str
+) -> None:
+ log_in(app, client)
+ assert client.get(f"/received?{query_string}").status_code == HTTPStatus.BAD_REQUEST
+
+
+def test_received_pagination_and_actions_keep_filters(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ for index in range(26):
+ create_received_webmention(
+ app,
+ source=f"https://match.example/{index}",
+ status="failed",
+ updated_at=datetime(2026, 11, 12, tzinfo=UTC),
+ )
+
+ filters = {
+ "status": "declined",
+ "q": "match.example",
+ "date_from": "2026-11-08",
+ "date_to": "2026-11-14",
+ }
+ response = client.get("/received", query_string=filters)
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert "26 total" in html
+ pagination_links = re.findall(r'href="([^"]+)"', html)
+ action_links = re.findall(r'data-action="([^"]+)"', html)
+ assert action_links
+ expected_filters = {key: [value] for key, value in filters.items()}
+ assert any(
+ urlsplit(unescape(link)).path == "/received"
+ and parse_qs(urlsplit(unescape(link)).query)
+ == {**expected_filters, "page": ["2"]}
+ for link in pagination_links
+ )
+ for link in action_links:
+ assert parse_qs(urlsplit(unescape(link)).query) == {
+ **expected_filters,
+ "page": ["1"],
+ }
+
+
+def test_received_pagination_and_actions_keep_sort_and_page_size(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ for index in range(38):
+ create_received_webmention(app, source=f"https://source.example/{index}")
+
+ response = client.get(
+ "/received", query_string={"sort": "updated", "order": "asc", "per_page": 37}
+ )
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ expected = {"sort": ["updated"], "order": ["asc"], "per_page": ["37"]}
+ assert any(
+ urlsplit(unescape(link)).path == "/received"
+ and parse_qs(urlsplit(unescape(link)).query) == {**expected, "page": ["2"]}
+ for link in re.findall(r'href="([^"]+)"', html)
+ )
+ for link in re.findall(r'data-action="([^"]+)"', html):
+ assert parse_qs(urlsplit(unescape(link)).query) == {**expected, "page": ["1"]}
+
+
+@pytest.mark.parametrize("action", ["delete", "reverify"])
+def test_received_action_redirect_keeps_sort_and_page_size(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app)
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ monkeypatch.setattr(views_module, "verify_webmention", Mock())
+
+ response = client.post(
+ f"/received/{identifier}/{action}",
+ query_string={"page": 3, "sort": "updated", "order": "asc", "per_page": 37},
+ )
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert parse_qs(urlsplit(response.headers["Location"]).query) == {
+ "page": ["3"],
+ "sort": ["updated"],
+ "order": ["asc"],
+ "per_page": ["37"],
+ }
+
+
+@pytest.mark.parametrize("action", ["delete", "reverify"])
+def test_received_action_redirect_keeps_filters(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app)
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ monkeypatch.setattr(views_module, "verify_webmention", Mock())
+
+ response = client.post(
+ f"/received/{identifier}/{action}",
+ query_string={
+ "page": 3,
+ "status": "declined",
+ "q": "example.org/a&b",
+ "date_from": "2026-11-08",
+ "date_to": "2026-11-14",
+ },
+ )
+
+ assert response.status_code == HTTPStatus.FOUND
+ redirect_url = urlsplit(response.headers["Location"])
+ assert redirect_url.path == "/received"
+ assert parse_qs(redirect_url.query) == {
+ "page": ["3"],
+ "status": ["declined"],
+ "q": ["example.org/a&b"],
+ "date_from": ["2026-11-08"],
+ "date_to": ["2026-11-14"],
+ }
+
+
+@pytest.mark.parametrize("action", ["delete", "reverify"])
+def test_received_action_rejects_invalid_filters_before_mutating(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app, status="received")
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ verify = Mock()
+ monkeypatch.setattr(views_module, "verify_webmention", verify)
+
+ response = client.post(
+ f"/received/{identifier}/{action}", query_string={"status": "invalid"}
+ )
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ with app.app_context():
+ row = db.session.get(ReceivedWebmention, identifier)
+ assert row is not None
+ assert row.status == "received"
+ verify.assert_not_called()
+
+
+@pytest.mark.parametrize("action", ["delete", "reverify"])
+@pytest.mark.parametrize("invalid", ["sort=invalid", "order=invalid", "per_page=101"])
+def test_received_action_rejects_invalid_sort_and_page_size_before_mutating(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+ invalid: str,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app, status="received")
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ verify = Mock()
+ monkeypatch.setattr(views_module, "verify_webmention", verify)
+
+ response = client.post(f"/received/{identifier}/{action}?{invalid}")
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ with app.app_context():
+ row = db.session.get(ReceivedWebmention, identifier)
+ assert row is not None
+ assert row.status == "received"
+ verify.assert_not_called()
+
+
+@pytest.mark.parametrize("action", ["delete", "reverify"])
+def test_received_admin_actions_require_login(client: FlaskClient, action: str) -> None:
+ response = client.post(f"/received/{uuid.uuid7()}/{action}")
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert "/login" in response.headers["Location"]
+
+
+@pytest.mark.parametrize("action", ["delete", "reverify"])
+def test_received_admin_actions_reject_invalid_form(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app)
+ form = mock_admin_action_form(views_module, monkeypatch, valid=False)
+
+ response = client.post(f"/received/{identifier}/{action}")
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ form.validate_on_submit.assert_called_once_with()
+
+
+@pytest.mark.parametrize("action", ["delete", "reverify"])
+def test_received_admin_actions_return_404_for_unknown_webmention(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+) -> None:
+ log_in(app, client)
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+
+ response = client.post(f"/received/{uuid.uuid7()}/{action}")
+
+ assert response.status_code == HTTPStatus.NOT_FOUND
+
+
+def test_delete_received_webmention(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app)
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+
+ response = client.post(f"/received/{identifier}/delete?page=3")
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert response.headers["Location"].endswith("/received?page=3")
+
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, identifier) is None
+
+
+def test_reverify_received_webmention(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(
+ app, status="failed", failure_reason="Previous failure"
+ )
+ with app.app_context():
+ row = db.session.get(ReceivedWebmention, identifier)
+ assert row is not None
+ row.recovery_attempts = 3
+ db.session.commit()
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ verify_webmention = Mock()
+ monkeypatch.setattr(views_module, "verify_webmention", verify_webmention)
+
+ response = client.post(f"/received/{identifier}/reverify?page=2")
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert response.headers["Location"].endswith("/received?page=2")
+
+ with app.app_context():
+ webmention = db.session.get(ReceivedWebmention, identifier)
+ assert webmention is not None
+ assert webmention.status == "received"
+ assert webmention.failure_reason is None
+ assert webmention.recovery_attempts == 0
+
+ verify_webmention.assert_called_once_with(identifier)
+
+
+def test_received_bulk_toolbar_and_shared_confirmation_modal(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ first = create_received_webmention(app)
+ second = create_received_webmention(app, source="https://other.example/post")
+
+ response = client.get("/received")
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert html.count('class="form-check-input received-select"') == 2
+ assert f'value="{first}"' in html
+ assert f'value="{second}"' in html
+ assert 'id="received-select-all"' in html
+ assert 'id="received-selected-count"' in html
+ assert 'data-received-bulk-action="reverify"' in html
+ assert 'data-received-bulk-action="block-sources"' in html
+ assert 'data-received-bulk-action="delete"' in html
+ assert 'data-title="Delete all declined webmentions?"' in html
+ assert html.count('id="confirmation-modal"') == 1
+ assert 'id="confirmation-modal-form"' in html
+ assert "received-bulk-actions.js" in html
+
+
+def test_received_delete_all_declined_available_without_matching_rows(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ create_received_webmention(app, status="verified")
+
+ response = client.get("/received", query_string={"status": "declined"})
+
+ assert response.status_code == HTTPStatus.OK
+ html = response.get_data(as_text=True)
+ assert 'data-title="Delete all declined webmentions?"' in html
+ assert 'id="confirmation-modal-form"' in html
+ assert 'data-received-bulk-action="delete"' not in html
+ assert 'data-received-bulk-action="block-sources"' not in html
+ assert 'id="received-select-all"' not in html
+
+
+@pytest.mark.parametrize(
+ "path",
+ [
+ "/received/bulk/reverify",
+ "/received/bulk/block-sources",
+ "/received/bulk/delete",
+ "/received/declined/delete",
+ ],
+)
+def test_received_bulk_actions_require_login(client: FlaskClient, path: str) -> None:
+ response = client.post(path)
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert "/login" in response.headers["Location"]
+
+
+@pytest.mark.parametrize(
+ "path",
+ [
+ "/received/bulk/reverify",
+ "/received/bulk/block-sources",
+ "/received/bulk/delete",
+ "/received/declined/delete",
+ ],
+)
+def test_received_bulk_actions_reject_invalid_form(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ path: str,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app, status="failed")
+ form = mock_admin_action_form(views_module, monkeypatch, valid=False)
+
+ response = client.post(path, data={"webmention_uuids": str(identifier)})
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ form.validate_on_submit.assert_called_once_with()
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, identifier).status == "failed"
+
+
+@pytest.mark.parametrize(
+ "path",
+ [
+ "/received/bulk/reverify",
+ "/received/bulk/block-sources",
+ "/received/bulk/delete",
+ "/received/declined/delete",
+ ],
+)
+def test_received_bulk_actions_reject_invalid_filters_before_mutating(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ path: str,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app, status="failed")
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ verify = Mock()
+ monkeypatch.setattr(views_module, "verify_webmention", verify)
+
+ response = client.post(
+ path,
+ query_string={"sort": "invalid"},
+ data={"webmention_uuids": str(identifier)},
+ )
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, identifier).status == "failed"
+ verify.assert_not_called()
+
+
+@pytest.mark.parametrize("action", ["reverify", "block-sources", "delete"])
+@pytest.mark.parametrize("selection", [[], ["bad-uuid"]])
+def test_received_bulk_actions_reject_empty_or_malformed_selection(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+ selection: list[str],
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app, status="failed")
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ verify = Mock()
+ monkeypatch.setattr(views_module, "verify_webmention", verify)
+
+ response = client.post(
+ f"/received/bulk/{action}", data={"webmention_uuids": selection}
+ )
+
+ assert response.status_code == HTTPStatus.BAD_REQUEST
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, identifier).status == "failed"
+ verify.assert_not_called()
+
+
+@pytest.mark.parametrize("action", ["reverify", "block-sources", "delete"])
+def test_received_bulk_actions_reject_duplicate_oversized_or_stale_selection(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+ action: str,
+) -> None:
+ log_in(app, client)
+ first = create_received_webmention(app, status="failed")
+ second = create_received_webmention(app, source="https://other.example/post")
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ verify = Mock()
+ monkeypatch.setattr(views_module, "verify_webmention", verify)
+ path = f"/received/bulk/{action}"
+
+ duplicate = client.post(path, data={"webmention_uuids": [str(first)] * 2})
+ assert duplicate.status_code == HTTPStatus.BAD_REQUEST
+
+ stale = client.post(
+ path, data={"webmention_uuids": [str(first), str(uuid.uuid7())]}
+ )
+ assert stale.status_code == HTTPStatus.NOT_FOUND
+
+ app.config["RECEIVED_MAX_PAGE_SIZE"] = 1
+ oversized = client.post(path, data={"webmention_uuids": [str(first), str(second)]})
+ assert oversized.status_code == HTTPStatus.BAD_REQUEST
+
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, first).status == "failed"
+ assert db.session.get(ReceivedWebmention, second) is not None
+ verify.assert_not_called()
+
+
+def test_delete_selected_received_webmentions(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ log_in(app, client)
+ first = create_received_webmention(app, status="failed")
+ second = create_received_webmention(app, source="https://other.example/post")
+ unselected = create_received_webmention(app, source="https://third.example/post")
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+
+ response = client.post(
+ "/received/bulk/delete",
+ query_string={"page": 3, "sort": "source", "order": "asc", "per_page": 37},
+ data={"webmention_uuids": [str(first), str(second)]},
+ )
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert parse_qs(urlsplit(response.headers["Location"]).query) == {
+ "page": ["3"],
+ "sort": ["source"],
+ "order": ["asc"],
+ "per_page": ["37"],
+ }
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, first) is None
+ assert db.session.get(ReceivedWebmention, second) is None
+ assert db.session.get(ReceivedWebmention, unselected) is not None
+
+
+def test_reverify_selected_received_webmentions(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ log_in(app, client)
+ first = create_received_webmention(app, status="failed", failure_reason="Failure")
+ second = create_received_webmention(
+ app, source="https://other.example/post", status="source_removed"
+ )
+ unselected = create_received_webmention(
+ app, source="https://third.example/post", status="failed"
+ )
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+ verify = Mock()
+ monkeypatch.setattr(views_module, "verify_webmention", verify)
+
+ response = client.post(
+ "/received/bulk/reverify",
+ query_string={"status": "declined", "page": 2},
+ data={"webmention_uuids": [str(first), str(second)]},
+ )
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert parse_qs(urlsplit(response.headers["Location"]).query) == {
+ "status": ["declined"],
+ "page": ["2"],
+ }
+ with app.app_context():
+ for identifier in (first, second):
+ webmention = db.session.get(ReceivedWebmention, identifier)
+ assert webmention is not None
+ assert webmention.status == "received"
+ assert webmention.failure_reason is None
+ assert webmention.recovery_attempts == 0
+ assert db.session.get(ReceivedWebmention, unselected).status == "failed"
+ assert verify.call_count == 2
+ assert {call.args[0] for call in verify.call_args_list} == {first, second}
+
+
+def test_delete_all_declined_received_webmentions_ignores_age_and_filters(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ log_in(app, client)
+ failed = create_received_webmention(
+ app, status="failed", updated_at=datetime.now(UTC)
+ )
+ removed = create_received_webmention(
+ app,
+ source="https://other.example/post",
+ status="source_removed",
+ updated_at=datetime.now(UTC) - timedelta(days=60),
+ )
+ retained = [
+ create_received_webmention(
+ app, source=f"https://{status}.example/post", status=status
+ )
+ for status in ("received", "verifying", "verified")
+ ]
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+
+ response = client.post(
+ "/received/declined/delete",
+ query_string={"page": 4, "status": "verified", "q": "no-match"},
+ )
+
+ assert response.status_code == HTTPStatus.FOUND
+ assert parse_qs(urlsplit(response.headers["Location"]).query) == {
+ "page": ["4"],
+ "status": ["verified"],
+ "q": ["no-match"],
+ }
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, failed) is None
+ assert db.session.get(ReceivedWebmention, removed) is None
+ for identifier in retained:
+ assert db.session.get(ReceivedWebmention, identifier) is not None
+
+
+def test_delete_all_declined_received_webmentions_when_none_exist(
+ app: Flask,
+ client: FlaskClient,
+ views_module: ModuleType,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app, status="verified")
+ mock_admin_action_form(views_module, monkeypatch, valid=True)
+
+ response = client.post("/received/declined/delete")
+
+ assert response.status_code == HTTPStatus.FOUND
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, identifier) is not None
+
+
+def test_received_bulk_delete_requires_real_csrf_token(
+ app: Flask, client: FlaskClient
+) -> None:
+ log_in(app, client)
+ identifier = create_received_webmention(app, status="failed")
+ app.config["WTF_CSRF_ENABLED"] = True
+
+ invalid = client.post(
+ "/received/bulk/delete", data={"webmention_uuids": str(identifier)}
+ )
+ assert invalid.status_code == HTTPStatus.BAD_REQUEST
+
+ html = client.get("/received").get_data(as_text=True)
+ match = re.search(
+ r'<input\b(?=[^>]*name="csrf_token")(?=[^>]*value="([^"]+)")[^>]*>', html
+ )
+ assert match is not None
+ valid = client.post(
+ "/received/bulk/delete",
+ data={"webmention_uuids": str(identifier), "csrf_token": match.group(1)},
+ )
+ assert valid.status_code == HTTPStatus.FOUND
+ with app.app_context():
+ assert db.session.get(ReceivedWebmention, identifier) is None