From 509d93b2976e353d29441a7a7b7e78ca466dc4fd Mon Sep 17 00:00:00 2001 From: Dennis Fink Date: Sun, 15 Nov 2026 20:42:20 +0100 Subject: refactor(core)!: standardize application terminology Rename configuration keys, task helpers, forms, network utilities, and view endpoints to make their responsibilities and domains more explicit. Align source-management routes and templates with the new terminology and rename the target-matching module and related task abstractions consistently. BREAKING CHANGE: configuration keys have been renamed and sent-source routes move from `/sent` to `/sources`, with corresponding blueprint endpoint changes. --- tests/test_net.py | 50 +++++++++++++++++++++++++------------------------- 1 file changed, 25 insertions(+), 25 deletions(-) (limited to 'tests/test_net.py') diff --git a/tests/test_net.py b/tests/test_net.py index 3b754c0..c7c65ba 100644 --- a/tests/test_net.py +++ b/tests/test_net.py @@ -17,17 +17,17 @@ from flask import Flask from webmentions_ssg.net import ( AddressResolutionError, DeadlineStream, - NetworkDeadline, PublicHTTPTransport, PublicNetworkBackend, + RequestDeadline, ResponseTooLargeError, UnsafeAddressError, - content_type_of, - hostname_of, is_http_url, is_public_address, - public_addresses, + media_type_of, + normalized_hostname, read_limited_body, + resolve_public_addresses, ) @@ -38,7 +38,7 @@ def test_backend_rejects_private_ip_without_socket( create_socket = Mock(side_effect=AssertionError("must not open socket")) monkeypatch.setattr(socket, "socket", create_socket) with pytest.raises(UnsafeAddressError): - PublicNetworkBackend(NetworkDeadline(5)).connect_tcp(host, 80) + PublicNetworkBackend(RequestDeadline(5)).connect_tcp(host, 80) create_socket.assert_not_called() @@ -48,7 +48,7 @@ def test_rebinding_cannot_change_socket_peer(monkeypatch: pytest.MonkeyPatch) -> :param monkeypatch: Pytest fixture for replacing the DNS resolver and socket calls. """ dns = Mock(return_value=("93.184.216.34",)) - monkeypatch.setattr("webmentions_ssg.net.public_addresses", dns) + monkeypatch.setattr("webmentions_ssg.net.resolve_public_addresses", dns) socket_instance = Mock() create_socket = Mock(return_value=socket_instance) monkeypatch.setattr(socket, "socket", create_socket) @@ -56,7 +56,7 @@ def test_rebinding_cannot_change_socket_peer(monkeypatch: pytest.MonkeyPatch) -> socket, "getaddrinfo", Mock(side_effect=AssertionError("second resolution")) ) - stream = PublicNetworkBackend(NetworkDeadline(5)).connect_tcp( + stream = PublicNetworkBackend(RequestDeadline(5)).connect_tcp( "rebinding.example", 443, timeout=2.0 ) assert isinstance(stream, DeadlineStream) @@ -72,14 +72,14 @@ def test_backend_closes_failed_socket_and_tries_next_address( monkeypatch: pytest.MonkeyPatch, ) -> None: monkeypatch.setattr( - "webmentions_ssg.net.public_addresses", + "webmentions_ssg.net.resolve_public_addresses", Mock(return_value=("93.184.216.34", "8.8.8.8")), ) first, second = Mock(), Mock() first.connect.side_effect = TimeoutError("connection timed out") monkeypatch.setattr(socket, "socket", Mock(side_effect=[first, second])) - stream = PublicNetworkBackend(NetworkDeadline(5)).connect_tcp("example.com", 443) + stream = PublicNetworkBackend(RequestDeadline(5)).connect_tcp("example.com", 443) assert isinstance(stream, DeadlineStream) first.close.assert_called_once_with() @@ -106,7 +106,7 @@ def test_backend_closes_socket_on_failure( monkeypatch.setattr(socket, "socket", Mock(return_value=sock)) with pytest.raises(expected, match=str(failure)): - PublicNetworkBackend(NetworkDeadline(5)).connect_tcp("8.8.8.8", 443) + PublicNetworkBackend(RequestDeadline(5)).connect_tcp("8.8.8.8", 443) sock.close.assert_called_once_with() @@ -184,7 +184,7 @@ def test_deadline_clips_each_read_and_stops_trickle( monkeypatch.setattr("webmentions_ssg.net.time.monotonic", lambda: clock[0]) fake_stream = Mock() fake_stream.read.return_value = b"x" - stream = DeadlineStream(fake_stream, NetworkDeadline(5.0)) + stream = DeadlineStream(fake_stream, RequestDeadline(5.0)) clock[0] = 103.0 assert stream.read(1, timeout=5.0) == b"x" @@ -249,17 +249,17 @@ def test_is_http_url(url: str, expected: bool) -> None: def test_ip_literal_does_not_use_dns() -> None: with patch("webmentions_ssg.net.dns.resolver.resolve_name") as dns_resolve: with pytest.raises(UnsafeAddressError): - public_addresses("169.254.169.254") + resolve_public_addresses("169.254.169.254") with pytest.raises(UnsafeAddressError): - public_addresses("::1") - assert public_addresses("8.8.8.8") == ("8.8.8.8",) + resolve_public_addresses("::1") + assert resolve_public_addresses("8.8.8.8") == ("8.8.8.8",) dns_resolve.assert_not_called() def test_public_addresses_resolves_hostname_once() -> None: with patch("webmentions_ssg.net.dns.resolver.resolve_name") as resolve: resolve.return_value.addresses.return_value = ["93.184.216.34", "8.8.8.8"] - assert public_addresses("example.com", lifetime=1.5) == ( + assert resolve_public_addresses("example.com", lifetime=1.5) == ( "93.184.216.34", "8.8.8.8", ) @@ -282,7 +282,7 @@ def test_public_addresses_resolves_hostname_once() -> None: def test_public_addresses_rejects_ipv6_transition_literals(address: str) -> None: with patch("webmentions_ssg.net.dns.resolver.resolve_name") as resolve: with pytest.raises(UnsafeAddressError, match="Non-public"): - public_addresses(address) + resolve_public_addresses(address) resolve.assert_not_called() @@ -293,7 +293,7 @@ def test_public_addresses_rejects_transition_addresses_in_dns(address: str) -> N with patch("webmentions_ssg.net.dns.resolver.resolve_name") as resolve: resolve.return_value.addresses.return_value = ["93.184.216.34", address] with pytest.raises(UnsafeAddressError, match="Non-public"): - public_addresses("transition.example") + resolve_public_addresses("transition.example") @pytest.mark.parametrize("address", ["2002:0a00:0001::1", "::ffff:10.0.0.1"]) @@ -310,7 +310,7 @@ def test_public_addresses_rejects_mixed_dns_results() -> None: with patch("webmentions_ssg.net.dns.resolver.resolve_name") as resolve: resolve.return_value.addresses.return_value = ["93.184.216.34", "127.0.0.1"] with pytest.raises(UnsafeAddressError, match="Non-public"): - public_addresses("rebinding.example", lifetime=1.5) + resolve_public_addresses("rebinding.example", lifetime=1.5) resolve.assert_called_once_with("rebinding.example", lifetime=1.5) @@ -318,7 +318,7 @@ def test_public_addresses_rejects_empty_dns_result() -> None: with patch("webmentions_ssg.net.dns.resolver.resolve_name") as resolve: resolve.return_value.addresses.return_value = [] with pytest.raises(AddressResolutionError): - public_addresses("empty.example") + resolve_public_addresses("empty.example") @pytest.mark.parametrize( @@ -336,11 +336,11 @@ def test_public_addresses_rejects_empty_dns_result() -> None: pytest.param(600, False, id="outside-server-error-range"), ], ) -def test_temporary_http_status(app: Flask, status: int, expected: bool) -> None: +def test_is_retryable_status(app: Flask, status: int, expected: bool) -> None: _ = app from webmentions_ssg.tasks import discovery - assert discovery.is_temporary_status(status) is expected + assert discovery.is_retryable_status(status) is expected @pytest.mark.parametrize( @@ -352,8 +352,8 @@ def test_temporary_http_status(app: Flask, status: int, expected: bool) -> None: pytest.param("http://[::1", None, id="malformed-ipv6"), ], ) -def test_hostname_of(url: str, expected: str | None) -> None: - assert hostname_of(url) == expected +def test_normalized_hostname(url: str, expected: str | None) -> None: + assert normalized_hostname(url) == expected @pytest.mark.parametrize( @@ -370,5 +370,5 @@ def test_hostname_of(url: str, expected: str | None) -> None: ), ], ) -def test_content_type_of(headers: dict[str, str], expected: str) -> None: - assert content_type_of(httpx.Headers(headers)) == expected +def test_media_type_of(headers: dict[str, str], expected: str) -> None: + assert media_type_of(httpx.Headers(headers)) == expected -- cgit v1.3.1