aboutsummaryrefslogtreecommitdiff
path: root/tests/views/test_sent.py
diff options
context:
space:
mode:
authorDennis Fink2026-11-19 18:15:34 +0100
committerDennis Fink2026-11-19 18:15:34 +0100
commit8ec35babe87ff8139ec23cc10b858b7481f132db (patch)
treeb1e2b2507abba25b570a32e7274b6c0158eac653 /tests/views/test_sent.py
parent45d3d3fde75173dfbf27e08aae8501842a9511dd (diff)
downloadwebmentions-ssg-8ec35babe87ff8139ec23cc10b858b7481f132db.tar.gz
webmentions-ssg-8ec35babe87ff8139ec23cc10b858b7481f132db.zip
refactor(sender)!: align sent Webmention terminology
Rename source-list forms, views, helpers, and tests around the Sent Webmentions UI while keeping source documents as the grouping model. BREAKING CHANGE: authenticated outgoing routes move from `/sources` to `/sent`, with corresponding blueprint endpoint and Python module renames.
Diffstat (limited to 'tests/views/test_sent.py')
-rw-r--r--tests/views/test_sent.py708
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