diff options
Diffstat (limited to 'tests/tasks/test_verification.py')
| -rw-r--r-- | tests/tasks/test_verification.py | 761 |
1 files changed, 761 insertions, 0 deletions
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 <me+coding@dennisfink.me> +# +# 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"<p>Document</p>", + 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"<p>Document</p>" + 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'<a href="{TARGET_URL}">Reply</a>'.encode(), + True, + id="html", + ), + pytest.param( + "TEXT/HTML; CHARSET=UTF-8", + f'<a href="{TARGET_URL}">Reply</a>'.encode(), + True, + id="case-insensitive-html", + ), + pytest.param( + "application/xhtml+xml", + b'<a href="https://example.com/">Other</a>', + 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"<p>Document</p>", + 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"<p>Document</p>" + + +@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) |
