From 9b00526ab79257b65cedd71595848f09ecf84279 Mon Sep 17 00:00:00 2001 From: Dennis Fink Date: Sun, 15 Nov 2026 21:18:19 +0100 Subject: refactor(core)!: clarify Webmention domain terminology Rename ambiguous models, statuses, task modules, fields, and helpers so names reflect source documents, verification, endpoint discovery, and delivery state. Migrate persisted status values and database identifiers without losing existing Webmention data. BREAKING CHANGE: persisted status values and database schema names have changed, and several public Python names have been renamed. --- tests/tasks/test_verification.py | 761 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 761 insertions(+) create mode 100644 tests/tasks/test_verification.py (limited to 'tests/tasks/test_verification.py') diff --git a/tests/tasks/test_verification.py b/tests/tasks/test_verification.py new file mode 100644 index 0000000..c336b19 --- /dev/null +++ b/tests/tasks/test_verification.py @@ -0,0 +1,761 @@ +# SPDX-FileCopyrightText: 2026 Dennis Fink +# +# SPDX-License-Identifier: BSD-3-Clause + +import logging +import uuid +from datetime import UTC, datetime, timedelta +from http import HTTPStatus +from types import ModuleType +from unittest.mock import Mock, patch + +import httpx +import pytest +import sqlalchemy as sa +from flask import Flask + +from webmentions_ssg import db +from webmentions_ssg.models import ReceivedWebmention +from webmentions_ssg.net import AddressResolutionError + +SOURCE_URL = "https://source.example/article" +TARGET_URL = "https://dennisfink.me/blog/example/" + + +@pytest.fixture +def verification(app: Flask) -> ModuleType: + from webmentions_ssg.tasks import verification + + return verification + + +def create_webmention( + app: Flask, + *, + source: str = SOURCE_URL, + target: str = TARGET_URL, + status: str = "received", + failure_reason: str | None = None, + recovery_attempts: int = 0, +) -> uuid.UUID: + identifier = uuid.uuid7() + + with app.app_context(): + webmention = ReceivedWebmention( + uuid=identifier, + source=source, + target=target, + status=status, + failure_reason=failure_reason, + recovery_attempts=recovery_attempts, + ) + + db.session.add(webmention) + db.session.commit() + + return identifier + + +def get_webmention_state(app: Flask, identifier: uuid.UUID) -> tuple[str, str | None]: + with app.app_context(): + webmention = db.session.get(ReceivedWebmention, identifier) + assert webmention is not None + return (webmention.status, webmention.failure_reason) + + +def set_stream_response(httpx_client: Mock, response: httpx.Response) -> Mock: + client = httpx_client.return_value.__enter__.return_value + client.stream.return_value.__enter__.return_value = response + return client + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_returns_response_and_body( + httpx_client: Mock, app: Flask, verification: ModuleType +) -> None: + response = httpx.Response( + HTTPStatus.OK, + headers={"Content-Type": "text/html"}, + content=b"

Document

", + request=httpx.Request("GET", SOURCE_URL), + ) + client = set_stream_response(httpx_client, response) + + with app.app_context(): + fetched_response, body = verification.fetch_source_document(SOURCE_URL) + + assert fetched_response is response + assert body == b"

Document

