diff options
Diffstat (limited to 'tests/views/test_sent.py')
| -rw-r--r-- | tests/views/test_sent.py | 708 |
1 files changed, 708 insertions, 0 deletions
diff --git a/tests/views/test_sent.py b/tests/views/test_sent.py new file mode 100644 index 0000000..9f9e65f --- /dev/null +++ b/tests/views/test_sent.py @@ -0,0 +1,708 @@ +# 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, Tag +from flask import Flask +from flask.testing import FlaskClient + +from webmentions_ssg import db +from webmentions_ssg.models.sources import ( + SentWebmention, + SentWebmentionStatus, + SourceDocument, +) +from webmentions_ssg.models.user import User + +from .helpers import ( + create_outgoing, + create_resendable_sent_webmention, + create_sent_source, + log_in, + mock_admin_action_form, +) + + +def _href(tag: Tag) -> str: + """Return an HTML link target, checking BeautifulSoup's attribute type.""" + href = tag.get("href") + assert isinstance(href, str) + return unescape(href) + + +@pytest.fixture +def sent_module(app: Flask) -> ModuleType: + _ = app + from webmentions_ssg.views import sent as module + + return module + + +@pytest.mark.parametrize("path", ["/sent", f"/sent/{uuid.uuid7()}"]) +def test_sent_views_require_login(client: FlaskClient, path: str) -> None: + response = client.get(path) + + assert response.status_code == HTTPStatus.FOUND + assert "/login" in response.headers["Location"] + + +def test_sent_lists_source_documents(app: Flask, client: FlaskClient) -> None: + log_in(app, client) + identifier = create_sent_source(app) + + response = client.get("/sent") + + assert response.status_code == HTTPStatus.OK + + html = response.get_data(as_text=True) + soup = BeautifulSoup(html, "html.parser") + + assert soup.h1 is not None + assert soup.h1.get_text(strip=True) == "Sent Webmentions" + assert "1 source document" in html + assert soup.select_one('form[action="/sent"]') is not None + assert "blog/example/index.html" in html + assert "https://dennisfink.me/blog/example/" in html + assert f"/sent/{identifier}" in html + + +def test_sent_source_documents_table_hides_secondary_columns_on_mobile( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + create_sent_source(app) + + response = client.get("/sent") + + assert response.status_code == HTTPStatus.OK + html = BeautifulSoup(response.get_data(as_text=True), "html.parser") + table = html.select_one(".table-responsive > table") + assert table is not None + headers = table.select("thead th") + cells = table.select("tbody tr:first-child td") + assert len(headers) == len(cells) == 7 + 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 + assert "d-none" not in cells[index].get_attribute_list("class") + assert "text-break" in cells[1].get_attribute_list("class") + + +def test_sent_source_lists_webmentions(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 + + html = response.get_data(as_text=True) + + assert "blog/example/index.html" in html + assert "https://dennisfink.me/blog/example/" in html + assert "Sent Webmention Source" in html + assert "Back to Sent Webmentions" in html + + first_target = "https://example.com/a" + second_target = "https://example.com/b" + + assert first_target in html + assert second_target in html + assert html.index(first_target) < html.index(second_target) + + assert "Webmention endpoint returned HTTP 400" in html + assert "https://example.com/webmention" in html + + +def test_sent_webmentions_table_keeps_status_and_actions_on_mobile( + 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 + html = BeautifulSoup(response.get_data(as_text=True), "html.parser") + table = html.select_one(".table-responsive > table") + assert table is not None + headers = table.select("thead th") + cells = table.select("tbody tr:first-child td") + assert len(headers) == len(cells) == 7 + for index in (2, 3, 4, 5): # Active, revisions, delivery, activity + 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, 6): # Target, status, resend action stay visible + assert "d-none" not in cells[index].get_attribute_list("class") + assert cells[6].select_one("button[data-action]") is not None + + +def test_sent_source_returns_404_for_unknown_source( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + response = client.get(f"/sent/{uuid.uuid7()}") + assert response.status_code == HTTPStatus.NOT_FOUND + + +def test_rescan_sent_sources_requires_login(client: FlaskClient) -> None: + response = client.post("/sent/rescan") + + assert response.status_code == HTTPStatus.FOUND + assert "/login" in response.headers["Location"] + + +@pytest.mark.parametrize("valid", [False, True]) +def test_rescan_sent_sources( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, + valid: bool, +) -> None: + log_in(app, client) + form = mock_admin_action_form(sent_module, monkeypatch, valid=valid) + manual_scan_sources = Mock() + monkeypatch.setattr(sent_module, "manual_scan_sources", manual_scan_sources) + + response = client.post("/sent/rescan") + + assert response.status_code == ( + HTTPStatus.FOUND if valid else HTTPStatus.BAD_REQUEST + ) + form.validate_on_submit.assert_called_once_with() + + if valid: + assert response.headers["Location"].endswith("/sent") + manual_scan_sources.assert_called_once_with() + else: + manual_scan_sources.assert_not_called() + + +def test_resend_sent_webmention_requires_login(client: FlaskClient) -> None: + response = client.post(f"/sent/{uuid.uuid7()}/{uuid.uuid7()}/resend") + + assert response.status_code == HTTPStatus.FOUND + assert "/login" in response.headers["Location"] + + +def test_resend_sent_webmention_rejects_invalid_form( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + 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" + ) + + assert response.status_code == HTTPStatus.BAD_REQUEST + + +def test_resend_sent_webmention_returns_404_for_unknown_webmention( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + source_identifier = create_sent_source(app) + mock_admin_action_form(sent_module, monkeypatch, valid=True) + + response = client.post(f"/sent/{source_identifier}/{uuid.uuid7()}/resend") + + assert response.status_code == HTTPStatus.NOT_FOUND + + +def test_resend_sent_webmention_rejects_wrong_source( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + _, webmention_identifier = create_resendable_sent_webmention(app) + wrong_source_identifier = create_sent_source(app) + mock_admin_action_form(sent_module, monkeypatch, valid=True) + + response = client.post( + f"/sent/{wrong_source_identifier}/{webmention_identifier}/resend" + ) + + assert response.status_code == HTTPStatus.NOT_FOUND + + +def test_resend_sent_webmention_reopens_current_revision( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + source_identifier, webmention_identifier = create_resendable_sent_webmention(app) + mock_admin_action_form(sent_module, monkeypatch, valid=True) + send_webmention = Mock() + monkeypatch.setattr(sent_module, "send_webmention", send_webmention) + + with app.app_context(): + webmention = db.session.get(SentWebmention, webmention_identifier) + assert webmention is not None + webmention.attempt_count = 6 + webmention.next_retry_at = datetime.now(UTC) + timedelta(hours=24) + db.session.commit() + + 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}") + + with app.app_context(): + webmention = db.session.get(SentWebmention, webmention_identifier) + assert webmention is not None + assert webmention.desired_revision == 3 + assert webmention.processed_revision is None + assert webmention.attempt_count == 0 + assert webmention.next_retry_at is None + assert webmention.sent_revision == 2 + assert webmention.status is None + assert webmention.failure_reason is None + assert webmention.webmention_endpoint is None + assert webmention.endpoint_response_status is None + assert webmention.status_url is None + + send_webmention.assert_called_once_with(webmention_identifier) + + +@pytest.mark.parametrize( + ("status_url", "safe"), + [ + ("https://example.com/status", True), + ("http://example.com/status", True), + ("javascript:alert(1)", False), + ("data:text/html,evil", False), + ("ftp://example.com/status", False), + ], +) +def test_admin_only_links_safe_existing_status_urls( + app: Flask, client: FlaskClient, status_url: str, safe: bool +) -> None: + source_identifier, _ = create_outgoing(app, status_url=status_url) + with app.app_context(): + user = User(username="admin", password="test") + db.session.add(user) + db.session.commit() + user_id = user.get_id() + + with client.session_transaction() as session: + session["_user_id"] = str(user_id) + session["_fresh"] = True + + response = client.get(f"/sent/{source_identifier}") + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + assert (f'href="{status_url}"' in html) is safe + assert status_url in html + + +def make_source( + app: Flask, + name: str, + *, + statuses: tuple[SentWebmentionStatus | None, ...] = (SentWebmentionStatus.SENT,), + retrying: bool = False, + processed: bool = True, + deleted: bool = False, + last_seen_at: datetime | None = None, + revision: int = 1, +) -> uuid.UUID: + """Create distinguishable sources with outgoing rows for list filtering.""" + now = last_seen_at or datetime(2026, 11, 12, 12, tzinfo=UTC) + with app.app_context(): + source = SourceDocument( + path=f"blog/{name}/index.html", + url=f"https://source.example/{name}/", + content_hash="a" * 32, + revision=revision, + last_seen_at=now, + revised_at=now, + deleted_at=now if deleted else None, + ) + for number, status in enumerate(statuses): + source.sent_webmentions.append( + SentWebmention( + target=f"https://target.example/{name}/{number}", + linked=True, + desired_revision=revision, + processed_revision=revision if processed else None, + status=status, + attempt_count=2 if retrying else 0, + next_retry_at=now + timedelta(days=10) if retrying else None, + ) + ) + db.session.add(source) + db.session.commit() + return source.uuid + + +@pytest.mark.parametrize( + ("status", "expected"), + [ + ("failing", {"failed", "retrying", "stale", "multiple"}), + ("retrying", {"retrying"}), + ("deleted", {"deleted"}), + ], +) +def test_sent_filter_by_delivery_state_without_duplicate_rows( + app: Flask, client: FlaskClient, status: str, expected: set[str] +) -> None: + log_in(app, client) + make_source(app, "failed", statuses=(SentWebmentionStatus.FAILED,)) + make_source( + app, + "retrying", + statuses=(SentWebmentionStatus.FAILED,), + retrying=True, + processed=False, + ) + make_source(app, "stale", statuses=(SentWebmentionStatus.FAILED,), retrying=True) + make_source( + app, + "multiple", + statuses=(SentWebmentionStatus.FAILED, SentWebmentionStatus.FAILED), + ) + make_source(app, "deleted", deleted=True) + make_source(app, "sent") + make_source(app, "pending", statuses=(None,), processed=False) + + response = client.get("/sent", query_string={"status": status}) + assert response.status_code == HTTPStatus.OK + 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)) + assert set(paths) == {f"blog/{name}/index.html" for name in expected} + assert len(paths) == len(expected) + assert ( + soup.select_one(f'select[name="status"] option[value="{status}"][selected]') + is not None + ) + + +@pytest.mark.parametrize( + ("q", "expected"), + [ + ("blog/alpha", "alpha"), + ("source.example/alpha", "alpha"), + ("target.example/alpha", "alpha"), + ("alpha/0", "alpha"), + ("alpha%", None), + ], +) +def test_sent_search_matches_path_source_url_and_sent_target( + app: Flask, client: FlaskClient, q: str, expected: str | None +) -> None: + log_in(app, client) + make_source(app, "alpha") + make_source(app, "beta") + + response = client.get("/sent", query_string={"q": f" {q} "}) + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + assert ("blog/alpha/index.html" in html) == (expected == "alpha") + assert "blog/beta/index.html" not in html + if expected is None: + assert "No source documents match these filters." in html + + +def test_sent_filter_by_inclusive_last_seen_dates( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + make_source(app, "old", last_seen_at=datetime(2026, 11, 7, tzinfo=UTC)) + make_source(app, "included", last_seen_at=datetime(2026, 11, 10, 22, tzinfo=UTC)) + make_source(app, "new", last_seen_at=datetime(2026, 11, 15, tzinfo=UTC)) + response = client.get( + "/sent", query_string={"date_from": "2026-11-08", "date_to": "2026-11-10"} + ) + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + assert "blog/included/index.html" in html + assert "blog/old/index.html" not in html + assert "blog/new/index.html" not in html + + +@pytest.mark.parametrize( + "sort", ["path", "url", "webmentions", "revision", "created", "last_seen", "status"] +) +def test_sent_sort_links_preserve_filters( + app: Flask, client: FlaskClient, sort: str +) -> None: + log_in(app, client) + make_source(app, "alpha", statuses=(SentWebmentionStatus.FAILED,)) + response = client.get( + "/sent", + query_string={ + "status": "failing", + "q": "alpha", + "date_from": "2026-11-01", + "sort": sort, + "order": "asc", + "per_page": 37, + }, + ) + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + soup = BeautifulSoup(html, "html.parser") + assert soup.select_one('th[aria-sort="ascending"]') is not None + links = [ + parse_qs(urlsplit(_href(a)).query) + for a in soup.select("th a[href]") + if urlsplit(_href(a)).path == "/sent" + ] + assert len(links) == 7 + for link in links: + assert link["status"] == ["failing"] + assert link["q"] == ["alpha"] + assert link["date_from"] == ["2026-11-01"] + assert link["per_page"] == ["37"] + assert link["sort"][0] in ( + "path", + "url", + "webmentions", + "revision", + "created", + "last_seen", + "status", + ) + assert any(link["sort"] == [sort] and link["order"] == ["desc"] for link in links) + + +def test_sent_sort_orders_by_count_and_path(app: Flask, client: FlaskClient) -> None: + log_in(app, client) + make_source(app, "z", statuses=(SentWebmentionStatus.SENT,)) + make_source( + app, "a", statuses=(SentWebmentionStatus.SENT, SentWebmentionStatus.FAILED) + ) + for sort, order, expected_first in ( + ("webmentions", "desc", "a"), + ("webmentions", "asc", "z"), + ("path", "asc", "a"), + ("path", "desc", "z"), + ): + 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" + + +def test_sent_filter_pagination_and_navigation_preserve_parameters( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + for number in range(28): + make_source(app, f"failed-{number:02}", statuses=(SentWebmentionStatus.FAILED,)) + filters = { + "status": "failing", + "q": "failed", + "sort": "path", + "order": "asc", + "per_page": "10", + } + response = client.get("/sent", query_string={**filters, "page": "2"}) + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + assert "28 source documents" in html + soup = BeautifulSoup(html, "html.parser") + assert len(soup.select("tbody tr")) == 10 + urls = [_href(a) for a in soup.select("a[href]")] + assert any( + urlsplit(url).path == "/sent" + and parse_qs(urlsplit(url).query) + == {**{k: [v] for k, v in filters.items()}, "page": ["3"]} + for url in urls + ) + detail_urls = [ + url for url in urls if re.search(r"/sent/[0-9a-f-]{36}", urlsplit(url).path) + ] + assert detail_urls + assert parse_qs(urlsplit(detail_urls[0]).query) == { + **{k: [v] for k, v in filters.items()}, + "source_page": ["2"], + } + detail = client.get(detail_urls[0]) + assert detail.status_code == HTTPStatus.OK + back = BeautifulSoup(detail.get_data(as_text=True), "html.parser").select_one( + 'a[href*="/sent?"]' + ) + assert back is not None + assert parse_qs(urlsplit(_href(back)).query) == { + **{k: [v] for k, v in filters.items()}, + "page": ["2"], + } + + +@pytest.mark.parametrize( + "invalid", + [ + "status=unknown", + "sort=unsupported", + "order=reverse", + "per_page=0", + "per_page=101", + "per_page=abc", + "date_from=2026-11-8", + "date_to=bad", + "date_from=2026-11-10&date_to=2026-11-01", + ], +) +def test_sent_bad_filters_return_400( + app: Flask, client: FlaskClient, invalid: str +) -> None: + log_in(app, client) + assert client.get(f"/sent?{invalid}").status_code == HTTPStatus.BAD_REQUEST + + +def test_rescan_sources_preserves_filter_query( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + mock_admin_action_form(sent_module, monkeypatch, valid=True) + scan = Mock() + monkeypatch.setattr(sent_module, "manual_scan_sources", scan) + response = client.post( + "/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) == { + "status": ["retrying"], + "per_page": ["37"], + "page": ["2"], + } + scan.assert_called_once_with() + + +def test_sent_show_failed_and_retrying_counts_and_retry_deadline( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + identifier = make_source( + app, + "retry-badges", + statuses=(SentWebmentionStatus.FAILED,), + retrying=True, + processed=False, + ) + response = client.get("/sent", query_string={"status": "retrying"}) + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + assert "1 failed" in html + assert "1 awaiting retry" in html + + response = client.get(f"/sent/{identifier}") + assert response.status_code == HTTPStatus.OK + assert "Retry scheduled after attempt 2:" in response.get_data(as_text=True) + + +def test_resend_preserves_source_filter_context( + app: Flask, + client: FlaskClient, + sent_module: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + log_in(app, client) + source_id, mention_id = create_resendable_sent_webmention(app) + 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}/{mention_id}/resend", + query_string={ + "status": "failing", + "q": "resend", + "sort": "path", + "source_page": 2, + "page": 3, + }, + ) + 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"], + "q": ["resend"], + "sort": ["path"], + "source_page": ["2"], + "page": ["3"], + } + send.assert_called_once_with(mention_id) + + +def test_sent_show_sql_statistics_with_zero_webmentions( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + make_source( + app, + "mixed-stats", + statuses=( + SentWebmentionStatus.SENT, + SentWebmentionStatus.SENT, + SentWebmentionStatus.FAILED, + SentWebmentionStatus.NO_ENDPOINT, + ), + ) + make_source(app, "empty-stats", statuses=()) + + response = client.get("/sent", query_string={"sort": "path", "order": "asc"}) + assert response.status_code == HTTPStatus.OK + rows = BeautifulSoup(response.get_data(as_text=True), "html.parser").select( + "tbody tr" + ) + assert len(rows) == 2 + assert "0 Total" in rows[0].get_text(" ", strip=True) + assert " sent" not in rows[0].get_text(" ", strip=True) + mixed = rows[1].get_text(" ", strip=True) + assert "4 Total" in mixed + assert "2 sent" in mixed + assert "1 failed" in mixed + assert "awaiting retry" not in mixed + + +def test_sent_empty_filter_result_keeps_rescan_modal( + app: Flask, client: FlaskClient +) -> None: + log_in(app, client) + response = client.get("/sent", query_string={"status": "failing"}) + assert response.status_code == HTTPStatus.OK + html = response.get_data(as_text=True) + assert "No source documents match these filters." in html + assert 'id="confirmation-modal"' in html |
