diff options
Diffstat (limited to 'tests/views/test_received.py')
| -rw-r--r-- | tests/views/test_received.py | 1063 |
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 |
