packages/python-dns
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
python-dns/backport-Retry-on-test-timeout.patch
eaglegai 65ccb8f6b0 fix build error 
(cherry picked from commit efcc9a44808cd93eac8bda286171c675e1d7e382)
2024-12-03 14:43:07 +08:00

555 lines
20 KiB
Diff
Raw Blame History

From 6c2c566b9af2bc18a1bd8ac05da239cc2548aeed Mon Sep 17 00:00:00 2001
From: Bob Halley <halley@dnspython.org>
Date: Sat, 12 Oct 2024 09:29:13 -0700
Subject: [PATCH] Retry on test timeout (#1146)
wrap all the tests that can time out
---
tests/test_async.py | 28 ++++++++++++++++++++++++++++
tests/test_ddr.py | 6 +++---
tests/test_doh.py | 11 +++++++++++
tests/test_query.py | 12 ++++++++++++
tests/test_resolver.py | 13 +++++++++++++
tests/util.py | 20 ++++++++++++++++++++
6 files changed, 87 insertions(+), 3 deletions(-)
diff --git a/tests/test_async.py b/tests/test_async.py
index b6e7a451e..9a19609cf 100644
--- a/tests/test_async.py
+++ b/tests/test_async.py
@@ -187,6 +187,7 @@ def setUp(self):
def async_run(self, afunc):
return asyncio.run(afunc())
+ @tests.util.retry_on_timeout
def testResolve(self):
async def run():
answer = await dns.asyncresolver.resolve("dns.google.", "A")
@@ -196,6 +197,7 @@ async def run():
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testResolveAddress(self):
async def run():
return await dns.asyncresolver.resolve_address("8.8.8.8")
@@ -204,6 +206,7 @@ async def run():
dnsgoogle = dns.name.from_text("dns.google.")
self.assertEqual(answer[0].target, dnsgoogle)
+ @tests.util.retry_on_timeout
def testResolveName(self):
async def run1():
return await dns.asyncresolver.resolve_name("dns.google.")
@@ -250,6 +253,7 @@ async def run5():
with self.assertRaises(dns.resolver.NoAnswer):
self.async_run(run5)
+ @tests.util.retry_on_timeout
def testCanonicalNameNoCNAME(self):
cname = dns.name.from_text("www.google.com")
@@ -258,6 +262,7 @@ async def run():
self.assertEqual(self.async_run(run), cname)
+ @tests.util.retry_on_timeout
def testCanonicalNameCNAME(self):
name = dns.name.from_text("www.dnspython.org")
cname = dns.name.from_text("dmfrjf4ips8xa.cloudfront.net")
@@ -270,6 +275,7 @@ async def run():
self.assertEqual(self.async_run(run), cname)
@unittest.skipIf(_systemd_resolved_present, "systemd-resolved in use")
+ @tests.util.retry_on_timeout
def testCanonicalNameDangling(self):
name = dns.name.from_text("dangling-cname.dnspython.org")
cname = dns.name.from_text("dangling-target.dnspython.org")
@@ -279,6 +285,7 @@ async def run():
self.assertEqual(self.async_run(run), cname)
+ @tests.util.retry_on_timeout
def testZoneForName1(self):
async def run():
name = dns.name.from_text("www.dnspython.org.")
@@ -288,6 +295,7 @@ async def run():
zname = self.async_run(run)
self.assertEqual(zname, ezname)
+ @tests.util.retry_on_timeout
def testZoneForName2(self):
async def run():
name = dns.name.from_text("a.b.www.dnspython.org.")
@@ -297,6 +305,7 @@ async def run():
zname = self.async_run(run)
self.assertEqual(zname, ezname)
+ @tests.util.retry_on_timeout
def testZoneForName3(self):
async def run():
name = dns.name.from_text("dnspython.org.")
@@ -317,6 +326,7 @@ async def run():
self.assertRaises(dns.resolver.NotAbsolute, bad)
+ @tests.util.retry_on_timeout
def testQueryUDP(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -334,6 +344,7 @@ async def run():
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testQueryUDPWithSocket(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -358,6 +369,7 @@ async def run():
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testQueryTCP(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -375,6 +387,7 @@ async def run():
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testQueryTCPWithSocket(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -403,6 +416,7 @@ async def run():
self.assertTrue("8.8.4.4" in seen)
@unittest.skipIf(not _ssl_available, "SSL not available")
+ @tests.util.retry_on_timeout
def testQueryTLS(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -421,6 +435,7 @@ async def run():
self.assertTrue("8.8.4.4" in seen)
@unittest.skipIf(not _ssl_available, "SSL not available")
+ @tests.util.retry_on_timeout
def testQueryTLSWithContext(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -443,6 +458,7 @@ async def run():
self.assertTrue("8.8.4.4" in seen)
@unittest.skipIf(not _ssl_available, "SSL not available")
+ @tests.util.retry_on_timeout
def testQueryTLSWithSocket(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -474,6 +490,7 @@ async def run():
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testQueryUDPFallback(self):
for address in query_addresses:
qname = dns.name.from_text(".")
@@ -485,6 +502,7 @@ async def run():
(_, tcp) = self.async_run(run)
self.assertTrue(tcp)
+ @tests.util.retry_on_timeout
def testQueryUDPFallbackNoFallback(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -496,6 +514,7 @@ async def run():
(_, tcp) = self.async_run(run)
self.assertFalse(tcp)
+ @tests.util.retry_on_timeout
def testUDPReceiveQuery(self):
async def run():
async with await self.backend.make_socket(
@@ -536,6 +555,7 @@ def run():
self.assertRaises(dns.exception.Timeout, run)
@unittest.skipIf(not dns.query._have_httpx, "httpx not available")
+ @tests.util.retry_on_timeout
def testDOHGetRequest(self):
async def run():
nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS)
@@ -548,6 +568,7 @@ async def run():
self.async_run(run)
@unittest.skipIf(not dns.query._have_httpx, "httpx not available")
+ @tests.util.retry_on_timeout
def testDOHPostRequest(self):
async def run():
nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS)
@@ -610,6 +634,7 @@ async def run():
self.async_run(run)
@unittest.skipIf(not dns.query._have_httpx, "httpx not available")
+ @tests.util.retry_on_timeout
def testResolverDOH(self):
async def run():
res = dns.asyncresolver.Resolver(configure=False)
@@ -622,6 +647,7 @@ async def run():
self.async_run(run)
@unittest.skipIf(not tests.util.have_ipv4(), "IPv4 not reachable")
+ @tests.util.retry_on_timeout
def testResolveAtAddress(self):
async def run():
answer = await dns.asyncresolver.resolve_at("8.8.8.8", "dns.google.", "A")
@@ -632,6 +658,7 @@ async def run():
self.async_run(run)
@unittest.skipIf(not tests.util.have_ipv4(), "IPv4 not reachable")
+ @tests.util.retry_on_timeout
def testResolveAtName(self):
async def run():
answer = await dns.asyncresolver.resolve_at(
@@ -661,6 +688,7 @@ def setUp(self):
def async_run(self, afunc):
return asyncio.run(afunc())
+ @tests.util.retry_on_timeout
def testUseAfterTimeout(self):
# Test #843 fix.
async def run():
diff --git a/tests/test_ddr.py b/tests/test_ddr.py
index ce38d0e94..c7892d025 100644
--- a/tests/test_ddr.py
+++ b/tests/test_ddr.py
@@ -1,21 +1,20 @@
# Copyright (C) Dnspython Contributors, see LICENSE for text of ISC license
import asyncio
-import time
import pytest
import dns.asyncbackend
import dns.asyncresolver
-import dns.resolver
import dns.nameserver
-
+import dns.resolver
import tests.util
@pytest.mark.skipif(
not tests.util.is_internet_reachable(), reason="Internet not reachable"
)
+@tests.util.retry_on_timeout
def test_basic_ddr_sync():
for nameserver in ["1.1.1.1", "8.8.8.8"]:
res = dns.resolver.Resolver(configure=False)
@@ -29,6 +28,7 @@ def test_basic_ddr_sync():
@pytest.mark.skipif(
not tests.util.is_internet_reachable(), reason="Internet not reachable"
)
+@tests.util.retry_on_timeout
def test_basic_ddr_async():
async def run():
dns.asyncbackend._default_backend = None
diff --git a/tests/test_doh.py b/tests/test_doh.py
index f5d413085..2743dee4a 100644
--- a/tests/test_doh.py
+++ b/tests/test_doh.py
@@ -18,6 +18,8 @@
import socket
import unittest
+import dns.exception
+
try:
import ssl
@@ -88,6 +90,7 @@ def setUp(self):
def tearDown(self):
self.session.close()
+ @tests.util.retry_on_timeout
def test_get_request(self):
nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS)
q = dns.message.make_query("example.com.", dns.rdatatype.A)
@@ -101,6 +104,7 @@ def test_get_request(self):
finally:
dns.query._have_http2 = saved_have_http2
+ @tests.util.retry_on_timeout
def test_post_request(self):
nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS)
q = dns.message.make_query("example.com.", dns.rdatatype.A)
@@ -114,6 +118,7 @@ def test_post_request(self):
)
self.assertTrue(q.is_response(r))
+ @tests.util.retry_on_timeout
def test_build_url_from_ip(self):
self.assertTrue(resolver_v4_addresses or resolver_v6_addresses)
if resolver_v4_addresses:
@@ -159,12 +164,14 @@ def test_build_url_from_ip(self):
# )
# self.assertTrue(q.is_response(r))
+ @tests.util.retry_on_timeout
def test_new_session(self):
nameserver_url = random.choice(KNOWN_ANYCAST_DOH_RESOLVER_URLS)
q = dns.message.make_query("example.com.", dns.rdatatype.A)
r = dns.query.https(q, nameserver_url, timeout=4)
self.assertTrue(q.is_response(r))
+ @tests.util.retry_on_timeout
def test_resolver(self):
res = dns.resolver.Resolver(configure=False)
res.nameservers = ["https://dns.google/dns-query"]
@@ -173,6 +180,7 @@ def test_resolver(self):
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def test_padded_get(self):
nameserver_url = random.choice(KNOWN_PAD_AWARE_DOH_RESOLVER_URLS)
q = dns.message.make_query("example.com.", dns.rdatatype.A, use_edns=0, pad=128)
diff --git a/tests/test_query.py b/tests/test_query.py
index dee6d3b20..e6b388a0e 100644
--- a/tests/test_query.py
+++ b/tests/test_query.py
@@ -66,6 +66,7 @@ class Server(object):
@unittest.skipIf(not tests.util.is_internet_reachable(), "Internet not reachable")
class QueryTests(unittest.TestCase):
+ @tests.util.retry_on_timeout
def testQueryUDP(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -79,6 +80,7 @@ def testQueryUDP(self):
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testQueryUDPWithSocket(self):
for address in query_addresses:
with socket.socket(
@@ -96,6 +98,7 @@ def testQueryUDPWithSocket(self):
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testQueryTCP(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -109,6 +112,7 @@ def testQueryTCP(self):
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testQueryTCPWithSocket(self):
for address in query_addresses:
with socket.socket(
@@ -130,6 +134,7 @@ def testQueryTCPWithSocket(self):
self.assertTrue("8.8.4.4" in seen)
@unittest.skipUnless(have_ssl, "No SSL support")
+ @tests.util.retry_on_timeout
def testQueryTLS(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -144,6 +149,7 @@ def testQueryTLS(self):
self.assertTrue("8.8.4.4" in seen)
@unittest.skipUnless(have_ssl, "No SSL support")
+ @tests.util.retry_on_timeout
def testQueryTLSWithContext(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -160,6 +166,7 @@ def testQueryTLSWithContext(self):
self.assertTrue("8.8.4.4" in seen)
@unittest.skipUnless(have_ssl, "No SSL support")
+ @tests.util.retry_on_timeout
def testQueryTLSWithSocket(self):
for address in query_addresses:
with socket.socket(
@@ -186,6 +193,7 @@ def testQueryTLSWithSocket(self):
self.assertTrue("8.8.4.4" in seen)
@unittest.skipUnless(have_ssl, "No SSL support")
+ @tests.util.retry_on_timeout
def testQueryTLSwithPadding(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -206,6 +214,7 @@ def testQueryTLSwithPadding(self):
has_pad = True
self.assertTrue(has_pad)
+ @tests.util.retry_on_timeout
def testQueryUDPFallback(self):
for address in query_addresses:
qname = dns.name.from_text(".")
@@ -213,6 +222,7 @@ def testQueryUDPFallback(self):
(_, tcp) = dns.query.udp_with_fallback(q, address, timeout=2)
self.assertTrue(tcp)
+ @tests.util.retry_on_timeout
def testQueryUDPFallbackWithSocket(self):
for address in query_addresses:
af = dns.inet.af_for_address(address)
@@ -230,6 +240,7 @@ def testQueryUDPFallbackWithSocket(self):
)
self.assertTrue(tcp)
+ @tests.util.retry_on_timeout
def testQueryUDPFallbackNoFallback(self):
for address in query_addresses:
qname = dns.name.from_text("dns.google.")
@@ -237,6 +248,7 @@ def testQueryUDPFallbackNoFallback(self):
(_, tcp) = dns.query.udp_with_fallback(q, address, timeout=2)
self.assertFalse(tcp)
+ @tests.util.retry_on_timeout
def testUDPReceiveQuery(self):
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as listener:
listener.bind(("127.0.0.1", 0))
diff --git a/tests/test_resolver.py b/tests/test_resolver.py
index 8694335cc..3e37648b9 100644
--- a/tests/test_resolver.py
+++ b/tests/test_resolver.py
@@ -630,18 +630,21 @@ def testUseTSIG(self):
@unittest.skipIf(not tests.util.is_internet_reachable(), "Internet not reachable")
class LiveResolverTests(unittest.TestCase):
+ @tests.util.retry_on_timeout
def testZoneForName1(self):
name = dns.name.from_text("www.dnspython.org.")
ezname = dns.name.from_text("dnspython.org.")
zname = dns.resolver.zone_for_name(name)
self.assertEqual(zname, ezname)
+ @tests.util.retry_on_timeout
def testZoneForName2(self):
name = dns.name.from_text("a.b.www.dnspython.org.")
ezname = dns.name.from_text("dnspython.org.")
zname = dns.resolver.zone_for_name(name)
self.assertEqual(zname, ezname)
+ @tests.util.retry_on_timeout
def testZoneForName3(self):
ezname = dns.name.from_text("dnspython.org.")
zname = dns.resolver.zone_for_name("dnspython.org.")
@@ -654,23 +657,27 @@ def bad():
self.assertRaises(dns.resolver.NotAbsolute, bad)
+ @tests.util.retry_on_timeout
def testResolve(self):
answer = dns.resolver.resolve("dns.google.", "A")
seen = set([rdata.address for rdata in answer])
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testResolveTCP(self):
answer = dns.resolver.resolve("dns.google.", "A", tcp=True)
seen = set([rdata.address for rdata in answer])
self.assertTrue("8.8.8.8" in seen)
self.assertTrue("8.8.4.4" in seen)
+ @tests.util.retry_on_timeout
def testResolveAddress(self):
answer = dns.resolver.resolve_address("8.8.8.8")
dnsgoogle = dns.name.from_text("dns.google.")
self.assertEqual(answer[0].target, dnsgoogle)
+ @tests.util.retry_on_timeout
def testResolveName(self):
answers = dns.resolver.resolve_name("dns.google.")
seen = set(answers.addresses())
@@ -700,6 +707,7 @@ def testResolveName(self):
with self.assertRaises(dns.resolver.NoAnswer):
dns.resolver.resolve_name(dns.reversename.from_address("8.8.8.8"))
+ @tests.util.retry_on_timeout
@patch.object(dns.message.Message, "use_edns")
def testResolveEdnsOptions(self, message_use_edns_mock):
resolver = dns.resolver.Resolver()
@@ -708,12 +716,14 @@ def testResolveEdnsOptions(self, message_use_edns_mock):
resolver.resolve("dns.google.", "A")
assert {"options": options} in message_use_edns_mock.call_args
+ @tests.util.retry_on_timeout
def testResolveNodataException(self):
def bad():
dns.resolver.resolve("dnspython.org.", "SRV")
self.assertRaises(dns.resolver.NoAnswer, bad)
+ @tests.util.retry_on_timeout
def testResolveNodataAnswer(self):
qname = dns.name.from_text("dnspython.org")
qclass = dns.rdataclass.from_text("IN")
@@ -726,6 +736,7 @@ def testResolveNodataAnswer(self):
),
)
+ @tests.util.retry_on_timeout
def testResolveNXDOMAIN(self):
qname = dns.name.from_text("nxdomain.dnspython.org")
qclass = dns.rdataclass.from_text("IN")
@@ -742,6 +753,7 @@ def bad():
self.assertGreaterEqual(len(nx.responses()), 1)
@unittest.skipIf(not tests.util.have_ipv4(), "IPv4 not reachable")
+ @tests.util.retry_on_timeout
def testResolveCacheHit(self):
res = dns.resolver.Resolver(configure=False)
res.nameservers = ["8.8.8.8"]
@@ -754,6 +766,7 @@ def testResolveCacheHit(self):
self.assertIs(answer2, answer1)
@unittest.skipIf(not tests.util.have_ipv4(), "IPv4 not reachable")
+ @tests.util.retry_on_timeout
def testTLSNameserver(self):
res = dns.resolver.Resolver(configure=False)
res.nameservers = [dns.nameserver.DoTNameserver("8.8.8.8", 853)]
diff --git a/tests/util.py b/tests/util.py
index 9f0d3f464..f029fb02b 100644
--- a/tests/util.py
+++ b/tests/util.py
@@ -16,10 +16,12 @@
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
import enum
+import functools
import inspect
import os
import socket
+import dns.exception
import dns.message
import dns.name
import dns.query
@@ -131,3 +133,20 @@ def is_docker() -> bool:
for flag, value in attr.__members__.items():
# print(module, flag, value)
eq_callback(getattr(module, flag), value)
+
+
+def retry_on_timeout(f):
+ @functools.wraps(f)
+ def wrapper(*args, **kwargs):
+ bad = True
+ for i in range(3):
+ try:
+ f(*args, **kwargs)
+ bad = False
+ break
+ except dns.exception.Timeout:
+ pass
+ if bad:
+ raise dns.exception.Timeout
+
+ return wrapper
Reference in New Issue View Git Blame Copy Permalink