# SPDX-FileCopyrightText: 2026 Dennis Fink # # SPDX-License-Identifier: BSD-3-Clause """Authenticated source-domain management and early endpoint rejection.""" import uuid from datetime import UTC, datetime from http import HTTPStatus from unittest.mock import Mock import pytest import sqlalchemy as sa from flask import Flask from flask.testing import FlaskClient from webmentions_ssg import db from webmentions_ssg.models.moderation import AllowedDomain, BlockedDomain from webmentions_ssg.models.received import ReceivedWebmention, ReceivedWebmentionStatus from webmentions_ssg.moderation_policy import rejection_reason from webmentions_ssg.tasks.verification import VerificationClaim from .helpers import SOURCE_URL, TARGET_URL, create_received_webmention, log_in def test_source_rules_require_login(client: FlaskClient) -> None: for method, path, data in ( ("get", "/moderation", None), ("post", "/moderation/blocked/add", {"domain": "bad.example"}), ("post", "/moderation/blocked/1/delete", None), ): response = client.open(path, method=method.upper(), data=data) assert response.status_code == HTTPStatus.FOUND assert "/login" in response.headers["Location"] def test_add_and_unblock_source_domain(app: Flask, client: FlaskClient) -> None: log_in(app, client) response = client.post("/moderation/blocked/add", data={"domain": "SPAM.Example."}) assert response.status_code == HTTPStatus.FOUND assert response.headers["Location"].endswith("/moderation") response = client.post("/moderation/blocked/add", data={"domain": "spam.example"}) assert response.status_code == HTTPStatus.FOUND with app.app_context(): rows = db.session.scalars(sa.select(BlockedDomain)).all() assert len(rows) == 1 assert rows[0].domain == "spam.example" entry_id = rows[0].id response = client.get("/moderation") assert response.status_code == HTTPStatus.OK assert b"spam.example" in response.data assert b"Unblock" in response.data assert b"Source rules" in response.data response = client.post(f"/moderation/blocked/{entry_id}/delete") assert response.status_code == HTTPStatus.FOUND assert response.headers["Location"].endswith("/moderation") with app.app_context(): assert db.session.scalar(sa.select(sa.func.count(BlockedDomain.id))) == 0 def test_allowlist_can_be_managed_while_mode_is_off( app: Flask, client: FlaskClient ) -> None: log_in(app, client) response = client.post( "/moderation/allowed/add", data={"domain": "friends.example"} ) assert response.status_code == HTTPStatus.FOUND with app.app_context(): row = db.session.scalar(sa.select(AllowedDomain)) assert row is not None assert row.domain == "friends.example" assert b"disabled" in client.get("/moderation").data @pytest.mark.parametrize( "domain", ["https://spam.example", "*.example.com", "example.com/path", "bad host"] ) def test_invalid_domains_are_rejected( client: FlaskClient, app: Flask, domain: str ) -> None: log_in(app, client) response = client.post("/moderation/blocked/add", data={"domain": domain}) assert response.status_code == HTTPStatus.BAD_REQUEST def test_invalid_list_kind_and_missing_entry(app: Flask, client: FlaskClient) -> None: log_in(app, client) assert ( client.post("/moderation/nope/add", data={"domain": "test.org"}).status_code == 404 ) assert client.post("/moderation/blocked/123/delete").status_code == 404 def test_block_selected_source_domains_deduplicates_and_preserves_mentions( app: Flask, client: FlaskClient ) -> None: from urllib.parse import parse_qs, urlsplit log_in(app, client) first = create_received_webmention(app, source="https://SPAM.Example./article") same_domain = create_received_webmention( app, source="https://spam.example/another-article" ) second = create_received_webmention(app, source="https://second.example/article") unselected = create_received_webmention(app, source="https://other.example/article") with app.app_context(): db.session.add(BlockedDomain(domain="second.example")) db.session.commit() response = client.post( "/received/bulk/block-sources", query_string={"page": 3, "status": "verified", "sort": "source"}, data={"webmention_uuids": [str(first), str(same_domain), str(second)]}, ) assert response.status_code == HTTPStatus.FOUND assert parse_qs(urlsplit(response.headers["Location"]).query) == { "page": ["3"], "status": ["verified"], "sort": ["source"], } with app.app_context(): assert set(db.session.scalars(sa.select(BlockedDomain.domain))) == { "spam.example", "second.example", } for identifier in (first, same_domain, second, unselected): assert db.session.get(ReceivedWebmention, identifier) is not None assert ( rejection_reason("https://child.spam.example/post") == "Source domain is blocked" ) assert rejection_reason("https://other.example/post") is None # Repeating the action is idempotent. response = client.post( "/received/bulk/block-sources", data={"webmention_uuids": [str(first), str(same_domain)]}, ) assert response.status_code == HTTPStatus.FOUND with app.app_context(): assert db.session.scalar(sa.select(sa.func.count(BlockedDomain.id))) == 2 def test_bulk_block_rejects_invalid_source_without_partial_changes( app: Flask, client: FlaskClient ) -> None: log_in(app, client) valid = create_received_webmention(app, source="https://valid.example/post") invalid = create_received_webmention(app, source="not-a-url") response = client.post( "/received/bulk/block-sources", data={"webmention_uuids": [str(valid), str(invalid)]}, ) assert response.status_code == HTTPStatus.BAD_REQUEST with app.app_context(): assert db.session.scalar(sa.select(sa.func.count(BlockedDomain.id))) == 0 def test_bulk_block_action_enforces_csrf(app: Flask, client: FlaskClient) -> None: log_in(app, client) identifier = create_received_webmention(app) app.config["WTF_CSRF_ENABLED"] = True response = client.post( "/received/bulk/block-sources", data={"webmention_uuids": str(identifier)} ) assert response.status_code == HTTPStatus.BAD_REQUEST with app.app_context(): assert db.session.scalar(sa.select(sa.func.count(BlockedDomain.id))) == 0 def test_endpoint_rejects_blocked_without_queue_or_insert( app: Flask, client: FlaskClient, monkeypatch: pytest.MonkeyPatch ) -> None: from webmentions_ssg.views import endpoint enqueue = Mock() monkeypatch.setattr(endpoint, "verify_webmention", enqueue) with app.app_context(): db.session.add(BlockedDomain(domain="source.example")) db.session.commit() response = client.post( "/endpoint", data={"source": SOURCE_URL, "target": TARGET_URL} ) assert response.status_code == HTTPStatus.FORBIDDEN assert response.json == {"error": "Source domain is blocked"} enqueue.assert_not_called() with app.app_context(): assert db.session.scalar(sa.select(sa.func.count(ReceivedWebmention.uuid))) == 0 def test_allowlist_mode_rejects_unlisted_and_allows_listed( app: Flask, client: FlaskClient, monkeypatch: pytest.MonkeyPatch ) -> None: from webmentions_ssg.views import endpoint app.config["ALLOWLIST_ENABLED"] = True enqueue = Mock() monkeypatch.setattr(endpoint, "verify_webmention", enqueue) data = {"source": SOURCE_URL, "target": TARGET_URL} assert client.post("/endpoint", data=data).status_code == HTTPStatus.FORBIDDEN with app.app_context(): db.session.add(AllowedDomain(domain="source.example")) db.session.commit() assert client.post("/endpoint", data=data).status_code == HTTPStatus.CREATED enqueue.assert_called_once() def test_worker_checks_rules_before_fetch( app: Flask, monkeypatch: pytest.MonkeyPatch ) -> None: from webmentions_ssg.tasks import verification claim = VerificationClaim( webmention_uuid=uuid.uuid7(), source=SOURCE_URL, target=TARGET_URL, lease_started_at=datetime.now(UTC), ) fetch = Mock() monkeypatch.setattr(verification, "source_mentions_target", fetch) with app.app_context(): db.session.add(BlockedDomain(domain="source.example")) db.session.commit() assert verification.determine_verification_outcome(claim) == ( ReceivedWebmentionStatus.FAILED, "Source domain is blocked", ) fetch.assert_not_called() def test_queued_worker_skips_fetch_after_source_is_blocked( app: Flask, monkeypatch: pytest.MonkeyPatch ) -> None: from webmentions_ssg.tasks import verification with app.app_context(): mention = ReceivedWebmention( uuid=uuid.uuid7(), source=SOURCE_URL, target=TARGET_URL ) db.session.add(mention) db.session.commit() identifier = mention.uuid # A user blocks the domain after the submission has already been queued. db.session.add(BlockedDomain(domain="source.example")) db.session.commit() fetch = Mock() monkeypatch.setattr(verification, "source_mentions_target", fetch) verification.verify_webmention.call_local(identifier) fetch.assert_not_called() with app.app_context(): mention = db.session.get(ReceivedWebmention, identifier) assert mention is not None assert mention.status == ReceivedWebmentionStatus.FAILED assert mention.failure_reason == "Source domain is blocked" def test_admin_actions_enforce_csrf(app: Flask, client: FlaskClient) -> None: log_in(app, client) app.config["WTF_CSRF_ENABLED"] = True assert ( client.post( "/moderation/blocked/add", data={"domain": "spam.example"} ).status_code == HTTPStatus.BAD_REQUEST )