aboutsummaryrefslogtreecommitdiff
path: root/tests/views/test_endpoint.py
diff options
context:
space:
mode:
Diffstat (limited to 'tests/views/test_endpoint.py')
-rw-r--r--tests/views/test_endpoint.py422
1 files changed, 422 insertions, 0 deletions
diff --git a/tests/views/test_endpoint.py b/tests/views/test_endpoint.py
new file mode 100644
index 0000000..652250f
--- /dev/null
+++ b/tests/views/test_endpoint.py
@@ -0,0 +1,422 @@
+# 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
+
+from .helpers import (
+ SOURCE_URL,
+ TARGET_URL,
+ create_received_webmention,
+ mock_endpoint_form,
+)
+
+
+@pytest.fixture
+def views_module(app: Flask) -> ModuleType:
+ _ = app
+ from webmentions_ssg.views import endpoint as module
+
+ return module
+
+
+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)
+
+
+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)
+
+
+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.views import endpoint as 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
+ )