aboutsummaryrefslogtreecommitdiff
path: root/tests/test_views.py
diff options
context:
space:
mode:
authorDennis Fink2026-11-12 19:57:08 +0100
committerDennis Fink2026-11-12 19:57:08 +0100
commit4bd1d9e348918b2e55db47a1ac3489d035cf55e2 (patch)
treef7ed41a374a8a4136792039a262dc62aa8cf8c59 /tests/test_views.py
parent7035e9f9467684cccae2b7ff3faaa62e6a9f91aa (diff)
downloadwebmentions-ssg-4bd1d9e348918b2e55db47a1ac3489d035cf55e2.tar.gz
webmentions-ssg-4bd1d9e348918b2e55db47a1ac3489d035cf55e2.zip
refactor(core): split modules by responsibility
Break up monolithic views, task helpers, networking, CLI, and application extension setup so each module owns a focused concern. Reorganize the test suite around the new boundaries while preserving existing Webmention behavior and coverage.
Diffstat (limited to 'tests/test_views.py')
-rw-r--r--tests/test_views.py1347
1 files changed, 0 insertions, 1347 deletions
diff --git a/tests/test_views.py b/tests/test_views.py
deleted file mode 100644
index 129bdbf..0000000
--- a/tests/test_views.py
+++ /dev/null
@@ -1,1347 +0,0 @@
-# SPDX-FileCopyrightText: 2026 Dennis Fink <me+coding@dennisfink.me>
-#
-# SPDX-License-Identifier: BSD-3-Clause
-
-import uuid
-from datetime import UTC, datetime, timedelta
-from types import ModuleType
-from unittest.mock import ANY, Mock
-
-import pytest
-import sqlalchemy as sa
-from flask import Flask
-from flask.testing import FlaskClient
-from sqlalchemy.exc import IntegrityError
-
-from webmentions_ssg import DATABASE as db
-from webmentions_ssg.models import (
- ReceivedWebmention,
- SentWebmention,
- SentWebmentionStatus,
- Source,
- User,
-)
-
-SOURCE_URL = "https://source.example/post"
-TARGET_URL = "https://dennisfink.me/blog/example/"
-
-
-@pytest.fixture
-def views_module(app: Flask) -> ModuleType:
- _ = app
- from webmentions_ssg import views
-
- return views
-
-
-def mock_endpoint_form(
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- *,
- valid: bool,
- source: str = SOURCE_URL,
- target: str = TARGET_URL,
- errors: dict[str, list[str]] | None = None,
-) -> Mock:
- form = Mock()
- form.validate_on_submit.return_value = valid
- form.source.data = source
- form.target.data = target
- form.errors = errors or {}
-
- monkeypatch.setattr(views_module.forms, "EndpointForm", Mock(return_value=form))
- return form
-
-
-def log_in(app: Flask, client: FlaskClient) -> None:
- 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
-
-
-def create_sent_source(app: Flask) -> uuid.UUID:
- now = datetime.now(UTC)
-
- with app.app_context():
- source = Source(
- path="blog/example/index.html",
- url="https://dennisfink.me/blog/example/",
- content_hash="0" * 32,
- revision=2,
- last_seen_at=now,
- revised_at=now,
- )
-
- source.sent_webmentions.extend(
- [
- SentWebmention(
- target="https://example.com/b",
- active=True,
- desired_revision=2,
- processed_revision=2,
- sent_revision=2,
- status=SentWebmentionStatus.SENT,
- endpoint="https://example.com/webmention",
- response_status=202,
- ),
- SentWebmention(
- target="https://example.com/a",
- active=True,
- desired_revision=2,
- processed_revision=2,
- sent_revision=1,
- status=SentWebmentionStatus.FAILED,
- failure_reason="Webmention endpoint returned HTTP 400",
- endpoint="https://example.com/webmention",
- response_status=400,
- ),
- ]
- )
-
- db.session.add(source)
- db.session.commit()
-
- return source.uuid
-
-
-def test_endpoint_only_accepts_post(client: FlaskClient) -> None:
- response = client.get("/endpoint")
- assert response.status_code == 405
-
-
-def test_endpoint_returns_form_errors(
- client: FlaskClient, views_module: ModuleType, monkeypatch: pytest.MonkeyPatch
-) -> None:
- errors = {"source": ["Invalid source"]}
- mock_endpoint_form(views_module, monkeypatch, valid=False, errors=errors)
-
- response = client.post("/endpoint")
-
- assert response.status_code == 400
- assert response.get_json() == errors
-
-
-def test_endpoint_creates_webmention(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- form = mock_endpoint_form(views_module, monkeypatch, valid=True)
- verify_webmention = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify_webmention)
-
- response = client.post("/endpoint")
-
- assert response.status_code == 201
- form.validate_on_submit.assert_called_once_with()
-
- with app.app_context():
- webmention = db.session.scalar(sa.select(ReceivedWebmention))
-
- assert webmention is not None
- assert webmention.source == SOURCE_URL
- assert webmention.target == TARGET_URL
- assert webmention.status == "received"
- assert webmention.failure_reason is None
-
- identifier = webmention.uuid
-
- assert response.headers["Location"].endswith(str(identifier))
- verify_webmention.assert_called_once_with(identifier)
-
-
-def test_endpoint_is_idempotent(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- mock_endpoint_form(views_module, monkeypatch, valid=True)
- verify_webmention = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify_webmention)
-
- first_response = client.post("/endpoint")
- second_response = client.post("/endpoint")
-
- assert first_response.status_code == 201
- assert second_response.status_code == 201
- assert first_response.headers["Location"] == second_response.headers["Location"]
-
- with app.app_context():
- webmentions = db.session.scalars(sa.select(ReceivedWebmention)).all()
-
- assert len(webmentions) == 1
-
- webmention = webmentions[0]
-
- assert webmention.source == SOURCE_URL
- assert webmention.target == TARGET_URL
- assert webmention.status == "received"
- assert webmention.failure_reason is None
-
- identifier = webmention.uuid
-
- verify_webmention.assert_called_once_with(identifier)
-
-
-def test_resending_resets_failure_state(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- mock_endpoint_form(views_module, monkeypatch, valid=True)
- verify_webmention = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify_webmention)
-
- with app.app_context():
- existing = ReceivedWebmention(
- uuid=uuid.uuid7(),
- source=SOURCE_URL,
- target=TARGET_URL,
- status="failed",
- failure_reason="Previous failure",
- updated_at=datetime.now(UTC) - timedelta(minutes=11),
- )
-
- db.session.add(existing)
- db.session.commit()
-
- identifier = existing.uuid
-
- response = client.post("/endpoint")
-
- assert response.status_code == 201
-
- with app.app_context():
- webmention = db.session.get(ReceivedWebmention, identifier)
-
- assert webmention is not None
- assert webmention.status == "received"
- assert webmention.failure_reason is None
-
- verify_webmention.assert_called_once_with(identifier)
-
-
-@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 == 302
- 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("/sent")
-
- assert response.status_code == 200
-
- html = response.get_data(as_text=True)
-
- 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_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 == 200
-
- 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_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 == 404
-
-
-def mock_login_form(
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- *,
- valid: bool,
- username: str = "admin",
- password: str | None = "test",
-) -> Mock:
- form = Mock()
- form.validate_on_submit.return_value = valid
- form.username.data = username
- form.password.data = password
-
- monkeypatch.setattr(views_module.forms, "LoginForm", Mock(return_value=form))
- return form
-
-
-def mock_admin_action_form(
- views_module: ModuleType, monkeypatch: pytest.MonkeyPatch, *, valid: bool
-) -> Mock:
- form = Mock()
- form.validate_on_submit.return_value = valid
-
- monkeypatch.setattr(views_module.forms, "AdminActionForm", Mock(return_value=form))
- return form
-
-
-def create_received_webmention(
- app: Flask,
- *,
- source: str = SOURCE_URL,
- target: str = TARGET_URL,
- status: str = "verified",
- failure_reason: str | None = None,
-) -> uuid.UUID:
- with app.app_context():
- webmention = ReceivedWebmention(
- uuid=uuid.uuid7(),
- source=source,
- target=target,
- status=status,
- failure_reason=failure_reason,
- )
-
- db.session.add(webmention)
- db.session.commit()
-
- return webmention.uuid
-
-
-def create_resendable_sent_webmention(app: Flask) -> tuple[uuid.UUID, uuid.UUID]:
- now = datetime.now(UTC)
-
- with app.app_context():
- source = Source(
- path="blog/resend/index.html",
- url="https://dennisfink.me/blog/resend/",
- content_hash="1" * 32,
- revision=3,
- last_seen_at=now,
- revised_at=now,
- )
- webmention = SentWebmention(
- target="https://example.com/resend",
- active=True,
- desired_revision=3,
- processed_revision=3,
- sent_revision=2,
- status=SentWebmentionStatus.FAILED,
- failure_reason="Previous failure",
- endpoint="https://example.com/webmention",
- response_status=500,
- status_url="https://example.com/webmention/status/123",
- )
- source.sent_webmentions.append(webmention)
-
- db.session.add(source)
- db.session.commit()
-
- return source.uuid, webmention.uuid
-
-
-def test_login_renders_form(client: FlaskClient) -> None:
- response = client.get("/login")
-
- assert response.status_code == 200
- assert "login" in response.get_data(as_text=True).lower()
-
-
-@pytest.mark.parametrize("password", ("wrong-password", None))
-def test_login_rejects_invalid_credentials(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- password: str | None,
-) -> None:
- with app.app_context():
- db.session.add(User(username="admin", password="test"))
- db.session.commit()
-
- mock_login_form(
- views_module, monkeypatch, valid=True, username="admin", password=password
- )
-
- response = client.post("/login")
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/login")
-
- with client.session_transaction() as session:
- assert "_user_id" not in session
- assert ("danger", "Invalid username or password") in session["_flashes"]
-
-
-@pytest.mark.parametrize(
- "next_url",
- [
- pytest.param("/", id="root"),
- pytest.param("/received", id="local-path"),
- pytest.param("/received?page=2", id="query-string"),
- pytest.param("/received#details", id="fragment"),
- ],
-)
-def test_login_redirects_to_local_next_page(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- next_url: str,
-) -> None:
- with app.app_context():
- user = User(username="admin", password="test")
- db.session.add(user)
- db.session.commit()
- user_id = user.get_id()
-
- mock_login_form(views_module, monkeypatch, valid=True)
-
- response = client.post("/login", query_string={"next": next_url})
-
- assert response.status_code == 302
- assert response.headers["Location"] == next_url
-
- with client.session_transaction() as session:
- assert session["_user_id"] == str(user_id)
-
-
-@pytest.mark.parametrize(
- "next_url",
- [
- pytest.param(None, id="missing"),
- pytest.param("", id="empty"),
- pytest.param("received", id="relative-path"),
- pytest.param("https://evil.example/phishing", id="absolute-https"),
- pytest.param("http://evil.example", id="absolute-http"),
- pytest.param("javascript:alert(1)", id="non-http-scheme"),
- pytest.param("//evil.example/phishing", id="scheme-relative"),
- pytest.param("///evil.example/phishing", id="triple-slash"),
- pytest.param("////evil.example", id="four-slashes"),
- pytest.param(r"/\evil.example", id="slash-backslash-host"),
- pytest.param(r"/received\evil.example", id="backslash-in-path"),
- pytest.param(r"\/evil.example", id="backslash-slash-host"),
- ],
-)
-def test_login_rejects_unsafe_next_page(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- next_url: str | None,
-) -> None:
- with app.app_context():
- user = User(username="admin", password="test")
- db.session.add(user)
- db.session.commit()
- user_id = user.get_id()
-
- mock_login_form(views_module, monkeypatch, valid=True)
-
- query_string = {} if next_url is None else {"next": next_url}
- response = client.post("/login", query_string=query_string)
-
- assert response.status_code == 302
- assert response.headers["Location"] == "/"
-
- with client.session_transaction() as session:
- assert session["_user_id"] == str(user_id)
-
-
-def test_login_redirects_authenticated_user(app: Flask, client: FlaskClient) -> None:
- log_in(app, client)
-
- response = client.get("/login")
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/")
-
-
-def test_received_requires_login(client: FlaskClient) -> None:
- response = client.get("/received")
-
- assert response.status_code == 302
- assert "/login" in response.headers["Location"]
-
-
-def test_received_lists_webmentions(app: Flask, client: FlaskClient) -> None:
- log_in(app, client)
- create_received_webmention(app)
-
- response = client.get("/received")
-
- assert response.status_code == 200
- html = response.get_data(as_text=True)
- assert SOURCE_URL in html
- assert TARGET_URL in html
-
-
-@pytest.mark.parametrize("action", ["delete", "reverify"])
-def test_received_admin_actions_require_login(client: FlaskClient, action: str) -> None:
- response = client.post(f"/received/{uuid.uuid7()}/{action}")
-
- assert response.status_code == 302
- assert "/login" in response.headers["Location"]
-
-
-@pytest.mark.parametrize("action", ["delete", "reverify"])
-def test_received_admin_actions_reject_invalid_form(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- action: str,
-) -> None:
- log_in(app, client)
- identifier = create_received_webmention(app)
- form = mock_admin_action_form(views_module, monkeypatch, valid=False)
-
- response = client.post(f"/received/{identifier}/{action}")
-
- assert response.status_code == 400
- form.validate_on_submit.assert_called_once_with()
-
-
-@pytest.mark.parametrize("action", ["delete", "reverify"])
-def test_received_admin_actions_return_404_for_unknown_webmention(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- action: str,
-) -> None:
- log_in(app, client)
- mock_admin_action_form(views_module, monkeypatch, valid=True)
-
- response = client.post(f"/received/{uuid.uuid7()}/{action}")
-
- assert response.status_code == 404
-
-
-def test_delete_received_webmention(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- log_in(app, client)
- identifier = create_received_webmention(app)
- mock_admin_action_form(views_module, monkeypatch, valid=True)
-
- response = client.post(f"/received/{identifier}/delete?page=3")
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/received?page=3")
-
- with app.app_context():
- assert db.session.get(ReceivedWebmention, identifier) is None
-
-
-def test_reverify_received_webmention(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- log_in(app, client)
- identifier = create_received_webmention(
- app, status="failed", failure_reason="Previous failure"
- )
- with app.app_context():
- row = db.session.get(ReceivedWebmention, identifier)
- assert row is not None
- row.recovery_attempts = 3
- db.session.commit()
- mock_admin_action_form(views_module, monkeypatch, valid=True)
- verify_webmention = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify_webmention)
-
- response = client.post(f"/received/{identifier}/reverify?page=2")
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/received?page=2")
-
- with app.app_context():
- webmention = db.session.get(ReceivedWebmention, identifier)
- assert webmention is not None
- assert webmention.status == "received"
- assert webmention.failure_reason is None
- assert webmention.recovery_attempts == 0
-
- verify_webmention.assert_called_once_with(identifier)
-
-
-def test_rescan_sent_sources_requires_login(client: FlaskClient) -> None:
- response = client.post("/sent/rescan")
-
- assert response.status_code == 302
- assert "/login" in response.headers["Location"]
-
-
-@pytest.mark.parametrize("valid", [False, True])
-def test_rescan_sent_sources(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- valid: bool,
-) -> None:
- log_in(app, client)
- form = mock_admin_action_form(views_module, monkeypatch, valid=valid)
- manual_scan_sources = Mock()
- monkeypatch.setattr(views_module, "manual_scan_sources", manual_scan_sources)
-
- response = client.post("/sent/rescan")
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/sent")
- form.validate_on_submit.assert_called_once_with()
-
- if valid:
- 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 == 302
- assert "/login" in response.headers["Location"]
-
-
-def test_resend_sent_webmention_rejects_invalid_form(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- log_in(app, client)
- source_identifier, webmention_identifier = create_resendable_sent_webmention(app)
- mock_admin_action_form(views_module, monkeypatch, valid=False)
-
- response = client.post(f"/sent/{source_identifier}/{webmention_identifier}/resend")
-
- assert response.status_code == 400
-
-
-def test_resend_sent_webmention_returns_404_for_unknown_webmention(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- log_in(app, client)
- source_identifier = create_sent_source(app)
- mock_admin_action_form(views_module, monkeypatch, valid=True)
-
- response = client.post(f"/sent/{source_identifier}/{uuid.uuid7()}/resend")
-
- assert response.status_code == 404
-
-
-def test_resend_sent_webmention_rejects_wrong_source(
- app: Flask,
- client: FlaskClient,
- views_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(views_module, monkeypatch, valid=True)
-
- response = client.post(
- f"/sent/{wrong_source_identifier}/{webmention_identifier}/resend"
- )
-
- assert response.status_code == 404
-
-
-def test_resend_sent_webmention_reopens_current_revision(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- log_in(app, client)
- source_identifier, webmention_identifier = create_resendable_sent_webmention(app)
- mock_admin_action_form(views_module, monkeypatch, valid=True)
- send_webmention = Mock()
- monkeypatch.setattr(views_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 == 302
- 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.endpoint is None
- assert webmention.response_status is None
- assert webmention.status_url is None
-
- send_webmention.assert_called_once_with(webmention_identifier)
-
-
-def test_status_returns_404_for_unknown_webmention(client: FlaskClient) -> None:
- response = client.get(f"/status/{uuid.uuid7()}")
-
- assert response.status_code == 404
-
-
-def test_status_displays_webmention(app: Flask, client: FlaskClient) -> None:
- identifier = create_received_webmention(
- app, status="failed", failure_reason="Verification failed"
- )
-
- response = client.get(f"/status/{identifier}")
-
- assert response.status_code == 200
- html = response.get_data(as_text=True)
- assert SOURCE_URL in html
- assert TARGET_URL in html
- assert "failed" in html
- assert "Verification failed" in html
-
-
-def test_endpoint_recovers_from_concurrent_insert(
- client: FlaskClient, views_module: ModuleType, monkeypatch: pytest.MonkeyPatch
-) -> None:
- mock_endpoint_form(views_module, monkeypatch, valid=True)
-
- competing_identifier = uuid.uuid7()
- competing_webmention = ReceivedWebmention(
- uuid=competing_identifier,
- source=SOURCE_URL,
- target=TARGET_URL,
- status="failed",
- failure_reason="Competing request failed",
- )
-
- initial_result = Mock()
- initial_result.scalar_one_or_none.return_value = None
- competing_result = Mock()
- competing_result.scalar_one_or_none.return_value = competing_webmention
-
- execute = Mock(side_effect=[initial_result, competing_result])
- add = Mock()
- rollback = Mock()
- commit = Mock(
- side_effect=[
- IntegrityError(
- "INSERT INTO received_webmention ...",
- {},
- Exception("duplicate source/target"),
- ),
- None,
- ]
- )
- verify_webmention = Mock()
-
- monkeypatch.setattr(views_module.db.session, "execute", execute)
- monkeypatch.setattr(views_module.db.session, "add", add)
- monkeypatch.setattr(views_module.db.session, "rollback", rollback)
- monkeypatch.setattr(views_module.db.session, "commit", commit)
- monkeypatch.setattr(views_module, "verify_webmention", verify_webmention)
-
- response = client.post("/endpoint")
-
- assert response.status_code == 201
- assert response.headers["Location"].endswith(f"/status/{competing_identifier}")
-
- assert execute.call_count == 2
- add.assert_called_once_with(ANY)
- rollback.assert_called_once_with()
- assert commit.call_count == 1
-
- assert competing_webmention.status == "failed"
- assert competing_webmention.failure_reason == "Competing request failed"
- verify_webmention.assert_not_called()
-
-
-def test_endpoint_rate_limits_requests_per_ip(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- app.config["ENDPOINT_RATE_LIMIT"] = "2/minute"
-
- form = mock_endpoint_form(views_module, monkeypatch, valid=True)
- verify = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify)
-
- responses = []
-
- for index in range(3):
- form.source.data = f"https://source.example/post-{index}"
- responses.append(
- client.post("/endpoint", environ_overrides={"REMOTE_ADDR": "192.0.2.10"})
- )
-
- assert [r.status_code for r in responses] == [201, 201, 429]
-
- assert verify.call_count == 2
-
- with app.app_context():
- count = db.session.scalar(
- sa.select(sa.func.count()).select_from(ReceivedWebmention)
- )
- assert count == 2
-
-
-def test_endpoint_rate_limit_distinguishes_clients_behind_trusted_proxy(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- from werkzeug.middleware.proxy_fix import ProxyFix
-
- app.config["ENDPOINT_RATE_LIMIT"] = "1/minute"
- app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1)
- form = mock_endpoint_form(views_module, monkeypatch, valid=True)
- monkeypatch.setattr(views_module, "verify_webmention", Mock())
-
- def attempt(client_ip: str, index: int) -> int:
- form.source.data = f"https://source.example/proxy-post-{index}"
- return client.post(
- "/endpoint",
- environ_overrides={"REMOTE_ADDR": "192.0.2.200"},
- headers={"X-Forwarded-For": client_ip},
- ).status_code
-
- assert attempt("198.51.100.11", 0) == 201
- assert attempt("198.51.100.11", 1) == 429
- assert attempt("198.51.100.12", 2) == 201
-
-
-def test_endpoint_global_rate_limit(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- app.config["ENDPOINT_GLOBAL_RATE_LIMIT"] = "2/minute"
-
- form = mock_endpoint_form(views_module, monkeypatch, valid=True)
- verify = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify)
-
- responses = []
-
- for index in range(3):
- form.source.data = f"https://source.example/post-{index}"
-
- responses.append(
- client.post(
- "/endpoint", environ_overrides={"REMOTE_ADDR": f"192.0.2.{index + 1}"}
- )
- )
-
- assert [r.status_code for r in responses] == [201, 201, 429]
- assert verify.call_count == 2
-
-
-def test_endpoint_recent_duplicate_does_not_reverify(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- mock_endpoint_form(views_module, monkeypatch, valid=True)
-
- verify = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify)
-
- with app.app_context():
- webmention = ReceivedWebmention(
- uuid=uuid.uuid7(),
- source=SOURCE_URL,
- target=TARGET_URL,
- status="failed",
- failure_reason="Previous failure",
- )
- db.session.add(webmention)
- db.session.commit()
- identifier = webmention.uuid
-
- response = client.post("/endpoint")
-
- assert response.status_code == 201
- assert response.headers["Location"].endswith(str(identifier))
-
- with app.app_context():
- stored = db.session.get(ReceivedWebmention, identifier)
- assert stored is not None
- assert stored.status == "failed"
- assert stored.failure_reason == "Previous failure"
-
- verify.assert_not_called()
-
-
-def test_endpoint_reverifies_after_cooldown(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- mock_endpoint_form(views_module, monkeypatch, valid=True)
-
- verify = Mock()
- monkeypatch.setattr(views_module, "verify_webmention", verify)
-
- with app.app_context():
- webmention = ReceivedWebmention(
- uuid=uuid.uuid7(),
- source=SOURCE_URL,
- target=TARGET_URL,
- status="failed",
- failure_reason="Previous failure",
- recovery_attempts=3,
- updated_at=datetime.now(UTC) - timedelta(minutes=11),
- )
- db.session.add(webmention)
- db.session.commit()
- identifier = webmention.uuid
-
- response = client.post("/endpoint")
-
- assert response.status_code == 201
-
- with app.app_context():
- stored = db.session.get(ReceivedWebmention, identifier)
- assert stored is not None
- assert stored.status == "received"
- assert stored.failure_reason is None
- assert stored.recovery_attempts == 0
-
- verify.assert_called_once_with(identifier)
-
-
-@pytest.mark.parametrize("username", ["admin", "unknown-user"])
-def test_login_always_checks_password(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
- username: str,
-) -> None:
- with app.app_context():
- db.session.add(User(username="admin", password="test"))
- db.session.commit()
-
- mock_login_form(
- views_module,
- monkeypatch,
- valid=True,
- username=username,
- password="wrong-password",
- )
-
- original_check_password = User.check_password
- checked_users: list[User] = []
-
- def spy_check_password(self: User, password: str) -> bool:
- checked_users.append(self)
- return original_check_password(self, password)
-
- monkeypatch.setattr(User, "check_password", spy_check_password)
-
- response = client.post("/login")
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/login")
- assert len(checked_users) == 1
-
- if username == "admin":
- assert checked_users[0].username == "admin"
- else:
- assert checked_users[0] is views_module.DUMMY_USER
-
- with client.session_transaction() as session:
- assert "_user_id" not in session
- assert ("danger", "Invalid username or password") in session["_flashes"]
-
-
-def test_login_rejects_dummy_user_even_if_password_matches(
- client: FlaskClient, views_module: ModuleType, monkeypatch: pytest.MonkeyPatch
-) -> None:
- mock_login_form(
- views_module,
- monkeypatch,
- valid=True,
- username="unknown-user",
- password="anything",
- )
-
- checked_users: list[User] = []
-
- def mock_check_password(self: User, password: str) -> bool:
- checked_users.append(self)
- return True
-
- monkeypatch.setattr(User, "check_password", mock_check_password)
-
- response = client.post("/login")
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/login")
- assert checked_users == [views_module.DUMMY_USER]
-
- with client.session_transaction() as session:
- assert "_user_id" not in session
-
-
-def test_login_rate_limit_is_independent_per_ip(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- app.config["LOGIN_RATE_LIMIT"] = "1/minute"
-
- mock_login_form(
- views_module,
- monkeypatch,
- valid=True,
- username="unknown-user",
- password="wrong-password",
- )
-
- def attempt(ip: str) -> int:
- response = client.post("/login", environ_overrides={"REMOTE_ADDR": ip})
- return response.status_code
-
- assert attempt("192.0.2.10") == 302
- assert attempt("192.0.2.10") == 429
-
- # Another IP still has its own allowance.
- assert attempt("192.0.2.11") == 302
- assert attempt("192.0.2.11") == 429
-
-
-def test_login_rate_limit_uses_forwarded_client_ip_when_proxy_is_trusted(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- from werkzeug.middleware.proxy_fix import ProxyFix
-
- app.config["LOGIN_RATE_LIMIT"] = "1/minute"
- app.wsgi_app = ProxyFix(app.wsgi_app, x_for=1, x_proto=1)
- mock_login_form(
- views_module,
- monkeypatch,
- valid=True,
- username="unknown-user",
- password="wrong-password",
- )
-
- def attempt(client_ip: str) -> int:
- response = client.post(
- "/login",
- environ_overrides={"REMOTE_ADDR": "192.0.2.200"},
- headers={"X-Forwarded-For": client_ip},
- )
- return response.status_code
-
- assert attempt("198.51.100.11") == 302
- # A forged earlier X-Forwarded-For entry cannot change the client bucket.
- assert attempt("203.0.113.99, 198.51.100.11") == 429
- assert attempt("198.51.100.12") == 302
-
-
-def test_login_username_limit_throttles_across_ips(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- app.config["LOGIN_RATE_LIMIT"] = "100/minute"
- app.config["LOGIN_USERNAME_RATE_LIMIT"] = "2/minute"
-
- with monkeypatch.context() as patcher:
- mock_login_form(
- views_module,
- patcher,
- valid=True,
- username="unknown-user",
- password="wrong-password",
- )
-
- def attempt(ip: str, username: str) -> int:
- return client.post(
- "/login",
- data={"username": username, "password": "wrong-password"},
- environ_overrides={"REMOTE_ADDR": ip},
- ).status_code
-
- assert attempt("192.0.2.10", "Admin") == 302
- assert attempt("192.0.2.11", " admin ") == 302
- assert attempt("192.0.2.12", "ADMIN") == 429
- # An unrelated username is not locked by attempts against Admin.
- assert attempt("192.0.2.12", "another-user") == 302
-
- # Restore the real form: the POST-only limits must not block a GET,
- # even from the client IP that submitted the throttled attempt.
- response = client.get("/login", environ_overrides={"REMOTE_ADDR": "192.0.2.12"})
- assert response.status_code == 200
-
-
-def test_login_missing_username_uses_per_ip_bucket(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- app.config["LOGIN_RATE_LIMIT"] = "100/minute"
- app.config["LOGIN_USERNAME_RATE_LIMIT"] = "1/minute"
- mock_login_form(
- views_module,
- monkeypatch,
- valid=True,
- username="unknown-user",
- password="wrong-password",
- )
-
- def attempt(ip: str) -> int:
- return client.post("/login", environ_overrides={"REMOTE_ADDR": ip}).status_code
-
- assert attempt("192.0.2.10") == 302
- assert attempt("192.0.2.10") == 429
- assert attempt("192.0.2.11") == 302
-
-
-def test_login_rate_limits_requests_per_ip(
- app: Flask,
- client: FlaskClient,
- views_module: ModuleType,
- monkeypatch: pytest.MonkeyPatch,
-) -> None:
- app.config["LOGIN_RATE_LIMIT"] = "2/minute"
-
- with monkeypatch.context() as patcher:
- form = mock_login_form(
- views_module,
- patcher,
- valid=True,
- username="unknown-user",
- password="wrong-password",
- )
-
- responses = [
- client.post("/login", environ_overrides={"REMOTE_ADDR": "192.0.2.10"})
- for _ in range(3)
- ]
-
- assert [response.status_code for response in responses] == [302, 302, 429]
- assert form.validate_on_submit.call_count == 2
- assert "Too many login attempts" in responses[-1].get_data(as_text=True)
-
- # The real LoginForm is restored here.
- # GET requests must remain accessible after throttling.
- response = client.get("/login", environ_overrides={"REMOTE_ADDR": "192.0.2.10"})
- assert response.status_code == 200
-
- with client.session_transaction() as session:
- assert "_user_id" not in session
-
-
-def test_logout_rejects_get(app: Flask, client: FlaskClient) -> None:
- log_in(app, client)
-
- response = client.get("/logout")
-
- assert response.status_code == 405
-
- with client.session_transaction() as session:
- assert "_user_id" in session
-
-
-@pytest.mark.parametrize(
- "data",
- [
- pytest.param({}, id="missing"),
- pytest.param({"csrf_token": "invalid"}, id="invalid"),
- ],
-)
-def test_logout_rejects_invalid_csrf(
- app: Flask, client: FlaskClient, data: dict[str, str]
-) -> None:
- app.config["WTF_CSRF_ENABLED"] = True
- log_in(app, client)
-
- response = client.post("/logout", data=data)
-
- assert response.status_code == 400
-
- with client.session_transaction() as session:
- assert "_user_id" in session
-
-
-def test_logout_ends_session(app: Flask, client: FlaskClient) -> None:
- import re
-
- app.config["WTF_CSRF_ENABLED"] = True
- log_in(app, client)
-
- page = client.get("/received")
- assert page.status_code == 200
-
- html = page.get_data(as_text=True)
-
- assert 'action="/logout"' in html
- assert 'method="post"' in html
-
- match = re.search(r'name="csrf_token"\s+value="([^"]+)"', html)
- assert match is not None
-
- response = client.post("/logout", data={"csrf_token": match.group(1)})
-
- assert response.status_code == 302
- assert response.headers["Location"].endswith("/")
-
- with client.session_transaction() as session:
- assert "_user_id" not in session
-
- protected_response = client.get("/received")
- assert protected_response.status_code == 302
- assert "/login" in protected_response.headers["Location"]
-
-
-def create_outgoing(
- app: Flask, *, status_url: str | None = None
-) -> tuple[uuid.UUID, uuid.UUID]:
- now = datetime.now(UTC)
- with app.app_context():
- source = Source(
- path="blog/post/index.html",
- url="https://source.example/blog/post",
- content_hash="0" * 32,
- revision=1,
- last_seen_at=now,
- revised_at=now,
- )
- mention = SentWebmention(
- target="https://example.com/article",
- active=True,
- desired_revision=1,
- status_url=status_url,
- response_status=201 if status_url is not None else None,
- )
- source.sent_webmentions.append(mention)
- db.session.add(source)
- db.session.commit()
- return source.uuid, mention.uuid
-
-
-@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 == 200
- html = response.get_data(as_text=True)
- assert (f'href="{status_url}"' in html) is safe
- assert status_url in html
-
-
-def test_endpoint_rejects_request_bodies_over_configured_maximum(
- app: Flask, client: FlaskClient
-) -> None:
- app.config["MAX_CONTENT_LENGTH"] = 128
- response = client.post(
- "/endpoint", data={"source": SOURCE_URL + "x" * 150, "target": TARGET_URL}
- )
- assert response.status_code == 413
-
-
-def test_endpoint_rejects_bad_url_before_inserting_row(
- app: Flask, client: FlaskClient, monkeypatch: pytest.MonkeyPatch
-) -> None:
- from webmentions_ssg import views
-
- verify_webmention = Mock()
- monkeypatch.setattr(views, "verify_webmention", verify_webmention)
-
- response = client.post(
- "/endpoint", data={"source": "http://ex☃mple.test/", "target": TARGET_URL}
- )
-
- assert response.status_code == 400
- assert "source" in response.get_json()
- verify_webmention.assert_not_called()
- with app.app_context():
- assert (
- db.session.scalar(
- sa.select(sa.func.count()).select_from(ReceivedWebmention)
- )
- == 0
- )