# SPDX-FileCopyrightText: 2026 Dennis Fink # # 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 sources_module(app: Flask) -> ModuleType: _ = app from webmentions_ssg.views import sources as module return module @pytest.mark.parametrize("path", ["/sources", f"/sources/{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_sources(app: Flask, client: FlaskClient) -> None: log_in(app, client) identifier = create_sent_source(app) response = client.get("/sources") 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 f"/sources/{identifier}" in html def test_sent_sources_table_hides_secondary_columns_on_mobile( app: Flask, client: FlaskClient ) -> None: log_in(app, client) create_sent_source(app) response = client.get("/sources") 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"/sources/{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 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"/sources/{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"/sources/{uuid.uuid7()}") assert response.status_code == HTTPStatus.NOT_FOUND def test_rescan_sent_sources_requires_login(client: FlaskClient) -> None: response = client.post("/sources/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, sources_module: ModuleType, monkeypatch: pytest.MonkeyPatch, valid: bool, ) -> None: log_in(app, client) form = mock_admin_action_form(sources_module, monkeypatch, valid=valid) manual_scan_sources = Mock() monkeypatch.setattr(sources_module, "manual_scan_sources", manual_scan_sources) response = client.post("/sources/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("/sources") 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"/sources/{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, sources_module: ModuleType, monkeypatch: pytest.MonkeyPatch, ) -> None: log_in(app, client) source_identifier, webmention_identifier = create_resendable_sent_webmention(app) mock_admin_action_form(sources_module, monkeypatch, valid=False) response = client.post( f"/sources/{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, sources_module: ModuleType, monkeypatch: pytest.MonkeyPatch, ) -> None: log_in(app, client) source_identifier = create_sent_source(app) mock_admin_action_form(sources_module, monkeypatch, valid=True) response = client.post(f"/sources/{source_identifier}/{uuid.uuid7()}/resend") assert response.status_code == HTTPStatus.NOT_FOUND def test_resend_sent_webmention_rejects_wrong_source( app: Flask, client: FlaskClient, sources_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(sources_module, monkeypatch, valid=True) response = client.post( f"/sources/{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, sources_module: ModuleType, monkeypatch: pytest.MonkeyPatch, ) -> None: log_in(app, client) source_identifier, webmention_identifier = create_resendable_sent_webmention(app) mock_admin_action_form(sources_module, monkeypatch, valid=True) send_webmention = Mock() monkeypatch.setattr(sources_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"/sources/{source_identifier}/{webmention_identifier}/resend" ) assert response.status_code == HTTPStatus.FOUND assert response.headers["Location"].endswith(f"/sources/{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"/sources/{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_sources_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("/sources", 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_sources_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("/sources", 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 sources match these filters." in html def test_sources_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( "/sources", 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_sources_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( "/sources", 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 == "/sources" ] 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_sources_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("/sources", 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_sources_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("/sources", query_string={**filters, "page": "2"}) assert response.status_code == HTTPStatus.OK html = response.get_data(as_text=True) assert "28 sources" 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 == "/sources" 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"/sources/[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*="/sources?"]' ) 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_sources_bad_filters_return_400( app: Flask, client: FlaskClient, invalid: str ) -> None: log_in(app, client) assert client.get(f"/sources?{invalid}").status_code == HTTPStatus.BAD_REQUEST def test_rescan_sources_preserves_filter_query( app: Flask, client: FlaskClient, sources_module: ModuleType, monkeypatch: pytest.MonkeyPatch, ) -> None: log_in(app, client) mock_admin_action_form(sources_module, monkeypatch, valid=True) scan = Mock() monkeypatch.setattr(sources_module, "manual_scan_sources", scan) response = client.post( "/sources/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_sources_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("/sources", 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"/sources/{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, sources_module: ModuleType, monkeypatch: pytest.MonkeyPatch, ) -> None: log_in(app, client) source_id, mention_id = create_resendable_sent_webmention(app) mock_admin_action_form(sources_module, monkeypatch, valid=True) send = Mock() monkeypatch.setattr(sources_module, "send_webmention", send) response = client.post( f"/sources/{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"/sources/{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_sources_empty_filter_result_keeps_rescan_modal( app: Flask, client: FlaskClient ) -> None: log_in(app, client) response = client.get("/sources", query_string={"status": "failing"}) assert response.status_code == HTTPStatus.OK html = response.get_data(as_text=True) assert "No sources match these filters." in html assert 'id="confirmation-modal"' in html