diff options
Diffstat (limited to '')
| -rw-r--r-- | tests/tasks/test_sender.py | 24 | ||||
| -rw-r--r-- | tests/test_failure_guidance.py | 116 | ||||
| -rw-r--r-- | tests/test_received_failure.py | 53 | ||||
| -rw-r--r-- | tests/views/test_sent.py | 409 |
4 files changed, 533 insertions, 69 deletions
diff --git a/tests/tasks/test_sender.py b/tests/tasks/test_sender.py index 0d68933..5be2177 100644 --- a/tests/tasks/test_sender.py +++ b/tests/tasks/test_sender.py @@ -11,12 +11,14 @@ from unittest.mock import MagicMock, Mock import httpx import pytest +import sqlalchemy as sa from flask import Flask from webmentions_ssg import db from webmentions_ssg.models.sources import ( SentWebmention, SentWebmentionStatus, + SentWebmentionStatusEvent, SourceDocument, ) @@ -184,6 +186,16 @@ def test_send_webmention_persists_success( assert webmention.last_sent_at is not None assert webmention.attempt_count == 1 assert webmention.next_retry_at is None + history = db.session.scalars( + sa.select(SentWebmentionStatusEvent).where( + SentWebmentionStatusEvent.webmention_uuid == identifier + ) + ).all() + assert len(history) == 1 + assert history[0].action == "Delivery succeeded" + assert history[0].status == SentWebmentionStatus.SENT + assert history[0].attempt_count == 1 + assert history[0].endpoint_response_status == HTTPStatus.CREATED def test_send_webmention_marks_unsupported_target_processed( @@ -221,6 +233,10 @@ def test_send_webmention_marks_unsupported_target_processed( assert webmention.endpoint_response_status is None assert webmention.status_url is None assert webmention.last_attempted_at is not None + history = db.session.scalars(sa.select(SentWebmentionStatusEvent)).all() + assert len(history) == 1 + assert history[0].action == "No endpoint discovered" + assert history[0].status == SentWebmentionStatus.NO_ENDPOINT def test_send_webmention_persists_permanent_failure( @@ -252,6 +268,10 @@ def test_send_webmention_persists_permanent_failure( assert webmention.webmention_endpoint == ENDPOINT_URL assert webmention.endpoint_response_status == HTTPStatus.BAD_REQUEST assert webmention.status_url is None + history = db.session.scalars(sa.select(SentWebmentionStatusEvent)).all() + assert len(history) == 1 + assert history[0].action == "Delivery failed" + assert history[0].failure_reason == webmention.failure_reason def test_send_webmention_persists_temporary_failure_with_backoff( @@ -291,6 +311,10 @@ def test_send_webmention_persists_temporary_failure_with_backoff( webmention.next_retry_at.replace(tzinfo=None) - webmention.last_attempted_at.replace(tzinfo=None) ).total_seconds() == 3600 + history = db.session.scalars(sa.select(SentWebmentionStatusEvent)).all() + assert len(history) == 1 + assert history[0].action == "Delivery failed; automatic retry scheduled" + assert history[0].attempt_count == 1 def test_backoff_delay_is_exponential_and_capped( diff --git a/tests/test_failure_guidance.py b/tests/test_failure_guidance.py new file mode 100644 index 0000000..008412f --- /dev/null +++ b/tests/test_failure_guidance.py @@ -0,0 +1,116 @@ +# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me> +# +# SPDX-License-Identifier: BSD-3-Clause + +import pytest + +from webmentions_ssg.failure_guidance import ( + describe_received_failure, + describe_sent_failure, +) + + +@pytest.mark.parametrize( + ("reason", "expected_fragment", "local_step"), + [ + ("Source does not mention target", "link to the target URL", False), + ("Source returned HTTP 410", "permanently gone", False), + ("Source document is too large", "maximum response size", False), + ("Source resolves to a non-public address", "non-public address", False), + ("Source hostname could not be resolved", "DNS", False), + ("Source could not be fetched", "could not fetch", False), + ("Invalid source hostname", "valid hostname", False), + ("Source domain is blocked", "blocklist", True), + ("Source domain is not allowlisted", "allowed source-domain", True), + ("Verification recovery limit reached", "automatic recovery stopped", True), + ("Target hostname is not in ALLOWED_TARGET_HOSTNAMES", "target hostname", True), + ( + "Target hostname is not in ALLOWED_TARGET_HOSTNAMES.", + "target hostname", + True, + ), + ("Source returned HTTP 404", "not found", False), + ("Source returned HTTP 401", "denied access", False), + ("Source returned HTTP 403", "denied access", False), + ("Source returned HTTP 429", "limiting requests", False), + ("Source returned HTTP 503", "server error", False), + ("Source returned HTTP 400", "returned HTTP 400", False), + ( + "Unsupported source content type: application/json", + "application/json", + False, + ), + ], +) +def test_only_receiver_controlled_failures_suggest_steps( + reason: str, expected_fragment: str, local_step: bool +) -> None: + guidance = describe_received_failure(reason) + assert guidance is not None + assert expected_fragment in guidance.explanation + assert bool(guidance.next_step) is local_step + + +@pytest.mark.parametrize("reason", ["unknown failure", "", "Source returned HTTP 999"]) +def test_unknown_received_failures_are_not_misclassified(reason: str) -> None: + assert describe_received_failure(reason) is None + + +@pytest.mark.parametrize( + ("reason", "expected_fragment", "operator_step"), + [ + ("No Webmention endpoint discovered", "does not advertise", False), + ("Target returned HTTP 404", "not found", False), + ("Target returned HTTP 410", "permanently gone", False), + ("Target returned HTTP 403", "denied access", False), + ("Target returned HTTP 429", "rate-limiting", True), + ("Target returned HTTP 503", "server error", True), + ("Target returned HTTP 400", "did not complete delivery", False), + ("Webmention endpoint returned HTTP 302", "did not complete delivery", False), + ("Webmention endpoint returned HTTP 400", "rejected the submission", True), + ("Webmention endpoint returned HTTP 422", "rejected the submission", True), + ("Webmention endpoint returned HTTP 404", "not found", False), + ("Webmention endpoint returned HTTP 408", "timed out", True), + ("Webmention endpoint returned HTTP 429", "rate-limiting", True), + ("Webmention endpoint returned HTTP 500", "server error", True), + ("Webmention endpoint returned HTTP 503.", "server error", True), + ("Target document is too large", "response-size limit", True), + ("Invalid target URL: 'ftp://example.com'", "valid HTTP", True), + ("Invalid Webmention endpoint: 'ftp://example.com'", "malformed", False), + ("Could not resolve hostname 'example.com'", "DNS resolution", True), + ("Non-public network address for 'localhost'", "non-public", True), + ("No public addresses available for 'example.com'", "public address", False), + ("Retry limit reached (6 attempts)", "exhausted", True), + ("Webmention request failed", "could not complete", True), + ("timed out", "timed out", True), + ("The read operation timed out", "read timeout", True), + ("[Errno 111] Connection refused", "refused", True), + ("All connection attempts failed", "could not establish", True), + ("Server disconnected without sending a response", "closed", False), + ], +) +def test_sent_failure_guidance( + reason: str, expected_fragment: str, operator_step: bool +) -> None: + guidance = describe_sent_failure(reason) + assert guidance is not None + assert expected_fragment in guidance.explanation + assert bool(guidance.next_step) is operator_step + + +@pytest.mark.parametrize( + "reason", + [ + "", + "Unrecognized sender failure", + "Target returned HTTP 999", + "Retry limit reached", + ], +) +def test_unknown_sent_failures_keep_raw_reason(reason: str) -> None: + assert describe_sent_failure(reason) is None + + +def test_received_and_sent_reasons_do_not_cross_classify() -> None: + assert describe_received_failure("No Webmention endpoint discovered") is None + assert describe_sent_failure("Source domain is blocked") is None diff --git a/tests/test_received_failure.py b/tests/test_received_failure.py deleted file mode 100644 index 095d7e1..0000000 --- a/tests/test_received_failure.py +++ /dev/null @@ -1,53 +0,0 @@ -# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me> -# -# SPDX-License-Identifier: BSD-3-Clause - -import pytest - -from webmentions_ssg.received_failure import describe_received_failure - - -@pytest.mark.parametrize( - ("reason", "expected_fragment", "local_step"), - [ - ("Source does not mention target", "link to the target URL", False), - ("Source returned HTTP 410", "permanently gone", False), - ("Source document is too large", "maximum response size", False), - ("Source resolves to a non-public address", "non-public address", False), - ("Source hostname could not be resolved", "DNS", False), - ("Source could not be fetched", "could not fetch", False), - ("Invalid source hostname", "valid hostname", False), - ("Source domain is blocked", "blocklist", True), - ("Source domain is not allowlisted", "allowed source-domain", True), - ("Verification recovery limit reached", "automatic recovery stopped", True), - ("Target hostname is not in ALLOWED_TARGET_HOSTNAMES", "target hostname", True), - ( - "Target hostname is not in ALLOWED_TARGET_HOSTNAMES.", - "target hostname", - True, - ), - ("Source returned HTTP 404", "not found", False), - ("Source returned HTTP 401", "denied access", False), - ("Source returned HTTP 403", "denied access", False), - ("Source returned HTTP 429", "limiting requests", False), - ("Source returned HTTP 503", "server error", False), - ("Source returned HTTP 400", "returned HTTP 400", False), - ( - "Unsupported source content type: application/json", - "application/json", - False, - ), - ], -) -def test_only_receiver_controlled_failures_suggest_steps( - reason: str, expected_fragment: str, local_step: bool -) -> None: - guidance = describe_received_failure(reason) - assert guidance is not None - assert expected_fragment in guidance.explanation - assert bool(guidance.next_step) is local_step - - -@pytest.mark.parametrize("reason", ["unknown failure", "", "Source returned HTTP 999"]) -def test_unknown_received_failures_are_not_misclassified(reason: str) -> None: - assert describe_received_failure(reason) is None diff --git a/tests/views/test_sent.py b/tests/views/test_sent.py index 9f9e65f..644fc6f 100644 --- a/tests/views/test_sent.py +++ b/tests/views/test_sent.py @@ -12,6 +12,7 @@ from unittest.mock import Mock from urllib.parse import parse_qs, urlsplit import pytest +import sqlalchemy as sa from bs4 import BeautifulSoup, Tag from flask import Flask from flask.testing import FlaskClient @@ -20,6 +21,7 @@ from webmentions_ssg import db from webmentions_ssg.models.sources import ( SentWebmention, SentWebmentionStatus, + SentWebmentionStatusEvent, SourceDocument, ) from webmentions_ssg.models.user import User @@ -90,15 +92,18 @@ def test_sent_source_documents_table_hides_secondary_columns_on_mobile( assert table is not None headers = table.select("thead th") cells = table.select("tbody tr:first-child td") - assert len(headers) == len(cells) == 7 + assert len(headers) == len(cells) == 8 for index in (2, 4, 5, 6): # URL, revision, created, last seen for cell in (headers[index], cells[index]): assert {"d-none", "d-md-table-cell"} <= set( cell.get_attribute_list("class") ) - for index in (0, 1, 3): # Path, count, status stay visible + for index in (0, 1, 3, 7): # Status, path, counts, details stay visible assert "d-none" not in cells[index].get_attribute_list("class") assert "text-break" in cells[1].get_attribute_list("class") + details = cells[7].select_one('a.btn[href^="/sent/"]') + assert details is not None + assert details.get_text(strip=True) == "Details" def test_sent_source_lists_webmentions(app: Flask, client: FlaskClient) -> None: @@ -211,9 +216,7 @@ def test_resend_sent_webmention_rejects_invalid_form( source_identifier, webmention_identifier = create_resendable_sent_webmention(app) mock_admin_action_form(sent_module, monkeypatch, valid=False) - response = client.post( - f"/sent/{source_identifier}/{webmention_identifier}/resend" - ) + response = client.post(f"/sent/{source_identifier}/{webmention_identifier}/resend") assert response.status_code == HTTPStatus.BAD_REQUEST @@ -270,9 +273,7 @@ def test_resend_sent_webmention_reopens_current_revision( webmention.next_retry_at = datetime.now(UTC) + timedelta(hours=24) db.session.commit() - response = client.post( - f"/sent/{source_identifier}/{webmention_identifier}/resend" - ) + response = client.post(f"/sent/{source_identifier}/{webmention_identifier}/resend") assert response.status_code == HTTPStatus.FOUND assert response.headers["Location"].endswith(f"/sent/{source_identifier}") @@ -290,6 +291,15 @@ def test_resend_sent_webmention_reopens_current_revision( assert webmention.webmention_endpoint is None assert webmention.endpoint_response_status is None assert webmention.status_url is None + events = db.session.scalars( + sa.select(SentWebmentionStatusEvent).where( + SentWebmentionStatusEvent.webmention_uuid == webmention_identifier + ) + ).all() + assert len(events) == 1 + assert events[0].status is None + assert events[0].action == "Manually queued for resend" + assert events[0].revision == 3 send_webmention.assert_called_once_with(webmention_identifier) @@ -400,9 +410,9 @@ def test_sent_filter_by_delivery_state_without_duplicate_rows( soup = BeautifulSoup(response.get_data(as_text=True), "html.parser") paths = [] for row in soup.select("tbody tr"): - link = row.select_one("td a") - assert link is not None - paths.append(link.get_text(strip=True)) + path = row.select_one("td:nth-child(2)") + assert path is not None + paths.append(path.get_text(strip=True)) assert set(paths) == {f"blog/{name}/index.html" for name in expected} assert len(paths) == len(expected) assert ( @@ -515,9 +525,9 @@ def test_sent_sort_orders_by_count_and_path(app: Flask, client: FlaskClient) -> response = client.get("/sent", query_string={"sort": sort, "order": order}) assert response.status_code == HTTPStatus.OK soup = BeautifulSoup(response.get_data(as_text=True), "html.parser") - link = soup.select_one("tbody tr td a") - assert link is not None - assert link.get_text(strip=True) == f"blog/{expected_first}/index.html" + path = soup.select_one("tbody tr td:nth-child(2)") + assert path is not None + assert path.get_text(strip=True) == f"blog/{expected_first}/index.html" def test_sent_filter_pagination_and_navigation_preserve_parameters( @@ -598,8 +608,7 @@ def test_rescan_sources_preserves_filter_query( scan = Mock() monkeypatch.setattr(sent_module, "manual_scan_sources", scan) response = client.post( - "/sent/rescan", - query_string={"status": "retrying", "per_page": 37, "page": 2}, + "/sent/rescan", query_string={"status": "retrying", "per_page": 37, "page": 2} ) assert response.status_code == HTTPStatus.FOUND assert parse_qs(urlsplit(response.headers["Location"]).query) == { @@ -706,3 +715,371 @@ def test_sent_empty_filter_result_keeps_rescan_modal( html = response.get_data(as_text=True) assert "No source documents match these filters." in html assert 'id="confirmation-modal"' in html + + +def test_sent_list_and_source_use_confirmation_actions_and_detail_history( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + source_id, mention_id = create_resendable_sent_webmention(app) + with app.app_context(): + mention = db.session.get(SentWebmention, mention_id) + assert mention is not None + mention.record_status_event("Delivery failed") + db.session.commit() + + listing = BeautifulSoup(client.get("/sent").get_data(as_text=True), "html.parser") + button = listing.select_one('button[data-action="/sent/failed/resend"]') + assert button is not None + assert button.get("data-bs-target") == "#confirmation-modal" + details = listing.select_one('tbody a.btn[href^="/sent/"]') + assert details is not None + assert urlsplit(_href(details)).path == f"/sent/{source_id}" + + detail = BeautifulSoup( + client.get(f"/sent/{source_id}").get_data(as_text=True), "html.parser" + ) + assert detail.select_one("section.card #source-details-heading") is not None + assert detail.select_one("section #sent-webmentions-heading") is not None + assert detail.select_one("section #status-history-heading") is not None + history = detail.select("#status-history-heading ~ ol li") + assert len(history) == 1 + assert "Delivery failed" in history[0].get_text() + assert "https://example.com/resend" in history[0].get_text() + assert detail.select_one("section table tbody tr") is not None + resend = detail.select_one('button[data-action*="resend-all"]') + assert resend is not None + assert resend.get_text(strip=True) == "Resend all" + + +@pytest.mark.parametrize( + "path", ["/sent/failed/resend", f"/sent/{uuid.uuid7()}/resend-all"] +) +def test_bulk_resend_requires_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("valid", [False, True]) +def test_global_resend_all_failed_ignores_filters_and_preserves_other_statuses( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, + valid: bool, +) -> None: + log_in(app, client) + first = make_source( + app, "first", statuses=(SentWebmentionStatus.FAILED, SentWebmentionStatus.SENT) + ) + second = make_source( + app, + "second", + statuses=(SentWebmentionStatus.FAILED,), + retrying=True, + processed=False, + ) + make_source(app, "third", statuses=(SentWebmentionStatus.NO_ENDPOINT, None)) + mock_admin_action_form(sent_module, monkeypatch, valid=valid) + send = Mock() + monkeypatch.setattr(sent_module, "send_webmention", send) + + response = client.post( + "/sent/failed/resend", + query_string={"status": "deleted", "q": "no-match", "page": 2}, + ) + assert response.status_code == ( + HTTPStatus.FOUND if valid else HTTPStatus.BAD_REQUEST + ) + if valid: + assert parse_qs(urlsplit(response.headers["Location"]).query) == { + "status": ["deleted"], + "q": ["no-match"], + "page": ["2"], + } + with app.app_context(): + all_mentions = db.session.scalars(sa.select(SentWebmention)).all() + affected = [m for m in all_mentions if m.source_uuid in (first, second)] + failed = [m for m in affected if m.target.endswith("/0")] + untouched = [m for m in all_mentions if m not in failed] + assert len(failed) == 2 + for mention in failed: + assert (mention.status is None) is valid + if valid: + assert mention.processed_revision is None + assert mention.attempt_count == 0 + assert mention.next_retry_at is None + assert any(m.status == SentWebmentionStatus.SENT for m in untouched) + assert any(m.status == SentWebmentionStatus.NO_ENDPOINT for m in untouched) + events = db.session.scalars(sa.select(SentWebmentionStatusEvent)).all() + assert len(events) == (2 if valid else 0) + assert {event.webmention_uuid for event in events} == ( + {m.uuid for m in failed} if valid else set() + ) + assert {call.args[0] for call in send.call_args_list} == ( + {m.uuid for m in failed} if valid else set() + ) + assert send.call_count == (2 if valid else 0) + + +def test_source_resend_all_includes_successful_and_pending_but_only_this_source( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + source_id = make_source( + app, + "bulk", + statuses=( + SentWebmentionStatus.SENT, + SentWebmentionStatus.FAILED, + SentWebmentionStatus.NO_ENDPOINT, + None, + ), + ) + other_source = make_source(app, "other", statuses=(SentWebmentionStatus.FAILED,)) + mock_admin_action_form(sent_module, monkeypatch, valid=True) + send = Mock() + monkeypatch.setattr(sent_module, "send_webmention", send) + + response = client.post( + f"/sent/{source_id}/resend-all", + query_string={ + "status": "failing", + "source_page": 2, + "page": 3, + "history_page": 4, + }, + ) + assert response.status_code == HTTPStatus.FOUND + assert urlsplit(response.headers["Location"]).path == f"/sent/{source_id}" + assert parse_qs(urlsplit(response.headers["Location"]).query) == { + "status": ["failing"], + "source_page": ["2"], + "page": ["3"], + "history_page": ["4"], + } + with app.app_context(): + mentions = db.session.scalars( + sa.select(SentWebmention).where(SentWebmention.source_uuid == source_id) + ).all() + assert len(mentions) == 4 + assert all(m.status is None and m.processed_revision is None for m in mentions) + assert all(m.attempt_count == 0 for m in mentions) + assert all(m.sent_revision is None for m in mentions) + other = db.session.scalar( + sa.select(SentWebmention).where(SentWebmention.source_uuid == other_source) + ) + assert other is not None and other.status == SentWebmentionStatus.FAILED + history = db.session.scalars(sa.select(SentWebmentionStatusEvent)).all() + assert {event.webmention_uuid for event in history} == { + m.uuid for m in mentions + } + assert {call.args[0] for call in send.call_args_list} == {m.uuid for m in mentions} + assert send.call_count == 4 + + +def test_source_resend_all_rejects_unknown_source_and_invalid_form( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + source_id = make_source(app, "protected", statuses=(SentWebmentionStatus.FAILED,)) + form = mock_admin_action_form(sent_module, monkeypatch, valid=False) + send = Mock() + monkeypatch.setattr(sent_module, "send_webmention", send) + assert ( + client.post(f"/sent/{source_id}/resend-all").status_code + == HTTPStatus.BAD_REQUEST + ) + form.validate_on_submit.assert_called_once_with() + mock_admin_action_form(sent_module, monkeypatch, valid=True) + assert ( + client.post(f"/sent/{uuid.uuid7()}/resend-all").status_code + == HTTPStatus.NOT_FOUND + ) + with app.app_context(): + mention = db.session.scalar(sa.select(SentWebmention)) + assert mention is not None and mention.status == SentWebmentionStatus.FAILED + send.assert_not_called() + + +def test_sent_source_history_is_paginated_independently_of_webmentions( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + source_id, mention_id = create_resendable_sent_webmention(app) + with app.app_context(): + mention = db.session.get(SentWebmention, mention_id) + assert mention is not None + for n in range(27): + mention.record_status_event(f"Historical delivery {n}") + db.session.commit() + + first_page = client.get(f"/sent/{source_id}") + assert first_page.status_code == HTTPStatus.OK + soup = BeautifulSoup(first_page.get_data(as_text=True), "html.parser") + history = soup.select("#status-history-heading ~ ol li") + assert len(history) == 25 + assert "Historical delivery 26" in history[0].get_text() + assert "Historical delivery 0" not in first_page.get_data(as_text=True) + links = [_href(link) for link in soup.select("#status-history-heading ~ div a")] + assert any("history_page=2" in link for link in links) + + second_page = client.get(f"/sent/{source_id}?history_page=2") + assert second_page.status_code == HTTPStatus.OK + soup = BeautifulSoup(second_page.get_data(as_text=True), "html.parser") + history = soup.select("#status-history-heading ~ ol li") + assert len(history) == 2 + assert "Historical delivery 0" in history[-1].get_text() + assert len(soup.select("section table tbody tr")) == 1 + + +def test_sent_source_history_links_keep_webmentions_page( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + source_id, mention_id = create_resendable_sent_webmention(app) + with app.app_context(): + source = db.session.get(SourceDocument, source_id) + mention = db.session.get(SentWebmention, mention_id) + assert source is not None and mention is not None + source.sent_webmentions.extend( + SentWebmention( + target=f"https://example.org/extra/{number}", + linked=True, + desired_revision=3, + ) + for number in range(25) + ) + for number in range(27): + mention.record_status_event(f"History event {number}") + db.session.commit() + + response = client.get(f"/sent/{source_id}?page=2&source_page=3") + assert response.status_code == HTTPStatus.OK + soup = BeautifulSoup(response.get_data(as_text=True), "html.parser") + history_links = [ + (_href(link), parse_qs(urlsplit(_href(link)).query)) + for link in soup.select("#status-history-heading ~ div a") + if urlsplit(_href(link)).path == f"/sent/{source_id}" + ] + next_history = next( + href + for href, query in history_links + if query.get("history_page") == ["2"] + ) + query = parse_qs(urlsplit(next_history).query) + assert query["page"] == ["2"] + assert query["source_page"] == ["3"] + + following = client.get(next_history) + assert following.status_code == HTTPStatus.OK + next_soup = BeautifulSoup(following.get_data(as_text=True), "html.parser") + assert len(next_soup.select("#status-history-heading ~ ol li")) == 2 + assert len(next_soup.select("section table tbody tr")) == 1 + + +def test_sent_source_explains_current_failed_delivery( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + identifier = create_sent_source(app) + + response = client.get(f"/sent/{identifier}") + + assert response.status_code == HTTPStatus.OK + soup = BeautifulSoup(response.get_data(as_text=True), "html.parser") + assert "Webmention endpoint rejected the submission" in soup.get_text() + assert "Check that your published source page links" in soup.get_text() + assert "Suggested next step:" in soup.get_text() + reason = soup.find("details") + assert reason is not None + assert "Webmention endpoint returned HTTP 400" in reason.get_text() + # Keep the existing target table and its resend action. + assert soup.select_one(".table-responsive table tbody tr button[data-action]") + + +def test_sent_source_explains_historical_failures_and_escapes_raw_reason( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + identifier = create_sent_source(app) + raw_reason = "Unexpected transport failure <script>alert('x')</script>" + with app.app_context(): + mention = db.session.scalar( + sa.select(SentWebmention).where(SentWebmention.source_uuid == identifier) + ) + assert mention is not None + db.session.add_all( + [ + SentWebmentionStatusEvent( + webmention_uuid=mention.uuid, + status=SentWebmentionStatus.FAILED, + action="Delivery failed; automatic retry scheduled", + revision=2, + attempt_count=1, + failure_reason="Webmention endpoint returned HTTP 503", + endpoint_response_status=503, + occurred_at=datetime(2026, 11, 12, tzinfo=UTC), + ), + SentWebmentionStatusEvent( + webmention_uuid=mention.uuid, + status=SentWebmentionStatus.FAILED, + action="Delivery failed", + revision=2, + attempt_count=2, + failure_reason=raw_reason, + occurred_at=datetime(2026, 11, 13, tzinfo=UTC), + ), + ] + ) + db.session.commit() + + response = client.get(f"/sent/{identifier}") + + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + soup = BeautifulSoup(html, "html.parser") + history = soup.select_one("#status-history-heading") + assert history is not None + assert "Webmention endpoint returned a server error" in soup.get_text() + assert "Automatic retries run while attempts remain" in soup.get_text() + assert raw_reason in soup.get_text() + assert "Check the application logs for details before resending." in soup.get_text() + assert "<script>" not in html + assert "<script>" in html + + +def test_sent_source_explains_no_endpoint_without_suggesting_remote_edits( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + identifier = create_sent_source(app) + with app.app_context(): + mention = db.session.scalar( + sa.select(SentWebmention).where(SentWebmention.source_uuid == identifier) + ) + assert mention is not None + mention.status = SentWebmentionStatus.NO_ENDPOINT + mention.failure_reason = "No Webmention endpoint discovered" + db.session.commit() + + response = client.get(f"/sent/{identifier}") + + assert response.status_code == HTTPStatus.OK + soup = BeautifulSoup(response.get_data(as_text=True), "html.parser") + assert "does not advertise a usable Webmention endpoint" in soup.get_text() + assert "No Webmention endpoint discovered" in soup.get_text() + # The unrelated failed mention may have guidance; the no-endpoint row must not. + no_endpoint_row = next( + row + for row in soup.select(".table-responsive table tbody tr") + if "No Webmention endpoint discovered" in row.get_text() + ) + assert "Suggested next step:" not in no_endpoint_row.get_text() |