" + client.stream.assert_called_once_with("GET", SOURCE_URL) + + options = httpx_client.call_args.kwargs + + assert options["headers"] == { + "Accept": "text/html, application/xhtml+xml;q=0.9, text/plain;q=0.8", + "User-Agent": f"{verification.APP_NAME}/{verification.VERSION} ReceivedWebmention", + } + assert options["follow_redirects"] is True + assert options["max_redirects"] == app.config.get("MAX_REDIRECTS", 20) + assert options["trust_env"] is False + assert options["transport"].__class__.__name__ == "PublicHTTPTransport" + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +@pytest.mark.parametrize( + ("status_code", "exception_name"), + [ + (HTTPStatus.BAD_REQUEST, "VerificationError"), + (HTTPStatus.NOT_FOUND, "VerificationError"), + (HTTPStatus.GONE, "SourceGoneError"), + (HTTPStatus.REQUEST_TIMEOUT, "RetryableFetchError"), + (HTTPStatus.TOO_EARLY, "RetryableFetchError"), + (HTTPStatus.TOO_MANY_REQUESTS, "RetryableFetchError"), + (HTTPStatus.INTERNAL_SERVER_ERROR, "RetryableFetchError"), + (HTTPStatus.SERVICE_UNAVAILABLE, "RetryableFetchError"), + ], +) +def test_fetch_source_document_maps_http_status_to_exception( + httpx_client: Mock, + app: Flask, + verification: ModuleType, + status_code: int, + exception_name: str, +) -> None: + set_stream_response( + httpx_client, + httpx.Response(status_code, request=httpx.Request("GET", SOURCE_URL)), + ) + + exception_type = getattr(verification, exception_name) + + with app.app_context(), pytest.raises(exception_type, match=f"HTTP {status_code}"): + verification.fetch_source_document(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_propagates_network_error( + httpx_client: Mock, app: Flask, verification: ModuleType +) -> None: + client = httpx_client.return_value.__enter__.return_value + client.stream.side_effect = httpx.ConnectError( + "Connection refused", request=httpx.Request("GET", SOURCE_URL) + ) + + with ( + app.app_context(), + pytest.raises(httpx.ConnectError, match="Connection refused"), + ): + verification.fetch_source_document(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_rejects_declared_oversized_body( + httpx_client: Mock, app: Flask, verification: ModuleType +) -> None: + app.config["MAX_RECEIVED_SOURCE_BYTES"] = 10 + + set_stream_response( + httpx_client, + httpx.Response( + HTTPStatus.OK, + headers={"Content-Type": "text/html", "Content-Length": "11"}, + content=b"x" * 11, + request=httpx.Request("GET", SOURCE_URL), + ), + ) + + with ( + app.app_context(), + pytest.raises( + verification.VerificationError, match="Source document is too large" + ), + ): + verification.fetch_source_document(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_rejects_streamed_oversized_body( + httpx_client: Mock, app: Flask, verification: ModuleType +) -> None: + app.config["MAX_RECEIVED_SOURCE_BYTES"] = 10 + + class BodyStream(httpx.SyncByteStream): + def __iter__(self): + yield b"x" * 6 + yield b"x" * 6 + + set_stream_response( + httpx_client, + httpx.Response( + HTTPStatus.OK, + headers={"Content-Type": "text/html"}, + stream=BodyStream(), + request=httpx.Request("GET", SOURCE_URL), + ), + ) + + with ( + app.app_context(), + pytest.raises( + verification.VerificationError, match="Source document is too large" + ), + ): + verification.fetch_source_document(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_does_not_mask_unexpected_value_error( + httpx_client: Mock, + app: Flask, + verification: ModuleType, + monkeypatch: pytest.MonkeyPatch, +) -> None: + set_stream_response( + httpx_client, + httpx.Response(HTTPStatus.OK, request=httpx.Request("GET", SOURCE_URL)), + ) + monkeypatch.setattr( + verification, + "read_limited_body", + Mock(side_effect=ValueError("unexpected bug")), + ) + + with app.app_context(), pytest.raises(ValueError, match="unexpected bug"): + verification.fetch_source_document(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.fetch_source_document") +@pytest.mark.parametrize( + ("content_type", "body", "expected"), + [ + pytest.param( + "text/html; charset=utf-8", + f'Reply'.encode(), + True, + id="html", + ), + pytest.param( + "TEXT/HTML; CHARSET=UTF-8", + f'Reply'.encode(), + True, + id="case-insensitive-html", + ), + pytest.param( + "application/xhtml+xml", + b'Other', + False, + id="xhtml-without-target", + ), + pytest.param( + "text/plain; charset=utf-8", + f"Reply to {TARGET_URL}".encode(), + True, + id="plain-text-utf-8", + ), + pytest.param( + "text/plain; charset=utf-8", + f"See ({TARGET_URL}), thanks".encode(), + True, + id="plain-text-with-surrounding-punctuation", + ), + pytest.param( + "text/plain; charset=iso-8859-1", + (f"Grüße. Reply to {TARGET_URL}").encode("iso-8859-1"), + True, + id="plain-text-declared-encoding", + ), + pytest.param( + "text/plain; charset=utf-8", + b"\xff Reply to " + TARGET_URL.encode(), + True, + id="plain-text-invalid-byte", + ), + pytest.param( + "text/plain", b"No target here.", False, id="plain-text-without-target" + ), + ], +) +def test_source_mentions_target_by_media_type( + fetch_source_document: Mock, + verification: ModuleType, + content_type: str, + body: bytes, + expected: bool, +) -> None: + response = httpx.Response( + HTTPStatus.OK, + headers={"Content-Type": content_type}, + content=body, + request=httpx.Request("GET", SOURCE_URL), + ) + fetch_source_document.return_value = response, body + + assert verification.source_mentions_target(SOURCE_URL, TARGET_URL) is expected + fetch_source_document.assert_called_once_with(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.fetch_source_document") +@pytest.mark.parametrize( + ("content_type", "expected_media_type"), + [ + ("application/json", "application/json"), + ("application/pdf", "application/pdf"), + ("", "missing"), + ], +) +def test_source_mentions_target_rejects_unsupported_media_type( + fetch_source_document: Mock, + verification: ModuleType, + content_type: str, + expected_media_type: str, +) -> None: + headers = {} + + if content_type: + headers["Content-Type"] = content_type + + response = httpx.Response( + HTTPStatus.OK, + headers=headers, + content=b"Document", + request=httpx.Request("GET", SOURCE_URL), + ) + fetch_source_document.return_value = response, b"Document" + + with pytest.raises( + verification.VerificationError, + match=f"Unsupported source content type: {expected_media_type}", + ): + verification.source_mentions_target(SOURCE_URL, TARGET_URL) + + +@pytest.mark.parametrize( + ("mentions", "expected_status", "expected_reason"), + [ + (True, "verified", None), + (False, "source_removed", "Source does not mention target"), + ], +) +def test_determine_verification_outcome_returns_outcome( + verification: ModuleType, + monkeypatch: pytest.MonkeyPatch, + mentions: bool, + expected_status: str, + expected_reason: str | None, +) -> None: + monkeypatch.setattr( + verification, "source_mentions_target", Mock(return_value=mentions) + ) + claim = verification.VerificationClaim( + uuid.uuid7(), SOURCE_URL, TARGET_URL, datetime.now(UTC) + ) + + assert verification.determine_verification_outcome(claim) == ( + expected_status, + expected_reason, + ) + + +@patch("webmentions_ssg.tasks.verification.source_mentions_target") +def test_verify_webmention_marks_row_verifying_before_check( + source_mentions_target: Mock, app: Flask, verification: ModuleType +) -> None: + identifier = create_webmention( + app, status="failed", failure_reason="Earlier failure" + ) + + def verify_source(source_url: str, target_url: str) -> bool: + webmention = db.session.get(ReceivedWebmention, identifier) + + assert webmention is not None + assert webmention.status == "verifying" + assert webmention.failure_reason is None + assert source_url == webmention.source + assert target_url == webmention.target + + return True + + source_mentions_target.side_effect = verify_source + verification.verify_webmention.call_local(identifier) + assert get_webmention_state(app, identifier) == ("verified", None) + + +@patch("webmentions_ssg.tasks.verification.source_mentions_target") +@pytest.mark.parametrize( + ("outcome", "expected_status", "expected_reason"), + [ + ("verified", "verified", None), + ("missing", "source_removed", "Source does not mention target"), + ("gone", "source_removed", "Source returned HTTP 410"), + ("permanent-failure", "failed", "Source returned HTTP 404"), + ], +) +def test_verify_webmention_persists_final_state( + source_mentions_target: Mock, + app: Flask, + verification: ModuleType, + outcome: str, + expected_status: str, + expected_reason: str | None, +) -> None: + identifier = create_webmention(app) + + match outcome: + case "verified": + source_mentions_target.return_value = True + case "missing": + source_mentions_target.return_value = False + case "gone": + source_mentions_target.side_effect = verification.SourceGoneError( + "Source returned HTTP 410" + ) + case "permanent-failure": + source_mentions_target.side_effect = verification.VerificationError( + "Source returned HTTP 404" + ) + case _: + raise AssertionError(f"Unexpected outcome: {outcome}") + verification.verify_webmention.call_local(identifier) + + assert get_webmention_state(app, identifier) == (expected_status, expected_reason) + + +@patch("webmentions_ssg.tasks.verification.source_mentions_target") +@pytest.mark.parametrize("failure", ["temporary-http", "network"]) +def test_verify_webmention_persists_retryable_failure_and_reraises( + source_mentions_target: Mock, app: Flask, verification: ModuleType, failure: str +) -> None: + identifier = create_webmention(app) + + match failure: + case "temporary-http": + exception = verification.RetryableFetchError("Source returned HTTP 503") + case "network": + exception = httpx.ConnectError( + "Connection refused", request=httpx.Request("GET", SOURCE_URL) + ) + case _: + raise AssertionError(f"Unexpected failure: {failure}") + + source_mentions_target.side_effect = exception + + with pytest.raises(type(exception), match=str(exception)): + verification.verify_webmention.call_local(identifier) + + assert get_webmention_state(app, identifier) == ("failed", str(exception)) + + +@patch("webmentions_ssg.tasks.verification.source_mentions_target") +@pytest.mark.parametrize("status", ["verifying", "verified", "source_removed"]) +def test_verify_webmention_skips_active_and_terminal_states( + source_mentions_target: Mock, app: Flask, verification: ModuleType, status: str +) -> None: + identifier = create_webmention(app, status=status) + + verification.verify_webmention.call_local(identifier) + + assert get_webmention_state(app, identifier) == (status, None) + source_mentions_target.assert_not_called() + + +def set_webmention_updated_at( + app: Flask, identifier: uuid.UUID, when: datetime +) -> None: + with app.app_context(): + db.session.execute( + sa.update(ReceivedWebmention) + .where(ReceivedWebmention.uuid == identifier) + .values(updated_at=when) + ) + db.session.commit() + + +@pytest.mark.parametrize("status", ["verifying", "received"]) +def test_reaper_requeues_stale_verifications( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch, status: str +) -> None: + app.config["VERIFICATION_STALE_AFTER_SECONDS"] = 900 + identifier = create_webmention(app, status=status, failure_reason="Interrupted") + set_webmention_updated_at(app, identifier, datetime.now(UTC) - timedelta(hours=1)) + enqueue = Mock() + monkeypatch.setattr(verification, "verify_webmention", enqueue) + + with app.app_context(): + assert verification.recover_stale_verifications() == 1 + assert verification.recover_stale_verifications() == 0 + row = db.session.get(ReceivedWebmention, identifier) + assert row is not None + assert row.updated_at.replace(tzinfo=UTC) > datetime.now(UTC) - timedelta( + seconds=10 + ) + + assert get_webmention_state(app, identifier) == ("received", None) + enqueue.assert_called_once_with(identifier) + + +def test_reaper_does_not_touch_recent_or_terminal_webmentions( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch +) -> None: + recent_verifying = create_webmention(app, status="verifying") + recent_received = create_webmention( + app, source="https://source.example/received", status="received" + ) + old_verified = create_webmention( + app, source="https://source.example/verified", status="verified" + ) + set_webmention_updated_at(app, old_verified, datetime.now(UTC) - timedelta(hours=1)) + enqueue = Mock() + monkeypatch.setattr(verification, "verify_webmention", enqueue) + + with app.app_context(): + assert verification.recover_stale_verifications() == 0 + + assert get_webmention_state(app, recent_verifying) == ("verifying", None) + assert get_webmention_state(app, recent_received) == ("received", None) + assert get_webmention_state(app, old_verified) == ("verified", None) + enqueue.assert_not_called() + + +def test_reaper_recovers_after_enqueue_failure( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch +) -> None: + identifier = create_webmention(app, status="verifying") + set_webmention_updated_at(app, identifier, datetime.now(UTC) - timedelta(hours=1)) + monkeypatch.setattr( + verification, "verify_webmention", Mock(side_effect=RuntimeError) + ) + + with app.app_context(), pytest.raises(RuntimeError): + verification.recover_stale_verifications() + + assert get_webmention_state(app, identifier) == ("received", None) + + # The reaper can recover the row again if the process died after the commit + # but before Huey persisted the task. + app.config["VERIFICATION_STALE_AFTER_SECONDS"] = 0 + enqueue = Mock() + monkeypatch.setattr(verification, "verify_webmention", enqueue) + with app.app_context(): + assert verification.recover_stale_verifications() == 1 + + enqueue.assert_called_once_with(identifier) + + +def test_late_worker_cannot_overwrite_recovered_verification( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch +) -> None: + identifier = create_webmention(app) + original_verify = verification.verify_webmention + + def concurrent_recovery(_source: str, _target: str) -> bool: + # The reaper supersedes this still-running attempt; a newer attempt + # subsequently completes before the original fetch returns. + app.config["VERIFICATION_STALE_AFTER_SECONDS"] = 0 + with app.app_context(): + with patch.object(verification, "verify_webmention", Mock()) as enqueue: + assert verification.recover_stale_verifications() == 1 + enqueue.assert_called_once_with(identifier) + db.session.execute( + sa.update(ReceivedWebmention) + .where(ReceivedWebmention.uuid == identifier) + .values(status="verified", updated_at=datetime.now(UTC)) + ) + db.session.commit() + return False + + monkeypatch.setattr(verification, "source_mentions_target", concurrent_recovery) + original_verify.call_local(identifier) + + assert get_webmention_state(app, identifier) == ("verified", None) + + +def test_reaper_requeues_and_verifies_integration( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch +) -> None: + identifier = create_webmention(app, status="verifying") + set_webmention_updated_at(app, identifier, datetime.now(UTC) - timedelta(hours=1)) + check = Mock(return_value=True) + monkeypatch.setattr(verification, "source_mentions_target", check) + + with app.app_context(): + assert verification.recover_stale_verifications() == 1 + + assert get_webmention_state(app, identifier) == ("verified", None) + check.assert_called_once_with(SOURCE_URL, TARGET_URL) + + +@patch("webmentions_ssg.tasks.verification.source_mentions_target") +@pytest.mark.parametrize( + "unexpected_error", + [ + pytest.param(httpx.InvalidURL("Invalid IDNA hostname"), id="invalid-url"), + pytest.param( + RuntimeError("Unexpected HTML parser error"), id="unexpected-error" + ), + ], +) +def test_verify_webmention_records_unexpected_error_as_terminal_failure( + source_mentions_target: Mock, + app: Flask, + verification: ModuleType, + unexpected_error: Exception, +) -> None: + identifier = create_webmention(app, source="http://ex☃mple.test/") + source_mentions_target.side_effect = unexpected_error + + verification.verify_webmention.call_local(identifier) + + assert get_webmention_state(app, identifier) == ("failed", str(unexpected_error)) + source_mentions_target.assert_called_once() + # Failed rows are not eligible for automatic reaper recovery. + set_webmention_updated_at(app, identifier, datetime.now(UTC) - timedelta(hours=1)) + with app.app_context(): + assert verification.recover_stale_verifications() == 0 + + +def test_reaper_caps_stale_verification_recoveries( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch +) -> None: + app.config["VERIFICATION_MAX_RECOVERIES"] = 3 + identifier = create_webmention(app, status="verifying") + enqueue = Mock() + monkeypatch.setattr(verification, "verify_webmention", enqueue) + + # Simulate workers that repeatedly crash before completing the task. + for attempt in range(3): + set_webmention_updated_at( + app, identifier, datetime.now(UTC) - timedelta(hours=1) + ) + with app.app_context(): + assert verification.recover_stale_verifications() == 1 + row = db.session.get(ReceivedWebmention, identifier) + assert row is not None + assert row.status == "received" + assert row.recovery_attempts == attempt + 1 + + set_webmention_updated_at(app, identifier, datetime.now(UTC) - timedelta(hours=1)) + with app.app_context(): + assert verification.recover_stale_verifications() == 0 + row = db.session.get(ReceivedWebmention, identifier) + assert row is not None + assert row.status == "failed" + assert row.failure_reason == verification.RECOVERY_EXHAUSTED_REASON + assert row.recovery_attempts == 3 + assert verification.recover_stale_verifications() == 0 + assert enqueue.call_count == 3 + + +def test_reaper_caps_received_rows_lost_before_first_task( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch +) -> None: + app.config["VERIFICATION_MAX_RECOVERIES"] = 1 + identifier = create_webmention(app, status="received", recovery_attempts=1) + set_webmention_updated_at(app, identifier, datetime.now(UTC) - timedelta(hours=1)) + enqueue = Mock() + monkeypatch.setattr(verification, "verify_webmention", enqueue) + + with app.app_context(): + assert verification.recover_stale_verifications() == 0 + assert get_webmention_state(app, identifier) == ( + "failed", + verification.RECOVERY_EXHAUSTED_REASON, + ) + enqueue.assert_not_called() + + +def test_exhausted_row_cannot_be_revived_by_late_huey_retry( + app: Flask, verification: ModuleType, monkeypatch: pytest.MonkeyPatch +) -> None: + identifier = create_webmention( + app, + status="failed", + failure_reason=verification.RECOVERY_EXHAUSTED_REASON, + recovery_attempts=3, + ) + source_mentions_target = Mock(return_value=True) + monkeypatch.setattr(verification, "source_mentions_target", source_mentions_target) + + verification.verify_webmention.call_local(identifier) + + assert get_webmention_state(app, identifier) == ( + "failed", + verification.RECOVERY_EXHAUSTED_REASON, + ) + source_mentions_target.assert_not_called() + + +def test_verify_webmention_ignores_unknown_identifier( + verification: ModuleType, caplog: pytest.LogCaptureFixture +) -> None: + identifier = uuid.uuid7() + + with caplog.at_level(logging.WARNING): + verification.verify_webmention.call_local(identifier) + + assert f"Cannot verify unknown ReceivedWebmention {identifier}" in caplog.text + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_rejects_unsafe_destination( + httpx_client: Mock, app: Flask, verification: ModuleType +) -> None: + from webmentions_ssg.net import UnsafeAddressError + + client = httpx_client.return_value.__enter__.return_value + client.stream.side_effect = UnsafeAddressError("Local address") + with ( + app.app_context(), + pytest.raises(verification.VerificationError, match="non-public address"), + ): + verification.fetch_source_document(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_treats_dns_failure_as_temporary( + httpx_client: Mock, app: Flask, verification: ModuleType +) -> None: + client = httpx_client.return_value.__enter__.return_value + client.stream.side_effect = AddressResolutionError("DNS timeout") + with ( + app.app_context(), + pytest.raises(verification.RetryableFetchError, match="could not be resolved"), + ): + verification.fetch_source_document(SOURCE_URL) + + +@patch("webmentions_ssg.tasks.verification.httpx.Client") +def test_fetch_source_document_ignores_invalid_content_length( + httpx_client: Mock, app: Flask, verification: ModuleType +) -> None: + response = httpx.Response( + HTTPStatus.OK, + headers={"Content-Type": "text/html", "Content-Length": "invalid"}, + content=b"

Document

", + request=httpx.Request("GET", SOURCE_URL), + ) + set_stream_response(httpx_client, response) + + with app.app_context(): + fetched_response, body = verification.fetch_source_document(SOURCE_URL) + + assert fetched_response is response + assert body == b"

Document

" + + +@patch("webmentions_ssg.tasks.verification.fetch_source_document") +def test_source_mentions_target_falls_back_for_unknown_encoding( + fetch_source_document: Mock, verification: ModuleType +) -> None: + body = f"Reply to {TARGET_URL}".encode() + + response = httpx.Response( + HTTPStatus.OK, + headers={"Content-Type": "text/plain"}, + content=body, + request=httpx.Request("GET", SOURCE_URL), + ) + response.encoding = "unknown-encoding" + fetch_source_document.return_value = response, body + + assert verification.source_mentions_target(SOURCE_URL, TARGET_URL) + fetch_source_document.assert_called_once_with(SOURCE_URL) -- cgit v1.3.1