Debian Codegraph @

tests/greendns_test.py

raw
1 """Tests for the eventlet.support.greendns module"""
2
3 import os
4 import socket
5 import tempfile
6 import time
7 from dns.resolver import NoAnswer, Answer, Resolver
8
9 from eventlet.support import greendns
10 from eventlet.support.greendns import dns
11 import tests
12 import tests.mock
13
14
15 def _make_host_resolver():
16 """Returns a HostResolver instance
17
18 The hosts file will be empty but accessible as a py.path.local
19 instance using the ``hosts`` attribute.
20 """
21 hosts = tempfile.NamedTemporaryFile()
22 hr = greendns.HostsResolver(fname=hosts.name)
23 hr.hosts = hosts
24 hr._last_stat = 0
25 return hr
26
27
28 class TestHostsResolver(tests.LimitedTestCase):
29
30 def test_default_fname(self):
31 hr = greendns.HostsResolver()
32 assert os.path.exists(hr.fname)
33
34 def test_readlines_lines(self):
35 hr = _make_host_resolver()
36 hr.hosts.write(b'line0\n')
37 hr.hosts.flush()
38 assert list(hr._readlines()) == ['line0']
39 hr._last_stat = 0
40 hr.hosts.write(b'line1\n')
41 hr.hosts.flush()
42 assert list(hr._readlines()) == ['line0', 'line1']
43 # Test reading of varied newline styles
44 hr._last_stat = 0
45 hr.hosts.seek(0)
46 hr.hosts.truncate()
47 hr.hosts.write(b'\naa\r\nbb\r cc \n\n\tdd ee')
48 hr.hosts.flush()
49 assert list(hr._readlines()) == ['aa', 'bb', 'cc', 'dd ee']
50 # Test comments, including inline comments
51 hr._last_stat = 0
52 hr.hosts.seek(0)
53 hr.hosts.truncate()
54 hr.hosts.write(b'''\
55 # First couple lines
56 # are comments.
57 line1
58 #comment
59 line2 # inline comment
60 ''')
61 hr.hosts.flush()
62 assert list(hr._readlines()) == ['line1', 'line2']
63
64 def test_readlines_missing_file(self):
65 hr = _make_host_resolver()
66 hr.hosts.close()
67 hr._last_stat = 0
68 assert list(hr._readlines()) == []
69
70 def test_load_no_contents(self):
71 hr = _make_host_resolver()
72 hr._load()
73 assert not hr._v4
74 assert not hr._v6
75 assert not hr._aliases
76
77 def test_load_v4_v6_cname_aliases(self):
78 hr = _make_host_resolver()
79 hr.hosts.write(b'1.2.3.4 v4.example.com v4\n'
80 b'dead:beef::1 v6.example.com v6\n')
81 hr.hosts.flush()
82 hr._load()
83 assert hr._v4 == {'v4.example.com': '1.2.3.4', 'v4': '1.2.3.4'}
84 assert hr._v6 == {'v6.example.com': 'dead:beef::1',
85 'v6': 'dead:beef::1'}
86 assert hr._aliases == {'v4': 'v4.example.com',
87 'v6': 'v6.example.com'}
88
89 def test_load_v6_link_local(self):
90 hr = _make_host_resolver()
91 hr.hosts.write(b'fe80:: foo\n'
92 b'fe80:dead:beef::1 bar\n')
93 hr.hosts.flush()
94 hr._load()
95 assert not hr._v4
96 assert not hr._v6
97
98 def test_query_A(self):
99 hr = _make_host_resolver()
100 hr._v4 = {'v4.example.com': '1.2.3.4'}
101 ans = hr.query('v4.example.com')
102 assert ans[0].address == '1.2.3.4'
103 ans = hr.query('v4.example.com')
104 assert ans[0].address == '1.2.3.4'
105 ans = hr.query(b'v4.example.com')
106 assert ans[0].address == '1.2.3.4'
107
108 def test_query_ans_types(self):
109 # This assumes test_query_A above succeeds
110 hr = _make_host_resolver()
111 hr._v4 = {'v4.example.com': '1.2.3.4'}
112 hr._last_stat = time.time()
113 ans = hr.query('v4.example.com')
114 assert isinstance(ans, greendns.dns.resolver.Answer)
115 assert ans.response is None
116 assert ans.qname == dns.name.from_text('v4.example.com')
117 assert ans.rdtype == dns.rdatatype.A
118 assert ans.rdclass == dns.rdataclass.IN
119 assert ans.canonical_name == dns.name.from_text('v4.example.com')
120 assert ans.expiration
121 assert isinstance(ans.rrset, dns.rrset.RRset)
122 assert ans.rrset.rdtype == dns.rdatatype.A
123 assert ans.rrset.rdclass == dns.rdataclass.IN
124 ttl = greendns.HOSTS_TTL
125 assert ttl - 1 <= ans.rrset.ttl <= ttl + 1
126 rr = ans.rrset[0]
127 assert isinstance(rr, greendns.dns.rdtypes.IN.A.A)
128 assert rr.rdtype == dns.rdatatype.A
129 assert rr.rdclass == dns.rdataclass.IN
130 assert rr.address == '1.2.3.4'
131
132 def test_query_AAAA(self):
133 hr = _make_host_resolver()
134 hr._v6 = {'v6.example.com': 'dead:beef::1'}
135 ans = hr.query('v6.example.com', dns.rdatatype.AAAA)
136 assert ans[0].address == 'dead:beef::1'
137
138 def test_query_unknown_raises(self):
139 hr = _make_host_resolver()
140 with tests.assert_raises(greendns.dns.resolver.NoAnswer):
141 hr.query('example.com')
142
143 def test_query_unknown_no_raise(self):
144 hr = _make_host_resolver()
145 ans = hr.query('example.com', raise_on_no_answer=False)
146 assert isinstance(ans, greendns.dns.resolver.Answer)
147 assert ans.response is None
148 assert ans.qname == dns.name.from_text('example.com')
149 assert ans.rdtype == dns.rdatatype.A
150 assert ans.rdclass == dns.rdataclass.IN
151 assert ans.canonical_name == dns.name.from_text('example.com')
152 assert ans.expiration
153 assert isinstance(ans.rrset, greendns.dns.rrset.RRset)
154 assert ans.rrset.rdtype == dns.rdatatype.A
155 assert ans.rrset.rdclass == dns.rdataclass.IN
156 assert len(ans.rrset) == 0
157
158 def test_query_CNAME(self):
159 hr = _make_host_resolver()
160 hr._aliases = {'host': 'host.example.com'}
161 ans = hr.query('host', dns.rdatatype.CNAME)
162 assert ans[0].target == dns.name.from_text('host.example.com')
163 assert str(ans[0].target) == 'host.example.com.'
164
165 def test_query_unknown_type(self):
166 hr = _make_host_resolver()
167 with tests.assert_raises(greendns.dns.resolver.NoAnswer):
168 hr.query('example.com', dns.rdatatype.MX)
169
170 def test_getaliases(self):
171 hr = _make_host_resolver()
172 hr._aliases = {'host': 'host.example.com',
173 'localhost': 'host.example.com'}
174 res = set(hr.getaliases('host'))
175 assert res == {'host.example.com', 'localhost'}
176
177 def test_getaliases_unknown(self):
178 hr = _make_host_resolver()
179 assert hr.getaliases('host.example.com') == []
180
181 def test_getaliases_fqdn(self):
182 hr = _make_host_resolver()
183 hr._aliases = {'host': 'host.example.com'}
184 res = set(hr.getaliases('host.example.com'))
185 assert res == {'host'}
186
187 def test_hosts_case_insensitive(self):
188 name = 'example.com'
189 hr = _make_host_resolver()
190 hr.hosts.write(b'1.2.3.4 ExAmPlE.CoM\n')
191 hr.hosts.flush()
192 hr._load()
193
194 ans = hr.query(name)
195 rr = ans.rrset[0]
196 assert isinstance(rr, greendns.dns.rdtypes.IN.A.A)
197 assert rr.rdtype == dns.rdatatype.A
198 assert rr.rdclass == dns.rdataclass.IN
199 assert rr.address == '1.2.3.4'
200
201
202 def _make_mock_base_resolver():
203 """A mocked base resolver class"""
204 class RR:
205 pass
206
207 class Resolver:
208 aliases = ['cname.example.com']
209 raises = None
210 rr = RR()
211 rr6 = RR()
212
213 def query(self, *args, **kwargs):
214 self.args = args
215 self.kwargs = kwargs
216 if self.raises:
217 raise self.raises()
218 if hasattr(self, 'rrset'):
219 rrset = self.rrset
220 else:
221 if self.rr6 and self.args[1] == dns.rdatatype.AAAA:
222 rrset = [self.rr6]
223 else:
224 rrset = [self.rr]
225 return greendns.HostsAnswer('foo', 1, 1, rrset, False)
226
227 def getaliases(self, *args, **kwargs):
228 return self.aliases
229
230 return Resolver
231
232
233 class TestUdp(tests.LimitedTestCase):
234
235 def setUp(self):
236 # Store this so we can reuse it for each test
237 self.query = greendns.dns.message.Message()
238 self.query.flags = greendns.dns.flags.QR
239 self.query_wire = self.query.to_wire()
240 super().setUp()
241
242 def test_udp_ipv4(self):
243 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
244 return_value=(self.query_wire,
245 ('127.0.0.1', 53))):
246 greendns.udp(self.query, '127.0.0.1')
247
248 def test_udp_ipv4_timeout(self):
249 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
250 side_effect=socket.timeout):
251 with tests.assert_raises(dns.exception.Timeout):
252 greendns.udp(self.query, '127.0.0.1', timeout=0.1)
253
254 def test_udp_ipv4_wrong_addr_ignore(self):
255 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
256 side_effect=socket.timeout):
257 with tests.assert_raises(dns.exception.Timeout):
258 greendns.udp(self.query, '127.0.0.1', timeout=0.1, ignore_unexpected=True)
259
260 def test_udp_ipv4_wrong_addr(self):
261 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
262 return_value=(self.query_wire,
263 ('127.0.0.2', 53))):
264 with tests.assert_raises(dns.query.UnexpectedSource):
265 greendns.udp(self.query, '127.0.0.1')
266
267 def test_udp_ipv6(self):
268 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
269 return_value=(self.query_wire,
270 ('::1', 53, 0, 0))):
271 greendns.udp(self.query, '::1')
272
273 def test_udp_ipv6_timeout(self):
274 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
275 side_effect=socket.timeout):
276 with tests.assert_raises(dns.exception.Timeout):
277 greendns.udp(self.query, '::1', timeout=0.1)
278
279 def test_udp_ipv6_addr_zeroes(self):
280 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
281 return_value=(self.query_wire,
282 ('0:00:0000::1', 53, 0, 0))):
283 greendns.udp(self.query, '::1')
284
285 def test_udp_ipv6_wrong_addr_ignore(self):
286 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
287 side_effect=socket.timeout):
288 with tests.assert_raises(dns.exception.Timeout):
289 greendns.udp(self.query, '::1', timeout=0.1, ignore_unexpected=True)
290
291 def test_udp_ipv6_wrong_addr(self):
292 with tests.mock.patch('eventlet.support.greendns.socket.socket.recvfrom',
293 return_value=(self.query_wire,
294 ('ffff:0000::1', 53, 0, 0))):
295 with tests.assert_raises(dns.query.UnexpectedSource):
296 greendns.udp(self.query, '::1')
297
298
299 class TestProxyResolver(tests.LimitedTestCase):
300
301 def test_clear(self):
302 rp = greendns.ResolverProxy()
303 assert rp._cached_resolver is None
304 resolver = rp._resolver
305 assert resolver is not None
306 rp.clear()
307 assert rp._resolver is not None
308 assert rp._resolver != resolver
309
310 def _make_mock_hostsresolver(self):
311 """A mocked HostsResolver"""
312 base_resolver = _make_mock_base_resolver()
313 base_resolver.rr.address = '1.2.3.4'
314 return base_resolver()
315
316 def _make_mock_resolver(self):
317 """A mocked Resolver"""
318 base_resolver = _make_mock_base_resolver()
319 base_resolver.rr.address = '5.6.7.8'
320 return base_resolver()
321
322 def test_hosts(self):
323 hostsres = self._make_mock_hostsresolver()
324 rp = greendns.ResolverProxy(hostsres)
325 ans = rp.query('host.example.com')
326 assert ans[0].address == '1.2.3.4'
327 ans = rp.query('host.example.com')
328 assert ans[0].address == '1.2.3.4'
329 ans = rp.query(b'host.example.com')
330 assert ans[0].address == '1.2.3.4'
331
332 def test_hosts_noanswer(self):
333 hostsres = self._make_mock_hostsresolver()
334 res = self._make_mock_resolver()
335 rp = greendns.ResolverProxy(hostsres)
336 rp._resolver = res
337 hostsres.raises = greendns.dns.resolver.NoAnswer
338 ans = rp.query('host.example.com')
339 assert ans[0].address == '5.6.7.8'
340
341 def test_resolver(self):
342 res = self._make_mock_resolver()
343 rp = greendns.ResolverProxy()
344 rp._resolver = res
345 ans = rp.query('host.example.com')
346 assert ans[0].address == '5.6.7.8'
347 assert isinstance(res.args[0], dns.name.Name)
348
349 ans = rp.query('host.example.com')
350 assert ans[0].address == '5.6.7.8'
351 assert isinstance(res.args[0], dns.name.Name)
352
353 ans = rp.query(b'host.example.com')
354 assert ans[0].address == '5.6.7.8'
355 assert isinstance(res.args[0], dns.name.Name)
356
357 def test_noanswer(self):
358 res = self._make_mock_resolver()
359 rp = greendns.ResolverProxy()
360 rp._resolver = res
361 res.raises = greendns.dns.resolver.NoAnswer
362 with tests.assert_raises(greendns.dns.resolver.NoAnswer):
363 rp.query('host.example.com')
364
365 def test_nxdomain(self):
366 res = self._make_mock_resolver()
367 rp = greendns.ResolverProxy()
368 rp._resolver = res
369 res.raises = greendns.dns.resolver.NXDOMAIN
370 with tests.assert_raises(greendns.dns.resolver.NXDOMAIN):
371 rp.query('host.example.com')
372
373 def test_noanswer_hosts(self):
374 hostsres = self._make_mock_hostsresolver()
375 res = self._make_mock_resolver()
376 rp = greendns.ResolverProxy(hostsres)
377 rp._resolver = res
378 hostsres.raises = greendns.dns.resolver.NoAnswer
379 res.raises = greendns.dns.resolver.NoAnswer
380 with tests.assert_raises(greendns.dns.resolver.NoAnswer):
381 rp.query('host.example.com')
382
383 def _make_mock_resolver_aliases(self):
384
385 class RR:
386 target = 'host.example.com'
387
388 class Resolver:
389 call_count = 0
390 exc_type = greendns.dns.resolver.NoAnswer
391
392 def query(self, *args, **kwargs):
393 self.args = args
394 self.kwargs = kwargs
395 self.call_count += 1
396 if self.call_count < 2:
397 return greendns.HostsAnswer(args[0], 1, 5, [RR()], False)
398 else:
399 raise self.exc_type()
400
401 return Resolver()
402
403 def test_getaliases(self):
404 aliases_res = self._make_mock_resolver_aliases()
405 rp = greendns.ResolverProxy()
406 rp._resolver = aliases_res
407 aliases = set(rp.getaliases('alias.example.com'))
408 assert aliases == {'host.example.com'}
409
410 def test_getaliases_fqdn(self):
411 aliases_res = self._make_mock_resolver_aliases()
412 rp = greendns.ResolverProxy()
413 rp._resolver = aliases_res
414 rp._resolver.call_count = 1
415 assert rp.getaliases('host.example.com') == []
416
417 def test_getaliases_nxdomain(self):
418 aliases_res = self._make_mock_resolver_aliases()
419 rp = greendns.ResolverProxy()
420 rp._resolver = aliases_res
421 rp._resolver.call_count = 1
422 rp._resolver.exc_type = greendns.dns.resolver.NXDOMAIN
423 assert rp.getaliases('host.example.com') == []
424
425
426 class TestResolve(tests.LimitedTestCase):
427
428 def setUp(self):
429 base_resolver = _make_mock_base_resolver()
430 base_resolver.rr.address = '1.2.3.4'
431 self._old_resolver = greendns.resolver
432 greendns.resolver = base_resolver()
433
434 def tearDown(self):
435 greendns.resolver = self._old_resolver
436
437 def test_A(self):
438 ans = greendns.resolve('host.example.com', socket.AF_INET)
439 assert ans[0].address == '1.2.3.4'
440 assert greendns.resolver.args == ('host.example.com', dns.rdatatype.A)
441
442 def test_AAAA(self):
443 greendns.resolver.rr6.address = 'dead:beef::1'
444 ans = greendns.resolve('host.example.com', socket.AF_INET6)
445 assert ans[0].address == 'dead:beef::1'
446 assert greendns.resolver.args == ('host.example.com', dns.rdatatype.AAAA)
447
448 def test_unknown_rdtype(self):
449 with tests.assert_raises(socket.gaierror):
450 greendns.resolve('host.example.com', socket.AF_INET6 + 1)
451
452 def test_timeout(self):
453 greendns.resolver.raises = greendns.dns.exception.Timeout
454 with tests.assert_raises(socket.gaierror):
455 greendns.resolve('host.example.com')
456
457 def test_exc(self):
458 greendns.resolver.raises = greendns.dns.exception.DNSException
459 with tests.assert_raises(socket.gaierror):
460 greendns.resolve('host.example.com')
461
462 def test_noraise_noanswer(self):
463 greendns.resolver.rrset = None
464 ans = greendns.resolve('example.com', raises=False)
465 assert not ans.rrset
466
467 def test_noraise_nxdomain(self):
468 greendns.resolver.raises = greendns.dns.resolver.NXDOMAIN
469 ans = greendns.resolve('example.com', raises=False)
470 assert not ans.rrset
471
472
473 class TestResolveCname(tests.LimitedTestCase):
474
475 def setUp(self):
476 base_resolver = _make_mock_base_resolver()
477 base_resolver.rr.target = 'cname.example.com'
478 self._old_resolver = greendns.resolver
479 greendns.resolver = base_resolver()
480
481 def tearDown(self):
482 greendns.resolver = self._old_resolver
483
484 def test_success(self):
485 cname = greendns.resolve_cname('alias.example.com')
486 assert cname == 'cname.example.com'
487
488 def test_timeout(self):
489 greendns.resolver.raises = greendns.dns.exception.Timeout
490 with tests.assert_raises(socket.gaierror):
491 greendns.resolve_cname('alias.example.com')
492
493 def test_nodata(self):
494 greendns.resolver.raises = greendns.dns.exception.DNSException
495 with tests.assert_raises(socket.gaierror):
496 greendns.resolve_cname('alias.example.com')
497
498 def test_no_answer(self):
499 greendns.resolver.raises = greendns.dns.resolver.NoAnswer
500 assert greendns.resolve_cname('host.example.com') == 'host.example.com'
501
502
503 def _make_mock_resolve():
504 """A stubbed out resolve function
505
506 This monkeypatches the greendns.resolve() function with a mock.
507 You must give it answers by calling .add().
508 """
509
510 class MockAnswer(list):
511 pass
512
513 class MockResolve:
514
515 def __init__(self):
516 self.answers = {}
517
518 def __call__(self, name, family=socket.AF_INET, raises=True,
519 _proxy=None, use_network=True):
520 qname = dns.name.from_text(name)
521 try:
522 rrset = self.answers[name][family]
523 except KeyError:
524 if raises:
525 raise greendns.dns.resolver.NoAnswer()
526 rrset = dns.rrset.RRset(qname, 1, 1)
527 ans = MockAnswer()
528 ans.qname = qname
529 ans.rrset = rrset
530 ans.extend(rrset.items)
531 return ans
532
533 def add(self, name, addr):
534 """Add an address to a name and family"""
535 try:
536 rdata = dns.rdtypes.IN.A.A(dns.rdataclass.IN,
537 dns.rdatatype.A, addr)
538 family = socket.AF_INET
539 except (OSError, dns.exception.SyntaxError):
540 rdata = dns.rdtypes.IN.AAAA.AAAA(dns.rdataclass.IN,
541 dns.rdatatype.AAAA, addr)
542 family = socket.AF_INET6
543 family_dict = self.answers.setdefault(name, {})
544 rrset = family_dict.get(family)
545 if not rrset:
546 family_dict[family] = rrset = dns.rrset.RRset(
547 dns.name.from_text(name), rdata.rdclass, rdata.rdtype)
548 rrset.add(rdata)
549
550 resolve = MockResolve()
551 return resolve
552
553
554 class TestGetaddrinfo(tests.LimitedTestCase):
555
556 def _make_mock_resolve_cname(self):
557 """A stubbed out cname function"""
558
559 class ResolveCname:
560 qname = None
561 cname = 'cname.example.com'
562
563 def __call__(self, host):
564 self.qname = host
565 return self.cname
566
567 resolve_cname = ResolveCname()
568 return resolve_cname
569
570 def setUp(self):
571 self._old_resolve = greendns.resolve
572 self._old_resolve_cname = greendns.resolve_cname
573 self._old_orig_getaddrinfo = greendns.socket.getaddrinfo
574
575 def tearDown(self):
576 greendns.resolve = self._old_resolve
577 greendns.resolve_cname = self._old_resolve_cname
578 greendns.socket.getaddrinfo = self._old_orig_getaddrinfo
579
580 def test_getaddrinfo(self):
581 greendns.resolve = _make_mock_resolve()
582 greendns.resolve.add('example.com', '127.0.0.2')
583 greendns.resolve.add('example.com', '::1')
584 res = greendns.getaddrinfo('example.com', 'domain')
585 addr = ('127.0.0.2', 53)
586 tcp = (socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
587 udp = (socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
588 addr = ('::1', 53, 0, 0)
589 tcp6 = (socket.AF_INET6, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
590 udp6 = (socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
591 filt_res = [ai[:3] + (ai[4],) for ai in res]
592 assert tcp in filt_res
593 assert udp in filt_res
594 assert tcp6 in filt_res
595 assert udp6 in filt_res
596
597 def test_getaddrinfo_idn(self):
598 greendns.resolve = _make_mock_resolve()
599 idn_name = 'евентлет.com'
600 greendns.resolve.add(idn_name.encode('idna').decode('ascii'), '127.0.0.2')
601 res = greendns.getaddrinfo(idn_name, 'domain')
602 addr = ('127.0.0.2', 53)
603 tcp = (socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
604 udp = (socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
605 filt_res = [ai[:3] + (ai[4],) for ai in res]
606 assert tcp in filt_res
607 assert udp in filt_res
608
609 def test_getaddrinfo_inet(self):
610 greendns.resolve = _make_mock_resolve()
611 greendns.resolve.add('example.com', '127.0.0.2')
612 res = greendns.getaddrinfo('example.com', 'domain', socket.AF_INET)
613 addr = ('127.0.0.2', 53)
614 tcp = (socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
615 udp = (socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
616 assert tcp in [ai[:3] + (ai[4],) for ai in res]
617 assert udp in [ai[:3] + (ai[4],) for ai in res]
618
619 def test_getaddrinfo_inet6(self):
620 greendns.resolve = _make_mock_resolve()
621 greendns.resolve.add('example.com', '::1')
622 res = greendns.getaddrinfo('example.com', 'domain', socket.AF_INET6)
623 addr = ('::1', 53, 0, 0)
624 tcp = (socket.AF_INET6, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
625 udp = (socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
626 assert tcp in [ai[:3] + (ai[4],) for ai in res]
627 assert udp in [ai[:3] + (ai[4],) for ai in res]
628
629 def test_getaddrinfo_only_a_ans(self):
630 greendns.resolve = _make_mock_resolve()
631 greendns.resolve.add('example.com', '1.2.3.4')
632 res = greendns.getaddrinfo('example.com', None)
633 addr = [('1.2.3.4', 0)] * len(res)
634 assert addr == [ai[-1] for ai in res]
635
636 def test_getaddrinfo_only_aaaa_ans(self):
637 greendns.resolve = _make_mock_resolve()
638 greendns.resolve.add('example.com', 'dead:beef::1')
639 res = greendns.getaddrinfo('example.com', None)
640 addr = [('dead:beef::1', 0, 0, 0)] * len(res)
641 assert addr == [ai[-1] for ai in res]
642
643 def test_getaddrinfo_hosts_only_ans_with_timeout(self):
644 def clear_raises(res_self):
645 res_self.raises = None
646 return greendns.dns.resolver.NoAnswer()
647
648 hostsres = _make_mock_base_resolver()
649 hostsres.raises = clear_raises
650 hostsres.rr.address = '1.2.3.4'
651 greendns.resolver = greendns.ResolverProxy(hostsres())
652 res = _make_mock_base_resolver()
653 res.raises = greendns.dns.exception.Timeout
654 greendns.resolver._resolver = res()
655
656 result = greendns.getaddrinfo('example.com', None, 0)
657 addr = [('1.2.3.4', 0)] * len(result)
658 assert addr == [ai[-1] for ai in result]
659
660 def test_getaddrinfo_hosts_only_ans_with_error(self):
661 def clear_raises(res_self):
662 res_self.raises = None
663 return greendns.dns.resolver.NoAnswer()
664
665 hostsres = _make_mock_base_resolver()
666 hostsres.raises = clear_raises
667 hostsres.rr.address = '1.2.3.4'
668 greendns.resolver = greendns.ResolverProxy(hostsres())
669 res = _make_mock_base_resolver()
670 res.raises = greendns.dns.exception.DNSException
671 greendns.resolver._resolver = res()
672
673 result = greendns.getaddrinfo('example.com', None, 0)
674 addr = [('1.2.3.4', 0)] * len(result)
675 assert addr == [ai[-1] for ai in result]
676
677 def test_getaddrinfo_bytes(self):
678 greendns.resolve = _make_mock_resolve()
679 greendns.resolve.add('example.com', '1.2.3.4')
680 res = greendns.getaddrinfo(b'example.com', b'0')
681 addr = [('1.2.3.4', 0)] * len(res)
682 assert addr == [ai[-1] for ai in res]
683
684 def test_getaddrinfo_hosts_only_timeout(self):
685 hostsres = _make_mock_base_resolver()
686 hostsres.raises = greendns.dns.resolver.NoAnswer
687 greendns.resolver = greendns.ResolverProxy(hostsres())
688 res = _make_mock_base_resolver()
689 res.raises = greendns.dns.exception.Timeout
690 greendns.resolver._resolver = res()
691
692 with tests.assert_raises(socket.gaierror):
693 greendns.getaddrinfo('example.com', None, 0)
694
695 def test_getaddrinfo_hosts_only_dns_error(self):
696 hostsres = _make_mock_base_resolver()
697 hostsres.raises = greendns.dns.resolver.NoAnswer
698 greendns.resolver = greendns.ResolverProxy(hostsres())
699 res = _make_mock_base_resolver()
700 res.raises = greendns.dns.exception.DNSException
701 greendns.resolver._resolver = res()
702
703 with tests.assert_raises(socket.gaierror):
704 greendns.getaddrinfo('example.com', None, 0)
705
706 def test_canonname(self):
707 greendns.resolve = _make_mock_resolve()
708 greendns.resolve.add('host.example.com', '1.2.3.4')
709 greendns.resolve_cname = self._make_mock_resolve_cname()
710 res = greendns.getaddrinfo('host.example.com', None,
711 0, 0, 0, socket.AI_CANONNAME)
712 assert res[0][3] == 'cname.example.com'
713
714 def test_host_none(self):
715 res = greendns.getaddrinfo(None, 80)
716 for addr in {ai[-1] for ai in res}:
717 assert addr in [('127.0.0.1', 80), ('::1', 80, 0, 0)]
718
719 def test_host_none_passive(self):
720 res = greendns.getaddrinfo(None, 80, 0, 0, 0, socket.AI_PASSIVE)
721 for addr in {ai[-1] for ai in res}:
722 assert addr in [('0.0.0.0', 80), ('::', 80, 0, 0)]
723
724 def test_v4mapped(self):
725 greendns.resolve = _make_mock_resolve()
726 greendns.resolve.add('example.com', '1.2.3.4')
727 res = greendns.getaddrinfo('example.com', 80,
728 socket.AF_INET6, 0, 0, socket.AI_V4MAPPED)
729 addrs = {ai[-1] for ai in res}
730 assert addrs == {('::ffff:1.2.3.4', 80, 0, 0)}
731
732 def test_v4mapped_all(self):
733 greendns.resolve = _make_mock_resolve()
734 greendns.resolve.add('example.com', '1.2.3.4')
735 greendns.resolve.add('example.com', 'dead:beef::1')
736 res = greendns.getaddrinfo('example.com', 80, socket.AF_INET6, 0, 0,
737 socket.AI_V4MAPPED | socket.AI_ALL)
738 addrs = {ai[-1] for ai in res}
739 for addr in addrs:
740 assert addr in [('::ffff:1.2.3.4', 80, 0, 0),
741 ('dead:beef::1', 80, 0, 0)]
742
743 def test_numericserv(self):
744 greendns.resolve = _make_mock_resolve()
745 greendns.resolve.add('example.com', '1.2.3.4')
746 with tests.assert_raises(socket.gaierror):
747 greendns.getaddrinfo('example.com', 'www', 0, 0, 0, socket.AI_NUMERICSERV)
748
749 def test_numerichost(self):
750 greendns.resolve = _make_mock_resolve()
751 greendns.resolve.add('example.com', '1.2.3.4')
752 with tests.assert_raises(socket.gaierror):
753 greendns.getaddrinfo('example.com', 80, 0, 0, 0, socket.AI_NUMERICHOST)
754
755 def test_noport(self):
756 greendns.resolve = _make_mock_resolve()
757 greendns.resolve.add('example.com', '1.2.3.4')
758 ai = greendns.getaddrinfo('example.com', None)
759 assert ai[0][-1][1] == 0
760
761 def test_AI_ADDRCONFIG(self):
762 # When the users sets AI_ADDRCONFIG but only has an IPv4
763 # address configured we will iterate over the results, but the
764 # call for the IPv6 address will fail rather then return an
765 # empty list. In that case we should catch the exception and
766 # only return the ones which worked.
767 def getaddrinfo(addr, port, family, socktype, proto, aiflags):
768 if addr == '127.0.0.1':
769 return [(socket.AF_INET, 1, 0, '', ('127.0.0.1', 0))]
770 elif addr == '::1' and aiflags & socket.AI_ADDRCONFIG:
771 raise OSError(socket.EAI_ADDRFAMILY,
772 'Address family for hostname not supported')
773 elif addr == '::1' and not aiflags & socket.AI_ADDRCONFIG:
774 return [(socket.AF_INET6, 1, 0, '', ('::1', 0, 0, 0))]
775 greendns.socket.getaddrinfo = getaddrinfo
776 greendns.resolve = _make_mock_resolve()
777 greendns.resolve.add('localhost', '127.0.0.1')
778 greendns.resolve.add('localhost', '::1')
779 res = greendns.getaddrinfo('localhost', None,
780 0, 0, 0, socket.AI_ADDRCONFIG)
781 assert res == [(socket.AF_INET, 1, 0, '', ('127.0.0.1', 0))]
782
783 def test_AI_ADDRCONFIG_noaddr(self):
784 # If AI_ADDRCONFIG is used but there is no address we need to
785 # get an exception, not an empty list.
786 def getaddrinfo(addr, port, family, socktype, proto, aiflags):
787 raise OSError(socket.EAI_ADDRFAMILY,
788 'Address family for hostname not supported')
789 greendns.socket.getaddrinfo = getaddrinfo
790 greendns.resolve = _make_mock_resolve()
791 try:
792 greendns.getaddrinfo('::1', None, 0, 0, 0, socket.AI_ADDRCONFIG)
793 except OSError as e:
794 assert e.errno == socket.EAI_ADDRFAMILY
795
796 def test_getaddrinfo_type_parameter(self):
797 greendns.resolve = _make_mock_resolve()
798 greendns.resolve.add('localhost', '127.0.0.1')
799 greendns.getaddrinfo('localhost', None, type=0)
800
801
802 class TestIsIpAddr(tests.LimitedTestCase):
803
804 def test_isv4(self):
805 assert greendns.is_ipv4_addr('1.2.3.4')
806
807 def test_isv4_false(self):
808 assert not greendns.is_ipv4_addr('260.0.0.0')
809
810 def test_isv6(self):
811 assert greendns.is_ipv6_addr('dead:beef::1')
812
813 def test_isv6_invalid(self):
814 assert not greendns.is_ipv6_addr('foobar::1')
815
816 def test_v4(self):
817 assert greendns.is_ip_addr('1.2.3.4')
818
819 def test_v4_illegal(self):
820 assert not greendns.is_ip_addr('300.0.0.1')
821
822 def test_v6_addr(self):
823 assert greendns.is_ip_addr('::1')
824
825 def test_isv4_none(self):
826 assert not greendns.is_ipv4_addr(None)
827
828 def test_isv6_none(self):
829 assert not greendns.is_ipv6_addr(None)
830
831 def test_none(self):
832 assert not greendns.is_ip_addr(None)
833
834
835 class TestGethostbyname(tests.LimitedTestCase):
836
837 def setUp(self):
838 self._old_resolve = greendns.resolve
839 greendns.resolve = _make_mock_resolve()
840
841 def tearDown(self):
842 greendns.resolve = self._old_resolve
843
844 def test_ipaddr(self):
845 assert greendns.gethostbyname('1.2.3.4') == '1.2.3.4'
846
847 def test_name(self):
848 greendns.resolve.add('host.example.com', '1.2.3.4')
849 assert greendns.gethostbyname('host.example.com') == '1.2.3.4'
850
851
852 class TestGetaliases(tests.LimitedTestCase):
853
854 def _make_mock_resolver(self):
855 base_resolver = _make_mock_base_resolver()
856 resolver = base_resolver()
857 resolver.aliases = ['cname.example.com']
858 return resolver
859
860 def setUp(self):
861 self._old_resolver = greendns.resolver
862 greendns.resolver = self._make_mock_resolver()
863
864 def tearDown(self):
865 greendns.resolver = self._old_resolver
866
867 def test_getaliases(self):
868 assert greendns.getaliases('host.example.com') == ['cname.example.com']
869
870
871 class TestGethostbyname_ex(tests.LimitedTestCase):
872
873 def _make_mock_getaliases(self):
874
875 class GetAliases:
876 aliases = ['cname.example.com']
877
878 def __call__(self, *args, **kwargs):
879 return self.aliases
880
881 getaliases = GetAliases()
882 return getaliases
883
884 def setUp(self):
885 self._old_resolve = greendns.resolve
886 greendns.resolve = _make_mock_resolve()
887 self._old_getaliases = greendns.getaliases
888
889 def tearDown(self):
890 greendns.resolve = self._old_resolve
891 greendns.getaliases = self._old_getaliases
892
893 def test_ipaddr(self):
894 res = greendns.gethostbyname_ex('1.2.3.4')
895 assert res == ('1.2.3.4', [], ['1.2.3.4'])
896
897 def test_name(self):
898 greendns.resolve.add('host.example.com', '1.2.3.4')
899 greendns.getaliases = self._make_mock_getaliases()
900 greendns.getaliases.aliases = []
901 res = greendns.gethostbyname_ex('host.example.com')
902 assert res == ('host.example.com', [], ['1.2.3.4'])
903
904 def test_multiple_addrs(self):
905 greendns.resolve.add('host.example.com', '1.2.3.4')
906 greendns.resolve.add('host.example.com', '1.2.3.5')
907 greendns.getaliases = self._make_mock_getaliases()
908 greendns.getaliases.aliases = []
909 res = greendns.gethostbyname_ex('host.example.com')
910 assert res == ('host.example.com', [], ['1.2.3.4', '1.2.3.5'])
911
912
913 class TinyDNSTests(tests.LimitedTestCase):
914
915 def test_raise_dns_tcp(self):
916 # https://github.com/eventlet/eventlet/issues/499
917 # None means we don't want the server to find the IP
918 with tests.dns_tcp_server(None) as dnsaddr:
919 resolver = Resolver()
920 resolver.nameservers = [dnsaddr[0]]
921 resolver.nameserver_ports[dnsaddr[0]] = dnsaddr[1]
922
923 with self.assertRaises(NoAnswer):
924 resolver.query('host.example.com', 'a', tcp=True)
925
926 def test_noraise_dns_tcp(self):
927 # https://github.com/eventlet/eventlet/issues/499
928 expected_ip = "192.168.1.1"
929 with tests.dns_tcp_server(expected_ip) as dnsaddr:
930 resolver = Resolver()
931 resolver.nameservers = [dnsaddr[0]]
932 resolver.nameserver_ports[dnsaddr[0]] = dnsaddr[1]
933 response = resolver.query('host.example.com', 'a', tcp=True)
934 self.assertIsInstance(response, Answer)
935 self.assertEqual(list(response.rrset.items)[0].address, expected_ip)
936
937
938 class TestRaiseErrors(tests.LimitedTestCase):
939
940 def test_raise_new_error(self):
941 # https://github.com/eventlet/eventlet/issues/810
942 # Raise exception multiple times
943 for _ in range(3):
944 with self.assertRaises(socket.gaierror) as error:
945 greendns._raise_new_error(greendns.EAI_EAGAIN_ERROR)
946
947 self.assertIsNone(error.exception.__traceback__)
948 # Check no memory leak of exception instance
949 self.assertIsNone(greendns.EAI_EAGAIN_ERROR.__traceback__)
950
951
952 def test_reverse_name():
953 tests.run_isolated('greendns_from_address_203.py')
954
955
956 def test_proxy_resolve_unqualified():
957 # https://github.com/eventlet/eventlet/issues/363
958 rp = greendns.ResolverProxy(filename=None)
959 rp._resolver.search.append(dns.name.from_text('example.com'))
960 with tests.mock.patch('dns.resolver.Resolver.query', side_effect=dns.resolver.NoAnswer) as m:
961 try:
962 rp.query('machine')
963 assert False, 'Expected NoAnswer exception'
964 except dns.resolver.NoAnswer:
965 pass
966 assert any(call[0][0] == dns.name.from_text('machine') for call in m.call_args_list)
967 assert any(call[0][0] == dns.name.from_text('machine.') for call in m.call_args_list)
968
969
970 def test_hosts_priority():
971 name = 'example.com'
972 addr_from_ns = '1.0.2.0'
973
974 hr = _make_host_resolver()
975 rp = greendns.ResolverProxy(hosts_resolver=hr, filename=None)
976 base = _make_mock_base_resolver()
977 base.rr.address = addr_from_ns
978 rp._resolver = base()
979
980 # Default behavior
981 rrns = greendns.resolve(name, _proxy=rp).rrset[0]
982 assert rrns.address == addr_from_ns
983
984 # Hosts result must shadow that from nameservers
985 hr.hosts.write(b'1.2.3.4 example.com\ndead:beef::1 example.com\n')
986 hr.hosts.flush()
987 hr._load()
988 rrs4 = greendns.resolve(name, family=socket.AF_INET, _proxy=rp).rrset
989 assert len(rrs4) == 1
990 assert rrs4[0].address == '1.2.3.4', rrs4[0].address
991 rrs6 = greendns.resolve(name, family=socket.AF_INET6, _proxy=rp).rrset
992 assert len(rrs6) == 1
993 assert rrs6[0].address == 'dead:beef::1', rrs6[0].address
994
995
996 def test_hosts_no_network():
997
998 name = 'example.com'
999 addr_from_ns = '1.0.2.0'
1000 addr6_from_ns = 'dead:beef::1'
1001
1002 hr = _make_host_resolver()
1003 rp = greendns.ResolverProxy(hosts_resolver=hr, filename=None)
1004 base = _make_mock_base_resolver()
1005 base.rr.address = addr_from_ns
1006 base.rr6.address = addr6_from_ns
1007 rp._resolver = base()
1008
1009 with tests.mock.patch.object(greendns, 'resolver',
1010 new_callable=tests.mock.PropertyMock(return_value=rp)):
1011 res = greendns.getaddrinfo('example.com', 'domain', socket.AF_UNSPEC)
1012 # Default behavior
1013 addr = (addr_from_ns, 53)
1014 tcp = (socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
1015 udp = (socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
1016 addr = (addr6_from_ns, 53, 0, 0)
1017 tcp6 = (socket.AF_INET6, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
1018 udp6 = (socket.AF_INET6, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
1019 filt_res = [ai[:3] + (ai[4],) for ai in res]
1020 assert tcp in filt_res
1021 assert udp in filt_res
1022 assert tcp6 in filt_res
1023 assert udp6 in filt_res
1024
1025 # Hosts result must shadow that from nameservers
1026 hr = _make_host_resolver()
1027 hr.hosts.write(b'1.2.3.4 example.com')
1028 hr.hosts.flush()
1029 hr._load()
1030 greendns.resolver._hosts = hr
1031
1032 res = greendns.getaddrinfo('example.com', 'domain', socket.AF_UNSPEC)
1033 filt_res = [ai[:3] + (ai[4],) for ai in res]
1034
1035 # Make sure that only IPv4 entry from hosts is present.
1036 assert tcp not in filt_res
1037 assert udp not in filt_res
1038 assert tcp6 not in filt_res
1039 assert udp6 not in filt_res
1040
1041 addr = ('1.2.3.4', 53)
1042 tcp = (socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, addr)
1043 udp = (socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP, addr)
1044 assert tcp in filt_res
1045 assert udp in filt_res
1046
1047
1048 def test_import_rdtypes_then_eventlet():
1049 # https://github.com/eventlet/eventlet/issues/479
1050 tests.run_isolated('greendns_import_rdtypes_then_eventlet.py')