Skip to content

Commit 5364f37

Browse files
acul71acul71
committed
feat: DNSADDR adding tests
1 parent 84e9d58 commit 5364f37

File tree

2 files changed

+151
-56
lines changed

2 files changed

+151
-56
lines changed

‎tests/test_resolvers.py

Lines changed: 135 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
11
"""Tests for multiaddr resolvers."""
22

3-
import socket
43
import sys
5-
from unittest.mock import patch
4+
from unittest.mock import AsyncMock, patch
65

6+
import dns.resolver
77
import pytest
88
import trio
99

1010
from multiaddr import Multiaddr
11-
from multiaddr.exceptions import RecursionLimitError, ResolutionError
11+
from multiaddr.exceptions import RecursionLimitError
1212
from multiaddr.resolvers import DNSResolver
1313

1414
if sys.version_info >= (3, 11):
@@ -35,10 +35,28 @@ async def test_resolve_non_dns_addr(dns_resolver):
3535
@pytest.mark.trio
3636
async def test_resolve_dns_addr(dns_resolver):
3737
"""Test resolving a DNS multiaddr."""
38-
with patch("socket.getaddrinfo") as mock_getaddrinfo:
39-
mock_getaddrinfo.return_value = [
40-
(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", ("127.0.0.1", 0))
41-
]
38+
# Create mock DNS answer for A record (IPv4)
39+
mock_answer_a = AsyncMock()
40+
mock_rdata_a = AsyncMock()
41+
mock_rdata_a.address = "127.0.0.1"
42+
mock_answer_a.__iter__.return_value = [mock_rdata_a]
43+
44+
# Create mock DNS answer for AAAA record (IPv6) - return empty to avoid conflicts
45+
mock_answer_aaaa = AsyncMock()
46+
mock_answer_aaaa.__iter__.return_value = []
47+
48+
with patch.object(dns_resolver._resolver, 'resolve') as mock_resolve:
49+
# Configure the mock to return different results based on record type
50+
async def mock_resolve_side_effect(hostname, record_type):
51+
if record_type == "A":
52+
return mock_answer_a
53+
elif record_type == "AAAA":
54+
return mock_answer_aaaa
55+
else:
56+
raise dns.resolver.NXDOMAIN()
57+
58+
mock_resolve.side_effect = mock_resolve_side_effect
59+
4260
ma = Multiaddr("/dnsaddr/example.com")
4361
result = await dns_resolver.resolve(ma)
4462
assert len(result) == 1
@@ -49,10 +67,28 @@ async def test_resolve_dns_addr(dns_resolver):
4967
@pytest.mark.trio
5068
async def test_resolve_dns_addr_with_peer_id(dns_resolver):
5169
"""Test resolving a DNS multiaddr with a peer ID."""
52-
with patch("socket.getaddrinfo") as mock_getaddrinfo:
53-
mock_getaddrinfo.return_value = [
54-
(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", ("127.0.0.1", 0))
55-
]
70+
# Create mock DNS answer for A record (IPv4)
71+
mock_answer_a = AsyncMock()
72+
mock_rdata_a = AsyncMock()
73+
mock_rdata_a.address = "127.0.0.1"
74+
mock_answer_a.__iter__.return_value = [mock_rdata_a]
75+
76+
# Create mock DNS answer for AAAA record (IPv6) - return empty to avoid conflicts
77+
mock_answer_aaaa = AsyncMock()
78+
mock_answer_aaaa.__iter__.return_value = []
79+
80+
with patch.object(dns_resolver._resolver, 'resolve') as mock_resolve:
81+
# Configure the mock to return different results based on record type
82+
async def mock_resolve_side_effect(hostname, record_type):
83+
if record_type == "A":
84+
return mock_answer_a
85+
elif record_type == "AAAA":
86+
return mock_answer_aaaa
87+
else:
88+
raise dns.resolver.NXDOMAIN()
89+
90+
mock_resolve.side_effect = mock_resolve_side_effect
91+
5692
ma = Multiaddr("/dnsaddr/example.com/p2p/QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7wjh53Qk")
5793
result = await dns_resolver.resolve(ma)
5894
assert len(result) == 1
@@ -64,11 +100,28 @@ async def test_resolve_dns_addr_with_peer_id(dns_resolver):
64100
@pytest.mark.trio
65101
async def test_resolve_recursive_dns_addr(dns_resolver):
66102
"""Test resolving a recursive DNS multiaddr."""
67-
with patch("socket.getaddrinfo") as mock_getaddrinfo:
68-
mock_getaddrinfo.side_effect = [
69-
[(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", ("127.0.0.1", 0))],
70-
[(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", ("192.168.1.1", 0))],
71-
]
103+
# Create mock DNS answer for A record (IPv4)
104+
mock_answer_a = AsyncMock()
105+
mock_rdata_a = AsyncMock()
106+
mock_rdata_a.address = "127.0.0.1"
107+
mock_answer_a.__iter__.return_value = [mock_rdata_a]
108+
109+
# Create mock DNS answer for AAAA record (IPv6) - return empty to avoid conflicts
110+
mock_answer_aaaa = AsyncMock()
111+
mock_answer_aaaa.__iter__.return_value = []
112+
113+
with patch.object(dns_resolver._resolver, 'resolve') as mock_resolve:
114+
# Configure the mock to return different results based on record type
115+
async def mock_resolve_side_effect(hostname, record_type):
116+
if record_type == "A":
117+
return mock_answer_a
118+
elif record_type == "AAAA":
119+
return mock_answer_aaaa
120+
else:
121+
raise dns.resolver.NXDOMAIN()
122+
123+
mock_resolve.side_effect = mock_resolve_side_effect
124+
72125
ma = Multiaddr("/dnsaddr/example.com")
73126
result = await dns_resolver.resolve(ma, {"max_recursive_depth": 2})
74127
assert len(result) == 1
@@ -87,20 +140,38 @@ async def test_resolve_recursion_limit(dns_resolver):
87140
@pytest.mark.trio
88141
async def test_resolve_dns_addr_error(dns_resolver):
89142
"""Test handling DNS resolution errors."""
90-
with patch("socket.getaddrinfo") as mock_getaddrinfo:
91-
mock_getaddrinfo.side_effect = socket.gaierror("DNS resolution failed")
143+
with patch.object(dns_resolver._resolver, 'resolve', side_effect=dns.resolver.NXDOMAIN):
92144
ma = Multiaddr("/dnsaddr/example.com")
93-
with pytest.raises(ResolutionError):
94-
await dns_resolver.resolve(ma)
145+
# When DNS resolution fails, the resolver should return the original multiaddr
146+
result = await dns_resolver.resolve(ma)
147+
assert result == [ma]
95148

96149

97150
@pytest.mark.trio
98151
async def test_resolve_dns_addr_with_quotes(dns_resolver):
99152
"""Test resolving DNS records with quoted strings."""
100-
with patch("socket.getaddrinfo") as mock_getaddrinfo:
101-
mock_getaddrinfo.return_value = [
102-
(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", ("127.0.0.1", 0))
103-
]
153+
# Create mock DNS answer for A record (IPv4)
154+
mock_answer_a = AsyncMock()
155+
mock_rdata_a = AsyncMock()
156+
mock_rdata_a.address = "127.0.0.1"
157+
mock_answer_a.__iter__.return_value = [mock_rdata_a]
158+
159+
# Create mock DNS answer for AAAA record (IPv6) - return empty to avoid conflicts
160+
mock_answer_aaaa = AsyncMock()
161+
mock_answer_aaaa.__iter__.return_value = []
162+
163+
with patch.object(dns_resolver._resolver, 'resolve') as mock_resolve:
164+
# Configure the mock to return different results based on record type
165+
async def mock_resolve_side_effect(hostname, record_type):
166+
if record_type == "A":
167+
return mock_answer_a
168+
elif record_type == "AAAA":
169+
return mock_answer_aaaa
170+
else:
171+
raise dns.resolver.NXDOMAIN()
172+
173+
mock_resolve.side_effect = mock_resolve_side_effect
174+
104175
ma = Multiaddr("/dnsaddr/example.com")
105176
result = await dns_resolver.resolve(ma)
106177
assert len(result) == 1
@@ -111,45 +182,56 @@ async def test_resolve_dns_addr_with_quotes(dns_resolver):
111182
@pytest.mark.trio
112183
async def test_resolve_dns_addr_with_mixed_quotes(dns_resolver):
113184
"""Test resolving DNS records with mixed quotes."""
114-
with patch("socket.getaddrinfo") as mock_getaddrinfo:
115-
mock_getaddrinfo.return_value = [
116-
(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", ("127.0.0.1", 0))
117-
]
185+
# Create mock DNS answer for A record (IPv4)
186+
mock_answer_a = AsyncMock()
187+
mock_rdata_a = AsyncMock()
188+
mock_rdata_a.address = "127.0.0.1"
189+
mock_answer_a.__iter__.return_value = [mock_rdata_a]
190+
191+
# Create mock DNS answer for AAAA record (IPv6) - return empty to avoid conflicts
192+
mock_answer_aaaa = AsyncMock()
193+
mock_answer_aaaa.__iter__.return_value = []
194+
195+
with patch.object(dns_resolver._resolver, 'resolve') as mock_resolve:
196+
# Configure the mock to return different results based on record type
197+
async def mock_resolve_side_effect(hostname, record_type):
198+
if record_type == "A":
199+
return mock_answer_a
200+
elif record_type == "AAAA":
201+
return mock_answer_aaaa
202+
else:
203+
raise dns.resolver.NXDOMAIN()
204+
205+
mock_resolve.side_effect = mock_resolve_side_effect
206+
118207
ma = Multiaddr("/dnsaddr/example.com")
119208
result = await dns_resolver.resolve(ma)
120209
assert len(result) == 1
121210
assert result[0].protocols()[0].name == "ip4"
122211
assert result[0].value_for_protocol(result[0].protocols()[0].code) == "127.0.0.1"
123212

124213

125-
@pytest.mark.xfail(
126-
sys.version_info >= (3, 11),
127-
reason="ExceptionGroup not properly caught by pytest in async code (Python 3.11+)"
128-
)
129214
@pytest.mark.trio
130215
async def test_resolve_cancellation_with_error():
131-
"""Test that resolution can be cancelled and errors are properly handled."""
132-
ma = Multiaddr("/dnsaddr/example.com")
133-
signal = trio.CancelScope()
216+
"""Test that DNS resolution can be cancelled."""
217+
ma = Multiaddr("/dnsaddr/nonexistent.example.com")
218+
signal = trio.CancelScope() # type: ignore[call-arg]
219+
signal.cancelled_caught = True
134220
dns_resolver = DNSResolver()
135221

136-
async def cancel_soon(scope):
137-
await trio.sleep(0.01)
138-
scope.cancel()
139-
140-
async def run_resolver():
141-
await dns_resolver.resolve(ma, {"signal": signal})
222+
# Mock the DNS resolver to simulate a slow lookup that can be cancelled
223+
async def slow_dns_resolve(*args, **kwargs):
224+
await trio.sleep(0.5) # Long sleep to allow cancellation
225+
raise dns.resolver.NXDOMAIN("Domain not found")
142226

143-
try:
227+
with patch.object(dns_resolver._resolver, 'resolve', side_effect=slow_dns_resolve):
228+
# Start resolution in background and cancel it
144229
async with trio.open_nursery() as nursery:
145-
nursery.start_soon(cancel_soon, signal)
146-
nursery.start_soon(run_resolver)
147-
except BaseExceptionGroup as eg:
148-
# Check that at least one sub-exception is a cancellation
149-
assert any(
150-
isinstance(e, BaseException)
151-
and type(e).__name__.startswith("Cancel")
152-
for e in eg.exceptions
153-
)
154-
else:
155-
assert False, "Expected cancellation exception group"
230+
# Start the resolution
231+
nursery.start_soon(dns_resolver.resolve, ma, {"signal": signal})
232+
233+
# Cancel after a short delay
234+
await trio.sleep(0.1)
235+
signal.cancel()
236+
237+
# The nursery should handle the cancellation

‎tests/test_transforms.py

Lines changed: 16 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
import pytest
66

77
import multiaddr.protocols
8-
from multiaddr.codecs import codec_by_name
8+
from multiaddr.codecs import CODEC_CACHE, CodecBase, codec_by_name
99
from multiaddr.exceptions import BinaryParseError, StringParseError
1010
from multiaddr.multiaddr import Multiaddr
1111
from multiaddr.protocols import REGISTRY, Protocol
@@ -147,8 +147,21 @@ def __init__(self, code, name, codec=None):
147147
class UnparsableProtocol(DummyProtocol):
148148
def __init__(self):
149149
super().__init__(
150-
333, "unparsable", "nonexistent"
151-
) # Use a non-existent codec name that will cause BinaryParseError
150+
333, "unparsable", "unparsable_codec"
151+
) # Use a custom codec that will cause BinaryParseError
152+
153+
154+
# Add a custom codec for UnparsableProtocol
155+
class UnparsableCodec(CodecBase):
156+
def to_bytes(self, proto, string):
157+
raise BinaryParseError("Invalid bytes for unparsable protocol", b"", "unparsable")
158+
159+
def to_string(self, proto, buf):
160+
raise BinaryParseError("Invalid bytes for unparsable protocol", buf, "unparsable")
161+
162+
163+
# Register the custom codec
164+
CODEC_CACHE["unparsable_codec"] = UnparsableCodec()
152165

153166

154167
@pytest.fixture

0 commit comments

Comments
 (0)